vtkImageData.h

Go to the documentation of this file.

/*=========================================================================
 
  Program:   Visualization Toolkit
  Module:    vtkImageData.h
 
  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.
 
=========================================================================*/
#ifndef vtkImageData_h
#define vtkImageData_h
 
#include "vtkCommonDataModelModule.h" // For export macro
#include "vtkDataSet.h"
 
#include "vtkStructuredData.h" // Needed for inline methods
 
class vtkDataArray;
class vtkLine;
class vtkPixel;
class vtkVertex;
class vtkVoxel;
 
class VTKCOMMONDATAMODEL_EXPORT vtkImageData : public vtkDataSet
{
public:
  static vtkImageData *New();
 
  vtkTypeMacro(vtkImageData,vtkDataSet);
  void PrintSelf(ostream& os, vtkIndent indent);
 
  virtual void CopyStructure(vtkDataSet *ds);
 
  virtual int GetDataObjectType() {return VTK_IMAGE_DATA;};
 
 
  virtual vtkIdType GetNumberOfCells();
  virtual vtkIdType GetNumberOfPoints();
  virtual double *GetPoint(vtkIdType ptId);
  virtual void GetPoint(vtkIdType id, double x[3]);
  virtual vtkCell *GetCell(vtkIdType cellId);
  virtual void GetCell(vtkIdType cellId, vtkGenericCell *cell);
  virtual void GetCellBounds(vtkIdType cellId, double bounds[6]);
  virtual vtkIdType FindPoint(double x, double y, double z)
    {
    return this->vtkDataSet::FindPoint(x, y, z);
    }
  virtual vtkIdType FindPoint(double x[3]);
  virtual vtkIdType FindCell(
    double x[3], vtkCell *cell, vtkIdType cellId, double tol2,
    int& subId, double pcoords[3], double *weights);
  virtual vtkIdType FindCell(
    double x[3], vtkCell *cell, vtkGenericCell *gencell,
    vtkIdType cellId, double tol2, int& subId,
    double pcoords[3], double *weights);
  virtual vtkCell *FindAndGetCell(double x[3], vtkCell *cell, vtkIdType cellId,
                                  double tol2, int& subId, double pcoords[3],
                                  double *weights);
  virtual int GetCellType(vtkIdType cellId);
  virtual void GetCellPoints(vtkIdType cellId, vtkIdList *ptIds)
    {vtkStructuredData::GetCellPoints(cellId,ptIds,this->DataDescription,
                                      this->GetDimensions());}
  virtual void GetPointCells(vtkIdType ptId, vtkIdList *cellIds)
    {vtkStructuredData::GetPointCells(ptId,cellIds,this->GetDimensions());}
  virtual void ComputeBounds();
  virtual int GetMaxCellSize() {return 8;}; //voxel is the largest
 
  virtual void Initialize();
 
  virtual void SetDimensions(int i, int j, int k);
 
  virtual void SetDimensions(const int dims[3]);
 
 
  virtual int *GetDimensions();
  virtual void GetDimensions(int dims[3]);
 
 
  virtual int ComputeStructuredCoordinates(
    const double x[3],  int ijk[3],  double pcoords[3]);
 
  static int ComputeStructuredCoordinates( const double x[3], int ijk[3], double pcoords[3],
                                           const int* extent,
                                           const double* spacing,
                                           const double* origin,
                                           const double* bounds);
 
  virtual void GetVoxelGradient(
    int i,int j,int k, vtkDataArray *s, vtkDataArray *g);
 
 
  virtual void GetPointGradient(
    int i, int j, int k, vtkDataArray *s, double g[3]);
 
  virtual int GetDataDimension();
 
 
  virtual vtkIdType ComputePointId(int ijk[3]) {
    return vtkStructuredData::ComputePointIdForExtent(this->Extent,ijk);};
 
 
  virtual vtkIdType ComputeCellId(int ijk[3]) {
    return vtkStructuredData::ComputeCellIdForExtent(this->Extent,ijk);};
 
 
  virtual void SetAxisUpdateExtent(int axis, int min, int max,
                                   const int* updateExtent,
                                   int* axisUpdateExtent);
  virtual void GetAxisUpdateExtent(int axis, int &min, int &max, const int* updateExtent);
 
 
  virtual void SetExtent(int extent[6]);
  virtual void SetExtent(int x1, int x2, int y1, int y2, int z1, int z2);
  vtkGetVector6Macro(Extent, int);
 
 
  virtual double GetScalarTypeMin(vtkInformation* meta_data);
  virtual double GetScalarTypeMin();
  virtual double GetScalarTypeMax(vtkInformation* meta_data);
  virtual double GetScalarTypeMax();
 
 
  virtual int GetScalarSize(vtkInformation* meta_data);
  virtual int GetScalarSize();
 
 
  virtual vtkIdType *GetIncrements();
  virtual void GetIncrements(vtkIdType &incX, vtkIdType &incY, vtkIdType &incZ);
  virtual void GetIncrements(vtkIdType inc[3]);
  virtual vtkIdType *GetIncrements(vtkDataArray *scalars);
  virtual void GetIncrements(vtkDataArray *scalars,
                             vtkIdType &incX, vtkIdType &incY, vtkIdType &incZ);
  virtual void GetIncrements(vtkDataArray *scalars, vtkIdType inc[3]);
 
 
  virtual void GetContinuousIncrements(
    int extent[6], vtkIdType &incX, vtkIdType &incY, vtkIdType &incZ);
  virtual void GetContinuousIncrements(vtkDataArray *scalars,
    int extent[6], vtkIdType &incX, vtkIdType &incY, vtkIdType &incZ);
 
 
  virtual void *GetScalarPointerForExtent(int extent[6]);
  virtual void *GetScalarPointer(int coordinates[3]);
  virtual void *GetScalarPointer(int x, int y, int z);
  virtual void *GetScalarPointer();
 
 
  virtual float GetScalarComponentAsFloat(int x, int y, int z, int component);
  virtual void SetScalarComponentFromFloat(
    int x, int y, int z, int component, float v);
  virtual double GetScalarComponentAsDouble(int x, int y, int z, int component);
  virtual void SetScalarComponentFromDouble(
    int x, int y, int z, int component, double v);
 
  virtual void AllocateScalars(int dataType, int numComponents);
 
  virtual void AllocateScalars(vtkInformation* pipeline_info);
 
 
  virtual void CopyAndCastFrom(vtkImageData *inData, int extent[6]);
  virtual void CopyAndCastFrom(vtkImageData *inData, int x0, int x1,
                               int y0, int y1, int z0, int z1)
    {int e[6]; e[0]=x0; e[1]=x1; e[2]=y0; e[3]=y1; e[4]=z0; e[5]=z1;
    this->CopyAndCastFrom(inData, e);}
 
  virtual void Crop(const int* updateExtent);
 
  virtual unsigned long GetActualMemorySize();
 
 
  vtkSetVector3Macro(Spacing,double);
  vtkGetVector3Macro(Spacing,double);
 
 
  vtkSetVector3Macro(Origin,double);
  vtkGetVector3Macro(Origin,double);
 
  static void SetScalarType(int, vtkInformation* meta_data);
  static int GetScalarType(vtkInformation* meta_data);
  static bool HasScalarType(vtkInformation* meta_data);
  int GetScalarType();
  const char* GetScalarTypeAsString()
    { return vtkImageScalarTypeNameMacro ( this->GetScalarType() ); };
 
 
  static void SetNumberOfScalarComponents( int n, vtkInformation* meta_data);
  static int GetNumberOfScalarComponents(vtkInformation* meta_data);
  static bool HasNumberOfScalarComponents(vtkInformation* meta_data);
  int GetNumberOfScalarComponents();
 
  virtual void CopyInformationFromPipeline(vtkInformation* information);
 
  virtual void CopyInformationToPipeline(vtkInformation* information);
 
  virtual void PrepareForNewData();
 
 
  virtual void ShallowCopy(vtkDataObject *src);
  virtual void DeepCopy(vtkDataObject *src);
 
  //--------------------------------------------------------------------------
  // Methods that apply to any array (not just scalars).
  // I am starting to experiment with generalizing imaging fitlers
  // to operate on more than just scalars.
 
 
  void *GetArrayPointerForExtent(vtkDataArray* array, int extent[6]);
  void *GetArrayPointer(vtkDataArray* array, int coordinates[3]);
 
  void GetArrayIncrements(vtkDataArray *array, vtkIdType increments[3]);
 
  void ComputeInternalExtent(int *intExt, int *tgtExt, int *bnds);
 
  virtual int GetExtentType() { return VTK_3D_EXTENT; };
 
  //BTX
 
  static vtkImageData* GetData(vtkInformation* info);
  static vtkImageData* GetData(vtkInformationVector* v, int i=0);
  //ETX
 
protected:
  vtkImageData();
  ~vtkImageData();
 
  // The extent of what is currently in the structured grid.
  // Dimensions is just an array to return a value.
  // Its contents are out of data until GetDimensions is called.
  int Dimensions[3];
  vtkIdType Increments[3];
 
  double Origin[3];
  double Spacing[3];
 
  int Extent[6];
 
  // The first method assumes Active Scalars
  void ComputeIncrements();
  // This one is given the number of components of the
  // scalar field explicitly
  void ComputeIncrements(int numberOfComponents);
  void ComputeIncrements(vtkDataArray *scalars);
 
  // The first method assumes Acitive Scalars
  void ComputeIncrements(vtkIdType inc[3]);
  // This one is given the number of components of the
  // scalar field explicitly
  void ComputeIncrements(int numberOfComponents, vtkIdType inc[3]);
  void ComputeIncrements(vtkDataArray *scalars, vtkIdType inc[3]);
  void CopyOriginAndSpacingFromPipeline(vtkInformation* info);
 
  vtkTimeStamp ExtentComputeTime;
 
  void SetDataDescription(int desc);
  int GetDataDescription() { return this->DataDescription; }
 
private:
  void InternalImageDataCopy(vtkImageData *src);
private:
 
  //BTX
  friend class vtkUniformGrid;
  //ETX
 
  // for the GetCell method
  vtkVertex *Vertex;
  vtkLine *Line;
  vtkPixel *Pixel;
  vtkVoxel *Voxel;
 
  // for the GetPoint method
  double Point[3];
 
  int DataDescription;
 
  vtkImageData(const vtkImageData&);  // Not implemented.
  void operator=(const vtkImageData&);  // Not implemented.
};
 
 
//----------------------------------------------------------------------------
inline void vtkImageData::ComputeIncrements()
{
  this->ComputeIncrements(this->Increments);
}
 
//----------------------------------------------------------------------------
inline void vtkImageData::ComputeIncrements(int numberOfComponents)
{
  this->ComputeIncrements(numberOfComponents, this->Increments);
}
 
//----------------------------------------------------------------------------
inline void vtkImageData::ComputeIncrements(vtkDataArray *scalars)
{
  this->ComputeIncrements(scalars, this->Increments);
}
 
//----------------------------------------------------------------------------
inline double * vtkImageData::GetPoint(vtkIdType id)
{
  this->GetPoint(id, this->Point);
  return this->Point;
}
 
//----------------------------------------------------------------------------
inline vtkIdType vtkImageData::GetNumberOfPoints()
{
  const int *extent = this->Extent;
  vtkIdType dims[3];
  dims[0] = extent[1] - extent[0] + 1;
  dims[1] = extent[3] - extent[2] + 1;
  dims[2] = extent[5] - extent[4] + 1;
 
  return dims[0]*dims[1]*dims[2];
}
 
//----------------------------------------------------------------------------
inline int vtkImageData::GetDataDimension()
{
  return vtkStructuredData::GetDataDimension(this->DataDescription);
}
 
#endif