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=========================================================================*/
91#ifndef vtkImageReslice_h
92#define vtkImageReslice_h
93
94#include "vtkImagingCoreModule.h" // For export macro
96
97// interpolation mode constants
98#define VTK_RESLICE_NEAREST VTK_NEAREST_INTERPOLATION
99#define VTK_RESLICE_LINEAR VTK_LINEAR_INTERPOLATION
100#define VTK_RESLICE_CUBIC VTK_CUBIC_INTERPOLATION
101
102class vtkImageData;
104class vtkMatrix4x4;
108
109class VTKIMAGINGCORE_EXPORT vtkImageReslice : public vtkThreadedImageAlgorithm
110{
111public:
114
115 void PrintSelf(ostream& os, vtkIndent indent) override;
116
118
134 vtkGetObjectMacro(ResliceAxes, vtkMatrix4x4);
136
138
144 void SetResliceAxesDirectionCosines(double x0, double x1, double x2, double y0, double y1,
145 double y2, double z0, double z1, double z2);
146 void SetResliceAxesDirectionCosines(const double x[3], const double y[3], const double z[3])
147 {
148 this->SetResliceAxesDirectionCosines(x[0], x[1], x[2], y[0], y[1], y[2], z[0], z[1], z[2]);
149 }
150 void SetResliceAxesDirectionCosines(const double xyz[9])
151 {
152 this->SetResliceAxesDirectionCosines(
153 xyz[0], xyz[1], xyz[2], xyz[3], xyz[4], xyz[5], xyz[6], xyz[7], xyz[8]);
154 }
155 void GetResliceAxesDirectionCosines(double x[3], double y[3], double z[3]);
157 {
158 this->GetResliceAxesDirectionCosines(&xyz[0], &xyz[3], &xyz[6]);
159 }
161 {
162 this->GetResliceAxesDirectionCosines(this->ResliceAxesDirectionCosines);
163 return this->ResliceAxesDirectionCosines;
164 }
166
168
174 void SetResliceAxesOrigin(double x, double y, double z);
175 void SetResliceAxesOrigin(const double xyz[3])
176 {
177 this->SetResliceAxesOrigin(xyz[0], xyz[1], xyz[2]);
178 }
179 void GetResliceAxesOrigin(double xyz[3]);
181 {
182 this->GetResliceAxesOrigin(this->ResliceAxesOrigin);
183 return this->ResliceAxesOrigin;
184 }
186
188
198 vtkGetObjectMacro(ResliceTransform, vtkAbstractTransform);
200
202
212 vtkGetObjectMacro(InformationInput, vtkImageData);
214
216
223 vtkSetMacro(TransformInputSampling, vtkTypeBool);
224 vtkBooleanMacro(TransformInputSampling, vtkTypeBool);
225 vtkGetMacro(TransformInputSampling, vtkTypeBool);
227
229
234 vtkSetMacro(AutoCropOutput, vtkTypeBool);
235 vtkBooleanMacro(AutoCropOutput, vtkTypeBool);
236 vtkGetMacro(AutoCropOutput, vtkTypeBool);
238
240
243 vtkSetMacro(Wrap, vtkTypeBool);
244 vtkGetMacro(Wrap, vtkTypeBool);
245 vtkBooleanMacro(Wrap, vtkTypeBool);
247
249
253 vtkSetMacro(Mirror, vtkTypeBool);
254 vtkGetMacro(Mirror, vtkTypeBool);
255 vtkBooleanMacro(Mirror, vtkTypeBool);
257
259
269 vtkSetMacro(Border, vtkTypeBool);
270 vtkGetMacro(Border, vtkTypeBool);
271 vtkBooleanMacro(Border, vtkTypeBool);
273
275
280 vtkSetMacro(BorderThickness, double);
281 vtkGetMacro(BorderThickness, double);
283
287 vtkSetClampMacro(InterpolationMode, int, VTK_RESLICE_NEAREST, VTK_RESLICE_CUBIC);
288 vtkGetMacro(InterpolationMode, int);
289 void SetInterpolationModeToNearestNeighbor() { this->SetInterpolationMode(VTK_RESLICE_NEAREST); }
290 void SetInterpolationModeToLinear() { this->SetInterpolationMode(VTK_RESLICE_LINEAR); }
291 void SetInterpolationModeToCubic() { this->SetInterpolationMode(VTK_RESLICE_CUBIC); }
292 virtual const char* GetInterpolationModeAsString();
294
296
303
305
311 vtkSetClampMacro(SlabMode, int, VTK_IMAGE_SLAB_MIN, VTK_IMAGE_SLAB_SUM);
312 vtkGetMacro(SlabMode, int);
313 void SetSlabModeToMin() { this->SetSlabMode(VTK_IMAGE_SLAB_MIN); }
314 void SetSlabModeToMax() { this->SetSlabMode(VTK_IMAGE_SLAB_MAX); }
315 void SetSlabModeToMean() { this->SetSlabMode(VTK_IMAGE_SLAB_MEAN); }
316 void SetSlabModeToSum() { this->SetSlabMode(VTK_IMAGE_SLAB_SUM); }
317 virtual const char* GetSlabModeAsString();
319
321
324 vtkSetMacro(SlabNumberOfSlices, int);
325 vtkGetMacro(SlabNumberOfSlices, int);
327
329
334 vtkSetMacro(SlabTrapezoidIntegration, vtkTypeBool);
335 vtkBooleanMacro(SlabTrapezoidIntegration, vtkTypeBool);
336 vtkGetMacro(SlabTrapezoidIntegration, vtkTypeBool);
338
340
349 vtkSetMacro(SlabSliceSpacingFraction, double);
350 vtkGetMacro(SlabSliceSpacingFraction, double);
352
354
358 vtkSetMacro(Optimization, vtkTypeBool);
359 vtkGetMacro(Optimization, vtkTypeBool);
360 vtkBooleanMacro(Optimization, vtkTypeBool);
362
364
371 vtkSetMacro(ScalarShift, double);
372 vtkGetMacro(ScalarShift, double);
374
376
383 vtkSetMacro(ScalarScale, double);
384 vtkGetMacro(ScalarScale, double);
386
388
398 vtkSetMacro(OutputScalarType, int);
399 vtkGetMacro(OutputScalarType, int);
401
403
406 vtkSetVector4Macro(BackgroundColor, double);
407 vtkGetVector4Macro(BackgroundColor, double);
409
411
414 void SetBackgroundLevel(double v) { this->SetBackgroundColor(v, v, v, v); }
415 double GetBackgroundLevel() { return this->GetBackgroundColor()[0]; }
417
419
423 virtual void SetOutputSpacing(double x, double y, double z);
424 virtual void SetOutputSpacing(const double a[3]) { this->SetOutputSpacing(a[0], a[1], a[2]); }
425 vtkGetVector3Macro(OutputSpacing, double);
428
430
434 virtual void SetOutputOrigin(double x, double y, double z);
435 virtual void SetOutputOrigin(const double a[3]) { this->SetOutputOrigin(a[0], a[1], a[2]); }
436 vtkGetVector3Macro(OutputOrigin, double);
439
441
445 virtual void SetOutputExtent(int a, int b, int c, int d, int e, int f);
446 virtual void SetOutputExtent(const int a[6])
447 {
448 this->SetOutputExtent(a[0], a[1], a[2], a[3], a[4], a[5]);
449 }
450 vtkGetVector6Macro(OutputExtent, int);
453
455
465 vtkSetMacro(OutputDimensionality, int);
466 vtkGetMacro(OutputDimensionality, int);
468
474
479
481
489 void SetInterpolate(int t)
490 {
491 if (t && !this->GetInterpolate())
492 {
493 this->SetInterpolationModeToLinear();
494 }
495 else if (!t && this->GetInterpolate())
496 {
497 this->SetInterpolationModeToNearestNeighbor();
498 }
499 }
500 void InterpolateOn() { this->SetInterpolate(1); }
501 void InterpolateOff() { this->SetInterpolate(0); }
502 int GetInterpolate() { return (this->GetInterpolationMode() != VTK_RESLICE_NEAREST); }
504
506
514
516
520 vtkSetMacro(GenerateStencilOutput, vtkTypeBool);
521 vtkGetMacro(GenerateStencilOutput, vtkTypeBool);
522 vtkBooleanMacro(GenerateStencilOutput, vtkTypeBool);
524
526
533
534protected:
537
539 double ResliceAxesDirectionCosines[9];
540 double ResliceAxesOrigin[3];
556 double BackgroundColor[4];
557 double OutputOrigin[3];
558 double OutputSpacing[3];
559 int OutputExtent[6];
570
573
579
584 virtual int ConvertScalarInfo(int& scalarType, int& numComponents);
585
594 virtual void ConvertScalars(void* inPtr, void* outPtr, int inputType, int inputNumComponents,
595 int count, int idX, int idY, int idZ, int threadId);
596
597 void ConvertScalarsBase(void* inPtr, void* outPtr, int inputType, int inputNumComponents,
598 int count, int idX, int idY, int idZ, int threadId)
599 {
600 this->ConvertScalars(
601 inPtr, outPtr, inputType, inputNumComponents, count, idX, idY, idZ, threadId);
602 }
603
610
611 void GetAutoCroppedOutputBounds(vtkInformation* inInfo, double bounds[6]);
612 void AllocateOutputData(vtkImageData* output, vtkInformation* outInfo, int* uExtent) override;
618 vtkInformationVector* outputVector, vtkImageData*** inData, vtkImageData** outData, int ext[6],
619 int id) override;
620 int FillInputPortInformation(int port, vtkInformation* info) override;
621 int FillOutputPortInformation(int port, vtkInformation* info) override;
622
624 vtkAbstractTransform* GetOptimizedTransform() { return this->OptimizedTransform; }
625
626private:
627 vtkImageReslice(const vtkImageReslice&) = delete;
628 void operator=(const vtkImageReslice&) = delete;
629};
630
631#endif
interpolate data values from images
superclass for all geometric transformations
Proxy object to connect input/output ports.
vtkAlgorithmOutput * GetOutputPort()
Definition: vtkAlgorithm.h:538
general representation of visualization data
Detect and break reference loops.
topologically and geometrically regular array of data
Definition: vtkImageData.h:157
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:113
Store zero or more vtkInformation instances.
Store vtkAlgorithm input/output information.
represent and manipulate 4x4 transformation matrices
Definition: vtkMatrix4x4.h:145
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(...)