vtkImageReslice.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 vtkImageReslice_h
#define vtkImageReslice_h
 
#include "vtkImagingCoreModule.h" // For export macro
#include "vtkThreadedImageAlgorithm.h"
 
// interpolation mode constants
#define VTK_RESLICE_NEAREST VTK_NEAREST_INTERPOLATION
#define VTK_RESLICE_LINEAR VTK_LINEAR_INTERPOLATION
#define VTK_RESLICE_CUBIC VTK_CUBIC_INTERPOLATION
 
VTK_ABI_NAMESPACE_BEGIN
class vtkImageData;
class vtkAbstractTransform;
class vtkMatrix4x4;
class vtkImageStencilData;
class vtkScalarsToColors;
class vtkAbstractImageInterpolator;
 
class VTKIMAGINGCORE_EXPORT vtkImageReslice : public vtkThreadedImageAlgorithm
{
public:
  static vtkImageReslice* New();
  vtkTypeMacro(vtkImageReslice, vtkThreadedImageAlgorithm);
 
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
 
  virtual void SetResliceAxes(vtkMatrix4x4*);
  vtkGetObjectMacro(ResliceAxes, vtkMatrix4x4);
 
 
  void SetResliceAxesDirectionCosines(double x0, double x1, double x2, double y0, double y1,
    double y2, double z0, double z1, double z2);
  void SetResliceAxesDirectionCosines(const double x[3], const double y[3], const double z[3])
  {
    this->SetResliceAxesDirectionCosines(x[0], x[1], x[2], y[0], y[1], y[2], z[0], z[1], z[2]);
  }
  void SetResliceAxesDirectionCosines(const double xyz[9])
  {
    this->SetResliceAxesDirectionCosines(
      xyz[0], xyz[1], xyz[2], xyz[3], xyz[4], xyz[5], xyz[6], xyz[7], xyz[8]);
  }
  void GetResliceAxesDirectionCosines(double x[3], double y[3], double z[3]);
  void GetResliceAxesDirectionCosines(double xyz[9])
  {
    this->GetResliceAxesDirectionCosines(&xyz[0], &xyz[3], &xyz[6]);
  }
  double* GetResliceAxesDirectionCosines() VTK_SIZEHINT(9)
  {
    this->GetResliceAxesDirectionCosines(this->ResliceAxesDirectionCosines);
    return this->ResliceAxesDirectionCosines;
  }
 
 
  void SetResliceAxesOrigin(double x, double y, double z);
  void SetResliceAxesOrigin(const double xyz[3])
  {
    this->SetResliceAxesOrigin(xyz[0], xyz[1], xyz[2]);
  }
  void GetResliceAxesOrigin(double xyz[3]);
  double* GetResliceAxesOrigin() VTK_SIZEHINT(3)
  {
    this->GetResliceAxesOrigin(this->ResliceAxesOrigin);
    return this->ResliceAxesOrigin;
  }
 
 
  virtual void SetResliceTransform(vtkAbstractTransform*);
  vtkGetObjectMacro(ResliceTransform, vtkAbstractTransform);
 
 
  virtual void SetInformationInput(vtkImageData*);
  vtkGetObjectMacro(InformationInput, vtkImageData);
 
 
  vtkSetMacro(TransformInputSampling, vtkTypeBool);
  vtkBooleanMacro(TransformInputSampling, vtkTypeBool);
  vtkGetMacro(TransformInputSampling, vtkTypeBool);
 
 
  vtkSetMacro(AutoCropOutput, vtkTypeBool);
  vtkBooleanMacro(AutoCropOutput, vtkTypeBool);
  vtkGetMacro(AutoCropOutput, vtkTypeBool);
 
 
  vtkSetMacro(Wrap, vtkTypeBool);
  vtkGetMacro(Wrap, vtkTypeBool);
  vtkBooleanMacro(Wrap, vtkTypeBool);
 
 
  vtkSetMacro(Mirror, vtkTypeBool);
  vtkGetMacro(Mirror, vtkTypeBool);
  vtkBooleanMacro(Mirror, vtkTypeBool);
 
 
  vtkSetMacro(Border, vtkTypeBool);
  vtkGetMacro(Border, vtkTypeBool);
  vtkBooleanMacro(Border, vtkTypeBool);
 
 
  vtkSetMacro(BorderThickness, double);
  vtkGetMacro(BorderThickness, double);
 
  vtkSetClampMacro(InterpolationMode, int, VTK_RESLICE_NEAREST, VTK_RESLICE_CUBIC);
  vtkGetMacro(InterpolationMode, int);
  void SetInterpolationModeToNearestNeighbor() { this->SetInterpolationMode(VTK_RESLICE_NEAREST); }
  void SetInterpolationModeToLinear() { this->SetInterpolationMode(VTK_RESLICE_LINEAR); }
  void SetInterpolationModeToCubic() { this->SetInterpolationMode(VTK_RESLICE_CUBIC); }
  virtual const char* GetInterpolationModeAsString();
 
 
  virtual void SetInterpolator(vtkAbstractImageInterpolator* sampler);
  virtual vtkAbstractImageInterpolator* GetInterpolator();
 
 
  vtkSetClampMacro(SlabMode, int, VTK_IMAGE_SLAB_MIN, VTK_IMAGE_SLAB_SUM);
  vtkGetMacro(SlabMode, int);
  void SetSlabModeToMin() { this->SetSlabMode(VTK_IMAGE_SLAB_MIN); }
  void SetSlabModeToMax() { this->SetSlabMode(VTK_IMAGE_SLAB_MAX); }
  void SetSlabModeToMean() { this->SetSlabMode(VTK_IMAGE_SLAB_MEAN); }
  void SetSlabModeToSum() { this->SetSlabMode(VTK_IMAGE_SLAB_SUM); }
  virtual const char* GetSlabModeAsString();
 
 
  vtkSetMacro(SlabNumberOfSlices, int);
  vtkGetMacro(SlabNumberOfSlices, int);
 
 
  vtkSetMacro(SlabTrapezoidIntegration, vtkTypeBool);
  vtkBooleanMacro(SlabTrapezoidIntegration, vtkTypeBool);
  vtkGetMacro(SlabTrapezoidIntegration, vtkTypeBool);
 
 
  vtkSetMacro(SlabSliceSpacingFraction, double);
  vtkGetMacro(SlabSliceSpacingFraction, double);
 
 
  vtkSetMacro(Optimization, vtkTypeBool);
  vtkGetMacro(Optimization, vtkTypeBool);
  vtkBooleanMacro(Optimization, vtkTypeBool);
 
 
  vtkSetMacro(ScalarShift, double);
  vtkGetMacro(ScalarShift, double);
 
 
  vtkSetMacro(ScalarScale, double);
  vtkGetMacro(ScalarScale, double);
 
 
  vtkSetMacro(OutputScalarType, int);
  vtkGetMacro(OutputScalarType, int);
 
 
  vtkSetVector4Macro(BackgroundColor, double);
  vtkGetVector4Macro(BackgroundColor, double);
 
 
  void SetBackgroundLevel(double v) { this->SetBackgroundColor(v, v, v, v); }
  double GetBackgroundLevel() { return this->GetBackgroundColor()[0]; }
 
 
  virtual void SetOutputSpacing(double x, double y, double z);
  virtual void SetOutputSpacing(const double a[3]) { this->SetOutputSpacing(a[0], a[1], a[2]); }
  vtkGetVector3Macro(OutputSpacing, double);
  void SetOutputSpacingToDefault();
 
 
  virtual void SetOutputDirection(double xx, double xy, double xz, double yx, double yy, double yz,
    double zx, double zy, double zz);
  virtual void SetOutputDirection(const double a[9])
  {
    this->SetOutputDirection(a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7], a[8]);
  }
  vtkGetVector3Macro(OutputDirection, double);
  void SetOutputDirectionToDefault();
 
 
  virtual void SetOutputOrigin(double x, double y, double z);
  virtual void SetOutputOrigin(const double a[3]) { this->SetOutputOrigin(a[0], a[1], a[2]); }
  vtkGetVector3Macro(OutputOrigin, double);
  void SetOutputOriginToDefault();
 
 
  virtual void SetOutputExtent(int a, int b, int c, int d, int e, int f);
  virtual void SetOutputExtent(const int a[6])
  {
    this->SetOutputExtent(a[0], a[1], a[2], a[3], a[4], a[5]);
  }
  vtkGetVector6Macro(OutputExtent, int);
  void SetOutputExtentToDefault();
 
 
  vtkSetMacro(OutputDimensionality, int);
  vtkGetMacro(OutputDimensionality, int);
 
  vtkMTimeType GetMTime() override;
 
  void ReportReferences(vtkGarbageCollector*) override;
 
 
  void SetInterpolate(int t)
  {
    if (t && !this->GetInterpolate())
    {
      this->SetInterpolationModeToLinear();
    }
    else if (!t && this->GetInterpolate())
    {
      this->SetInterpolationModeToNearestNeighbor();
    }
  }
  void InterpolateOn() { this->SetInterpolate(1); }
  void InterpolateOff() { this->SetInterpolate(0); }
  int GetInterpolate() { return (this->GetInterpolationMode() != VTK_RESLICE_NEAREST); }
 
 
  void SetStencilData(vtkImageStencilData* stencil);
  vtkImageStencilData* GetStencil();
 
 
  vtkSetMacro(GenerateStencilOutput, vtkTypeBool);
  vtkGetMacro(GenerateStencilOutput, vtkTypeBool);
  vtkBooleanMacro(GenerateStencilOutput, vtkTypeBool);
 
 
  vtkAlgorithmOutput* GetStencilOutputPort() { return this->GetOutputPort(1); }
  vtkImageStencilData* GetStencilOutput();
  void SetStencilOutput(vtkImageStencilData* stencil);
 
protected:
  vtkImageReslice();
  ~vtkImageReslice() override;
 
  vtkMatrix4x4* ResliceAxes;
  double ResliceAxesDirectionCosines[9];
  double ResliceAxesOrigin[3];
  vtkAbstractTransform* ResliceTransform;
  vtkAbstractImageInterpolator* Interpolator;
  vtkImageData* InformationInput;
  vtkTypeBool Wrap;
  vtkTypeBool Mirror;
  vtkTypeBool Border;
  int InterpolationMode;
  vtkTypeBool Optimization;
  int SlabMode;
  int SlabNumberOfSlices;
  vtkTypeBool SlabTrapezoidIntegration;
  double SlabSliceSpacingFraction;
  double ScalarShift;
  double ScalarScale;
  double BorderThickness;
  double BackgroundColor[4];
  double OutputDirection[9];
  double OutputOrigin[3];
  double OutputSpacing[3];
  int OutputExtent[6];
  int OutputScalarType;
  int OutputDimensionality;
  vtkTypeBool TransformInputSampling;
  vtkTypeBool AutoCropOutput;
  int HitInputExtent;
  int UsePermuteExecute;
  int ComputeOutputSpacing;
  bool PassDirectionToOutput;
  int ComputeOutputOrigin;
  int ComputeOutputExtent;
  vtkTypeBool GenerateStencilOutput;
 
  vtkMatrix4x4* IndexMatrix;
  vtkAbstractTransform* OptimizedTransform;
 
  vtkTypeBool HasConvertScalars;
 
  virtual int ConvertScalarInfo(int& scalarType, int& numComponents);
 
  virtual void ConvertScalars(void* inPtr, void* outPtr, int inputType, int inputNumComponents,
    int count, int idX, int idY, int idZ, int threadId);
 
  void ConvertScalarsBase(void* inPtr, void* outPtr, int inputType, int inputNumComponents,
    int count, int idX, int idY, int idZ, int threadId)
  {
    this->ConvertScalars(
      inPtr, outPtr, inputType, inputNumComponents, count, idX, idY, idZ, threadId);
  }
 
  int RequestInformationBase(vtkInformationVector**, vtkInformationVector*);
 
  void GetAutoCroppedOutputBounds(
    vtkInformation* inInfo, const double outDirection[9], double bounds[6]);
  void AllocateOutputData(vtkImageData* output, vtkInformation* outInfo, int* uExtent) override;
  vtkImageData* AllocateOutputData(vtkDataObject*, vtkInformation*) override;
  int RequestInformation(vtkInformation*, vtkInformationVector**, vtkInformationVector*) override;
  int RequestUpdateExtent(vtkInformation*, vtkInformationVector**, vtkInformationVector*) override;
  int RequestData(vtkInformation*, vtkInformationVector**, vtkInformationVector*) override;
  void ThreadedRequestData(vtkInformation* request, vtkInformationVector** inputVector,
    vtkInformationVector* outputVector, vtkImageData*** inData, vtkImageData** outData, int ext[6],
    int id) override;
  int FillInputPortInformation(int port, vtkInformation* info) override;
  int FillOutputPortInformation(int port, vtkInformation* info) override;
 
  vtkMatrix4x4* GetIndexMatrix(vtkInformation* inInfo, vtkInformation* outInfo);
  vtkAbstractTransform* GetOptimizedTransform() { return this->OptimizedTransform; }
 
private:
  vtkImageReslice(const vtkImageReslice&) = delete;
  void operator=(const vtkImageReslice&) = delete;
};
 
VTK_ABI_NAMESPACE_END
#endif