vtkPolyData.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 vtkPolyData_h
#define vtkPolyData_h
 
#include "vtkCommonDataModelModule.h" // For export macro
#include "vtkPointSet.h"
#include "vtkWrappingHints.h" // For VTK_MARSHALAUTO
 
#include "vtkCellArray.h"         // Needed for inline methods
#include "vtkCellLinks.h"         // Needed for inline methods
#include "vtkPolyDataInternals.h" // Needed for inline methods
 
VTK_ABI_NAMESPACE_BEGIN
struct vtkPolyDataDummyContainter;
class vtkIncrementalPointLocator;
 
class VTKCOMMONDATAMODEL_EXPORT VTK_MARSHALAUTO vtkPolyData : public vtkPointSet
{
public:
  static vtkPolyData* New();
  static vtkPolyData* ExtendedNew();
 
  vtkTypeMacro(vtkPolyData, vtkPointSet);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
  int GetDataObjectType() override { return VTK_POLY_DATA; }
 
  void CopyStructure(vtkDataSet* ds) override;
 
 
  vtkIdType GetNumberOfCells() override;
  using vtkDataSet::GetCell;
  vtkCell* GetCell(vtkIdType cellId) override;
  void GetCell(vtkIdType cellId, vtkGenericCell* cell) override;
  int GetCellType(vtkIdType cellId) override;
  vtkIdType GetCellSize(vtkIdType cellId) override;
  void GetCellBounds(vtkIdType cellId, double bounds[6]) override;
  void GetCellNeighbors(vtkIdType cellId, vtkIdList* ptIds, vtkIdList* cellIds) override;
 
  void CopyCells(vtkPolyData* pd, vtkIdList* idList, vtkIncrementalPointLocator* locator = nullptr);
 
  void GetCellPoints(vtkIdType cellId, vtkIdList* ptIds) override;
 
  void GetPointCells(vtkIdType ptId, vtkIdList* cellIds) override;
 
  void ComputeCellsBounds();
 
  void GetCellsBounds(double bounds[6]);
 
  void Squeeze() override;
 
  int GetMaxCellSize() override;
 
 
  int GetMaxSpatialDimension() override;
  int GetMinSpatialDimension() override;
 
  vtkIdType GetCellIdRelativeToCellArray(vtkIdType cellId);
 
  void SetVerts(vtkCellArray* v);
 
  vtkCellArray* GetVerts();
 
  void SetLines(vtkCellArray* l);
 
  vtkCellArray* GetLines();
 
  void SetPolys(vtkCellArray* p);
 
  vtkCellArray* GetPolys();
 
  void SetStrips(vtkCellArray* s);
 
  vtkCellArray* GetStrips();
 
 
  vtkIdType GetNumberOfVerts() { return (this->Verts ? this->Verts->GetNumberOfCells() : 0); }
  vtkIdType GetNumberOfLines() { return (this->Lines ? this->Lines->GetNumberOfCells() : 0); }
  vtkIdType GetNumberOfPolys() { return (this->Polys ? this->Polys->GetNumberOfCells() : 0); }
  vtkIdType GetNumberOfStrips() { return (this->Strips ? this->Strips->GetNumberOfCells() : 0); }
 
  bool AllocateEstimate(vtkIdType numCells, vtkIdType maxCellSize);
 
  bool AllocateEstimate(vtkIdType numVerts, vtkIdType maxVertSize, vtkIdType numLines,
    vtkIdType maxLineSize, vtkIdType numPolys, vtkIdType maxPolySize, vtkIdType numStrips,
    vtkIdType maxStripSize);
 
  bool AllocateExact(vtkIdType numCells, vtkIdType connectivitySize);
 
  bool AllocateExact(vtkIdType numVerts, vtkIdType vertConnSize, vtkIdType numLines,
    vtkIdType lineConnSize, vtkIdType numPolys, vtkIdType polyConnSize, vtkIdType numStrips,
    vtkIdType stripConnSize);
 
  bool AllocateCopy(vtkPolyData* pd);
 
  bool AllocateProportional(vtkPolyData* pd, double ratio);
 
  void Allocate(vtkIdType numCells = 1000, int vtkNotUsed(extSize) = 1000)
  {
    this->AllocateExact(numCells, numCells);
  }
 
  void Allocate(vtkPolyData* inPolyData, vtkIdType numCells = 1000, int vtkNotUsed(extSize) = 1000)
  {
    this->AllocateProportional(
      inPolyData, static_cast<double>(numCells) / inPolyData->GetNumberOfCells());
  }
 
  vtkIdType InsertNextCell(int type, int npts, const vtkIdType pts[]) VTK_SIZEHINT(pts, npts);
 
  vtkIdType InsertNextCell(int type, vtkIdList* pts);
 
  void Reset();
 
  void BuildCells();
 
  bool NeedToBuildCells() { return this->Cells == nullptr; }
 
  void BuildLinks(int initialSize = 0);
 
 
  vtkSetSmartPointerMacro(Links, vtkAbstractCellLinks);
  vtkGetSmartPointerMacro(Links, vtkAbstractCellLinks);
 
  void DeleteCells();
 
  void DeleteLinks();
 
 
  void GetPointCells(vtkIdType ptId, vtkIdType& ncells, vtkIdType*& cells)
    VTK_SIZEHINT(cells, ncells);
 
  void GetCellEdgeNeighbors(vtkIdType cellId, vtkIdType p1, vtkIdType p2, vtkIdList* cellIds);
 
  unsigned char GetCellPoints(vtkIdType cellId, vtkIdType& npts, vtkIdType const*& pts)
    VTK_SIZEHINT(pts, npts);
 
  void GetCellPoints(vtkIdType cellId, vtkIdType& npts, vtkIdType const*& pts, vtkIdList* ptIds)
    VTK_SIZEHINT(pts, npts) override;
 
  int IsTriangle(int v1, int v2, int v3);
 
  int IsEdge(vtkIdType p1, vtkIdType p2);
 
  int IsPointUsedByCell(vtkIdType ptId, vtkIdType cellId);
 
  void ReplaceCell(vtkIdType cellId, vtkIdList* ids);
  void ReplaceCell(vtkIdType cellId, int npts, const vtkIdType pts[]) VTK_SIZEHINT(pts, npts);
 
  void ReplaceCellPoint(vtkIdType cellId, vtkIdType oldPtId, vtkIdType newPtId);
  void ReplaceCellPoint(
    vtkIdType cellId, vtkIdType oldPtId, vtkIdType newPtId, vtkIdList* cellPointIds);
 
  void ReverseCell(vtkIdType cellId);
 
 
  void DeletePoint(vtkIdType ptId);
  void DeleteCell(vtkIdType cellId);
 
  void RemoveDeletedCells();
 
 
  vtkIdType InsertNextLinkedPoint(int numLinks);
  vtkIdType InsertNextLinkedPoint(double x[3], int numLinks);
 
  vtkIdType InsertNextLinkedCell(int type, int npts, const vtkIdType pts[]) VTK_SIZEHINT(pts, npts);
 
  void ReplaceLinkedCell(vtkIdType cellId, int npts, const vtkIdType pts[]) VTK_SIZEHINT(pts, npts);
 
  void RemoveCellReference(vtkIdType cellId);
 
  void AddCellReference(vtkIdType cellId);
 
  void RemoveReferenceToCell(vtkIdType ptId, vtkIdType cellId);
 
  void AddReferenceToCell(vtkIdType ptId, vtkIdType cellId);
 
  void ResizeCellList(vtkIdType ptId, int size);
 
  void Initialize() override;
 
 
  virtual int GetPiece();
  virtual int GetNumberOfPieces();
 
  virtual int GetGhostLevel();
 
  unsigned long GetActualMemorySize() override;
 
 
  void ShallowCopy(vtkDataObject* src) override;
  void DeepCopy(vtkDataObject* src) override;
 
  void RemoveGhostCells();
 
 
  static vtkPolyData* GetData(vtkInformation* info);
  static vtkPolyData* GetData(vtkInformationVector* v, int i = 0);
 
  enum
  {
    ERR_NO_SUCH_FIELD = -4,
    ERR_INCORRECT_FIELD = -3,
    ERR_NON_MANIFOLD_STAR = -2,
    REGULAR_POINT = -1,
    MINIMUM = 0,
    SADDLE = 1,
    MAXIMUM = 2
  };
 
  int GetScalarFieldCriticalIndex(vtkIdType pointId, vtkDataArray* scalarField);
  int GetScalarFieldCriticalIndex(vtkIdType pointId, int fieldId);
  int GetScalarFieldCriticalIndex(vtkIdType pointId, const char* fieldName);
 
  vtkMTimeType GetMeshMTime() override;
 
  vtkMTimeType GetMTime() override;
 
  unsigned char GetCell(vtkIdType cellId, const vtkIdType*& pts);
 
protected:
  vtkPolyData();
  ~vtkPolyData() override;
 
  void ReportReferences(vtkGarbageCollector*) override;
 
  using TaggedCellId = vtkPolyData_detail::TaggedCellId;
  using CellMap = vtkPolyData_detail::CellMap;
 
  vtkCellArray* GetCellArrayInternal(TaggedCellId tag);
 
  // points inherited
  // point data (i.e., scalars, vectors, normals, tcoords) inherited
  vtkSmartPointer<vtkCellArray> Verts;
  vtkSmartPointer<vtkCellArray> Lines;
  vtkSmartPointer<vtkCellArray> Polys;
  vtkSmartPointer<vtkCellArray> Strips;
 
  // supporting structures for more complex topological operations
  // built only when necessary
  vtkSmartPointer<CellMap> Cells;
  vtkSmartPointer<vtkAbstractCellLinks> Links;
 
  vtkNew<vtkIdList> LegacyBuffer;
 
  // dummy static member below used as a trick to simplify traversal
  static vtkPolyDataDummyContainter DummyContainer;
 
  // Take into account only points that belong to at least one cell.
  double CellsBounds[6];
 
  vtkTimeStamp CellsBoundsTime;
 
private:
  void Cleanup();
 
  vtkPolyData(const vtkPolyData&) = delete;
  void operator=(const vtkPolyData&) = delete;
};
 
//------------------------------------------------------------------------------
inline vtkIdType vtkPolyData::GetNumberOfCells()
{
  return (this->GetNumberOfVerts() + this->GetNumberOfLines() + this->GetNumberOfPolys() +
    this->GetNumberOfStrips());
}
 
//------------------------------------------------------------------------------
inline int vtkPolyData::GetCellType(vtkIdType cellId)
{
  if (!this->Cells)
  {
    this->BuildCells();
  }
  return static_cast<int>(this->Cells->GetTag(cellId).GetCellType());
}
 
//------------------------------------------------------------------------------
inline vtkIdType vtkPolyData::GetCellSize(vtkIdType cellId)
{
  if (!this->Cells)
  {
    this->BuildCells();
  }
  switch (this->GetCellType(cellId))
  {
    case VTK_EMPTY_CELL:
      return 0;
    case VTK_VERTEX:
      return 1;
    case VTK_LINE:
      return 2;
    case VTK_TRIANGLE:
      return 3;
    case VTK_QUAD:
      return 4;
    case VTK_POLY_VERTEX:
      return this->Verts ? this->Verts->GetCellSize(this->GetCellIdRelativeToCellArray(cellId)) : 0;
    case VTK_POLY_LINE:
      return this->Lines ? this->Lines->GetCellSize(this->GetCellIdRelativeToCellArray(cellId)) : 0;
    case VTK_POLYGON:
      return this->Polys ? this->Polys->GetCellSize(this->GetCellIdRelativeToCellArray(cellId)) : 0;
    case VTK_TRIANGLE_STRIP:
      return this->Strips ? this->Strips->GetCellSize(this->GetCellIdRelativeToCellArray(cellId))
                          : 0;
  }
  vtkWarningMacro(<< "Cell type not supported.");
  return 0;
}
 
//------------------------------------------------------------------------------
inline int vtkPolyData::IsPointUsedByCell(vtkIdType ptId, vtkIdType cellId)
{
  vtkIdType npts;
  const vtkIdType* pts;
 
  this->GetCellPoints(cellId, npts, pts);
  for (vtkIdType i = 0; i < npts; i++)
  {
    if (pts[i] == ptId)
    {
      return 1;
    }
  }
 
  return 0;
}
 
//------------------------------------------------------------------------------
inline void vtkPolyData::DeletePoint(vtkIdType ptId)
{
  static_cast<vtkCellLinks*>(this->Links.Get())->DeletePoint(ptId);
}
 
//------------------------------------------------------------------------------
inline void vtkPolyData::DeleteCell(vtkIdType cellId)
{
  this->Cells->GetTag(cellId).MarkDeleted();
}
 
//------------------------------------------------------------------------------
inline void vtkPolyData::RemoveCellReference(vtkIdType cellId)
{
  const vtkIdType* pts;
  vtkIdType npts;
 
  this->GetCellPoints(cellId, npts, pts);
  auto links = static_cast<vtkCellLinks*>(this->Links.Get());
  for (vtkIdType i = 0; i < npts; i++)
  {
    links->RemoveCellReference(cellId, pts[i]);
  }
}
 
//------------------------------------------------------------------------------
inline void vtkPolyData::AddCellReference(vtkIdType cellId)
{
  const vtkIdType* pts;
  vtkIdType npts;
 
  this->GetCellPoints(cellId, npts, pts);
  auto links = static_cast<vtkCellLinks*>(this->Links.Get());
  for (vtkIdType i = 0; i < npts; i++)
  {
    links->AddCellReference(cellId, pts[i]);
  }
}
 
//------------------------------------------------------------------------------
inline void vtkPolyData::ResizeCellList(vtkIdType ptId, int size)
{
  static_cast<vtkCellLinks*>(this->Links.Get())->ResizeCellList(ptId, size);
}
 
//------------------------------------------------------------------------------
inline vtkCellArray* vtkPolyData::GetCellArrayInternal(vtkPolyData::TaggedCellId tag)
{
  switch (tag.GetTarget())
  {
    case vtkPolyData_detail::Target::Verts:
      return this->Verts;
    case vtkPolyData_detail::Target::Lines:
      return this->Lines;
    case vtkPolyData_detail::Target::Polys:
      return this->Polys;
    case vtkPolyData_detail::Target::Strips:
      return this->Strips;
  }
  return nullptr; // unreachable
}
 
//------------------------------------------------------------------------------
inline void vtkPolyData::ReplaceCellPoint(vtkIdType cellId, vtkIdType oldPtId, vtkIdType newPtId)
{
  vtkNew<vtkIdList> ids;
  this->ReplaceCellPoint(cellId, oldPtId, newPtId, ids);
}
 
//------------------------------------------------------------------------------
inline void vtkPolyData::ReplaceCellPoint(
  vtkIdType cellId, vtkIdType oldPtId, vtkIdType newPtId, vtkIdList* cellPointIds)
{
  if (!this->Cells)
  {
    this->BuildCells();
  }
  vtkIdType npts;
  const vtkIdType* pts;
  this->GetCellPoints(cellId, npts, pts, cellPointIds);
  for (vtkIdType i = 0; i < npts; i++)
  {
    if (pts[i] == oldPtId)
    {
      const TaggedCellId tag = this->Cells->GetTag(cellId);
      vtkCellArray* cells = this->GetCellArrayInternal(tag);
      cells->ReplaceCellPointAtId(tag.GetCellId(), i, newPtId);
      break;
    }
  }
}
 
//------------------------------------------------------------------------------
inline unsigned char vtkPolyData::GetCellPoints(
  vtkIdType cellId, vtkIdType& npts, vtkIdType const*& pts)
{
  if (!this->Cells)
  {
    this->BuildCells();
  }
 
  const TaggedCellId tag = this->Cells->GetTag(cellId);
  if (tag.IsDeleted())
  {
    npts = 0;
    pts = nullptr;
    return VTK_EMPTY_CELL;
  }
 
  vtkCellArray* cells = this->GetCellArrayInternal(tag);
  cells->GetCellAtId(tag.GetCellId(), npts, pts);
  return tag.GetCellType();
}
 
//------------------------------------------------------------------------------
inline void vtkPolyData::GetCellPoints(
  vtkIdType cellId, vtkIdType& npts, vtkIdType const*& pts, vtkIdList* ptIds)
{
  if (!this->Cells)
  {
    this->BuildCells();
  }
 
  const TaggedCellId tag = this->Cells->GetTag(cellId);
  if (tag.IsDeleted())
  {
    npts = 0;
    pts = nullptr;
  }
  else
  {
    vtkCellArray* cells = this->GetCellArrayInternal(tag);
    cells->GetCellAtId(tag.GetCellId(), npts, pts, ptIds);
  }
}
 
VTK_ABI_NAMESPACE_END
#endif