vtkDataSet.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 vtkDataSet_h
#define vtkDataSet_h
 
#include "vtkCommonDataModelModule.h" // For export macro
#include "vtkDataObject.h"
#include "vtkNew.h"           // For vtkNew
#include "vtkSmartPointer.h"  // For vtkSmartPointer
#include "vtkWrappingHints.h" // For VTK_MARSHALAUTO
 
VTK_ABI_NAMESPACE_BEGIN
class vtkCell;
class vtkCellData;
class vtkCellIterator;
class vtkCellTypes;
class vtkGenericCell;
class vtkIdList;
class vtkPointData;
class vtkPoints;
class vtkUnsignedCharArray;
class vtkCallbackCommand;
 
class VTKCOMMONDATAMODEL_EXPORT VTK_MARSHALAUTO vtkDataSet : public vtkDataObject
{
public:
  vtkTypeMacro(vtkDataSet, vtkDataObject);
  void PrintSelf(ostream& os, vtkIndent indent) override;

  virtual void CopyStructure(vtkDataSet* ds) = 0;

  virtual void CopyAttributes(vtkDataSet* ds);

  virtual vtkIdType GetNumberOfPoints() = 0;

  virtual vtkIdType GetNumberOfCells() = 0;

  virtual vtkPoints* GetPoints();

  virtual double* GetPoint(vtkIdType ptId) VTK_SIZEHINT(3) = 0;

  virtual void GetPoint(vtkIdType id, double x[3]);

  VTK_NEWINSTANCE
  virtual vtkCellIterator* NewCellIterator();

  virtual vtkCell* GetCell(vtkIdType cellId) = 0;
  virtual vtkCell* GetCell(int vtkNotUsed(i), int vtkNotUsed(j), int vtkNotUsed(k))
  {
    vtkErrorMacro("ijk indices are only valid with structured data!");
    return nullptr;
  }
 
  void SetCellOrderAndRationalWeights(vtkIdType cellId, vtkGenericCell* cell);

  virtual void GetCell(vtkIdType cellId, vtkGenericCell* cell) = 0;

  virtual void GetCellBounds(vtkIdType cellId, double bounds[6]);

  virtual int GetCellType(vtkIdType cellId) = 0;

  virtual vtkIdType GetCellSize(vtkIdType cellId);

  virtual void GetDistinctCellTypes(vtkCellTypes* types);

  virtual void GetCellPoints(vtkIdType cellId, vtkIdList* ptIds) = 0;

  virtual void GetCellPoints(vtkIdType cellId, vtkIdType& npts, vtkIdType const*& pts,
    vtkIdList* ptIds) VTK_SIZEHINT(pts, npts);

  virtual void GetPointCells(vtkIdType ptId, vtkIdList* cellIds) = 0;

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

  virtual int GetCellNumberOfFaces(
    vtkIdType cellId, unsigned char& cellType, vtkGenericCell* tempCell);


  virtual void GetCellFacePoints(vtkIdType cellId, int faceId, vtkIdList* facePtIds,
    unsigned char& cellType, vtkIdList* tempCellPointIds, vtkGenericCell* tempCell);
  virtual void GetCellFacePointsFromCellPoints(vtkIdType cellId, int faceId, vtkIdList* facePtIds,
    unsigned char cellType, vtkIdType cellNpts, const vtkIdType* cellPts, vtkGenericCell* tempCell);

  virtual int GetCellNumberOfEdges(
    vtkIdType cellId, unsigned char& cellType, vtkGenericCell* tempCell);


  virtual void GetCellEdgePoints(vtkIdType cellId, int edgeId, vtkIdList* edgePtIds,
    unsigned char& cellType, vtkIdList* tempCellPointIds, vtkGenericCell* tempCell);
  virtual void GetCellEdgePointsFromCellPoints(vtkIdType cellId, int edgeId, vtkIdList* edgePtIds,
    unsigned char cellType, vtkIdType cellNpts, const vtkIdType* cellPts, vtkGenericCell* tempCell);


  vtkIdType FindPoint(double x, double y, double z)
  {
    double xyz[3];
    xyz[0] = x;
    xyz[1] = y;
    xyz[2] = z;
    return this->FindPoint(xyz);
  }
  virtual vtkIdType FindPoint(double x[3]) = 0;

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

  virtual vtkCell* FindAndGetCell(double x[3], vtkCell* cell, vtkIdType cellId, double tol2,
    int& subId, double pcoords[3], double* weights);

  vtkMTimeType GetMTime() override;

  vtkCellData* GetCellData() { return this->CellData; }

  vtkPointData* GetPointData() { return this->PointData; }

  virtual void Squeeze();

  virtual void ComputeBounds();

  double* GetBounds() VTK_SIZEHINT(6);

  void GetBounds(double bounds[6]);

  double* GetCenter() VTK_SIZEHINT(3);

  void GetCenter(double center[3]);

  double GetLength();

  double GetLength2();

  double GetSampledMaxCellLength2(vtkIdType numSamples = 100);

  void Initialize() override;

  virtual void GetScalarRange(double range[2]);

  double* GetScalarRange() VTK_SIZEHINT(2);

  virtual int GetMaxCellSize() = 0;


  virtual int GetMaxSpatialDimension();
  virtual int GetMinSpatialDimension();

  unsigned long GetActualMemorySize() override;

  int GetDataObjectType() VTK_FUTURE_CONST override { return VTK_DATA_SET; }


  void ShallowCopy(vtkDataObject* src) override;
  void DeepCopy(vtkDataObject* src) override;
 
  enum FieldDataType
  {
    DATA_OBJECT_FIELD = 0,
    POINT_DATA_FIELD = 1,
    CELL_DATA_FIELD = 2
  };

  int CheckAttributes();


  virtual void GenerateGhostArray(int zeroExt[6]) { this->GenerateGhostArray(zeroExt, false); }
  virtual void GenerateGhostArray(int zeroExt[6], bool cellOnly);


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

  vtkFieldData* GetAttributesAsFieldData(int type) override;

  vtkIdType GetNumberOfElements(int type) override;

  virtual vtkMTimeType GetMeshMTime();

  bool HasAnyGhostCells();
  bool HasAnyGhostPoints();
  virtual bool HasAnyBlankCells() { return false; }
  virtual bool HasAnyBlankPoints() { return false; }

  vtkUnsignedCharArray* GetPointGhostArray();

  vtkUnsignedCharArray* AllocatePointGhostArray();

  vtkUnsignedCharArray* GetCellGhostArray();

  vtkUnsignedCharArray* AllocateCellGhostArray();
  vtkUnsignedCharArray* GetGhostArray(int type) override;

  bool SupportsGhostArray(int type) override;
 
protected:
  // Constructor with default bounds (0,1, 0,1, 0,1).
  vtkDataSet();
  ~vtkDataSet() override;
 
  vtkNew<vtkGenericCell> GenericCell; // used by GetCell()

  vtkMTimeType GetGhostCellsTime();

  virtual void ComputeScalarRange();
 
  vtkCellData* CellData;            // Scalars, vectors, etc. associated w/ each cell
  vtkPointData* PointData;          // Scalars, vectors, etc. associated w/ each point
  vtkCallbackCommand* DataObserver; // Observes changes to cell/point data
  vtkTimeStamp ComputeTime;         // Time at which bounds, center, etc. computed
  double Bounds[6];                 // (xmin,xmax, ymin,ymax, zmin,zmax) geometric bounds
  double Center[3];
 
  // Cached scalar range
  double ScalarRange[2];
 
  // Time at which scalar range is computed
  vtkTimeStamp ScalarRangeComputeTime;
 
private:
  void InternalDataSetCopy(vtkDataSet* src);
 
  // This should only be used if a vtkDataSet subclass don't define GetPoints()
  vtkSmartPointer<vtkPoints> TempPoints;
 
  vtkDataSet(const vtkDataSet&) = delete;
  void operator=(const vtkDataSet&) = delete;
};
 
inline void vtkDataSet::GetPoint(vtkIdType id, double x[3])
{
  double* pt = this->GetPoint(id);
  x[0] = pt[0];
  x[1] = pt[1];
  x[2] = pt[2];
}
 
VTK_ABI_NAMESPACE_END
#endif