VTK  9.2.6
vtkImageReslice.h
Go to the documentation of this file.
1 /*=========================================================================
2 
3  Program: Visualization Toolkit
4  Module: vtkImageReslice.h
5 
6  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
7  All rights reserved.
8  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
9 
10  This software is distributed WITHOUT ANY WARRANTY; without even
11  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
12  PURPOSE. See the above copyright notice for more information.
13 
14 =========================================================================*/
97 #ifndef vtkImageReslice_h
98 #define vtkImageReslice_h
99 
100 #include "vtkImagingCoreModule.h" // For export macro
102 
103 // interpolation mode constants
104 #define VTK_RESLICE_NEAREST VTK_NEAREST_INTERPOLATION
105 #define VTK_RESLICE_LINEAR VTK_LINEAR_INTERPOLATION
106 #define VTK_RESLICE_CUBIC VTK_CUBIC_INTERPOLATION
107 
108 class vtkImageData;
110 class vtkMatrix4x4;
111 class vtkImageStencilData;
112 class vtkScalarsToColors;
114 
115 class VTKIMAGINGCORE_EXPORT vtkImageReslice : public vtkThreadedImageAlgorithm
116 {
117 public:
118  static vtkImageReslice* New();
120 
121  void PrintSelf(ostream& os, vtkIndent indent) override;
122 
124 
139  virtual void SetResliceAxes(vtkMatrix4x4*);
140  vtkGetObjectMacro(ResliceAxes, vtkMatrix4x4);
142 
144 
150  void SetResliceAxesDirectionCosines(double x0, double x1, double x2, double y0, double y1,
151  double y2, double z0, double z1, double z2);
152  void SetResliceAxesDirectionCosines(const double x[3], const double y[3], const double z[3])
153  {
154  this->SetResliceAxesDirectionCosines(x[0], x[1], x[2], y[0], y[1], y[2], z[0], z[1], z[2]);
155  }
156  void SetResliceAxesDirectionCosines(const double xyz[9])
157  {
158  this->SetResliceAxesDirectionCosines(
159  xyz[0], xyz[1], xyz[2], xyz[3], xyz[4], xyz[5], xyz[6], xyz[7], xyz[8]);
160  }
161  void GetResliceAxesDirectionCosines(double x[3], double y[3], double z[3]);
162  void GetResliceAxesDirectionCosines(double xyz[9])
163  {
164  this->GetResliceAxesDirectionCosines(&xyz[0], &xyz[3], &xyz[6]);
165  }
167  {
168  this->GetResliceAxesDirectionCosines(this->ResliceAxesDirectionCosines);
169  return this->ResliceAxesDirectionCosines;
170  }
172 
174 
180  void SetResliceAxesOrigin(double x, double y, double z);
181  void SetResliceAxesOrigin(const double xyz[3])
182  {
183  this->SetResliceAxesOrigin(xyz[0], xyz[1], xyz[2]);
184  }
185  void GetResliceAxesOrigin(double xyz[3]);
187  {
188  this->GetResliceAxesOrigin(this->ResliceAxesOrigin);
189  return this->ResliceAxesOrigin;
190  }
192 
194 
204  vtkGetObjectMacro(ResliceTransform, vtkAbstractTransform);
206 
208 
218  vtkGetObjectMacro(InformationInput, vtkImageData);
220 
222 
229  vtkSetMacro(TransformInputSampling, vtkTypeBool);
230  vtkBooleanMacro(TransformInputSampling, vtkTypeBool);
231  vtkGetMacro(TransformInputSampling, vtkTypeBool);
233 
235 
240  vtkSetMacro(AutoCropOutput, vtkTypeBool);
241  vtkBooleanMacro(AutoCropOutput, vtkTypeBool);
242  vtkGetMacro(AutoCropOutput, vtkTypeBool);
244 
246 
249  vtkSetMacro(Wrap, vtkTypeBool);
250  vtkGetMacro(Wrap, vtkTypeBool);
251  vtkBooleanMacro(Wrap, vtkTypeBool);
253 
255 
259  vtkSetMacro(Mirror, vtkTypeBool);
260  vtkGetMacro(Mirror, vtkTypeBool);
261  vtkBooleanMacro(Mirror, vtkTypeBool);
263 
265 
275  vtkSetMacro(Border, vtkTypeBool);
276  vtkGetMacro(Border, vtkTypeBool);
277  vtkBooleanMacro(Border, vtkTypeBool);
279 
281 
286  vtkSetMacro(BorderThickness, double);
287  vtkGetMacro(BorderThickness, double);
289 
293  vtkSetClampMacro(InterpolationMode, int, VTK_RESLICE_NEAREST, VTK_RESLICE_CUBIC);
294  vtkGetMacro(InterpolationMode, int);
295  void SetInterpolationModeToNearestNeighbor() { this->SetInterpolationMode(VTK_RESLICE_NEAREST); }
296  void SetInterpolationModeToLinear() { this->SetInterpolationMode(VTK_RESLICE_LINEAR); }
297  void SetInterpolationModeToCubic() { this->SetInterpolationMode(VTK_RESLICE_CUBIC); }
298  virtual const char* GetInterpolationModeAsString();
300 
302 
309 
311 
317  vtkSetClampMacro(SlabMode, int, VTK_IMAGE_SLAB_MIN, VTK_IMAGE_SLAB_SUM);
318  vtkGetMacro(SlabMode, int);
319  void SetSlabModeToMin() { this->SetSlabMode(VTK_IMAGE_SLAB_MIN); }
320  void SetSlabModeToMax() { this->SetSlabMode(VTK_IMAGE_SLAB_MAX); }
321  void SetSlabModeToMean() { this->SetSlabMode(VTK_IMAGE_SLAB_MEAN); }
322  void SetSlabModeToSum() { this->SetSlabMode(VTK_IMAGE_SLAB_SUM); }
323  virtual const char* GetSlabModeAsString();
325 
327 
330  vtkSetMacro(SlabNumberOfSlices, int);
331  vtkGetMacro(SlabNumberOfSlices, int);
333 
335 
340  vtkSetMacro(SlabTrapezoidIntegration, vtkTypeBool);
341  vtkBooleanMacro(SlabTrapezoidIntegration, vtkTypeBool);
342  vtkGetMacro(SlabTrapezoidIntegration, vtkTypeBool);
344 
346 
355  vtkSetMacro(SlabSliceSpacingFraction, double);
356  vtkGetMacro(SlabSliceSpacingFraction, double);
358 
360 
364  vtkSetMacro(Optimization, vtkTypeBool);
365  vtkGetMacro(Optimization, vtkTypeBool);
366  vtkBooleanMacro(Optimization, vtkTypeBool);
368 
370 
377  vtkSetMacro(ScalarShift, double);
378  vtkGetMacro(ScalarShift, double);
380 
382 
389  vtkSetMacro(ScalarScale, double);
390  vtkGetMacro(ScalarScale, double);
392 
394 
404  vtkSetMacro(OutputScalarType, int);
405  vtkGetMacro(OutputScalarType, int);
407 
409 
412  vtkSetVector4Macro(BackgroundColor, double);
413  vtkGetVector4Macro(BackgroundColor, double);
415 
417 
420  void SetBackgroundLevel(double v) { this->SetBackgroundColor(v, v, v, v); }
421  double GetBackgroundLevel() { return this->GetBackgroundColor()[0]; }
423 
425 
429  virtual void SetOutputSpacing(double x, double y, double z);
430  virtual void SetOutputSpacing(const double a[3]) { this->SetOutputSpacing(a[0], a[1], a[2]); }
431  vtkGetVector3Macro(OutputSpacing, double);
434 
436 
440  virtual void SetOutputOrigin(double x, double y, double z);
441  virtual void SetOutputOrigin(const double a[3]) { this->SetOutputOrigin(a[0], a[1], a[2]); }
442  vtkGetVector3Macro(OutputOrigin, double);
445 
447 
451  virtual void SetOutputExtent(int a, int b, int c, int d, int e, int f);
452  virtual void SetOutputExtent(const int a[6])
453  {
454  this->SetOutputExtent(a[0], a[1], a[2], a[3], a[4], a[5]);
455  }
456  vtkGetVector6Macro(OutputExtent, int);
459 
461 
471  vtkSetMacro(OutputDimensionality, int);
472  vtkGetMacro(OutputDimensionality, int);
474 
479  vtkMTimeType GetMTime() override;
480 
485 
487 
495  void SetInterpolate(int t)
496  {
497  if (t && !this->GetInterpolate())
498  {
499  this->SetInterpolationModeToLinear();
500  }
501  else if (!t && this->GetInterpolate())
502  {
503  this->SetInterpolationModeToNearestNeighbor();
504  }
505  }
506  void InterpolateOn() { this->SetInterpolate(1); }
507  void InterpolateOff() { this->SetInterpolate(0); }
508  int GetInterpolate() { return (this->GetInterpolationMode() != VTK_RESLICE_NEAREST); }
510 
512 
520 
522 
526  vtkSetMacro(GenerateStencilOutput, vtkTypeBool);
527  vtkGetMacro(GenerateStencilOutput, vtkTypeBool);
528  vtkBooleanMacro(GenerateStencilOutput, vtkTypeBool);
530 
532 
539 
540 protected:
542  ~vtkImageReslice() override;
543 
545  double ResliceAxesDirectionCosines[9];
546  double ResliceAxesOrigin[3];
555  int SlabMode;
559  double ScalarShift;
560  double ScalarScale;
562  double BackgroundColor[4];
563  double OutputOrigin[3];
564  double OutputSpacing[3];
565  int OutputExtent[6];
576 
579 
585 
590  virtual int ConvertScalarInfo(int& scalarType, int& numComponents);
591 
600  virtual void ConvertScalars(void* inPtr, void* outPtr, int inputType, int inputNumComponents,
601  int count, int idX, int idY, int idZ, int threadId);
602 
603  void ConvertScalarsBase(void* inPtr, void* outPtr, int inputType, int inputNumComponents,
604  int count, int idX, int idY, int idZ, int threadId)
605  {
606  this->ConvertScalars(
607  inPtr, outPtr, inputType, inputNumComponents, count, idX, idY, idZ, threadId);
608  }
609 
616 
617  void GetAutoCroppedOutputBounds(vtkInformation* inInfo, double bounds[6]);
618  void AllocateOutputData(vtkImageData* output, vtkInformation* outInfo, int* uExtent) override;
624  vtkInformationVector* outputVector, vtkImageData*** inData, vtkImageData** outData, int ext[6],
625  int id) override;
628 
630  vtkAbstractTransform* GetOptimizedTransform() { return this->OptimizedTransform; }
631 
632 private:
633  vtkImageReslice(const vtkImageReslice&) = delete;
634  void operator=(const vtkImageReslice&) = delete;
635 };
636 
637 #endif
interpolate data values from images
superclass for all geometric transformations
Proxy object to connect input/output ports.
vtkAlgorithmOutput * GetOutputPort()
Definition: vtkAlgorithm.h:529
general representation of visualization data
Detect and break reference loops.
topologically and geometrically regular array of data
Definition: vtkImageData.h:163
Reslices a volume along a new set of axes.
void InterpolateOff()
Convenient methods for switching between nearest-neighbor and linear interpolation.
int HasConvertScalars
This should be set to 1 by derived classes that override the ConvertScalars method.
void SetResliceAxesDirectionCosines(const double x[3], const double y[3], const double z[3])
Specify the direction cosines for the ResliceAxes (i.e.
virtual void SetOutputOrigin(const double a[3])
Set the origin for the output data.
void PrintSelf(ostream &os, vtkIndent indent) override
Methods invoked by print to print information about the object including superclasses.
void ReportReferences(vtkGarbageCollector *) override
Report object referenced by instances of this class.
int FillInputPortInformation(int port, vtkInformation *info) override
These method should be reimplemented by subclasses that have more than a single input or single outpu...
double * GetResliceAxesOrigin()
Specify the origin for the ResliceAxes (i.e.
virtual void SetOutputExtent(int a, int b, int c, int d, int e, int f)
Set the extent for the output data.
void SetResliceAxesDirectionCosines(const double xyz[9])
Specify the direction cosines for the ResliceAxes (i.e.
virtual const char * GetInterpolationModeAsString()
vtkTypeBool Wrap
vtkTypeBool TransformInputSampling
void GetAutoCroppedOutputBounds(vtkInformation *inInfo, double bounds[6])
virtual void SetResliceTransform(vtkAbstractTransform *)
Set a transform to be applied to the resampling grid that has been defined via the ResliceAxes and th...
vtkTypeBool Border
int RequestInformationBase(vtkInformationVector **, vtkInformationVector *)
For derived classes, this should be called at the very end of RequestInformation() to ensure that var...
void SetResliceAxesDirectionCosines(double x0, double x1, double x2, double y0, double y1, double y2, double z0, double z1, double z2)
Specify the direction cosines for the ResliceAxes (i.e.
static vtkImageReslice * New()
void SetSlabModeToMean()
Set the slab mode, for generating thick slices.
void InterpolateOn()
Convenient methods for switching between nearest-neighbor and linear interpolation.
void SetResliceAxesOrigin(double x, double y, double z)
Specify the origin for the ResliceAxes (i.e.
void SetResliceAxesOrigin(const double xyz[3])
Specify the origin for the ResliceAxes (i.e.
virtual void ConvertScalars(void *inPtr, void *outPtr, int inputType, int inputNumComponents, int count, int idX, int idY, int idZ, int threadId)
This should be overridden by derived classes that operate on the interpolated data before it is place...
void GetResliceAxesDirectionCosines(double xyz[9])
Specify the direction cosines for the ResliceAxes (i.e.
virtual void SetOutputExtent(const int a[6])
Set the extent for the output data.
virtual void SetOutputOrigin(double x, double y, double z)
Set the origin for the output data.
vtkTypeBool Optimization
int RequestInformation(vtkInformation *, vtkInformationVector **, vtkInformationVector *) override
Subclasses can reimplement this method to collect information from their inputs and set information f...
void SetOutputSpacingToDefault()
Set the voxel spacing for the output data.
void SetStencilOutput(vtkImageStencilData *stencil)
Get the output stencil.
void ThreadedRequestData(vtkInformation *request, vtkInformationVector **inputVector, vtkInformationVector *outputVector, vtkImageData ***inData, vtkImageData **outData, int ext[6], int id) override
If the subclass does not define an Execute method, then the task will be broken up,...
double * GetResliceAxesDirectionCosines()
Specify the direction cosines for the ResliceAxes (i.e.
void SetInterpolationModeToCubic()
vtkAlgorithmOutput * GetStencilOutputPort()
Get the output stencil.
int RequestUpdateExtent(vtkInformation *, vtkInformationVector **, vtkInformationVector *) override
Subclasses can reimplement this method to translate the update extent requests from each output port ...
double SlabSliceSpacingFraction
vtkTypeBool Mirror
int GetInterpolate()
Convenient methods for switching between nearest-neighbor and linear interpolation.
void GetResliceAxesOrigin(double xyz[3])
Specify the origin for the ResliceAxes (i.e.
void SetSlabModeToMin()
Set the slab mode, for generating thick slices.
vtkImageStencilData * GetStencilOutput()
Get the output stencil.
virtual void SetOutputSpacing(const double a[3])
Set the voxel spacing for the output data.
double GetBackgroundLevel()
Set background grey level (for single-component images).
vtkImageStencilData * GetStencil()
Use a stencil to limit the calculations to a specific region of the output.
virtual int ConvertScalarInfo(int &scalarType, int &numComponents)
This should be overridden by derived classes that operate on the interpolated data before it is place...
~vtkImageReslice() override
void AllocateOutputData(vtkImageData *output, vtkInformation *outInfo, int *uExtent) override
Allocate the output data.
void SetSlabModeToMax()
Set the slab mode, for generating thick slices.
vtkAbstractTransform * OptimizedTransform
vtkTypeBool SlabTrapezoidIntegration
vtkMatrix4x4 * IndexMatrix
vtkMTimeType GetMTime() override
When determining the modified time of the filter, this check the modified time of the transform and m...
vtkTypeBool AutoCropOutput
vtkTypeBool GenerateStencilOutput
virtual const char * GetSlabModeAsString()
Set the slab mode, for generating thick slices.
vtkMatrix4x4 * ResliceAxes
vtkAbstractTransform * GetOptimizedTransform()
virtual void SetOutputSpacing(double x, double y, double z)
Set the voxel spacing for the output data.
int RequestData(vtkInformation *, vtkInformationVector **, vtkInformationVector *) override
This is called by the superclass.
void ConvertScalarsBase(void *inPtr, void *outPtr, int inputType, int inputNumComponents, int count, int idX, int idY, int idZ, int threadId)
vtkAbstractTransform * ResliceTransform
virtual void SetInterpolator(vtkAbstractImageInterpolator *sampler)
Set the interpolator to use.
virtual void SetResliceAxes(vtkMatrix4x4 *)
This method is used to set up the axes for the output voxels.
vtkAbstractImageInterpolator * Interpolator
virtual vtkAbstractImageInterpolator * GetInterpolator()
Set the interpolator to use.
void SetInterpolationModeToNearestNeighbor()
vtkMatrix4x4 * GetIndexMatrix(vtkInformation *inInfo, vtkInformation *outInfo)
void SetOutputExtentToDefault()
Set the extent for the output data.
void SetInterpolate(int t)
Convenient methods for switching between nearest-neighbor and linear interpolation.
void GetResliceAxesDirectionCosines(double x[3], double y[3], double z[3])
Specify the direction cosines for the ResliceAxes (i.e.
vtkImageData * InformationInput
vtkImageData * AllocateOutputData(vtkDataObject *, vtkInformation *) override
Allocate the output data.
void SetBackgroundLevel(double v)
Set background grey level (for single-component images).
void SetOutputOriginToDefault()
Set the origin for the output data.
virtual void SetInformationInput(vtkImageData *)
Set a vtkImageData from which the default Spacing, Origin, and WholeExtent of the output will be copi...
void SetInterpolationModeToLinear()
int FillOutputPortInformation(int port, vtkInformation *info) override
These method should be reimplemented by subclasses that have more than a single input or single outpu...
void SetStencilData(vtkImageStencilData *stencil)
Use a stencil to limit the calculations to a specific region of the output.
void SetSlabModeToSum()
Set the slab mode, for generating thick slices.
efficient description of an image stencil
a simple class to control print indentation
Definition: vtkIndent.h:119
Store zero or more vtkInformation instances.
Store vtkAlgorithm input/output information.
represent and manipulate 4x4 transformation matrices
Definition: vtkMatrix4x4.h:151
Superclass for mapping scalar values to colors.
Generic filter that has one input.
@ info
Definition: vtkX3D.h:382
@ port
Definition: vtkX3D.h:453
int vtkTypeBool
Definition: vtkABI.h:69
#define VTK_RESLICE_CUBIC
#define VTK_RESLICE_NEAREST
#define VTK_RESLICE_LINEAR
#define VTK_IMAGE_SLAB_MAX
#define VTK_IMAGE_SLAB_MIN
#define VTK_IMAGE_SLAB_SUM
#define VTK_IMAGE_SLAB_MEAN
vtkTypeUInt32 vtkMTimeType
Definition: vtkType.h:287
#define VTK_SIZEHINT(...)