vtkImageResliceMapper.h

Go to the documentation of this file.

/*=========================================================================
 
  Program:   Visualization Toolkit
  Module:    vtkImageResliceMapper.h
 
  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
  All rights reserved.
  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
 
     This software is distributed WITHOUT ANY WARRANTY; without even
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
     PURPOSE.  See the above copyright notice for more information.
 
=========================================================================*/
#ifndef vtkImageResliceMapper_h
#define vtkImageResliceMapper_h
 
#include "vtkImageMapper3D.h"
#include "vtkRenderingImageModule.h" // For export macro
 
 
class vtkImageSliceMapper;
class vtkRenderer;
class vtkRenderWindow;
class vtkCamera;
class vtkLookupTable;
class vtkImageSlice;
class vtkImageData;
class vtkImageResliceToColors;
class vtkMatrix4x4;
class vtkAbstractImageInterpolator;
 
class VTKRENDERINGIMAGE_EXPORT vtkImageResliceMapper : public vtkImageMapper3D {
public:
  static vtkImageResliceMapper *New();
  vtkTypeMacro(vtkImageResliceMapper, vtkImageMapper3D);
  void PrintSelf(ostream &os, vtkIndent indent) override;
 
  virtual void SetSlicePlane(vtkPlane *plane);
 
 
  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);
 
 
  virtual void SetInterpolator(vtkAbstractImageInterpolator *sampler);
  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;
 
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;
 
  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 *SliceToWorldMatrix;      // Slice to World transform matrix
  vtkTimeStamp UpdateTime;
 
private:
  vtkImageResliceMapper(const vtkImageResliceMapper &) = delete;
  void operator=(const vtkImageResliceMapper &) = delete;
};
 
#endif