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 "vtkRenderingImageModule.h" // For export macro
#include "vtkImageMapper3D.h"

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); };

  int ProcessRequest(vtkInformation* request,
                     vtkInformationVector** inInfo,
                     vtkInformationVector* outInfo) 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;
  int Update(int port, vtkInformationVector* requests) override;
  int 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