VTK  9.1.0
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
63class vtkImageData;
65class vtkMatrix4x4;
69
70class VTKIMAGINGCORE_EXPORT vtkImageReslice : public vtkThreadedImageAlgorithm
71{
72public:
75
76 void PrintSelf(ostream& os, vtkIndent indent) override;
77
79
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]);
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
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
495protected:
498
500 double ResliceAxesDirectionCosines[9];
501 double ResliceAxesOrigin[3];
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
571
572 void GetAutoCroppedOutputBounds(vtkInformation* inInfo, double bounds[6]);
573 void AllocateOutputData(vtkImageData* output, vtkInformation* outInfo, int* uExtent) override;
579 vtkInformationVector* outputVector, vtkImageData*** inData, vtkImageData** outData, int ext[6],
580 int id) override;
581 int FillInputPortInformation(int port, vtkInformation* info) override;
582 int FillOutputPortInformation(int port, vtkInformation* info) override;
583
585 vtkAbstractTransform* GetOptimizedTransform() { return this->OptimizedTransform; }
586
587private:
588 vtkImageReslice(const vtkImageReslice&) = delete;
589 void operator=(const vtkImageReslice&) = delete;
590};
591
592#endif
interpolate data values from images
superclass for all geometric transformations
Proxy object to connect input/output ports.
vtkAlgorithmOutput * GetOutputPort()
Definition: vtkAlgorithm.h:479
general representation of visualization data
Definition: vtkDataObject.h:60
Detect and break reference loops.
topologically and geometrically regular array of data
Definition: vtkImageData.h:48
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.
vtkImageStencilData * GetStencil()
Use a stencil to limit the calculations to a specific region of the output.
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...
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.
vtkTypeBool Wrap
vtkTypeBool TransformInputSampling
double * GetResliceAxesOrigin()
Specify the origin for the ResliceAxes (i.e.
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...
virtual const char * GetInterpolationModeAsString()
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.
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,...
vtkImageStencilData * GetStencilOutput()
Get the output stencil.
virtual vtkAbstractImageInterpolator * GetInterpolator()
Set the interpolator to use.
void SetInterpolationModeToCubic()
int RequestUpdateExtent(vtkInformation *, vtkInformationVector **, vtkInformationVector *) override
Subclasses can reimplement this method to translate the update extent requests from each output port ...
double SlabSliceSpacingFraction
vtkImageData * AllocateOutputData(vtkDataObject *, vtkInformation *) override
Allocate the output data.
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.
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).
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
vtkMatrix4x4 * ResliceAxes
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.
static vtkImageReslice * New()
void ConvertScalarsBase(void *inPtr, void *outPtr, int inputType, int inputNumComponents, int count, int idX, int idY, int idZ, int threadId)
double * GetResliceAxesDirectionCosines()
Specify the direction cosines for the ResliceAxes (i.e.
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
vtkAlgorithmOutput * GetStencilOutputPort()
Get the output stencil.
void SetInterpolationModeToNearestNeighbor()
void SetOutputExtentToDefault()
Set the extent for the output data.
virtual const char * GetSlabModeAsString()
Set the slab mode, for generating thick slices.
void SetInterpolate(int t)
Convenient methods for switching between nearest-neighbor and linear interpolation.
vtkAbstractTransform * GetOptimizedTransform()
void GetResliceAxesDirectionCosines(double x[3], double y[3], double z[3])
Specify the direction cosines for the ResliceAxes (i.e.
vtkMatrix4x4 * GetIndexMatrix(vtkInformation *inInfo, vtkInformation *outInfo)
vtkImageData * InformationInput
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: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.
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(...)