vtkPolyData.h

Go to the documentation of this file.

/*=========================================================================
 
  Program:   Visualization Toolkit
  Module:    vtkPolyData.h
 
  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
  All rights reserved.
  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
 
     This software is distributed WITHOUT ANY WARRANTY; without even
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
     PURPOSE.  See the above copyright notice for more information.
 
=========================================================================*/
#ifndef vtkPolyData_h
#define vtkPolyData_h
 
#include "vtkCommonDataModelModule.h" // For export macro
#include "vtkPointSet.h"
 
#include "vtkCellArray.h"         // Needed for inline methods
#include "vtkCellLinks.h"         // Needed for inline methods
#include "vtkPolyDataInternals.h" // Needed for inline methods
 
class vtkVertex;
class vtkPolyVertex;
class vtkLine;
class vtkPolyLine;
class vtkTriangle;
class vtkQuad;
class vtkPolygon;
class vtkTriangleStrip;
class vtkEmptyCell;
struct vtkPolyDataDummyContainter;
class vtkIncrementalPointLocator;
 
class VTKCOMMONDATAMODEL_EXPORT 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;
 
  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);
 
 
  virtual void SetLinks(vtkAbstractCellLinks* links);
  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 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);
 
  virtual vtkMTimeType GetMeshMTime();
 
  vtkMTimeType GetMTime() override;
 
  unsigned char GetCell(vtkIdType cellId, const vtkIdType*& pts);
 
protected:
  vtkPolyData();
  ~vtkPolyData() override;
 
  using TaggedCellId = vtkPolyData_detail::TaggedCellId;
  using CellMap = vtkPolyData_detail::CellMap;
 
  vtkCellArray* GetCellArrayInternal(TaggedCellId tag);
 
  // constant cell objects returned by GetCell called.
  vtkSmartPointer<vtkVertex> Vertex;
  vtkSmartPointer<vtkPolyVertex> PolyVertex;
  vtkSmartPointer<vtkLine> Line;
  vtkSmartPointer<vtkPolyLine> PolyLine;
  vtkSmartPointer<vtkTriangle> Triangle;
  vtkSmartPointer<vtkQuad> Quad;
  vtkSmartPointer<vtkPolygon> Polygon;
  vtkSmartPointer<vtkTriangleStrip> TriangleStrip;
  vtkSmartPointer<vtkEmptyCell> EmptyCell;
 
  // 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<vtkCellLinks> 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();
 
private:
  vtkPolyData(const vtkPolyData&) = delete;
  void operator=(const vtkPolyData&) = delete;
};
 
//------------------------------------------------------------------------------
inline void vtkPolyData::GetPointCells(vtkIdType ptId, vtkIdType& ncells, vtkIdType*& cells)
{
  ncells = this->Links->GetNcells(ptId);
  cells = this->Links->GetCells(ptId);
}
 
//------------------------------------------------------------------------------
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::IsTriangle(int v1, int v2, int v3)
{
  vtkIdType n1;
  int i, j, tVerts[3];
  vtkIdType* cells;
  const vtkIdType* tVerts2;
  vtkIdType n2;
 
  tVerts[0] = v1;
  tVerts[1] = v2;
  tVerts[2] = v3;
 
  for (i = 0; i < 3; i++)
  {
    this->GetPointCells(tVerts[i], n1, cells);
    for (j = 0; j < n1; j++)
    {
      this->GetCellPoints(cells[j], n2, tVerts2);
      if ((tVerts[0] == tVerts2[0] || tVerts[0] == tVerts2[1] || tVerts[0] == tVerts2[2]) &&
        (tVerts[1] == tVerts2[0] || tVerts[1] == tVerts2[1] || tVerts[1] == tVerts2[2]) &&
        (tVerts[2] == tVerts2[0] || tVerts[2] == tVerts2[1] || tVerts[2] == tVerts2[2]))
      {
        return 1;
      }
    }
  }
  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)
{
  this->Links->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);
  for (vtkIdType i = 0; i < npts; i++)
  {
    this->Links->RemoveCellReference(cellId, pts[i]);
  }
}
 
//------------------------------------------------------------------------------
inline void vtkPolyData::AddCellReference(vtkIdType cellId)
{
  const vtkIdType* pts;
  vtkIdType npts;
 
  this->GetCellPoints(cellId, npts, pts);
  for (vtkIdType i = 0; i < npts; i++)
  {
    this->Links->AddCellReference(cellId, pts[i]);
  }
}
 
//------------------------------------------------------------------------------
inline void vtkPolyData::ResizeCellList(vtkIdType ptId, int size)
{
  this->Links->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->GetCellPoints(cellId, ids);
  for (vtkIdType i = 0; i < ids->GetNumberOfIds(); i++)
  {
    if (ids->GetId(i) == oldPtId)
    {
      ids->SetId(i, newPtId);
      break;
    }
  }
  this->ReplaceCell(cellId, static_cast<int>(ids->GetNumberOfIds()), ids->GetPointer(0));
}
 
//------------------------------------------------------------------------------
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;
  }
 
  vtkCellArray* cells = this->GetCellArrayInternal(tag);
  cells->GetCellAtId(tag.GetCellId(), npts, pts, ptIds);
}
 
#endif