vtkImageResliceMapper.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
// SPDX-License-Identifier: BSD-3-Clause
#ifndef vtkImageResliceMapper_h
#define vtkImageResliceMapper_h
 
#include "vtkImageMapper3D.h"
#include "vtkRenderingImageModule.h" // For export macro
#include "vtkWrappingHints.h"
 
VTK_ABI_NAMESPACE_BEGIN
class vtkImageSliceMapper;
class vtkRenderer;
class vtkRenderWindow;
class vtkCamera;
class vtkLookupTable;
class vtkImageSlice;
class vtkImageData;
class vtkImageResliceToColors;
class vtkMatrix4x4;
class vtkAbstractImageInterpolator;
class vtkImageChangeInformation;
 
class VTKRENDERINGIMAGE_EXPORT VTK_MARSHALAUTO vtkImageResliceMapper : public vtkImageMapper3D
{
public:
  static vtkImageResliceMapper* New();
  vtkTypeMacro(vtkImageResliceMapper, vtkImageMapper3D);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
 
  virtual void SetSlicePlane(vtkPlane* plane);
  vtkPlane* GetSlicePlane() override { return this->SlicePlane; }
 
 
  vtkSetMacro(JumpToNearestSlice, vtkTypeBool);
  vtkBooleanMacro(JumpToNearestSlice, vtkTypeBool);
  vtkGetMacro(JumpToNearestSlice, vtkTypeBool);
 
 
  vtkSetMacro(SlabThickness, double);
  vtkGetMacro(SlabThickness, double);
 
 
  vtkSetClampMacro(SlabType, int, VTK_IMAGE_SLAB_MIN, VTK_IMAGE_SLAB_SUM);
  vtkGetMacro(SlabType, int);
  void SetSlabTypeToMin() { this->SetSlabType(VTK_IMAGE_SLAB_MIN); }
  void SetSlabTypeToMax() { this->SetSlabType(VTK_IMAGE_SLAB_MAX); }
  void SetSlabTypeToMean() { this->SetSlabType(VTK_IMAGE_SLAB_MEAN); }
  void SetSlabTypeToSum() { this->SetSlabType(VTK_IMAGE_SLAB_SUM); }
  virtual const char* GetSlabTypeAsString();
 
 
  vtkSetClampMacro(SlabSampleFactor, int, 1, 2);
  vtkGetMacro(SlabSampleFactor, int);
 
 
  vtkSetClampMacro(ImageSampleFactor, int, 1, 16);
  vtkGetMacro(ImageSampleFactor, int);
 
 
  vtkSetMacro(AutoAdjustImageQuality, vtkTypeBool);
  vtkBooleanMacro(AutoAdjustImageQuality, vtkTypeBool);
  vtkGetMacro(AutoAdjustImageQuality, vtkTypeBool);
 
 
  vtkSetMacro(ResampleToScreenPixels, vtkTypeBool);
  vtkBooleanMacro(ResampleToScreenPixels, vtkTypeBool);
  vtkGetMacro(ResampleToScreenPixels, vtkTypeBool);
 
 
  vtkSetMacro(SeparateWindowLevelOperation, vtkTypeBool);
  vtkBooleanMacro(SeparateWindowLevelOperation, vtkTypeBool);
  vtkGetMacro(SeparateWindowLevelOperation, vtkTypeBool);
 
 
  VTK_MARSHALEXCLUDE(VTK_MARSHAL_EXCLUDE_REASON_IS_REDUNDANT)
  virtual void SetInterpolator(vtkAbstractImageInterpolator* interpolator);
  VTK_MARSHALEXCLUDE(VTK_MARSHAL_EXCLUDE_REASON_IS_REDUNDANT)
  virtual vtkAbstractImageInterpolator* GetInterpolator();
 
  void Render(vtkRenderer* renderer, vtkImageSlice* prop) override;
 
  void ReleaseGraphicsResources(vtkWindow*) override;
 
  vtkMTimeType GetMTime() override;
 
 
  double* GetBounds() override;
  void GetBounds(double bounds[6]) override { this->vtkAbstractMapper3D::GetBounds(bounds); }
 
  vtkTypeBool ProcessRequest(
    vtkInformation* request, vtkInformationVector** inInfo, vtkInformationVector* outInfo) override;
 
  // return the bounds in index space
  void GetIndexBounds(double extent[6]) override;
 
  vtkGetObjectMacro(ImageReslice, vtkImageResliceToColors);
  void SetImageReslice(vtkImageResliceToColors*);
 
protected:
  vtkImageResliceMapper();
  ~vtkImageResliceMapper() override;
 
  void CheckerboardImage(vtkImageData* input, vtkCamera* camera, vtkImageProperty* property);
 
  void UpdateSliceToWorldMatrix(vtkCamera* camera);
 
  void UpdateWorldToDataMatrix(vtkImageSlice* prop);
 
  void UpdateResliceMatrix(vtkRenderer* ren, vtkImageSlice* prop);
 
  void UpdateResliceInformation(vtkRenderer* ren);
 
  void UpdateResliceInterpolation(vtkImageProperty* property);
 
  void UpdateColorInformation(vtkImageProperty* property);
 
  void UpdatePolygonCoords(vtkRenderer* ren);
 
 
  void Update(int port) override;
  void Update() override;
  vtkTypeBool Update(int port, vtkInformationVector* requests) override;
  vtkTypeBool Update(vtkInformation* requests) override;
 
  void ReportReferences(vtkGarbageCollector*) override;
 
  vtkImageChangeInformation* ChangeInformation; // Prepare image for mapper
  vtkImageSliceMapper* SliceMapper;             // Does the OpenGL rendering
 
  vtkTypeBool JumpToNearestSlice;           // Adjust SliceAtFocalPoint
  vtkTypeBool AutoAdjustImageQuality;       // LOD-style behavior
  vtkTypeBool SeparateWindowLevelOperation; // Do window/level as a separate step
  double SlabThickness;                     // Current slab thickness
  int SlabType;                             // Current slab mode
  int SlabSampleFactor;                     // Sampling factor for slab mode
  int ImageSampleFactor;                    // Sampling factor for image pixels
  vtkTypeBool ResampleToScreenPixels;       // Use software interpolation only
  int InternalResampleToScreenPixels;       // Use software interpolation only
  int ResliceNeedUpdate;                    // Execute reslice on next render
  vtkImageResliceToColors* ImageReslice;    // For software interpolation
  vtkMatrix4x4* ResliceMatrix;              // Cached reslice matrix
  vtkMatrix4x4* WorldToDataMatrix;          // World to Data transform matrix
  vtkMatrix4x4* DataToSliceMatrix;          // Data to Slice transform matrix
  vtkMatrix4x4* SliceToWorldMatrix;         // Slice to World transform matrix
  vtkTimeStamp UpdateTime;
 
private:
  vtkImageResliceMapper(const vtkImageResliceMapper&) = delete;
  void operator=(const vtkImageResliceMapper&) = delete;
};
 
VTK_ABI_NAMESPACE_END
#endif