VTK
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
62#include "vtkImagingCoreModule.h" // For export macro
64
65// interpolation mode constants
66#define VTK_RESLICE_NEAREST VTK_NEAREST_INTERPOLATION
67#define VTK_RESLICE_LINEAR VTK_LINEAR_INTERPOLATION
68#define VTK_RESLICE_CUBIC VTK_CUBIC_INTERPOLATION
69
70class vtkImageData;
72class vtkMatrix4x4;
76
77class VTKIMAGINGCORE_EXPORT vtkImageReslice : public vtkThreadedImageAlgorithm
78{
79public:
82
83 void PrintSelf(ostream& os, vtkIndent indent) VTK_OVERRIDE;
84
86
102 vtkGetObjectMacro(ResliceAxes, vtkMatrix4x4);
104
106
112 void SetResliceAxesDirectionCosines(double x0, double x1, double x2,
113 double y0, double y1, double y2,
114 double z0, double z1, double z2);
115 void SetResliceAxesDirectionCosines(const double x[3],
116 const double y[3],
117 const double z[3]) {
118 this->SetResliceAxesDirectionCosines(x[0], x[1], x[2],
119 y[0], y[1], y[2],
120 z[0], z[1], z[2]); };
121 void SetResliceAxesDirectionCosines(const double xyz[9]) {
122 this->SetResliceAxesDirectionCosines(xyz[0], xyz[1], xyz[2],
123 xyz[3], xyz[4], xyz[5],
124 xyz[6], xyz[7], xyz[8]); };
125 void GetResliceAxesDirectionCosines(double x[3], double y[3], double z[3]);
126 void GetResliceAxesDirectionCosines(double xyz[9]) {
127 this->GetResliceAxesDirectionCosines(&xyz[0], &xyz[3], &xyz[6]); };
129 this->GetResliceAxesDirectionCosines(this->ResliceAxesDirectionCosines);
130 return this->ResliceAxesDirectionCosines; };
132
134
140 void SetResliceAxesOrigin(double x, double y, double z);
141 void SetResliceAxesOrigin(const double xyz[3]) {
142 this->SetResliceAxesOrigin(xyz[0], xyz[1], xyz[2]); };
143 void GetResliceAxesOrigin(double xyz[3]);
145 this->GetResliceAxesOrigin(this->ResliceAxesOrigin);
146 return this->ResliceAxesOrigin; };
148
150
160 vtkGetObjectMacro(ResliceTransform, vtkAbstractTransform);
162
164
174 vtkGetObjectMacro(InformationInput, vtkImageData);
176
178
185 vtkSetMacro(TransformInputSampling, int);
186 vtkBooleanMacro(TransformInputSampling, int);
187 vtkGetMacro(TransformInputSampling, int);
189
191
196 vtkSetMacro(AutoCropOutput, int);
197 vtkBooleanMacro(AutoCropOutput, int);
198 vtkGetMacro(AutoCropOutput, int);
200
202
205 vtkSetMacro(Wrap, int);
206 vtkGetMacro(Wrap, int);
207 vtkBooleanMacro(Wrap, int);
209
211
215 vtkSetMacro(Mirror, int);
216 vtkGetMacro(Mirror, int);
217 vtkBooleanMacro(Mirror, int);
219
221
231 vtkSetMacro(Border, int);
232 vtkGetMacro(Border, int);
233 vtkBooleanMacro(Border, int);
235
237
240 vtkSetClampMacro(InterpolationMode, int,
242 vtkGetMacro(InterpolationMode, int);
244 this->SetInterpolationMode(VTK_RESLICE_NEAREST); };
246 this->SetInterpolationMode(VTK_RESLICE_LINEAR); };
248 this->SetInterpolationMode(VTK_RESLICE_CUBIC); };
249 virtual const char *GetInterpolationModeAsString();
251
253
260
262
268 vtkSetClampMacro(SlabMode, int, VTK_IMAGE_SLAB_MIN, VTK_IMAGE_SLAB_SUM);
269 vtkGetMacro(SlabMode, int);
271 this->SetSlabMode(VTK_IMAGE_SLAB_MIN); };
273 this->SetSlabMode(VTK_IMAGE_SLAB_MAX); };
275 this->SetSlabMode(VTK_IMAGE_SLAB_MEAN); };
277 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, int);
296 vtkBooleanMacro(SlabTrapezoidIntegration, int);
297 vtkGetMacro(SlabTrapezoidIntegration, int);
299
301
310 vtkSetMacro(SlabSliceSpacingFraction, double);
311 vtkGetMacro(SlabSliceSpacingFraction, double);
313
315
319 vtkSetMacro(Optimization, int);
320 vtkGetMacro(Optimization, int);
321 vtkBooleanMacro(Optimization, int);
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]) {
386 this->SetOutputSpacing(a[0], a[1], a[2]); };
387 vtkGetVector3Macro(OutputSpacing, double);
390
392
396 virtual void SetOutputOrigin(double x, double y, double z);
397 virtual void SetOutputOrigin(const double a[3]) {
398 this->SetOutputOrigin(a[0], a[1], a[2]); };
399 vtkGetVector3Macro(OutputOrigin, double);
402
404
408 virtual void SetOutputExtent(int a, int b, int c, int d, int e, int f);
409 virtual void SetOutputExtent(const int a[6]) {
410 this->SetOutputExtent(a[0], a[1], a[2], a[3], a[4], a[5]); };
411 vtkGetVector6Macro(OutputExtent, int);
414
416
426 vtkSetMacro(OutputDimensionality, int);
427 vtkGetMacro(OutputDimensionality, int);
429
434 vtkMTimeType GetMTime() VTK_OVERRIDE;
435
439 void ReportReferences(vtkGarbageCollector*) VTK_OVERRIDE;
440
442
450 void SetInterpolate(int t) {
451 if (t && !this->GetInterpolate()) {
452 this->SetInterpolationModeToLinear(); }
453 else if (!t && this->GetInterpolate()) {
454 this->SetInterpolationModeToNearestNeighbor(); } };
456 this->SetInterpolate(1); };
458 this->SetInterpolate(0); };
460 return (this->GetInterpolationMode() != VTK_RESLICE_NEAREST); };
462
464
472
474
478 vtkSetMacro(GenerateStencilOutput, int);
479 vtkGetMacro(GenerateStencilOutput, int);
480 vtkBooleanMacro(GenerateStencilOutput, int);
482
484
488 return this->GetOutputPort(1); }
492
493protected:
496
498 double ResliceAxesDirectionCosines[9];
499 double ResliceAxesOrigin[3];
503 int Wrap;
514 double BackgroundColor[4];
515 double OutputOrigin[3];
516 double OutputSpacing[3];
517 int OutputExtent[6];
528
531
537
542 virtual int ConvertScalarInfo(int &scalarType, int &numComponents);
543
552 virtual void ConvertScalars(void *inPtr, void *outPtr,
553 int inputType, int inputNumComponents,
554 int count, int idX, int idY, int idZ,
555 int threadId);
556
557 void ConvertScalarsBase(void *inPtr, void *outPtr,
558 int inputType, int inputNumComponents,
559 int count, int idX, int idY, int idZ, int threadId) {
560 this->ConvertScalars(inPtr, outPtr, inputType, inputNumComponents,
561 count, idX, idY, idZ, threadId); }
562
563 void GetAutoCroppedOutputBounds(vtkInformation *inInfo, double bounds[6]);
564 virtual void AllocateOutputData(vtkImageData *output, vtkInformation *outInfo, int *uExtent) VTK_OVERRIDE;
567 vtkInformationVector *) VTK_OVERRIDE;
569 vtkInformationVector *) VTK_OVERRIDE;
571 vtkInformationVector *) VTK_OVERRIDE;
572 virtual void ThreadedRequestData(vtkInformation *request,
573 vtkInformationVector **inputVector,
574 vtkInformationVector *outputVector,
575 vtkImageData ***inData,
576 vtkImageData **outData, int ext[6], int id) VTK_OVERRIDE;
577 virtual int FillInputPortInformation(int port, vtkInformation *info) VTK_OVERRIDE;
578 virtual int FillOutputPortInformation(int port, vtkInformation *info) VTK_OVERRIDE;
579
581 vtkInformation *outInfo);
583 return this->OptimizedTransform; };
584
585private:
586 vtkImageReslice(const vtkImageReslice&) VTK_DELETE_FUNCTION;
587 void operator=(const vtkImageReslice&) VTK_DELETE_FUNCTION;
588};
589
590#endif
interpolate data values from images
superclass for all geometric transformations
Proxy object to connect input/output ports.
vtkAlgorithmOutput * GetOutputPort()
Definition: vtkAlgorithm.h:459
general representation of visualization data
Definition: vtkDataObject.h:65
Detect and break reference loops.
topologically and geometrically regular array of data
Definition: vtkImageData.h:46
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])
vtkImageStencilData * GetStencil()
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.
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])
double * GetResliceAxesOrigin()
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...
virtual 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,...
virtual int RequestUpdateExtent(vtkInformation *, vtkInformationVector **, vtkInformationVector *) override
Subclasses can reimplement this method to translate the update extent requests from each output port ...
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 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.
virtual void AllocateOutputData(vtkImageData *output, vtkInformation *outInfo, int *uExtent) override
Allocate the output data.
void SetOutputSpacingToDefault()
void SetStencilOutput(vtkImageStencilData *stencil)
vtkImageStencilData * GetStencilOutput()
virtual vtkAbstractImageInterpolator * GetInterpolator()
void SetInterpolationModeToCubic()
double SlabSliceSpacingFraction
void GetResliceAxesOrigin(double xyz[3])
virtual void SetOutputSpacing(const double a[3])
double GetBackgroundLevel()
virtual int ConvertScalarInfo(int &scalarType, int &numComponents)
This should be overridden by derived classes that operate on the interpolated data before it is place...
virtual int RequestInformation(vtkInformation *, vtkInformationVector **, vtkInformationVector *) override
Subclasses can reimplement this method to collect information from their inputs and set information f...
virtual int FillOutputPortInformation(int port, vtkInformation *info) override
These method should be reimplemented by subclasses that have more than a single input or single outpu...
vtkAbstractTransform * OptimizedTransform
vtkMatrix4x4 * IndexMatrix
vtkMTimeType GetMTime() override
When determining the modified time of the filter, this check the modified time of the transform and m...
vtkMatrix4x4 * ResliceAxes
virtual void SetOutputSpacing(double x, double y, double z)
Set the voxel spacing for the output data.
static vtkImageReslice * New()
void ConvertScalarsBase(void *inPtr, void *outPtr, int inputType, int inputNumComponents, int count, int idX, int idY, int idZ, int threadId)
virtual vtkImageData * AllocateOutputData(vtkDataObject *, vtkInformation *) override
double * GetResliceAxesDirectionCosines()
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()
virtual const char * GetSlabModeAsString()
vtkAbstractTransform * GetOptimizedTransform()
virtual int RequestData(vtkInformation *, vtkInformationVector **, vtkInformationVector *) override
This is called by the superclass.
void GetResliceAxesDirectionCosines(double x[3], double y[3], double z[3])
vtkMatrix4x4 * GetIndexMatrix(vtkInformation *inInfo, vtkInformation *outInfo)
vtkImageData * InformationInput
void SetOutputOriginToDefault()
virtual int FillInputPortInformation(int port, vtkInformation *info) override
Fill the input port information objects for this algorithm.
virtual void SetInformationInput(vtkImageData *)
Set a vtkImageData from which the default Spacing, Origin, and WholeExtent of the output will be copi...
void SetInterpolationModeToLinear()
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: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.
@ info
Definition: vtkX3D.h:376
@ port
Definition: vtkX3D.h:447
#define VTK_RESLICE_CUBIC
#define VTK_RESLICE_NEAREST
#define VTK_RESLICE_LINEAR
vtkSetMacro(IgnoreDriverBugs, bool)
Updates the extensions string.
vtkBooleanMacro(IgnoreDriverBugs, bool)
Updates the extensions string.
#define VTK_IMAGE_SLAB_MAX
#define VTK_IMAGE_SLAB_MIN
#define VTK_IMAGE_SLAB_SUM
#define VTK_IMAGE_SLAB_MEAN
vtkTypeUInt64 vtkMTimeType
Definition: vtkType.h:248