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 vtkMatrix3x3;
class vtkMatrix4x4;
class vtkPixel;
class vtkVertex;
class vtkVoxel;
 
class VTKCOMMONDATAMODEL_EXPORT vtkImageData : public vtkDataSet
{
public:
  static vtkImageData* New();
  static vtkImageData* ExtendedNew();
 
  vtkTypeMacro(vtkImageData, vtkDataSet);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
  void CopyStructure(vtkDataSet* ds) override;
 
  int GetDataObjectType() override { return VTK_IMAGE_DATA; }
 
 
  vtkIdType GetNumberOfCells() override;
  vtkIdType GetNumberOfPoints() override;
  double* GetPoint(vtkIdType ptId) VTK_SIZEHINT(3) override;
  void GetPoint(vtkIdType id, double x[3]) override;
  vtkCell* GetCell(vtkIdType cellId) override;
  vtkCell* GetCell(int i, int j, int k) override;
  void GetCell(vtkIdType cellId, vtkGenericCell* cell) override;
  void GetCellBounds(vtkIdType cellId, double bounds[6]) override;
  virtual vtkIdType FindPoint(double x, double y, double z)
  {
    return this->vtkDataSet::FindPoint(x, y, z);
  }
  vtkIdType FindPoint(double x[3]) override;
  vtkIdType FindCell(double x[3], vtkCell* cell, vtkIdType cellId, double tol2, int& subId,
    double pcoords[3], double* weights) override;
  vtkIdType FindCell(double x[3], vtkCell* cell, vtkGenericCell* gencell, vtkIdType cellId,
    double tol2, int& subId, double pcoords[3], double* weights) override;
  vtkCell* FindAndGetCell(double x[3], vtkCell* cell, vtkIdType cellId, double tol2, int& subId,
    double pcoords[3], double* weights) override;
  int GetCellType(vtkIdType cellId) override;
  void GetCellPoints(vtkIdType cellId, vtkIdList* ptIds) override
  {
    int dimensions[3];
    this->GetDimensions(dimensions);
    vtkStructuredData::GetCellPoints(cellId, ptIds, this->DataDescription, dimensions);
  }
  void GetPointCells(vtkIdType ptId, vtkIdList* cellIds) override
  {
    int dimensions[3];
    this->GetDimensions(dimensions);
    vtkStructuredData::GetPointCells(ptId, cellIds, dimensions);
  }
  void ComputeBounds() override;
  int GetMaxCellSize() override { return 8; } // voxel is the largest
  void GetCellNeighbors(vtkIdType cellId, vtkIdList* ptIds, vtkIdList* cellIds) override;
 
  void GetCellNeighbors(vtkIdType cellId, vtkIdList* ptIds, vtkIdList* cellIds, int* seedLoc);
 
  void Initialize() override;
 
  unsigned char IsPointVisible(vtkIdType ptId);
 
  unsigned char IsCellVisible(vtkIdType cellId);
 
  bool HasAnyBlankPoints() override;
  bool HasAnyBlankCells() override;
 
  void GetCellDims(int cellDims[3]);
 
  virtual void SetDimensions(int i, int j, int k);
 
  virtual void SetDimensions(const int dims[3]);
 
  virtual int* GetDimensions() VTK_SIZEHINT(3);
 
  virtual void GetDimensions(int dims[3]);
#if VTK_ID_TYPE_IMPL != VTK_INT
  virtual void GetDimensions(vtkIdType dims[3]);
#endif
 
  virtual int ComputeStructuredCoordinates(const double x[3], int ijk[3], double pcoords[3]);
 
  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() VTK_SIZEHINT(3);
  virtual void GetIncrements(vtkIdType& incX, vtkIdType& incY, vtkIdType& incZ);
  virtual void GetIncrements(vtkIdType inc[3]);
  virtual vtkIdType* GetIncrements(vtkDataArray* scalars) VTK_SIZEHINT(3);
  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 vtkIdType GetScalarIndexForExtent(int extent[6]);
  virtual vtkIdType GetScalarIndex(int coordinates[3]);
  virtual vtkIdType GetScalarIndex(int x, int y, int z);
 
 
  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);
  }
 
  void Crop(const int* updateExtent) override;
 
  unsigned long GetActualMemorySize() override;
 
 
  vtkGetVector3Macro(Spacing, double);
  virtual void SetSpacing(double i, double j, double k);
  virtual void SetSpacing(const double ijk[3]);
 
 
  vtkGetVector3Macro(Origin, double);
  virtual void SetOrigin(double i, double j, double k);
  virtual void SetOrigin(const double ijk[3]);
 
 
  vtkGetObjectMacro(DirectionMatrix, vtkMatrix3x3);
  virtual void SetDirectionMatrix(vtkMatrix3x3* m);
  virtual void SetDirectionMatrix(const double elements[9]);
  virtual void SetDirectionMatrix(double e00, double e01, double e02, double e10, double e11,
    double e12, double e20, double e21, double e22);
 
 
  vtkGetObjectMacro(IndexToPhysicalMatrix, vtkMatrix4x4);
 
 
  virtual void TransformContinuousIndexToPhysicalPoint(double i, double j, double k, double xyz[3]);
  virtual void TransformContinuousIndexToPhysicalPoint(const double ijk[3], double xyz[3]);
  virtual void TransformIndexToPhysicalPoint(int i, int j, int k, double xyz[3]);
  virtual void TransformIndexToPhysicalPoint(const int ijk[3], double xyz[3]);
  static void TransformContinuousIndexToPhysicalPoint(double i, double j, double k,
    double const origin[3], double const spacing[3], double const direction[9], double xyz[3]);
 
 
  vtkGetObjectMacro(PhysicalToIndexMatrix, vtkMatrix4x4);
 
 
  virtual void TransformPhysicalPointToContinuousIndex(double x, double y, double z, double ijk[3]);
  virtual void TransformPhysicalPointToContinuousIndex(const double xyz[3], double ijk[3]);
 
  static void ComputeIndexToPhysicalMatrix(
    double const origin[3], double const spacing[3], double const direction[9], double result[16]);
 
 
  virtual void TransformPhysicalNormalToContinuousIndex(const double xyz[3], double ijk[3]);
 
  virtual void TransformPhysicalPlaneToContinuousIndex(double const pplane[4], double iplane[4]);
 
  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();
 
  void CopyInformationFromPipeline(vtkInformation* information) override;
 
  void CopyInformationToPipeline(vtkInformation* information) override;
 
  void PrepareForNewData() override;
 
 
  void ShallowCopy(vtkDataObject* src) override;
  void DeepCopy(vtkDataObject* src) override;
 
  //--------------------------------------------------------------------------
  // Methods that apply to any array (not just scalars).
  // I am starting to experiment with generalizing imaging filters
  // to operate on more than just scalars.
 
 
  void* GetArrayPointerForExtent(vtkDataArray* array, int extent[6]);
  void* GetArrayPointer(vtkDataArray* array, int coordinates[3]);
 
 
  vtkIdType GetTupleIndex(vtkDataArray* array, int coordinates[3]);
 
  void GetArrayIncrements(vtkDataArray* array, vtkIdType increments[3]);
 
  void ComputeInternalExtent(int* intExt, int* tgtExt, int* bnds);
 
  int GetExtentType() override { return VTK_3D_EXTENT; }
 
 
  static vtkImageData* GetData(vtkInformation* info);
  static vtkImageData* GetData(vtkInformationVector* v, int i = 0);
 
protected:
  vtkImageData();
  ~vtkImageData() override;
 
  // 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];
 
  // Variables used to define dataset physical orientation
  double Origin[3];
  double Spacing[3];
  vtkMatrix3x3* DirectionMatrix;
  vtkMatrix4x4* IndexToPhysicalMatrix;
  vtkMatrix4x4* PhysicalToIndexMatrix;
 
  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]);
 
  // for the index to physical methods
  void ComputeTransforms();
 
  // Cell utilities
  vtkCell* GetCellTemplateForDataDescription();
  bool GetCellTemplateForDataDescription(vtkGenericCell* cell);
  bool GetIJKMinForCellId(vtkIdType cellId, int ijkMin[3]);
  bool GetIJKMaxForIJKMin(int ijkMin[3], int ijkMax[3]);
  void AddPointsToCellTemplate(vtkCell* cell, int ijkMin[3], int ijkMax[3]);
 
  vtkTimeStamp ExtentComputeTime;
 
  void SetDataDescription(int desc);
  int GetDataDescription() { return this->DataDescription; }
 
private:
  void InternalImageDataCopy(vtkImageData* src);
 
private:
  friend class vtkUniformGrid;
 
  // for the GetCell method
  vtkVertex* Vertex;
  vtkLine* Line;
  vtkPixel* Pixel;
  vtkVoxel* Voxel;
 
  // for the GetPoint method
  double Point[3];
 
  int DataDescription;
 
  vtkImageData(const vtkImageData&) = delete;
  void operator=(const vtkImageData&) = delete;
};
 
//----------------------------------------------------------------------------
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