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 "vtkDataSet.h"
#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, 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;
  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();
 
  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(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();
 
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<int>> StructuredCellTypes;
};
 
//----------------------------------------------------------------------------
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