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=========================================================================*/
58#ifndef vtkImageReslice_h
59#define vtkImageReslice_h
60
61#include "vtkImagingCoreModule.h" // For export macro
63
64// interpolation mode constants
65#define VTK_RESLICE_NEAREST VTK_NEAREST_INTERPOLATION
66#define VTK_RESLICE_LINEAR VTK_LINEAR_INTERPOLATION
67#define VTK_RESLICE_CUBIC VTK_CUBIC_INTERPOLATION
68
69class vtkImageData;
71class vtkMatrix4x4;
75
76class VTKIMAGINGCORE_EXPORT vtkImageReslice : public vtkThreadedImageAlgorithm
77{
78public:
81
82 void PrintSelf(ostream& os, vtkIndent indent) override;
83
85
101 vtkGetObjectMacro(ResliceAxes, vtkMatrix4x4);
103
105
111 void SetResliceAxesDirectionCosines(double x0, double x1, double x2, double y0, double y1,
112 double y2, double z0, double z1, double z2);
113 void SetResliceAxesDirectionCosines(const double x[3], const double y[3], const double z[3])
114 {
115 this->SetResliceAxesDirectionCosines(x[0], x[1], x[2], y[0], y[1], y[2], z[0], z[1], z[2]);
116 }
117 void SetResliceAxesDirectionCosines(const double xyz[9])
118 {
119 this->SetResliceAxesDirectionCosines(
120 xyz[0], xyz[1], xyz[2], xyz[3], xyz[4], xyz[5], xyz[6], xyz[7], xyz[8]);
121 }
122 void GetResliceAxesDirectionCosines(double x[3], double y[3], double z[3]);
124 {
125 this->GetResliceAxesDirectionCosines(&xyz[0], &xyz[3], &xyz[6]);
126 }
128 {
129 this->GetResliceAxesDirectionCosines(this->ResliceAxesDirectionCosines);
130 return this->ResliceAxesDirectionCosines;
131 }
133
135
141 void SetResliceAxesOrigin(double x, double y, double z);
142 void SetResliceAxesOrigin(const double xyz[3])
143 {
144 this->SetResliceAxesOrigin(xyz[0], xyz[1], xyz[2]);
145 }
146 void GetResliceAxesOrigin(double xyz[3]);
148 {
149 this->GetResliceAxesOrigin(this->ResliceAxesOrigin);
150 return this->ResliceAxesOrigin;
151 }
153
155
165 vtkGetObjectMacro(ResliceTransform, vtkAbstractTransform);
167
169
179 vtkGetObjectMacro(InformationInput, vtkImageData);
181
183
190 vtkSetMacro(TransformInputSampling, vtkTypeBool);
191 vtkBooleanMacro(TransformInputSampling, vtkTypeBool);
192 vtkGetMacro(TransformInputSampling, vtkTypeBool);
194
196
201 vtkSetMacro(AutoCropOutput, vtkTypeBool);
202 vtkBooleanMacro(AutoCropOutput, vtkTypeBool);
203 vtkGetMacro(AutoCropOutput, vtkTypeBool);
205
207
210 vtkSetMacro(Wrap, vtkTypeBool);
211 vtkGetMacro(Wrap, vtkTypeBool);
212 vtkBooleanMacro(Wrap, vtkTypeBool);
214
216
220 vtkSetMacro(Mirror, vtkTypeBool);
221 vtkGetMacro(Mirror, vtkTypeBool);
222 vtkBooleanMacro(Mirror, vtkTypeBool);
224
226
236 vtkSetMacro(Border, vtkTypeBool);
237 vtkGetMacro(Border, vtkTypeBool);
238 vtkBooleanMacro(Border, vtkTypeBool);
240
242
247 vtkSetMacro(BorderThickness, double);
248 vtkGetMacro(BorderThickness, double);
250
254 vtkSetClampMacro(InterpolationMode, int, VTK_RESLICE_NEAREST, VTK_RESLICE_CUBIC);
255 vtkGetMacro(InterpolationMode, int);
256 void SetInterpolationModeToNearestNeighbor() { this->SetInterpolationMode(VTK_RESLICE_NEAREST); }
257 void SetInterpolationModeToLinear() { this->SetInterpolationMode(VTK_RESLICE_LINEAR); }
258 void SetInterpolationModeToCubic() { this->SetInterpolationMode(VTK_RESLICE_CUBIC); }
259 virtual const char* GetInterpolationModeAsString();
261
263
270
272
278 vtkSetClampMacro(SlabMode, int, VTK_IMAGE_SLAB_MIN, VTK_IMAGE_SLAB_SUM);
279 vtkGetMacro(SlabMode, int);
280 void SetSlabModeToMin() { this->SetSlabMode(VTK_IMAGE_SLAB_MIN); }
281 void SetSlabModeToMax() { this->SetSlabMode(VTK_IMAGE_SLAB_MAX); }
282 void SetSlabModeToMean() { this->SetSlabMode(VTK_IMAGE_SLAB_MEAN); }
283 void SetSlabModeToSum() { this->SetSlabMode(VTK_IMAGE_SLAB_SUM); }
284 virtual const char* GetSlabModeAsString();
286
288
291 vtkSetMacro(SlabNumberOfSlices, int);
292 vtkGetMacro(SlabNumberOfSlices, int);
294
296
301 vtkSetMacro(SlabTrapezoidIntegration, vtkTypeBool);
302 vtkBooleanMacro(SlabTrapezoidIntegration, vtkTypeBool);
303 vtkGetMacro(SlabTrapezoidIntegration, vtkTypeBool);
305
307
316 vtkSetMacro(SlabSliceSpacingFraction, double);
317 vtkGetMacro(SlabSliceSpacingFraction, double);
319
321
325 vtkSetMacro(Optimization, vtkTypeBool);
326 vtkGetMacro(Optimization, vtkTypeBool);
327 vtkBooleanMacro(Optimization, vtkTypeBool);
329
331
338 vtkSetMacro(ScalarShift, double);
339 vtkGetMacro(ScalarShift, double);
341
343
350 vtkSetMacro(ScalarScale, double);
351 vtkGetMacro(ScalarScale, double);
353
355
365 vtkSetMacro(OutputScalarType, int);
366 vtkGetMacro(OutputScalarType, int);
368
370
373 vtkSetVector4Macro(BackgroundColor, double);
374 vtkGetVector4Macro(BackgroundColor, double);
376
378
381 void SetBackgroundLevel(double v) { this->SetBackgroundColor(v, v, v, v); }
382 double GetBackgroundLevel() { return this->GetBackgroundColor()[0]; }
384
386
390 virtual void SetOutputSpacing(double x, double y, double z);
391 virtual void SetOutputSpacing(const double a[3]) { this->SetOutputSpacing(a[0], a[1], a[2]); }
392 vtkGetVector3Macro(OutputSpacing, double);
395
397
401 virtual void SetOutputOrigin(double x, double y, double z);
402 virtual void SetOutputOrigin(const double a[3]) { this->SetOutputOrigin(a[0], a[1], a[2]); }
403 vtkGetVector3Macro(OutputOrigin, double);
406
408
412 virtual void SetOutputExtent(int a, int b, int c, int d, int e, int f);
413 virtual void SetOutputExtent(const int a[6])
414 {
415 this->SetOutputExtent(a[0], a[1], a[2], a[3], a[4], a[5]);
416 }
417 vtkGetVector6Macro(OutputExtent, int);
420
422
432 vtkSetMacro(OutputDimensionality, int);
433 vtkGetMacro(OutputDimensionality, int);
435
441
446
448
456 void SetInterpolate(int t)
457 {
458 if (t && !this->GetInterpolate())
459 {
460 this->SetInterpolationModeToLinear();
461 }
462 else if (!t && this->GetInterpolate())
463 {
464 this->SetInterpolationModeToNearestNeighbor();
465 }
466 }
467 void InterpolateOn() { this->SetInterpolate(1); }
468 void InterpolateOff() { this->SetInterpolate(0); }
469 int GetInterpolate() { return (this->GetInterpolationMode() != VTK_RESLICE_NEAREST); }
471
473
481
483
487 vtkSetMacro(GenerateStencilOutput, vtkTypeBool);
488 vtkGetMacro(GenerateStencilOutput, vtkTypeBool);
489 vtkBooleanMacro(GenerateStencilOutput, vtkTypeBool);
491
493
500
501protected:
504
506 double ResliceAxesDirectionCosines[9];
507 double ResliceAxesOrigin[3];
523 double BackgroundColor[4];
524 double OutputOrigin[3];
525 double OutputSpacing[3];
526 int OutputExtent[6];
537
540
546
551 virtual int ConvertScalarInfo(int& scalarType, int& numComponents);
552
561 virtual void ConvertScalars(void* inPtr, void* outPtr, int inputType, int inputNumComponents,
562 int count, int idX, int idY, int idZ, int threadId);
563
564 void ConvertScalarsBase(void* inPtr, void* outPtr, int inputType, int inputNumComponents,
565 int count, int idX, int idY, int idZ, int threadId)
566 {
567 this->ConvertScalars(
568 inPtr, outPtr, inputType, inputNumComponents, count, idX, idY, idZ, threadId);
569 }
570
577
578 void GetAutoCroppedOutputBounds(vtkInformation* inInfo, double bounds[6]);
579 void AllocateOutputData(vtkImageData* output, vtkInformation* outInfo, int* uExtent) override;
585 vtkInformationVector* outputVector, vtkImageData*** inData, vtkImageData** outData, int ext[6],
586 int id) override;
587 int FillInputPortInformation(int port, vtkInformation* info) override;
588 int FillOutputPortInformation(int port, vtkInformation* info) override;
589
591 vtkAbstractTransform* GetOptimizedTransform() { return this->OptimizedTransform; }
592
593private:
594 vtkImageReslice(const vtkImageReslice&) = delete;
595 void operator=(const vtkImageReslice&) = delete;
596};
597
598#endif
interpolate data values from images
superclass for all geometric transformations
Proxy object to connect input/output ports.
vtkAlgorithmOutput * GetOutputPort()
Definition: vtkAlgorithm.h:470
general representation of visualization data
Definition: vtkDataObject.h:66
Detect and break reference loops.
topologically and geometrically regular array of data
Definition: vtkImageData.h:54
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:40
Store zero or more vtkInformation instances.
Store vtkAlgorithm input/output information.
represent and manipulate 4x4 transformation matrices
Definition: vtkMatrix4x4.h:42
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(...)