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
66VTK_ABI_NAMESPACE_BEGIN
67class vtkVertex;
68class vtkPolyVertex;
69class vtkLine;
70class vtkPolyLine;
71class vtkTriangle;
72class vtkQuad;
73class vtkPolygon;
75class vtkEmptyCell;
76struct vtkPolyDataDummyContainter;
78
79class VTKCOMMONDATAMODEL_EXPORT vtkPolyData : public vtkPointSet
80{
81public:
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;
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
363
367 bool NeedToBuildCells() { return this->Cells == nullptr; }
368
375 void BuildLinks(int initialSize = 0);
376
378
383 virtual void SetLinks(vtkAbstractCellLinks* links);
386
393
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
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
692
702 unsigned char GetCell(vtkIdType cellId, const vtkIdType*& pts);
703
704protected:
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
748private:
749 void Cleanup();
750
751 vtkPolyData(const vtkPolyData&) = delete;
752 void operator=(const vtkPolyData&) = delete;
753};
754
755//------------------------------------------------------------------------------
756inline 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;
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//------------------------------------------------------------------------------
813inline 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//------------------------------------------------------------------------------
899inline void vtkPolyData::ResizeCellList(vtkIdType ptId, int size)
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//------------------------------------------------------------------------------
922inline void vtkPolyData::ReplaceCellPoint(vtkIdType cellId, vtkIdType oldPtId, vtkIdType newPtId)
923{
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//------------------------------------------------------------------------------
952inline 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
993VTK_ABI_NAMESPACE_END
994#endif
object to represent cell connectivity
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
general representation of visualization data
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
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
Allocate and hold a VTK object.
Definition vtkNew.h:51
concrete class for storing a set of points
Definition vtkPointSet.h:59
void GetCellPoints(vtkIdType, vtkIdList *idList) override
This method resets parameter idList, as there is no cell in a vtkPointSet.
void GetPointCells(vtkIdType, vtkIdList *idList) override
This method resets parameter idList, as there is no cell in a vtkPointSet.
vtkIdType GetCellSize(vtkIdType) override
This method always returns 1, as all cells are point in a pure vtkPointSet.
vtkIdType GetNumberOfCells() override
This method always returns 0, as there are no cells in a vtkPointSet.
int GetCellType(vtkIdType) override
This method always returns VTK_EMPTY_CELL, as there is no cell in a vtkPointSet.
concrete dataset represents vertices, lines, polygons, and triangle strips
Definition vtkPolyData.h:80
vtkCellArray * GetStrips()
Get the cell array defining triangle strips.
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
static vtkPolyData * ExtendedNew()
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.
bool NeedToBuildCells()
Check if BuildCells is needed.
bool AllocateEstimate(vtkIdType numCells, vtkIdType maxCellSize)
Preallocate memory for the internal cell arrays.
int GetScalarFieldCriticalIndex(vtkIdType pointId, const char *fieldName)
vtkCell * GetCell(vtkIdType cellId) override
Standard vtkDataSet interface.
void SetPolys(vtkCellArray *p)
Set the cell array defining polygons.
vtkCellArray * GetCellArrayInternal(TaggedCellId tag)
vtkIdType GetCellIdRelativeToCellArray(vtkIdType cellId)
Maps the cell at position cellId inside the vtkPolyData to its location in the corresponding cell arr...
void GetCellsBounds(double bounds[6])
Get the cells bounds.
void RemoveCellReference(vtkIdType cellId)
Remove all references to cell in cell structure.
static vtkPolyData * GetData(vtkInformationVector *v, int i=0)
Retrieve an instance of this class from an information object.
void ComputeCellsBounds()
Compute the (X, Y, Z) bounds of the data.
vtkIdType GetNumberOfLines()
Return the number of primitives of a particular type held.
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.
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
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
int GetCellType(vtkIdType cellId) override
Standard vtkDataSet interface.
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
vtkSmartPointer< vtkPolyLine > PolyLine
vtkIdType GetNumberOfStrips()
Return the number of primitives of a particular type held.
int GetScalarFieldCriticalIndex(vtkIdType pointId, vtkDataArray *scalarField)
bool AllocateCopy(vtkPolyData *pd)
Preallocate memory for the internal cell arrays such that they are the same size as those in pd.
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.
void ShallowCopy(vtkDataObject *src) override
Shallow and Deep copy.
vtkSmartPointer< vtkCellArray > Strips
vtkSmartPointer< vtkQuad > Quad
void DeleteCell(vtkIdType cellId)
Mark a point/cell as deleted from this vtkPolyData.
vtkSmartPointer< vtkPolygon > Polygon
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
void ResizeCellList(vtkIdType ptId, int size)
Resize the list of cells using a particular point.
virtual int GetPiece()
Get the piece and the number of pieces.
vtkTimeStamp CellsBoundsTime
virtual void SetLinks(vtkAbstractCellLinks *links)
Set/Get the links that you created possibly without using BuildLinks.
vtkIdType GetNumberOfCells() override
Standard vtkDataSet interface.
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 .
vtkCellArray * GetVerts()
Get the cell array defining vertices.
vtkSmartPointer< vtkCellArray > Polys
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
vtkCellArray * GetPolys()
Get the cell array defining polygons.
void AddCellReference(vtkIdType cellId)
Add references to cell in cell structure.
int GetDataObjectType() override
Return what type of dataset this is.
Definition vtkPolyData.h:91
void ReportReferences(vtkGarbageCollector *) override
vtkSmartPointer< vtkCellArray > Lines
void GetCellEdgeNeighbors(vtkIdType cellId, vtkIdType p1, vtkIdType p2, vtkIdList *cellIds)
Get the neighbors at an edge.
vtkSmartPointer< vtkEmptyCell > EmptyCell
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.
void DeleteCells()
Release data structure that allows random access of the cells.
virtual vtkMTimeType GetMeshMTime()
Return the mesh (geometry/topology) modification time.
static vtkPolyData * GetData(vtkInformation *info)
Retrieve an instance of this class from an information object.
vtkSmartPointer< vtkVertex > Vertex
int IsPointUsedByCell(vtkIdType ptId, vtkIdType cellId)
Determine whether a point is used by a particular cell.
void ReplaceCellPoint(vtkIdType cellId, vtkIdType oldPtId, vtkIdType newPtId)
Replace a point in the cell connectivity list with a different point.
vtkSmartPointer< CellMap > Cells
void GetPointCells(vtkIdType ptId, vtkIdList *cellIds) override
Efficient method to obtain cells using a particular point.
vtkSmartPointer< vtkTriangle > Triangle
void BuildCells()
Create data structure that allows random access of cells.
void DeletePoint(vtkIdType ptId)
Mark a point/cell as deleted from this vtkPolyData.
void CopyCells(vtkPolyData *pd, vtkIdList *idList, vtkIncrementalPointLocator *locator=nullptr)
Copy cells listed in idList from pd, including points, point data, and cell data.
vtkCellArray * GetLines()
Get the cell array defining lines.
void Allocate(vtkIdType numCells=1000, int vtkNotUsed(extSize)=1000)
Method allocates initial storage for vertex, line, polygon, and triangle strip arrays.
void BuildLinks(int initialSize=0)
Create upward links from points to cells that use each point.
vtkIdType GetCellSize(vtkIdType cellId) override
Standard vtkDataSet interface.
void Allocate(vtkPolyData *inPolyData, vtkIdType numCells=1000, int vtkNotUsed(extSize)=1000)
Similar to the method above, this method allocates initial storage for vertex, line,...
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
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
a cell that represents an n-sided polygon
Definition vtkPolygon.h:32
a cell that represents a 2D quadrilateral
Definition vtkQuad.h:28
Hold a reference to a vtkObjectBase instance.
record modification and/or execution time
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
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(...)