You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
278 lines
12 KiB
278 lines
12 KiB
/*=========================================================================
|
|
|
|
Program: Visualization Toolkit
|
|
Module: $RCSfile: vtkImageImport.h,v $
|
|
|
|
Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
|
|
All rights reserved.
|
|
See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
|
|
|
|
This software is distributed WITHOUT ANY WARRANTY; without even
|
|
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
|
|
PURPOSE. See the above copyright notice for more information.
|
|
|
|
=========================================================================*/
|
|
// .NAME vtkImageImport - Import data from a C array.
|
|
// .SECTION Description
|
|
// vtkImageImport provides methods needed to import image data from a source
|
|
// independent of VTK, such as a simple C array or a third-party pipeline.
|
|
// Note that the VTK convention is for the image voxel index (0,0,0) to be
|
|
// the lower-left corner of the image, while most 2D image formats use
|
|
// the upper-left corner. You can use vtkImageFlip to correct the
|
|
// orientation after the image has been loaded into VTK.
|
|
// Note that is also possible to import the raw data from a Python string
|
|
// instead of from a C array.
|
|
// .SECTION See Also
|
|
// vtkImageExport
|
|
|
|
#ifndef __vtkImageImport_h
|
|
#define __vtkImageImport_h
|
|
|
|
#include "vtkImageAlgorithm.h"
|
|
//#include "vtkTransform.h"
|
|
|
|
class VTK_IMAGING_EXPORT vtkImageImport : public vtkImageAlgorithm
|
|
{
|
|
public:
|
|
static vtkImageImport *New();
|
|
vtkTypeRevisionMacro(vtkImageImport,vtkImageAlgorithm);
|
|
void PrintSelf(ostream& os, vtkIndent indent);
|
|
|
|
// Description:
|
|
// Import data and make an internal copy of it. If you do not want
|
|
// VTK to copy the data, then use SetImportVoidPointer instead (do
|
|
// not use both). Give the size of the data array in bytes.
|
|
void CopyImportVoidPointer(void *ptr, int size);
|
|
|
|
// Description:
|
|
// Set the pointer from which the image data is imported. VTK will
|
|
// not make its own copy of the data, it will access the data directly
|
|
// from the supplied array. VTK will not attempt to delete the data
|
|
// nor modify the data.
|
|
void SetImportVoidPointer(void *ptr);
|
|
void *GetImportVoidPointer() {return this->ImportVoidPointer;};
|
|
|
|
// Description:
|
|
// Set the pointer from which the image data is imported. Set save to 1
|
|
// (the default) unless you want VTK to delete the array via C++ delete
|
|
// when the vtkImageImport object is deallocated. VTK will not make its
|
|
// own copy of the data, it will access the data directly from the
|
|
// supplied array.
|
|
void SetImportVoidPointer(void *ptr, int save);
|
|
|
|
// Description:
|
|
// Set/Get the data type of pixels in the imported data. This is used
|
|
// as the scalar type of the Output. Default: Short.
|
|
vtkSetMacro(DataScalarType,int);
|
|
void SetDataScalarTypeToDouble(){this->SetDataScalarType(VTK_DOUBLE);}
|
|
void SetDataScalarTypeToFloat(){this->SetDataScalarType(VTK_FLOAT);}
|
|
void SetDataScalarTypeToInt(){this->SetDataScalarType(VTK_INT);}
|
|
void SetDataScalarTypeToShort(){this->SetDataScalarType(VTK_SHORT);}
|
|
void SetDataScalarTypeToUnsignedShort()
|
|
{this->SetDataScalarType(VTK_UNSIGNED_SHORT);}
|
|
void SetDataScalarTypeToUnsignedChar()
|
|
{this->SetDataScalarType(VTK_UNSIGNED_CHAR);}
|
|
vtkGetMacro(DataScalarType, int);
|
|
const char *GetDataScalarTypeAsString() {
|
|
return vtkImageScalarTypeNameMacro(this->DataScalarType); }
|
|
|
|
// Description:
|
|
// Set/Get the number of scalar components, for RGB images this must be 3.
|
|
// Default: 1.
|
|
vtkSetMacro(NumberOfScalarComponents,int);
|
|
vtkGetMacro(NumberOfScalarComponents,int);
|
|
|
|
// Description:
|
|
// Get/Set the extent of the data buffer. The dimensions of your data
|
|
// must be equal to (extent[1]-extent[0]+1) * (extent[3]-extent[2]+1) *
|
|
// (extent[5]-DataExtent[4]+1). For example, for a 2D image use
|
|
// (0,width-1, 0,height-1, 0,0).
|
|
vtkSetVector6Macro(DataExtent,int);
|
|
vtkGetVector6Macro(DataExtent,int);
|
|
void SetDataExtentToWholeExtent()
|
|
{this->SetDataExtent(this->GetWholeExtent());}
|
|
|
|
// Description:
|
|
// Set/Get the spacing (typically in mm) between image voxels.
|
|
// Default: (1.0, 1.0, 1.0).
|
|
vtkSetVector3Macro(DataSpacing,double);
|
|
vtkGetVector3Macro(DataSpacing,double);
|
|
|
|
// Description:
|
|
// Set/Get the origin of the data, i.e. the coordinates (usually in mm)
|
|
// of voxel (0,0,0). Default: (0.0, 0.0, 0.0).
|
|
vtkSetVector3Macro(DataOrigin,double);
|
|
vtkGetVector3Macro(DataOrigin,double);
|
|
|
|
// Description:
|
|
// Get/Set the whole extent of the image. This is the largest possible
|
|
// extent. Set the DataExtent to the extent of the image in the buffer
|
|
// pointed to by the ImportVoidPointer.
|
|
vtkSetVector6Macro(WholeExtent,int);
|
|
vtkGetVector6Macro(WholeExtent,int);
|
|
|
|
// Description:
|
|
// Propagates the update extent through the callback if it is set.
|
|
virtual int RequestUpdateExtent( vtkInformation* request,
|
|
vtkInformationVector** inputVector,
|
|
vtkInformationVector* outputVector);
|
|
|
|
//BTX
|
|
// Description:
|
|
// These are function pointer types for the pipeline connection
|
|
// callbacks. See furhter documentation on each individual callback.
|
|
typedef void (*UpdateInformationCallbackType)(void*);
|
|
typedef int (*PipelineModifiedCallbackType)(void*);
|
|
typedef int* (*WholeExtentCallbackType)(void*);
|
|
typedef double* (*SpacingCallbackType)(void*);
|
|
typedef double* (*OriginCallbackType)(void*);
|
|
typedef const char* (*ScalarTypeCallbackType)(void*);
|
|
typedef int (*NumberOfComponentsCallbackType)(void*);
|
|
typedef void (*PropagateUpdateExtentCallbackType)(void*, int*);
|
|
typedef void (*UpdateDataCallbackType)(void*);
|
|
typedef int* (*DataExtentCallbackType)(void*);
|
|
typedef void* (*BufferPointerCallbackType)(void*);
|
|
|
|
// Description:
|
|
// Set/Get the callback for propagating UpdateInformation calls to a
|
|
// third-party pipeline. The callback should make sure that the
|
|
// third-party pipeline information is up to date.
|
|
vtkSetMacro(UpdateInformationCallback, UpdateInformationCallbackType);
|
|
vtkGetMacro(UpdateInformationCallback, UpdateInformationCallbackType);
|
|
|
|
// Description:
|
|
// Set/Get the callback for checking whether the third-party
|
|
// pipeline has been modified since the last invocation of the
|
|
// callback. The callback should return 1 for modified, and 0 for
|
|
// not modified. The first call should always return modified.
|
|
vtkSetMacro(PipelineModifiedCallback, PipelineModifiedCallbackType);
|
|
vtkGetMacro(PipelineModifiedCallback, PipelineModifiedCallbackType);
|
|
|
|
// Description:
|
|
// Set/Get the callback for getting the whole extent of the input
|
|
// image from a third-party pipeline. The callback should return a
|
|
// vector of six integers describing the extent of the whole image
|
|
// (x1 x2 y1 y2 z1 z2).
|
|
vtkSetMacro(WholeExtentCallback, WholeExtentCallbackType);
|
|
vtkGetMacro(WholeExtentCallback, WholeExtentCallbackType);
|
|
|
|
// Description:
|
|
// Set/Get the callback for getting the spacing of the input image
|
|
// from a third-party pipeline. The callback should return a vector
|
|
// of three double values describing the spacing (dx dy dz).
|
|
vtkSetMacro(SpacingCallback, SpacingCallbackType);
|
|
vtkGetMacro(SpacingCallback, SpacingCallbackType);
|
|
|
|
// Description:
|
|
// Set/Get the callback for getting the origin of the input image
|
|
// from a third-party pipeline. The callback should return a vector
|
|
// of three double values describing the origin (x0 y0 z0).
|
|
vtkSetMacro(OriginCallback, OriginCallbackType);
|
|
vtkGetMacro(OriginCallback, OriginCallbackType);
|
|
|
|
// Description:
|
|
// Set/Get the callback for getting the scalar value type of the
|
|
// input image from a third-party pipeline. The callback should
|
|
// return a string with the name of the type.
|
|
vtkSetMacro(ScalarTypeCallback, ScalarTypeCallbackType);
|
|
vtkGetMacro(ScalarTypeCallback, ScalarTypeCallbackType);
|
|
|
|
// Description:
|
|
// Set/Get the callback for getting the number of components of the
|
|
// input image from a third-party pipeline. The callback should
|
|
// return an integer with the number of components.
|
|
vtkSetMacro(NumberOfComponentsCallback, NumberOfComponentsCallbackType);
|
|
vtkGetMacro(NumberOfComponentsCallback, NumberOfComponentsCallbackType);
|
|
|
|
// Description:
|
|
// Set/Get the callback for propagating the pipeline update extent
|
|
// to a third-party pipeline. The callback should take a vector of
|
|
// six integers describing the extent. This should cause the
|
|
// third-party pipeline to provide data which contains at least this
|
|
// extent after the next UpdateData callback.
|
|
vtkSetMacro(PropagateUpdateExtentCallback,PropagateUpdateExtentCallbackType);
|
|
vtkGetMacro(PropagateUpdateExtentCallback,PropagateUpdateExtentCallbackType);
|
|
|
|
// Description:
|
|
// Set/Get the callback for propagating UpdateData calls to a
|
|
// third-party pipeline. The callback should make sure the
|
|
// third-party pipeline is up to date.
|
|
vtkSetMacro(UpdateDataCallback, UpdateDataCallbackType);
|
|
vtkGetMacro(UpdateDataCallback, UpdateDataCallbackType);
|
|
|
|
// Description:
|
|
// Set/Get the callback for getting the data extent of the input
|
|
// image from a third-party pipeline. The callback should return a
|
|
// vector of six integers describing the extent of the buffered
|
|
// portion of the image (x1 x2 y1 y2 z1 z2). The buffer location
|
|
// should be set with the BufferPointerCallback.
|
|
vtkSetMacro(DataExtentCallback, DataExtentCallbackType);
|
|
vtkGetMacro(DataExtentCallback, DataExtentCallbackType);
|
|
|
|
// Description:
|
|
// Set/Get the callback for getting a pointer to the data buffer of
|
|
// an image from a third-party pipeline. The callback should return
|
|
// a pointer to the beginning of the buffer. The extent of the
|
|
// buffer should be set with the DataExtentCallback.
|
|
vtkSetMacro(BufferPointerCallback, BufferPointerCallbackType);
|
|
vtkGetMacro(BufferPointerCallback, BufferPointerCallbackType);
|
|
|
|
// Description:
|
|
// Set/Get the user data which will be passed as the first argument
|
|
// to all of the third-party pipeline callbacks.
|
|
vtkSetMacro(CallbackUserData, void*);
|
|
vtkGetMacro(CallbackUserData, void*);
|
|
|
|
//ETX
|
|
|
|
// Description:
|
|
// Invoke the appropriate callbacks
|
|
int InvokePipelineModifiedCallbacks();
|
|
void InvokeUpdateInformationCallbacks();
|
|
void InvokeExecuteInformationCallbacks();
|
|
void InvokeExecuteDataCallbacks();
|
|
void LegacyCheckWholeExtent();
|
|
|
|
protected:
|
|
vtkImageImport();
|
|
~vtkImageImport();
|
|
|
|
virtual int RequestInformation (vtkInformation *, vtkInformationVector **,
|
|
vtkInformationVector *);
|
|
|
|
|
|
void *ImportVoidPointer;
|
|
int SaveUserArray;
|
|
|
|
int NumberOfScalarComponents;
|
|
int DataScalarType;
|
|
|
|
int WholeExtent[6];
|
|
int DataExtent[6];
|
|
double DataSpacing[3];
|
|
double DataOrigin[3];
|
|
|
|
void* CallbackUserData;
|
|
|
|
//BTX
|
|
UpdateInformationCallbackType UpdateInformationCallback;
|
|
PipelineModifiedCallbackType PipelineModifiedCallback;
|
|
WholeExtentCallbackType WholeExtentCallback;
|
|
SpacingCallbackType SpacingCallback;
|
|
OriginCallbackType OriginCallback;
|
|
ScalarTypeCallbackType ScalarTypeCallback;
|
|
NumberOfComponentsCallbackType NumberOfComponentsCallback;
|
|
PropagateUpdateExtentCallbackType PropagateUpdateExtentCallback;
|
|
UpdateDataCallbackType UpdateDataCallback;
|
|
DataExtentCallbackType DataExtentCallback;
|
|
BufferPointerCallbackType BufferPointerCallback;
|
|
//ETX
|
|
|
|
virtual void ExecuteData(vtkDataObject *d);
|
|
|
|
private:
|
|
vtkImageImport(const vtkImageImport&); // Not implemented.
|
|
void operator=(const vtkImageImport&); // Not implemented.
|
|
};
|
|
|
|
#endif
|
|
|