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

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

  void Squeeze() override;

  int GetMaxCellSize() override;

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

  void DeleteCells();

  void DeleteLinks();


  void GetPointCells(vtkIdType ptId, vtkIdType& ncells, vtkIdType*& cells)
    VTK_SIZEHINT(cells, ncells);
#ifndef VTK_LEGACY_REMOVE
  VTK_LEGACY(void GetPointCells(vtkIdType ptId, unsigned short& ncells, vtkIdType*& cells))
  VTK_SIZEHINT(cells, ncells);
#endif


  void GetCellEdgeNeighbors(vtkIdType cellId, vtkIdType p1, vtkIdType p2, vtkIdList* cellIds);

  unsigned char GetCellPoints(vtkIdType cellId, vtkIdType& npts, vtkIdType const*& pts)
    VTK_SIZEHINT(pts, npts);

  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;

private:
  // Hide these from the user and the compiler.

  void GetCellNeighbors(vtkIdType cellId, vtkIdList& ptIds, vtkIdList& cellIds)
  {
    this->GetCellNeighbors(cellId, &ptIds, &cellIds);
  }

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

#ifndef VTK_LEGACY_REMOVE
inline void vtkPolyData::GetPointCells(vtkIdType ptId, unsigned short& ncells, vtkIdType*& cells)
{
  VTK_LEGACY_BODY(vtkPolyData::GetPointCells, "VTK 9.0");
  ncells = static_cast<unsigned short>(this->Links->GetNcells(ptId));
  cells = this->Links->GetCells(ptId);
}
#endif

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

#endif