VTK  9.0.1
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 =========================================================================*/
52 #ifndef vtkImageReslice_h
53 #define vtkImageReslice_h
54 
55 #include "vtkImagingCoreModule.h" // For export macro
57 
58 // interpolation mode constants
59 #define VTK_RESLICE_NEAREST VTK_NEAREST_INTERPOLATION
60 #define VTK_RESLICE_LINEAR VTK_LINEAR_INTERPOLATION
61 #define VTK_RESLICE_CUBIC VTK_CUBIC_INTERPOLATION
62 
63 class vtkImageData;
65 class vtkMatrix4x4;
67 class vtkScalarsToColors;
69 
70 class VTKIMAGINGCORE_EXPORT vtkImageReslice : public vtkThreadedImageAlgorithm
71 {
72 public:
73  static vtkImageReslice* New();
75 
76  void PrintSelf(ostream& os, vtkIndent indent) override;
77 
79 
94  virtual void SetResliceAxes(vtkMatrix4x4*);
95  vtkGetObjectMacro(ResliceAxes, vtkMatrix4x4);
97 
99 
105  void SetResliceAxesDirectionCosines(double x0, double x1, double x2, double y0, double y1,
106  double y2, double z0, double z1, double z2);
107  void SetResliceAxesDirectionCosines(const double x[3], const double y[3], const double z[3])
108  {
109  this->SetResliceAxesDirectionCosines(x[0], x[1], x[2], y[0], y[1], y[2], z[0], z[1], z[2]);
110  }
111  void SetResliceAxesDirectionCosines(const double xyz[9])
112  {
113  this->SetResliceAxesDirectionCosines(
114  xyz[0], xyz[1], xyz[2], xyz[3], xyz[4], xyz[5], xyz[6], xyz[7], xyz[8]);
115  }
116  void GetResliceAxesDirectionCosines(double x[3], double y[3], double z[3]);
117  void GetResliceAxesDirectionCosines(double xyz[9])
118  {
119  this->GetResliceAxesDirectionCosines(&xyz[0], &xyz[3], &xyz[6]);
120  }
122  {
123  this->GetResliceAxesDirectionCosines(this->ResliceAxesDirectionCosines);
124  return this->ResliceAxesDirectionCosines;
125  }
127 
129 
135  void SetResliceAxesOrigin(double x, double y, double z);
136  void SetResliceAxesOrigin(const double xyz[3])
137  {
138  this->SetResliceAxesOrigin(xyz[0], xyz[1], xyz[2]);
139  }
140  void GetResliceAxesOrigin(double xyz[3]);
142  {
143  this->GetResliceAxesOrigin(this->ResliceAxesOrigin);
144  return this->ResliceAxesOrigin;
145  }
147 
149 
159  vtkGetObjectMacro(ResliceTransform, vtkAbstractTransform);
161 
163 
173  vtkGetObjectMacro(InformationInput, vtkImageData);
175 
177 
184  vtkSetMacro(TransformInputSampling, vtkTypeBool);
185  vtkBooleanMacro(TransformInputSampling, vtkTypeBool);
186  vtkGetMacro(TransformInputSampling, vtkTypeBool);
188 
190 
195  vtkSetMacro(AutoCropOutput, vtkTypeBool);
196  vtkBooleanMacro(AutoCropOutput, vtkTypeBool);
197  vtkGetMacro(AutoCropOutput, vtkTypeBool);
199 
201 
204  vtkSetMacro(Wrap, vtkTypeBool);
205  vtkGetMacro(Wrap, vtkTypeBool);
206  vtkBooleanMacro(Wrap, vtkTypeBool);
208 
210 
214  vtkSetMacro(Mirror, vtkTypeBool);
215  vtkGetMacro(Mirror, vtkTypeBool);
216  vtkBooleanMacro(Mirror, vtkTypeBool);
218 
220 
230  vtkSetMacro(Border, vtkTypeBool);
231  vtkGetMacro(Border, vtkTypeBool);
232  vtkBooleanMacro(Border, vtkTypeBool);
234 
236 
241  vtkSetMacro(BorderThickness, double);
242  vtkGetMacro(BorderThickness, double);
244 
248  vtkSetClampMacro(InterpolationMode, int, VTK_RESLICE_NEAREST, VTK_RESLICE_CUBIC);
249  vtkGetMacro(InterpolationMode, int);
250  void SetInterpolationModeToNearestNeighbor() { this->SetInterpolationMode(VTK_RESLICE_NEAREST); }
251  void SetInterpolationModeToLinear() { this->SetInterpolationMode(VTK_RESLICE_LINEAR); }
252  void SetInterpolationModeToCubic() { this->SetInterpolationMode(VTK_RESLICE_CUBIC); }
253  virtual const char* GetInterpolationModeAsString();
255 
257 
264 
266 
272  vtkSetClampMacro(SlabMode, int, VTK_IMAGE_SLAB_MIN, VTK_IMAGE_SLAB_SUM);
273  vtkGetMacro(SlabMode, int);
274  void SetSlabModeToMin() { this->SetSlabMode(VTK_IMAGE_SLAB_MIN); }
275  void SetSlabModeToMax() { this->SetSlabMode(VTK_IMAGE_SLAB_MAX); }
276  void SetSlabModeToMean() { this->SetSlabMode(VTK_IMAGE_SLAB_MEAN); }
277  void SetSlabModeToSum() { this->SetSlabMode(VTK_IMAGE_SLAB_SUM); }
278  virtual const char* GetSlabModeAsString();
280 
282 
285  vtkSetMacro(SlabNumberOfSlices, int);
286  vtkGetMacro(SlabNumberOfSlices, int);
288 
290 
295  vtkSetMacro(SlabTrapezoidIntegration, vtkTypeBool);
296  vtkBooleanMacro(SlabTrapezoidIntegration, vtkTypeBool);
297  vtkGetMacro(SlabTrapezoidIntegration, vtkTypeBool);
299 
301 
310  vtkSetMacro(SlabSliceSpacingFraction, double);
311  vtkGetMacro(SlabSliceSpacingFraction, double);
313 
315 
319  vtkSetMacro(Optimization, vtkTypeBool);
320  vtkGetMacro(Optimization, vtkTypeBool);
321  vtkBooleanMacro(Optimization, vtkTypeBool);
323 
325 
332  vtkSetMacro(ScalarShift, double);
333  vtkGetMacro(ScalarShift, double);
335 
337 
344  vtkSetMacro(ScalarScale, double);
345  vtkGetMacro(ScalarScale, double);
347 
349 
359  vtkSetMacro(OutputScalarType, int);
360  vtkGetMacro(OutputScalarType, int);
362 
364 
367  vtkSetVector4Macro(BackgroundColor, double);
368  vtkGetVector4Macro(BackgroundColor, double);
370 
372 
375  void SetBackgroundLevel(double v) { this->SetBackgroundColor(v, v, v, v); }
376  double GetBackgroundLevel() { return this->GetBackgroundColor()[0]; }
378 
380 
384  virtual void SetOutputSpacing(double x, double y, double z);
385  virtual void SetOutputSpacing(const double a[3]) { this->SetOutputSpacing(a[0], a[1], a[2]); }
386  vtkGetVector3Macro(OutputSpacing, double);
389 
391 
395  virtual void SetOutputOrigin(double x, double y, double z);
396  virtual void SetOutputOrigin(const double a[3]) { this->SetOutputOrigin(a[0], a[1], a[2]); }
397  vtkGetVector3Macro(OutputOrigin, double);
400 
402 
406  virtual void SetOutputExtent(int a, int b, int c, int d, int e, int f);
407  virtual void SetOutputExtent(const int a[6])
408  {
409  this->SetOutputExtent(a[0], a[1], a[2], a[3], a[4], a[5]);
410  }
411  vtkGetVector6Macro(OutputExtent, int);
414 
416 
426  vtkSetMacro(OutputDimensionality, int);
427  vtkGetMacro(OutputDimensionality, int);
429 
434  vtkMTimeType GetMTime() override;
435 
440 
442 
450  void SetInterpolate(int t)
451  {
452  if (t && !this->GetInterpolate())
453  {
454  this->SetInterpolationModeToLinear();
455  }
456  else if (!t && this->GetInterpolate())
457  {
458  this->SetInterpolationModeToNearestNeighbor();
459  }
460  }
461  void InterpolateOn() { this->SetInterpolate(1); }
462  void InterpolateOff() { this->SetInterpolate(0); }
463  int GetInterpolate() { return (this->GetInterpolationMode() != VTK_RESLICE_NEAREST); }
465 
467 
475 
477 
481  vtkSetMacro(GenerateStencilOutput, vtkTypeBool);
482  vtkGetMacro(GenerateStencilOutput, vtkTypeBool);
483  vtkBooleanMacro(GenerateStencilOutput, vtkTypeBool);
485 
487 
494 
495 protected:
497  ~vtkImageReslice() override;
498 
500  double ResliceAxesDirectionCosines[9];
501  double ResliceAxesOrigin[3];
510  int SlabMode;
514  double ScalarShift;
515  double ScalarScale;
517  double BackgroundColor[4];
518  double OutputOrigin[3];
519  double OutputSpacing[3];
520  int OutputExtent[6];
531 
534 
540 
545  virtual int ConvertScalarInfo(int& scalarType, int& numComponents);
546 
555  virtual void ConvertScalars(void* inPtr, void* outPtr, int inputType, int inputNumComponents,
556  int count, int idX, int idY, int idZ, int threadId);
557 
558  void ConvertScalarsBase(void* inPtr, void* outPtr, int inputType, int inputNumComponents,
559  int count, int idX, int idY, int idZ, int threadId)
560  {
561  this->ConvertScalars(
562  inPtr, outPtr, inputType, inputNumComponents, count, idX, idY, idZ, threadId);
563  }
564 
565  void GetAutoCroppedOutputBounds(vtkInformation* inInfo, double bounds[6]);
566  void AllocateOutputData(vtkImageData* output, vtkInformation* outInfo, int* uExtent) override;
572  vtkInformationVector* outputVector, vtkImageData*** inData, vtkImageData** outData, int ext[6],
573  int id) override;
576 
578  vtkAbstractTransform* GetOptimizedTransform() { return this->OptimizedTransform; }
579 
580 private:
581  vtkImageReslice(const vtkImageReslice&) = delete;
582  void operator=(const vtkImageReslice&) = delete;
583 };
584 
585 #endif
interpolate data values from images
superclass for all geometric transformations
Proxy object to connect input/output ports.
vtkAlgorithmOutput * GetOutputPort()
Definition: vtkAlgorithm.h:477
general representation of visualization data
Definition: vtkDataObject.h:60
Detect and break reference loops.
topologically and geometrically regular array of data
Definition: vtkImageData.h:42
Reslices a volume along a new set of axes.
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])
virtual void SetOutputOrigin(const double a[3])
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
Fill the input port information objects for this algorithm.
double * GetResliceAxesOrigin()
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])
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
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 SetResliceAxesOrigin(double x, double y, double z)
Specify the origin for the ResliceAxes (i.e.
void SetResliceAxesOrigin(const double xyz[3])
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])
virtual void SetOutputExtent(const int a[6])
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()
void SetStencilOutput(vtkImageStencilData *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()
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
void GetResliceAxesOrigin(double xyz[3])
vtkImageStencilData * GetStencilOutput()
virtual void SetOutputSpacing(const double a[3])
double GetBackgroundLevel()
vtkImageStencilData * GetStencil()
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.
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()
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()
void SetInterpolationModeToNearestNeighbor()
vtkMatrix4x4 * GetIndexMatrix(vtkInformation *inInfo, vtkInformation *outInfo)
void SetOutputExtentToDefault()
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])
vtkImageData * InformationInput
vtkImageData * AllocateOutputData(vtkDataObject *, vtkInformation *) override
void SetBackgroundLevel(double v)
Set background grey level (for single-component images).
void SetOutputOriginToDefault()
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.
efficient description of an image stencil
a simple class to control print indentation
Definition: vtkIndent.h:34
Store zero or more vtkInformation instances.
Store vtkAlgorithm input/output information.
represent and manipulate 4x4 transformation matrices
Definition: vtkMatrix4x4.h:36
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:293
#define VTK_SIZEHINT(...)