VTK  9.3.0
vtkPolyData.h
Go to the documentation of this file.
1 // SPDX-FileCopyrightText: Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
2 // SPDX-License-Identifier: BSD-3-Clause
56 #ifndef vtkPolyData_h
57 #define vtkPolyData_h
58 
59 #include "vtkCommonDataModelModule.h" // For export macro
60 #include "vtkPointSet.h"
61 
62 #include "vtkCellArray.h" // Needed for inline methods
63 #include "vtkCellLinks.h" // Needed for inline methods
64 #include "vtkPolyDataInternals.h" // Needed for inline methods
65 
66 VTK_ABI_NAMESPACE_BEGIN
67 class vtkVertex;
68 class vtkPolyVertex;
69 class vtkLine;
70 class vtkPolyLine;
71 class vtkTriangle;
72 class vtkQuad;
73 class vtkPolygon;
74 class vtkTriangleStrip;
75 class vtkEmptyCell;
76 struct vtkPolyDataDummyContainter;
78 
79 class VTKCOMMONDATAMODEL_EXPORT vtkPolyData : public vtkPointSet
80 {
81 public:
82  static vtkPolyData* New();
84 
85  vtkTypeMacro(vtkPolyData, vtkPointSet);
86  void PrintSelf(ostream& os, vtkIndent indent) override;
87 
91  int GetDataObjectType() override { return VTK_POLY_DATA; }
92 
96  void CopyStructure(vtkDataSet* ds) override;
97 
99 
102  vtkIdType GetNumberOfCells() override;
103  using vtkDataSet::GetCell;
104  vtkCell* GetCell(vtkIdType cellId) override;
105  void GetCell(vtkIdType cellId, vtkGenericCell* cell) override;
106  int GetCellType(vtkIdType cellId) override;
107  vtkIdType GetCellSize(vtkIdType cellId) override;
108  void GetCellBounds(vtkIdType cellId, double bounds[6]) override;
109  void GetCellNeighbors(vtkIdType cellId, vtkIdList* ptIds, vtkIdList* cellIds) override;
111 
119  void CopyCells(vtkPolyData* pd, vtkIdList* idList, vtkIncrementalPointLocator* locator = nullptr);
120 
124  void GetCellPoints(vtkIdType cellId, vtkIdList* ptIds) override;
125 
130  void GetPointCells(vtkIdType ptId, vtkIdList* cellIds) override;
131 
151 
157  void GetCellsBounds(double bounds[6]);
158 
165  void Squeeze() override;
166 
170  int GetMaxCellSize() override;
171 
178 
183 
189 
194 
200 
205 
211 
216 
223 
225 
228  vtkIdType GetNumberOfVerts() { return (this->Verts ? this->Verts->GetNumberOfCells() : 0); }
229  vtkIdType GetNumberOfLines() { return (this->Lines ? this->Lines->GetNumberOfCells() : 0); }
230  vtkIdType GetNumberOfPolys() { return (this->Polys ? this->Polys->GetNumberOfCells() : 0); }
231  vtkIdType GetNumberOfStrips() { return (this->Strips ? this->Strips->GetNumberOfCells() : 0); }
233 
243  bool AllocateEstimate(vtkIdType numCells, vtkIdType maxCellSize);
244 
254  bool AllocateEstimate(vtkIdType numVerts, vtkIdType maxVertSize, vtkIdType numLines,
255  vtkIdType maxLineSize, vtkIdType numPolys, vtkIdType maxPolySize, vtkIdType numStrips,
256  vtkIdType maxStripSize);
257 
267  bool AllocateExact(vtkIdType numCells, vtkIdType connectivitySize);
268 
279  bool AllocateExact(vtkIdType numVerts, vtkIdType vertConnSize, vtkIdType numLines,
280  vtkIdType lineConnSize, vtkIdType numPolys, vtkIdType polyConnSize, vtkIdType numStrips,
281  vtkIdType stripConnSize);
282 
292 
302  bool AllocateProportional(vtkPolyData* pd, double ratio);
303 
310  void Allocate(vtkIdType numCells = 1000, int vtkNotUsed(extSize) = 1000)
311  {
312  this->AllocateExact(numCells, numCells);
313  }
314 
325  void Allocate(vtkPolyData* inPolyData, vtkIdType numCells = 1000, int vtkNotUsed(extSize) = 1000)
326  {
327  this->AllocateProportional(
328  inPolyData, static_cast<double>(numCells) / inPolyData->GetNumberOfCells());
329  }
330 
338  vtkIdType InsertNextCell(int type, int npts, const vtkIdType pts[]) VTK_SIZEHINT(pts, npts);
339 
348 
353  void Reset();
354 
362  void BuildCells();
363 
367  bool NeedToBuildCells() { return this->Cells == nullptr; }
368 
375  void BuildLinks(int initialSize = 0);
376 
378 
383  virtual void SetLinks(vtkAbstractCellLinks* links);
386 
392  void DeleteCells();
393 
397  void DeleteLinks();
398 
400 
404  void GetPointCells(vtkIdType ptId, vtkIdType& ncells, vtkIdType*& cells)
405  VTK_SIZEHINT(cells, ncells);
407 
414 
426  unsigned char GetCellPoints(vtkIdType cellId, vtkIdType& npts, vtkIdType const*& pts)
427  VTK_SIZEHINT(pts, npts);
428 
443  void GetCellPoints(vtkIdType cellId, vtkIdType& npts, vtkIdType const*& pts, vtkIdList* ptIds)
444  VTK_SIZEHINT(pts, npts) override;
445 
450  int IsTriangle(int v1, int v2, int v3);
451 
460 
465  int IsPointUsedByCell(vtkIdType ptId, vtkIdType cellId);
466 
475  void ReplaceCell(vtkIdType cellId, vtkIdList* ids);
476  void ReplaceCell(vtkIdType cellId, int npts, const vtkIdType pts[]) VTK_SIZEHINT(pts, npts);
480 
489  void ReplaceCellPoint(vtkIdType cellId, vtkIdType oldPtId, vtkIdType newPtId);
490  void ReplaceCellPoint(
491  vtkIdType cellId, vtkIdType oldPtId, vtkIdType newPtId, vtkIdList* cellPointIds);
493 
498  void ReverseCell(vtkIdType cellId);
499 
501 
505  void DeletePoint(vtkIdType ptId);
506  void DeleteCell(vtkIdType cellId);
508 
518 
520 
529  vtkIdType InsertNextLinkedPoint(double x[3], int numLinks);
531 
538  vtkIdType InsertNextLinkedCell(int type, int npts, const vtkIdType pts[]) VTK_SIZEHINT(pts, npts);
539 
549  void ReplaceLinkedCell(vtkIdType cellId, int npts, const vtkIdType pts[]) VTK_SIZEHINT(pts, npts);
550 
558  void RemoveCellReference(vtkIdType cellId);
559 
567  void AddCellReference(vtkIdType cellId);
568 
577 
586 
592  void ResizeCellList(vtkIdType ptId, int size);
593 
597  void Initialize() override;
598 
600 
603  virtual int GetPiece();
604  virtual int GetNumberOfPieces();
606 
610  virtual int GetGhostLevel();
611 
620  unsigned long GetActualMemorySize() override;
621 
623 
626  void ShallowCopy(vtkDataObject* src) override;
627  void DeepCopy(vtkDataObject* src) override;
629 
637 
639 
643  static vtkPolyData* GetData(vtkInformationVector* v, int i = 0);
645 
664  enum
665  {
666  ERR_NO_SUCH_FIELD = -4,
667  ERR_INCORRECT_FIELD = -3,
668  ERR_NON_MANIFOLD_STAR = -2,
669  REGULAR_POINT = -1,
670  MINIMUM = 0,
671  SADDLE = 1,
672  MAXIMUM = 2
673  };
674 
676  int GetScalarFieldCriticalIndex(vtkIdType pointId, int fieldId);
677  int GetScalarFieldCriticalIndex(vtkIdType pointId, const char* fieldName);
678 
687 
691  vtkMTimeType GetMTime() override;
692 
702  unsigned char GetCell(vtkIdType cellId, const vtkIdType*& pts);
703 
704 protected:
706  ~vtkPolyData() override;
707 
709 
712 
713  vtkCellArray* GetCellArrayInternal(TaggedCellId tag);
714 
715  // constant cell objects returned by GetCell called.
725 
726  // points inherited
727  // point data (i.e., scalars, vectors, normals, tcoords) inherited
732 
733  // supporting structures for more complex topological operations
734  // built only when necessary
737 
739 
740  // dummy static member below used as a trick to simplify traversal
741  static vtkPolyDataDummyContainter DummyContainer;
742 
743  // Take into account only points that belong to at least one cell.
744  double CellsBounds[6];
745 
747 
748 private:
749  void Cleanup();
750 
751  vtkPolyData(const vtkPolyData&) = delete;
752  void operator=(const vtkPolyData&) = delete;
753 };
754 
755 //------------------------------------------------------------------------------
756 inline void vtkPolyData::GetPointCells(vtkIdType ptId, vtkIdType& ncells, vtkIdType*& cells)
757 {
758  ncells = this->Links->GetNcells(ptId);
759  cells = this->Links->GetCells(ptId);
760 }
761 
762 //------------------------------------------------------------------------------
764 {
765  return (this->GetNumberOfVerts() + this->GetNumberOfLines() + this->GetNumberOfPolys() +
766  this->GetNumberOfStrips());
767 }
768 
769 //------------------------------------------------------------------------------
771 {
772  if (!this->Cells)
773  {
774  this->BuildCells();
775  }
776  return static_cast<int>(this->Cells->GetTag(cellId).GetCellType());
777 }
778 
779 //------------------------------------------------------------------------------
781 {
782  if (!this->Cells)
783  {
784  this->BuildCells();
785  }
786  switch (this->GetCellType(cellId))
787  {
788  case VTK_EMPTY_CELL:
789  return 0;
790  case VTK_VERTEX:
791  return 1;
792  case VTK_LINE:
793  return 2;
794  case VTK_TRIANGLE:
795  return 3;
796  case VTK_QUAD:
797  return 4;
798  case VTK_POLY_VERTEX:
799  return this->Verts ? this->Verts->GetCellSize(this->GetCellIdRelativeToCellArray(cellId)) : 0;
800  case VTK_POLY_LINE:
801  return this->Lines ? this->Lines->GetCellSize(this->GetCellIdRelativeToCellArray(cellId)) : 0;
802  case VTK_POLYGON:
803  return this->Polys ? this->Polys->GetCellSize(this->GetCellIdRelativeToCellArray(cellId)) : 0;
804  case VTK_TRIANGLE_STRIP:
805  return this->Strips ? this->Strips->GetCellSize(this->GetCellIdRelativeToCellArray(cellId))
806  : 0;
807  }
808  vtkWarningMacro(<< "Cell type not supported.");
809  return 0;
810 }
811 
812 //------------------------------------------------------------------------------
813 inline int vtkPolyData::IsTriangle(int v1, int v2, int v3)
814 {
815  vtkIdType n1;
816  int i, j, tVerts[3];
817  vtkIdType* cells;
818  const vtkIdType* tVerts2;
819  vtkIdType n2;
820 
821  tVerts[0] = v1;
822  tVerts[1] = v2;
823  tVerts[2] = v3;
824 
825  for (i = 0; i < 3; i++)
826  {
827  this->GetPointCells(tVerts[i], n1, cells);
828  for (j = 0; j < n1; j++)
829  {
830  this->GetCellPoints(cells[j], n2, tVerts2);
831  if ((tVerts[0] == tVerts2[0] || tVerts[0] == tVerts2[1] || tVerts[0] == tVerts2[2]) &&
832  (tVerts[1] == tVerts2[0] || tVerts[1] == tVerts2[1] || tVerts[1] == tVerts2[2]) &&
833  (tVerts[2] == tVerts2[0] || tVerts[2] == tVerts2[1] || tVerts[2] == tVerts2[2]))
834  {
835  return 1;
836  }
837  }
838  }
839  return 0;
840 }
841 
842 //------------------------------------------------------------------------------
844 {
845  vtkIdType npts;
846  const vtkIdType* pts;
847 
848  this->GetCellPoints(cellId, npts, pts);
849  for (vtkIdType i = 0; i < npts; i++)
850  {
851  if (pts[i] == ptId)
852  {
853  return 1;
854  }
855  }
856 
857  return 0;
858 }
859 
860 //------------------------------------------------------------------------------
862 {
863  this->Links->DeletePoint(ptId);
864 }
865 
866 //------------------------------------------------------------------------------
868 {
869  this->Cells->GetTag(cellId).MarkDeleted();
870 }
871 
872 //------------------------------------------------------------------------------
874 {
875  const vtkIdType* pts;
876  vtkIdType npts;
877 
878  this->GetCellPoints(cellId, npts, pts);
879  for (vtkIdType i = 0; i < npts; i++)
880  {
881  this->Links->RemoveCellReference(cellId, pts[i]);
882  }
883 }
884 
885 //------------------------------------------------------------------------------
887 {
888  const vtkIdType* pts;
889  vtkIdType npts;
890 
891  this->GetCellPoints(cellId, npts, pts);
892  for (vtkIdType i = 0; i < npts; i++)
893  {
894  this->Links->AddCellReference(cellId, pts[i]);
895  }
896 }
897 
898 //------------------------------------------------------------------------------
900 {
901  this->Links->ResizeCellList(ptId, size);
902 }
903 
904 //------------------------------------------------------------------------------
906 {
907  switch (tag.GetTarget())
908  {
910  return this->Verts;
912  return this->Lines;
914  return this->Polys;
916  return this->Strips;
917  }
918  return nullptr; // unreachable
919 }
920 
921 //------------------------------------------------------------------------------
922 inline void vtkPolyData::ReplaceCellPoint(vtkIdType cellId, vtkIdType oldPtId, vtkIdType newPtId)
923 {
924  vtkNew<vtkIdList> ids;
925  this->ReplaceCellPoint(cellId, oldPtId, newPtId, ids);
926 }
927 
928 //------------------------------------------------------------------------------
930  vtkIdType cellId, vtkIdType oldPtId, vtkIdType newPtId, vtkIdList* cellPointIds)
931 {
932  if (!this->Cells)
933  {
934  this->BuildCells();
935  }
936  vtkIdType npts;
937  const vtkIdType* pts;
938  this->GetCellPoints(cellId, npts, pts, cellPointIds);
939  for (vtkIdType i = 0; i < npts; i++)
940  {
941  if (pts[i] == oldPtId)
942  {
943  const TaggedCellId tag = this->Cells->GetTag(cellId);
944  vtkCellArray* cells = this->GetCellArrayInternal(tag);
945  cells->ReplaceCellPointAtId(tag.GetCellId(), i, newPtId);
946  break;
947  }
948  }
949 }
950 
951 //------------------------------------------------------------------------------
952 inline unsigned char vtkPolyData::GetCellPoints(
953  vtkIdType cellId, vtkIdType& npts, vtkIdType const*& pts)
954 {
955  if (!this->Cells)
956  {
957  this->BuildCells();
958  }
959 
960  const TaggedCellId tag = this->Cells->GetTag(cellId);
961  if (tag.IsDeleted())
962  {
963  npts = 0;
964  pts = nullptr;
965  return VTK_EMPTY_CELL;
966  }
967 
968  vtkCellArray* cells = this->GetCellArrayInternal(tag);
969  cells->GetCellAtId(tag.GetCellId(), npts, pts);
970  return tag.GetCellType();
971 }
972 
973 //------------------------------------------------------------------------------
975  vtkIdType cellId, vtkIdType& npts, vtkIdType const*& pts, vtkIdList* ptIds)
976 {
977  if (!this->Cells)
978  {
979  this->BuildCells();
980  }
981 
982  const TaggedCellId tag = this->Cells->GetTag(cellId);
983  if (tag.IsDeleted())
984  {
985  npts = 0;
986  pts = nullptr;
987  }
988 
989  vtkCellArray* cells = this->GetCellArrayInternal(tag);
990  cells->GetCellAtId(tag.GetCellId(), npts, pts, ptIds);
991 }
992 
993 VTK_ABI_NAMESPACE_END
994 #endif
object to represent cell connectivity
Definition: vtkCellArray.h:176
vtkIdType GetCellSize(vtkIdType cellId) const
Return the size of the cell at cellId.
void GetCellAtId(vtkIdType cellId, vtkIdType &cellSize, vtkIdType const *&cellPoints)
Return the point ids for the cell at cellId.
void ReplaceCellPointAtId(vtkIdType cellId, vtkIdType cellPointIndex, vtkIdType newPointId)
Replaces the pointId at cellPointIndex of a cell with newPointId.
abstract class to specify cell behavior
Definition: vtkCell.h:50
abstract superclass for arrays of numeric data
Definition: vtkDataArray.h:45
general representation of visualization data
Definition: vtkDataObject.h:55
abstract class to specify dataset behavior
Definition: vtkDataSet.h:53
virtual vtkCell * GetCell(vtkIdType cellId)=0
Get cell with cellId such that: 0 <= cellId < NumberOfCells.
an empty cell used as a place-holder during processing
Definition: vtkEmptyCell.h:22
Detect and break reference loops.
provides thread-safe access to cells
list of point or cell ids
Definition: vtkIdList.h:23
Abstract class in support of both point location and point insertion.
a simple class to control print indentation
Definition: vtkIndent.h:29
Store zero or more vtkInformation instances.
Store vtkAlgorithm input/output information.
cell represents a 1D line
Definition: vtkLine.h:23
concrete class for storing a set of points
Definition: vtkPointSet.h:59
void GetPointCells(vtkIdType, vtkIdList *idList) override
This method resets parameter idList, as there is no cell in a vtkPointSet.
Definition: vtkPointSet.h:140
vtkIdType GetCellSize(vtkIdType) override
This method always returns 1, as all cells are point in a pure vtkPointSet.
Definition: vtkPointSet.h:158
vtkIdType GetNumberOfCells() override
This method always returns 0, as there are no cells in a vtkPointSet.
Definition: vtkPointSet.h:123
virtual void GetCellPoints(vtkIdType cellId, vtkIdList *ptIds)=0
This method resets parameter idList, as there is no cell in a vtkPointSet.
int GetCellType(vtkIdType) override
This method always returns VTK_EMPTY_CELL, as there is no cell in a vtkPointSet.
Definition: vtkPointSet.h:152
concrete dataset represents vertices, lines, polygons, and triangle strips
Definition: vtkPolyData.h:80
vtkIdType InsertNextCell(int type, int npts, const vtkIdType pts[])
Insert a cell of type VTK_VERTEX, VTK_POLY_VERTEX, VTK_LINE, VTK_POLY_LINE, VTK_TRIANGLE,...
vtkSmartPointer< vtkPolyVertex > PolyVertex
Definition: vtkPolyData.h:717
void GetCell(vtkIdType cellId, vtkGenericCell *cell) override
Standard vtkDataSet interface.
void Squeeze() override
Recover extra allocated memory when creating data whose initial size is unknown.
static vtkPolyData * GetData(vtkInformationVector *v, int i=0)
Retrieve an instance of this class from an information object.
bool NeedToBuildCells()
Check if BuildCells is needed.
Definition: vtkPolyData.h:367
bool AllocateEstimate(vtkIdType numCells, vtkIdType maxCellSize)
Preallocate memory for the internal cell arrays.
int GetScalarFieldCriticalIndex(vtkIdType pointId, const char *fieldName)
void SetPolys(vtkCellArray *p)
Set the cell array defining polygons.
vtkCellArray * GetCellArrayInternal(TaggedCellId tag)
Definition: vtkPolyData.h:905
vtkIdType GetCellIdRelativeToCellArray(vtkIdType cellId)
Maps the cell at position cellId inside the vtkPolyData to its location in the corresponding cell arr...
vtkCellArray * GetStrips()
Get the cell array defining triangle strips.
void GetCellsBounds(double bounds[6])
Get the cells bounds.
void RemoveCellReference(vtkIdType cellId)
Remove all references to cell in cell structure.
Definition: vtkPolyData.h:873
void ComputeCellsBounds()
Compute the (X, Y, Z) bounds of the data.
vtkIdType GetNumberOfLines()
Return the number of primitives of a particular type held.
Definition: vtkPolyData.h:229
bool AllocateEstimate(vtkIdType numVerts, vtkIdType maxVertSize, vtkIdType numLines, vtkIdType maxLineSize, vtkIdType numPolys, vtkIdType maxPolySize, vtkIdType numStrips, vtkIdType maxStripSize)
Preallocate memory for the internal cell arrays.
void GetCellPoints(vtkIdType cellId, vtkIdList *ptIds) override
Copy a cells point ids into list provided.
int IsTriangle(int v1, int v2, int v3)
Given three vertices, determine whether it's a triangle.
Definition: vtkPolyData.h:813
void SetLines(vtkCellArray *l)
Set the cell array defining lines.
void SetVerts(vtkCellArray *v)
Set the cell array defining vertices.
void PrintSelf(ostream &os, vtkIndent indent) override
Standard methods for type information and printing.
vtkSmartPointer< vtkCellLinks > Links
Definition: vtkPolyData.h:736
bool AllocateExact(vtkIdType numVerts, vtkIdType vertConnSize, vtkIdType numLines, vtkIdType lineConnSize, vtkIdType numPolys, vtkIdType polyConnSize, vtkIdType numStrips, vtkIdType stripConnSize)
Preallocate memory for the internal cell arrays.
void Initialize() override
Restore object to initial state.
void AddReferenceToCell(vtkIdType ptId, vtkIdType cellId)
Add a reference to a cell in a particular point's link list.
void GetCellNeighbors(vtkIdType cellId, vtkIdList *ptIds, vtkIdList *cellIds) override
Standard vtkDataSet interface.
~vtkPolyData() override
int GetScalarFieldCriticalIndex(vtkIdType pointId, int fieldId)
void ReplaceLinkedCell(vtkIdType cellId, int npts, const vtkIdType pts[])
Replace one cell with another in cell structure.
vtkGetSmartPointerMacro(Links, vtkAbstractCellLinks)
Set/Get the links that you created possibly without using BuildLinks.
void CopyStructure(vtkDataSet *ds) override
Copy the geometric and topological structure of an input poly data object.
vtkNew< vtkIdList > LegacyBuffer
Definition: vtkPolyData.h:738
int GetCellType(vtkIdType cellId) override
Standard vtkDataSet interface.
Definition: vtkPolyData.h:770
void GetCellBounds(vtkIdType cellId, double bounds[6]) override
Standard vtkDataSet interface.
void ReplaceCell(vtkIdType cellId, vtkIdList *ids)
Replace the points defining cell "cellId" with a new set of points.
virtual int GetGhostLevel()
Get the ghost level.
vtkMTimeType GetMTime() override
Get MTime which also considers its cell array MTime.
vtkSmartPointer< vtkCellArray > Verts
Definition: vtkPolyData.h:728
vtkSmartPointer< vtkPolyLine > PolyLine
Definition: vtkPolyData.h:719
vtkIdType GetNumberOfStrips()
Return the number of primitives of a particular type held.
Definition: vtkPolyData.h:231
int GetScalarFieldCriticalIndex(vtkIdType pointId, vtkDataArray *scalarField)
vtkCellArray * GetVerts()
Get the cell array defining vertices.
static vtkPolyData * ExtendedNew()
bool AllocateCopy(vtkPolyData *pd)
Preallocate memory for the internal cell arrays such that they are the same size as those in pd.
static vtkPolyData * GetData(vtkInformation *info)
Retrieve an instance of this class from an information object.
vtkIdType InsertNextLinkedCell(int type, int npts, const vtkIdType pts[])
Add a new cell to the cell data structure (after cell pointers have been built).
vtkIdType InsertNextCell(int type, vtkIdList *pts)
Insert a cell of type VTK_VERTEX, VTK_POLY_VERTEX, VTK_LINE, VTK_POLY_LINE, VTK_TRIANGLE,...
vtkIdType GetNumberOfPolys()
Return the number of primitives of a particular type held.
Definition: vtkPolyData.h:230
void ShallowCopy(vtkDataObject *src) override
Shallow and Deep copy.
vtkSmartPointer< vtkCellArray > Strips
Definition: vtkPolyData.h:731
vtkSmartPointer< vtkQuad > Quad
Definition: vtkPolyData.h:721
vtkCell * GetCell(vtkIdType cellId) override
Standard vtkDataSet interface.
void DeleteCell(vtkIdType cellId)
Mark a point/cell as deleted from this vtkPolyData.
Definition: vtkPolyData.h:867
vtkSmartPointer< vtkPolygon > Polygon
Definition: vtkPolyData.h:722
vtkIdType InsertNextLinkedPoint(double x[3], int numLinks)
Add a point to the cell data structure (after cell pointers have been built).
int GetMaxCellSize() override
Return the maximum cell size in this poly data.
void RemoveGhostCells()
This method will remove any cell that is marked as ghost (has the vtkDataSetAttributes::DUPLICATECELL...
vtkSmartPointer< vtkLine > Line
Definition: vtkPolyData.h:718
void ResizeCellList(vtkIdType ptId, int size)
Resize the list of cells using a particular point.
Definition: vtkPolyData.h:899
virtual int GetPiece()
Get the piece and the number of pieces.
vtkTimeStamp CellsBoundsTime
Definition: vtkPolyData.h:746
vtkCellArray * GetPolys()
Get the cell array defining polygons.
virtual void SetLinks(vtkAbstractCellLinks *links)
Set/Get the links that you created possibly without using BuildLinks.
vtkIdType GetNumberOfCells() override
Standard vtkDataSet interface.
Definition: vtkPolyData.h:763
bool AllocateExact(vtkIdType numCells, vtkIdType connectivitySize)
Preallocate memory for the internal cell arrays.
vtkIdType InsertNextLinkedPoint(int numLinks)
Add a point to the cell data structure (after cell pointers have been built).
unsigned char GetCell(vtkIdType cellId, const vtkIdType *&pts)
Get a pointer to the cell, ie [npts pid1 .
vtkSmartPointer< vtkCellArray > Polys
Definition: vtkPolyData.h:730
void Reset()
Begin inserting data all over again.
static vtkPolyData * New()
unsigned long GetActualMemorySize() override
Return the actual size of the data in kibibytes (1024 bytes).
void RemoveReferenceToCell(vtkIdType ptId, vtkIdType cellId)
Remove a reference to a cell in a particular point's link list.
int IsEdge(vtkIdType p1, vtkIdType p2)
Determine whether two points form an edge.
void ReplaceCell(vtkIdType cellId, int npts, const vtkIdType pts[])
Replace the points defining cell "cellId" with a new set of points.
static vtkPolyDataDummyContainter DummyContainer
Definition: vtkPolyData.h:741
void AddCellReference(vtkIdType cellId)
Add references to cell in cell structure.
Definition: vtkPolyData.h:886
int GetDataObjectType() override
Return what type of dataset this is.
Definition: vtkPolyData.h:91
void ReportReferences(vtkGarbageCollector *) override
vtkSmartPointer< vtkCellArray > Lines
Definition: vtkPolyData.h:729
void GetCellEdgeNeighbors(vtkIdType cellId, vtkIdType p1, vtkIdType p2, vtkIdList *cellIds)
Get the neighbors at an edge.
vtkSmartPointer< vtkEmptyCell > EmptyCell
Definition: vtkPolyData.h:724
virtual int GetNumberOfPieces()
Get the piece and the number of pieces.
void DeepCopy(vtkDataObject *src) override
Shallow and Deep copy.
void RemoveDeletedCells()
The cells marked by calls to DeleteCell are stored in the Cell Array VTK_EMPTY_CELL,...
vtkIdType GetNumberOfVerts()
Return the number of primitives of a particular type held.
Definition: vtkPolyData.h:228
void DeleteCells()
Release data structure that allows random access of the cells.
virtual vtkMTimeType GetMeshMTime()
Return the mesh (geometry/topology) modification time.
vtkSmartPointer< vtkVertex > Vertex
Definition: vtkPolyData.h:716
int IsPointUsedByCell(vtkIdType ptId, vtkIdType cellId)
Determine whether a point is used by a particular cell.
Definition: vtkPolyData.h:843
void ReplaceCellPoint(vtkIdType cellId, vtkIdType oldPtId, vtkIdType newPtId)
Replace a point in the cell connectivity list with a different point.
Definition: vtkPolyData.h:922
vtkSmartPointer< CellMap > Cells
Definition: vtkPolyData.h:735
void GetPointCells(vtkIdType ptId, vtkIdList *cellIds) override
Efficient method to obtain cells using a particular point.
vtkCellArray * GetLines()
Get the cell array defining lines.
vtkSmartPointer< vtkTriangle > Triangle
Definition: vtkPolyData.h:720
void BuildCells()
Create data structure that allows random access of cells.
void DeletePoint(vtkIdType ptId)
Mark a point/cell as deleted from this vtkPolyData.
Definition: vtkPolyData.h:861
void CopyCells(vtkPolyData *pd, vtkIdList *idList, vtkIncrementalPointLocator *locator=nullptr)
Copy cells listed in idList from pd, including points, point data, and cell data.
void Allocate(vtkIdType numCells=1000, int vtkNotUsed(extSize)=1000)
Method allocates initial storage for vertex, line, polygon, and triangle strip arrays.
Definition: vtkPolyData.h:310
void BuildLinks(int initialSize=0)
Create upward links from points to cells that use each point.
vtkIdType GetCellSize(vtkIdType cellId) override
Standard vtkDataSet interface.
Definition: vtkPolyData.h:780
void Allocate(vtkPolyData *inPolyData, vtkIdType numCells=1000, int vtkNotUsed(extSize)=1000)
Similar to the method above, this method allocates initial storage for vertex, line,...
Definition: vtkPolyData.h:325
void DeleteLinks()
Release the upward links from point to cells that use each point.
void ReverseCell(vtkIdType cellId)
Reverse the order of point ids defining the cell.
vtkSmartPointer< vtkTriangleStrip > TriangleStrip
Definition: vtkPolyData.h:723
void SetStrips(vtkCellArray *s)
Set the cell array defining triangle strips.
bool AllocateProportional(vtkPolyData *pd, double ratio)
Preallocate memory for the internal cell arrays such that they are proportional to those in pd by a f...
cell represents a set of 1D lines
Definition: vtkPolyLine.h:30
cell represents a set of 0D vertices
Definition: vtkPolyVertex.h:25
a cell that represents an n-sided polygon
Definition: vtkPolygon.h:32
a cell that represents a 2D quadrilateral
Definition: vtkQuad.h:28
record modification and/or execution time
Definition: vtkTimeStamp.h:25
a cell that represents a triangle strip
a cell that represents a triangle
Definition: vtkTriangle.h:28
a cell that represents a 3D point
Definition: vtkVertex.h:23
@ info
Definition: vtkX3D.h:376
@ type
Definition: vtkX3D.h:516
@ size
Definition: vtkX3D.h:253
unsigned char GetCellType() const noexcept
vtkIdType GetCellId() const noexcept
@ VTK_TRIANGLE_STRIP
Definition: vtkCellType.h:43
@ VTK_POLY_LINE
Definition: vtkCellType.h:41
@ VTK_TRIANGLE
Definition: vtkCellType.h:42
@ VTK_POLYGON
Definition: vtkCellType.h:44
@ VTK_EMPTY_CELL
Definition: vtkCellType.h:37
@ VTK_LINE
Definition: vtkCellType.h:40
@ VTK_QUAD
Definition: vtkCellType.h:46
@ VTK_VERTEX
Definition: vtkCellType.h:38
@ VTK_POLY_VERTEX
Definition: vtkCellType.h:39
int vtkIdType
Definition: vtkType.h:315
vtkTypeUInt32 vtkMTimeType
Definition: vtkType.h:270
#define VTK_POLY_DATA
Definition: vtkType.h:65
#define VTK_SIZEHINT(...)