vtkImageData.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
// SPDX-License-Identifier: BSD-3-Clause
#ifndef vtkImageData_h
#define vtkImageData_h

#include "vtkCartesianGrid.h"
#include "vtkCommonDataModelModule.h" // For export macro
#include "vtkSmartPointer.h"          // For vtkSmartPointer ivars
#include "vtkStructuredData.h"        // Needed for inline methods
#include "vtkWrappingHints.h"         // For VTK_MARSHALAUTO

VTK_ABI_NAMESPACE_BEGIN
class vtkDataArray;
class vtkStructuredCellArray;
class vtkLine;
class vtkMatrix3x3;
class vtkMatrix4x4;
class vtkPixel;
class vtkPoints;
class vtkVertex;
class vtkVoxel;

class VTKCOMMONDATAMODEL_EXPORT VTK_MARSHALAUTO vtkImageData : public vtkCartesianGrid
{
public:
  static vtkImageData* New();
  static vtkImageData* ExtendedNew();

  vtkTypeMacro(vtkImageData, vtkCartesianGrid);
  void PrintSelf(ostream& os, vtkIndent indent) override;

  int GetDataObjectType() VTK_FUTURE_CONST override { return VTK_IMAGE_DATA; }


  void ShallowCopy(vtkDataObject* src) override;
  void DeepCopy(vtkDataObject* src) override;

  void CopyStructure(vtkDataSet* ds) override;

  using Superclass::FindCell;
  using Superclass::GetCell;


  void GetCell(vtkIdType cellId, vtkGenericCell* cell) override;
  void GetCellBounds(vtkIdType cellId, double bounds[6]) override;
  using vtkDataSet::FindPoint;
  vtkIdType FindPoint(double x[3]) override;
  vtkIdType FindCell(double x[3], vtkCell* cell, vtkGenericCell* genCell, vtkIdType cellId,
    double tol2, int& subId, double pcoords[3], double* weights) override;
  void ComputeBounds() override;


  int ComputeStructuredCoordinates(const double x[3], int ijk[3], double pcoords[3]) override;
  virtual int ComputeStructuredCoordinates(
    const double x[3], int ijk[3], double pcoords[3], double tol2);

  vtkIdType ComputePointId(int ijk[3]) override;

  vtkIdType ComputeCellId(int ijk[3]) override;

  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 void SetAxisUpdateExtent(
    int axis, int min, int max, const int updateExtent[6], int axisUpdateExtent[6]);
  virtual void GetAxisUpdateExtent(int axis, int& min, int& max, const int updateExtent[6]);


  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(
    VTK_FUTURE_CONST int extent[6], vtkIdType& incX, vtkIdType& incY, vtkIdType& incZ);
  virtual void GetContinuousIncrements(vtkDataArray* scalars, VTK_FUTURE_CONST int extent[6],
    vtkIdType& incX, vtkIdType& incY, vtkIdType& incZ);


  virtual void* GetScalarPointerForExtent(VTK_FUTURE_CONST 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, VTK_FUTURE_CONST 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[6]) 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);


  void ApplyIndexToPhysicalMatrix(vtkMatrix4x4* source);


  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);


  void ApplyPhysicalToIndexMatrix(vtkMatrix4x4* source);


  virtual void TransformPhysicalPointToContinuousIndex(double x, double y, double z, double ijk[3]);
  virtual void TransformPhysicalPointToContinuousIndex(const double xyz[3], double ijk[3]);


  virtual void TransformPhysicalNormalToContinuousIndex(const double xyz[3], double ijk[3]);

  virtual void TransformPhysicalPlaneToContinuousIndex(double const pplane[4], double iplane[4]);


  static void ComputeIndexToPhysicalMatrix(
    double const origin[3], double const spacing[3], double const direction[9], double result[16]);


  static void ComputePhysicalToIndexMatrix(
    double const origin[3], double const spacing[3], double const direction[9], double result[16]);

  void CopyInformationFromPipeline(vtkInformation* information) override;

  void CopyInformationToPipeline(vtkInformation* information) override;

  void PrepareForNewData() 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, VTK_FUTURE_CONST int extent[6]);
  void* GetArrayPointer(vtkDataArray* array, VTK_FUTURE_CONST int coordinates[3]);
  void* GetArrayPointer(vtkDataArray* array, int x, int y, int z);

  void GetArrayIncrements(vtkDataArray* array, vtkIdType increments[3]);

  void ComputeInternalExtent(int* intExt, int* tgtExt, int* bnds);


  static vtkImageData* GetData(vtkInformation* info);
  static vtkImageData* GetData(vtkInformationVector* v, int i = 0);

protected:
  vtkImageData();
  ~vtkImageData() override;

  vtkIdType Increments[3];

  // Variables used to define dataset physical orientation
  double Origin[3];
  double Spacing[3];
  vtkMatrix3x3* DirectionMatrix;
  vtkMatrix4x4* IndexToPhysicalMatrix;
  vtkMatrix4x4* PhysicalToIndexMatrix;

  // 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 Active 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();

  void BuildPoints() override;

  void ComputeScalarRange() override;

private:
  void InternalImageDataCopy(vtkImageData* src);

  friend class vtkUniformGrid;

  bool DirectionMatrixIsIdentity;

  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 vtkIdType vtkImageData::ComputePointId(int ijk[3])
{
  return vtkStructuredData::ComputePointIdForExtent(this->GetExtent(), ijk);
}

//----------------------------------------------------------------------------
inline vtkIdType vtkImageData::ComputeCellId(int ijk[3])
{
  return vtkStructuredData::ComputeCellIdForExtent(this->GetExtent(), ijk);
}

VTK_ABI_NAMESPACE_END
#endif