vtkCartesianGrid.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 vtkCartesianGrid_h
#define vtkCartesianGrid_h

#include "vtkCommonDataModelModule.h" // For export macro
#include "vtkConstantArray.h"         // For vtkConstantArray
#include "vtkDataSet.h"
#include "vtkDeprecation.h"    // For VTK_DEPRECATED_IN_9_6_0()
#include "vtkStructuredData.h" // For inline methods

VTK_ABI_NAMESPACE_BEGIN
class vtkStructuredCellArray;
class VTKCOMMONDATAMODEL_EXPORT VTK_MARSHALAUTO vtkCartesianGrid : public vtkDataSet
{
public:

  vtkTypeMacro(vtkCartesianGrid, vtkDataSet);
  void PrintSelf(ostream& os, vtkIndent indent) override;
  void ShallowCopy(vtkDataObject* src) override;
  void DeepCopy(vtkDataObject* src) override;
  void CopyStructure(vtkDataSet* ds) override;

  int GetDataObjectType() VTK_FUTURE_CONST override { return VTK_CARTESIAN_GRID; }

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


  vtkPoints* GetPoints() override;
  void GetPoint(vtkIdType id, double x[3]) override;
  double* GetPoint(vtkIdType ptId) VTK_SIZEHINT(3) override;
  vtkIdType GetNumberOfCells() override;
  vtkIdType GetNumberOfPoints() override;
  int GetMaxSpatialDimension() override;
  int GetMinSpatialDimension() override;
  int GetCellType(vtkIdType cellId) override;
  vtkIdType GetCellSize(vtkIdType cellId) override;
  void GetCellPoints(vtkIdType cellId, vtkIdType& npts, vtkIdType const*& pts, vtkIdList* ptIds)
    VTK_SIZEHINT(pts, npts) override;
  void GetCellPoints(vtkIdType cellId, vtkIdList* ptIds) override;
  vtkIdType FindCell(double x[3], vtkCell* cell, vtkIdType cellId, double tol2, int& subId,
    double pcoords[3], double* weights) override;
  void GetPointCells(vtkIdType ptId, vtkIdList* cellIds) override
  {
    vtkStructuredData::GetPointCells(ptId, cellIds, this->GetDimensions());
  }
  int GetMaxCellSize() override { return 8; } // voxel is the largest
  void GetCellNeighbors(vtkIdType cellId, vtkIdList* ptIds, vtkIdList* cellIds) override;
  vtkCell* GetCell(vtkIdType cellId) override;
  vtkCell* GetCell(int i, int j, int k) override;
  bool HasAnyBlankPoints() override;
  bool HasAnyBlankCells() override;
  void Initialize() override;

  virtual int ComputeStructuredCoordinates(const double x[3], int ijk[3], double pcoords[3]) = 0;

  virtual vtkIdType ComputePointId(int ijk[3]) = 0;

  virtual vtkIdType ComputeCellId(int ijk[3]) = 0;

  void GetCellNeighbors(vtkIdType cellId, vtkIdList* ptIds, vtkIdList* cellIds, int* seedLoc);

  int GetDataDimension();

  vtkStructuredCellArray* GetCells();


  using vtkDataSet::GetCellTypes; // VTK_DEPRECATED_IN_9_6_0
  vtkConstantArray<unsigned char>* GetCellTypes();
  VTK_DEPRECATED_IN_9_6_0("Use vtkConstantArray<unsigned char>* GetCellTypes() instead")
  vtkConstantArray<int>* GetCellTypesArray();

  void GetCellDims(int cellDims[3]);


  virtual void BlankPoint(vtkIdType ptId);
  virtual void UnBlankPoint(vtkIdType ptId);
  virtual void BlankPoint(int i, int j, int k);
  virtual void UnBlankPoint(int i, int j, int k);


  virtual void BlankCell(vtkIdType ptId);
  virtual void UnBlankCell(vtkIdType ptId);
  virtual void BlankCell(int i, int j, int k);
  virtual void UnBlankCell(int i, int j, int k);

  unsigned char IsPointVisible(vtkIdType ptId);

  unsigned char IsCellVisible(vtkIdType cellId);

  vtkGetMacro(DataDescription, int);


  void SetDimensions(int i, int j, int k) { this->SetExtent(0, i - 1, 0, j - 1, 0, k - 1); };
  void SetDimensions(const int dim[3])
  {
    this->SetExtent(0, dim[0] - 1, 0, dim[1] - 1, 0, dim[2] - 1);
  };

  int* GetDimensions() VTK_SIZEHINT(3);

  void GetDimensions(int dims[3]);
#if VTK_ID_TYPE_IMPL != VTK_INT
  void GetDimensions(vtkIdType dims[3]);
#endif

  int GetExtentType() VTK_FUTURE_CONST override { return VTK_3D_EXTENT; }


  void SetExtent(VTK_FUTURE_CONST int extent[6]);
  void SetExtent(int xMin, int xMax, int yMin, int yMax, int zMin, int zMax);
  vtkGetVector6Macro(Extent, int);


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


  vtkIdType GetTupleIndexForExtent(vtkDataArray* array, VTK_FUTURE_CONST int extent[6]);
  vtkIdType GetTupleIndex(vtkDataArray* array, VTK_FUTURE_CONST int coordinates[3]);
  vtkIdType GetTupleIndex(vtkDataArray* array, int x, int y, int z);


  vtkIdType GetValueIndexForExtent(vtkDataArray* array, VTK_FUTURE_CONST int extent[6]);
  vtkIdType GetValueIndex(vtkDataArray* array, VTK_FUTURE_CONST int coordinates[3]);
  vtkIdType GetValueIndex(vtkDataArray* array, int x, int y, int z);


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

protected:
  vtkCartesianGrid();
  ~vtkCartesianGrid() override = default;

  void SetStructuredPoints(vtkPoints*);

  virtual void BuildPoints() = 0;

private:
  // Build internals fields
  void BuildImplicitStructures();
  void BuildCells();
  void BuildCellTypes();

  // API members
  int DataDescription = vtkStructuredData::VTK_STRUCTURED_EMPTY;
  int Dimensions[3] = { 0, 0, 0 };
  int Extent[6] = { 0, -1, 0, -1, 0, -1 };

  // For the GetPoint method
  double Point[3] = { 0, 0, 0 };

  // Internals fields
  vtkSmartPointer<vtkPoints> StructuredPoints;
  vtkSmartPointer<vtkStructuredCellArray> StructuredCells;
  vtkSmartPointer<vtkConstantArray<unsigned char>> StructuredCellTypes;
  vtkSmartPointer<vtkConstantArray<int>> LegacyStructuredCellTypes; // VTK_DEPRECATED_IN_9_6_0
};

//----------------------------------------------------------------------------
inline double* vtkCartesianGrid::GetPoint(vtkIdType id)
{
  this->GetPoint(id, this->Point);
  return this->Point;
}

//----------------------------------------------------------------------------
inline vtkIdType vtkCartesianGrid::GetNumberOfPoints()
{
  return vtkStructuredData::GetNumberOfPoints(this->Extent);
}

//----------------------------------------------------------------------------
inline vtkIdType vtkCartesianGrid::GetNumberOfCells()
{
  return vtkStructuredData::GetNumberOfCells(this->Extent);
}

//----------------------------------------------------------------------------
inline int vtkCartesianGrid::GetDataDimension()
{
  return vtkStructuredData::GetDataDimension(this->DataDescription);
}

//----------------------------------------------------------------------------
inline int vtkCartesianGrid::GetMaxSpatialDimension()
{
  return vtkStructuredData::GetDataDimension(this->DataDescription);
}

//----------------------------------------------------------------------------
inline int vtkCartesianGrid::GetMinSpatialDimension()
{
  return vtkStructuredData::GetDataDimension(this->DataDescription);
}

VTK_ABI_NAMESPACE_END
#endif