VTK
vtkPolyData.h
Go to the documentation of this file.
1/*=========================================================================
2
3 Program: Visualization Toolkit
4 Module: vtkPolyData.h
5
6 Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
7 All rights reserved.
8 See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
9
10 This software is distributed WITHOUT ANY WARRANTY; without even
11 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
12 PURPOSE. See the above copyright notice for more information.
13
14=========================================================================*/
64#ifndef vtkPolyData_h
65#define vtkPolyData_h
66
67#include "vtkCommonDataModelModule.h" // For export macro
68#include "vtkPointSet.h"
69
70#include "vtkCellTypes.h" // Needed for inline methods
71#include "vtkCellLinks.h" // Needed for inline methods
72#include "vtkCellArray.h" // Needed for inline methods
73
74class vtkVertex;
75class vtkPolyVertex;
76class vtkLine;
77class vtkPolyLine;
78class vtkTriangle;
79class vtkQuad;
80class vtkPolygon;
82class vtkEmptyCell;
83struct vtkPolyDataDummyContainter;
84
85class VTKCOMMONDATAMODEL_EXPORT vtkPolyData : public vtkPointSet
86{
87public:
88 static vtkPolyData *New();
89
90 vtkTypeMacro(vtkPolyData,vtkPointSet);
91 void PrintSelf(ostream& os, vtkIndent indent) VTK_OVERRIDE;
92
96 int GetDataObjectType() VTK_OVERRIDE {return VTK_POLY_DATA;}
97
101 void CopyStructure(vtkDataSet *ds) VTK_OVERRIDE;
102
104
108 vtkCell *GetCell(vtkIdType cellId) VTK_OVERRIDE;
109 void GetCell(vtkIdType cellId, vtkGenericCell *cell) VTK_OVERRIDE;
110 int GetCellType(vtkIdType cellId) VTK_OVERRIDE;
111 void GetCellBounds(vtkIdType cellId, double bounds[6]) VTK_OVERRIDE;
112 void GetCellNeighbors(vtkIdType cellId, vtkIdList *ptIds,
113 vtkIdList *cellIds) VTK_OVERRIDE;
115
122 void CopyCells(vtkPolyData *pd, vtkIdList *idList,
123 vtkPointLocator *locator = NULL);
124
128 void GetCellPoints(vtkIdType cellId, vtkIdList *ptIds) VTK_OVERRIDE;
129
134 void GetPointCells(vtkIdType ptId, vtkIdList *cellIds) VTK_OVERRIDE;
135
139 void ComputeBounds() VTK_OVERRIDE;
140
147 void Squeeze() VTK_OVERRIDE;
148
152 int GetMaxCellSize() VTK_OVERRIDE;
153
157 void SetVerts (vtkCellArray* v);
158
163 vtkCellArray *GetVerts();
164
168 void SetLines (vtkCellArray* l);
169
174 vtkCellArray *GetLines();
175
179 void SetPolys (vtkCellArray* p);
180
185 vtkCellArray *GetPolys();
186
190 void SetStrips (vtkCellArray* s);
191
197 vtkCellArray *GetStrips();
198
200
203 vtkIdType GetNumberOfVerts();
204 vtkIdType GetNumberOfLines();
205 vtkIdType GetNumberOfPolys();
206 vtkIdType GetNumberOfStrips();
208
216 void Allocate(vtkIdType numCells=1000, int extSize=1000);
217
228 void Allocate(vtkPolyData *inPolyData, vtkIdType numCells=1000,
229 int extSize=1000);
230
238 vtkIdType InsertNextCell(int type, int npts, vtkIdType *pts);
239
247 vtkIdType InsertNextCell(int type, vtkIdList *pts);
248
253 void Reset();
254
262 void BuildCells();
263
267 bool NeedToBuildCells() { return this->Cells == 0; }
268
275 void BuildLinks(int initialSize=0);
276
283
288
292 void GetPointCells(vtkIdType ptId, unsigned short& ncells,
293 vtkIdType* &cells);
294
301 vtkIdList *cellIds);
302
309 unsigned char GetCellPoints(vtkIdType cellId,
310 vtkIdType& npts, vtkIdType* &pts);
311
318 unsigned char GetCell(vtkIdType cellId, vtkIdType* &pts);
319
324 int IsTriangle(int v1, int v2, int v3);
325
334
339 int IsPointUsedByCell(vtkIdType ptId, vtkIdType cellId);
340
347 void ReplaceCell(vtkIdType cellId, int npts, vtkIdType *pts);
348
352 void ReplaceCellPoint(vtkIdType cellId, vtkIdType oldPtId,
353 vtkIdType newPtId);
354
358 void ReverseCell(vtkIdType cellId);
359
361
364 void DeletePoint(vtkIdType ptId);
365 void DeleteCell(vtkIdType cellId);
367
376
378
386 vtkIdType InsertNextLinkedPoint(double x[3], int numLinks);
388
395
404 void ReplaceLinkedCell(vtkIdType cellId, int npts, vtkIdType *pts);
405
412 void RemoveCellReference(vtkIdType cellId);
413
420 void AddCellReference(vtkIdType cellId);
421
429
437
442 void ResizeCellList(vtkIdType ptId, int size);
443
447 void Initialize() VTK_OVERRIDE;
448
450
453 virtual int GetPiece();
454 virtual int GetNumberOfPieces();
456
460 virtual int GetGhostLevel();
461
470 unsigned long GetActualMemorySize() VTK_OVERRIDE;
471
473
476 void ShallowCopy(vtkDataObject *src) VTK_OVERRIDE;
477 void DeepCopy(vtkDataObject *src) VTK_OVERRIDE;
479
485 void RemoveGhostCells();
486
488
491 static vtkPolyData* GetData(vtkInformation* info);
492 static vtkPolyData* GetData(vtkInformationVector* v, int i=0);
494
513 enum
514 {
515 ERR_NO_SUCH_FIELD = -4,
516 ERR_INCORRECT_FIELD = -3,
517 ERR_NON_MANIFOLD_STAR = -2,
518 REGULAR_POINT = -1,
519 MINIMUM = 0,
520 SADDLE = 1,
521 MAXIMUM = 2
522 };
523
525 vtkDataArray *scalarField);
526 int GetScalarFieldCriticalIndex (vtkIdType pointId, int fieldId);
527 int GetScalarFieldCriticalIndex (vtkIdType pointId, const char* fieldName);
528
529protected:
531 ~vtkPolyData() VTK_OVERRIDE;
532
533 // constant cell objects returned by GetCell called.
534 vtkVertex *Vertex;
535 vtkPolyVertex *PolyVertex;
536 vtkLine *Line;
537 vtkPolyLine *PolyLine;
538 vtkTriangle *Triangle;
539 vtkQuad *Quad;
540 vtkPolygon *Polygon;
541 vtkTriangleStrip *TriangleStrip;
542 vtkEmptyCell *EmptyCell;
543
544 // points inherited
545 // point data (i.e., scalars, vectors, normals, tcoords) inherited
550
551 // dummy static member below used as a trick to simplify traversal
552 static vtkPolyDataDummyContainter DummyContainer;
553
554 // supporting structures for more complex topological operations
555 // built only when necessary
558
559private:
560 // Hide these from the user and the compiler.
561
565 void GetCellNeighbors(vtkIdType cellId, vtkIdList& ptIds, vtkIdList& cellIds)
566 {this->GetCellNeighbors(cellId, &ptIds, &cellIds);}
567
568 void Cleanup();
569
570private:
571 vtkPolyData(const vtkPolyData&) VTK_DELETE_FUNCTION;
572 void operator=(const vtkPolyData&) VTK_DELETE_FUNCTION;
573};
574
575inline void vtkPolyData::GetPointCells(vtkIdType ptId, unsigned short& ncells,
576 vtkIdType* &cells)
577{
578 ncells = this->Links->GetNcells(ptId);
579 cells = this->Links->GetCells(ptId);
580}
581
582inline int vtkPolyData::IsTriangle(int v1, int v2, int v3)
583{
584 unsigned short int n1;
585 int i, j, tVerts[3];
586 vtkIdType *cells, *tVerts2, n2;
587
588 tVerts[0] = v1;
589 tVerts[1] = v2;
590 tVerts[2] = v3;
591
592 for (i=0; i<3; i++)
593 {
594 this->GetPointCells(tVerts[i], n1, cells);
595 for (j=0; j<n1; j++)
596 {
597 this->GetCellPoints(cells[j], n2, tVerts2);
598 if ( (tVerts[0] == tVerts2[0] || tVerts[0] == tVerts2[1] ||
599 tVerts[0] == tVerts2[2]) &&
600 (tVerts[1] == tVerts2[0] || tVerts[1] == tVerts2[1] ||
601 tVerts[1] == tVerts2[2]) &&
602 (tVerts[2] == tVerts2[0] || tVerts[2] == tVerts2[1] ||
603 tVerts[2] == tVerts2[2]) )
604 {
605 return 1;
606 }
607 }
608 }
609 return 0;
610}
611
613{
614 vtkIdType *pts, npts;
615
616 this->GetCellPoints(cellId, npts, pts);
617 for (vtkIdType i=0; i < npts; i++)
618 {
619 if ( pts[i] == ptId )
620 {
621 return 1;
622 }
623 }
624
625 return 0;
626}
627
629{
630 this->Links->DeletePoint(ptId);
631}
632
634{
635 this->Cells->DeleteCell(cellId);
636}
637
639{
640 vtkIdType *pts, npts;
641
642 this->GetCellPoints(cellId, npts, pts);
643 for (vtkIdType i=0; i<npts; i++)
644 {
645 this->Links->RemoveCellReference(cellId, pts[i]);
646 }
647}
648
650{
651 vtkIdType *pts, npts;
652
653 this->GetCellPoints(cellId, npts, pts);
654 for (vtkIdType i=0; i<npts; i++)
655 {
656 this->Links->AddCellReference(cellId, pts[i]);
657 }
658}
659
661{
662 this->Links->ResizeCellList(ptId,size);
663}
664
666 vtkIdType newPtId)
667{
668 int i;
669 vtkIdType *verts, nverts;
670
671 this->GetCellPoints(cellId,nverts,verts);
672 for ( i=0; i < nverts; i++ )
673 {
674 if ( verts[i] == oldPtId )
675 {
676 verts[i] = newPtId; // this is very nasty! direct write!
677 return;
678 }
679 }
680}
681
682inline unsigned char vtkPolyData::GetCellPoints(
683 vtkIdType cellId, vtkIdType& npts, vtkIdType* &pts)
684{
685 unsigned char type = this->Cells->GetCellType(cellId);
686 vtkCellArray *cells;
687 switch (type)
688 {
689 case VTK_VERTEX: case VTK_POLY_VERTEX:
690 cells = this->Verts;
691 break;
692
693 case VTK_LINE: case VTK_POLY_LINE:
694 cells = this->Lines;
695 break;
696
697 case VTK_TRIANGLE: case VTK_QUAD: case VTK_POLYGON:
698 cells = this->Polys;
699 break;
700
702 cells = this->Strips;
703 break;
704
705 default:
706 cells = NULL;
707 npts = 0;
708 pts = NULL;
709 return 0;
710 }
711 int loc = this->Cells->GetCellLocation(cellId);
712 cells->GetCell(loc, npts, pts);
713 return type;
714}
715
716inline unsigned char vtkPolyData::GetCell(
717 vtkIdType cellId, vtkIdType* &cell)
718{
719 unsigned char type = this->Cells->GetCellType(cellId);
720 vtkCellArray *cells;
721 switch (type)
722 {
723 case VTK_VERTEX: case VTK_POLY_VERTEX:
724 cells = this->Verts;
725 break;
726
727 case VTK_LINE: case VTK_POLY_LINE:
728 cells = this->Lines;
729 break;
730
731 case VTK_TRIANGLE: case VTK_QUAD: case VTK_POLYGON:
732 cells = this->Polys;
733 break;
734
736 cells = this->Strips;
737 break;
738
739 default:
740 cells = NULL;
741 cell = NULL;
742 return 0;
743 }
744 int loc = this->Cells->GetCellLocation(cellId);
745 cell = cells->GetData()->GetPointer(loc);
746 return type;
747}
748
749#endif
object to represent cell connectivity
Definition: vtkCellArray.h:51
vtkIdTypeArray * GetData()
Return the underlying data as a data array.
Definition: vtkCellArray.h:256
void GetCell(vtkIdType loc, vtkIdType &npts, vtkIdType *&pts)
Internal method used to retrieve a cell given an offset into the internal array.
Definition: vtkCellArray.h:373
object provides direct access to cells in vtkCellArray and type information
Definition: vtkCellTypes.h:53
vtkIdType GetCellLocation(int cellId)
Return the location of the cell in the associated vtkCellArray.
Definition: vtkCellTypes.h:82
void DeleteCell(vtkIdType cellId)
Delete cell by setting to NULL cell type.
Definition: vtkCellTypes.h:87
unsigned char GetCellType(int cellId)
Return the type of cell.
Definition: vtkCellTypes.h:107
abstract class to specify cell behavior
Definition: vtkCell.h:60
abstract superclass for arrays of numeric data
Definition: vtkDataArray.h:55
general representation of visualization data
Definition: vtkDataObject.h:65
abstract class to specify dataset behavior
Definition: vtkDataSet.h:63
virtual void GetPointCells(vtkIdType ptId, vtkIdList *cellIds)=0
Topological inquiry to get cells using point.
virtual vtkCell * GetCell(vtkIdType cellId)=0
Get cell with cellId such that: 0 <= cellId < NumberOfCells.
virtual void GetCellPoints(vtkIdType cellId, vtkIdList *ptIds)=0
Topological inquiry to get points defining cell.
virtual void GetCellNeighbors(vtkIdType cellId, vtkIdList *ptIds, vtkIdList *cellIds)
Topological inquiry to get all cells using list of points exclusive of cell specified (e....
an empty cell used as a place-holder during processing
Definition: vtkEmptyCell.h:33
provides thread-safe access to cells
list of point or cell ids
Definition: vtkIdList.h:37
a simple class to control print indentation
Definition: vtkIndent.h:40
Store zero or more vtkInformation instances.
Store vtkAlgorithm input/output information.
cell represents a 1D line
Definition: vtkLine.h:36
quickly locate points in 3-space
abstract class for specifying dataset behavior
Definition: vtkPointSet.h:43
concrete dataset represents vertices, lines, polygons, and triangle strips
Definition: vtkPolyData.h:86
vtkCellTypes * Cells
Definition: vtkPolyData.h:556
vtkCellArray * Verts
Definition: vtkPolyData.h:546
vtkCellArray * Lines
Definition: vtkPolyData.h:547
int GetScalarFieldCriticalIndex(vtkIdType pointId, const char *fieldName)
vtkCell * GetCell(vtkIdType cellId) override
Get cell with cellId such that: 0 <= cellId < NumberOfCells.
void RemoveCellReference(vtkIdType cellId)
Remove all references to cell in cell structure.
Definition: vtkPolyData.h:638
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:582
void PrintSelf(ostream &os, vtkIndent indent) override
Methods invoked by print to print information about the object including superclasses.
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.
~vtkPolyData() override
int GetScalarFieldCriticalIndex(vtkIdType pointId, int fieldId)
void CopyStructure(vtkDataSet *ds) override
Copy the geometric and topological structure of an input poly data object.
void ReplaceLinkedCell(vtkIdType cellId, int npts, vtkIdType *pts)
Replace one cell with another in cell structure.
int GetScalarFieldCriticalIndex(vtkIdType pointId, vtkDataArray *scalarField)
void ReplaceCell(vtkIdType cellId, int npts, vtkIdType *pts)
Replace the points defining cell "cellId" with a new set of points.
vtkCellLinks * Links
Definition: vtkPolyData.h:557
void DeleteCell(vtkIdType cellId)
Definition: vtkPolyData.h:633
vtkIdType InsertNextLinkedPoint(double x[3], int numLinks)
void ResizeCellList(vtkIdType ptId, int size)
Resize the list of cells using a particular point.
Definition: vtkPolyData.h:660
vtkIdType GetNumberOfCells() override
Standard vtkDataSet interface.
vtkIdType InsertNextLinkedPoint(int numLinks)
Add a point to the cell data structure (after cell pointers have been built).
vtkIdType InsertNextLinkedCell(int type, int npts, vtkIdType *pts)
Add a new cell to the cell data structure (after cell pointers have been built).
static vtkPolyData * New()
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 AddCellReference(vtkIdType cellId)
Add references to cell in cell structure.
Definition: vtkPolyData.h:649
int GetDataObjectType() override
Return what type of dataset this is.
Definition: vtkPolyData.h:96
void GetCellEdgeNeighbors(vtkIdType cellId, vtkIdType p1, vtkIdType p2, vtkIdList *cellIds)
Get the neighbors at an edge.
void RemoveDeletedCells()
The cells marked by calls to DeleteCell are stored in the Cell Array VTK_EMPTY_CELL,...
void DeleteCells()
Release data structure that allows random access of the cells.
int IsPointUsedByCell(vtkIdType ptId, vtkIdType cellId)
Determine whether a point is used by a particular cell.
Definition: vtkPolyData.h:612
vtkCellArray * Strips
Definition: vtkPolyData.h:549
void ReplaceCellPoint(vtkIdType cellId, vtkIdType oldPtId, vtkIdType newPtId)
Replace a point in the cell connectivity list with a different point.
Definition: vtkPolyData.h:665
void GetPointCells(vtkIdType ptId, vtkIdList *cellIds) override
Efficient method to obtain cells using a particular point.
void DeletePoint(vtkIdType ptId)
Mark a point/cell as deleted from this vtkPolyData.
Definition: vtkPolyData.h:628
vtkCellArray * Polys
Definition: vtkPolyData.h:548
void BuildLinks(int initialSize=0)
Create upward links from points to cells that use each point.
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.
cell represents a set of 1D lines
Definition: vtkPolyLine.h:43
cell represents a set of 0D vertices
Definition: vtkPolyVertex.h:39
a cell that represents an n-sided polygon
Definition: vtkPolygon.h:46
a cell that represents a 2D quadrilateral
Definition: vtkQuad.h:42
a cell that represents a triangle strip
a cell that represents a triangle
Definition: vtkTriangle.h:42
a cell that represents a 3D point
Definition: vtkVertex.h:37
@ info
Definition: vtkX3D.h:376
@ type
Definition: vtkX3D.h:516
@ size
Definition: vtkX3D.h:253
void DeepCopy(vtkPistonReference *self, vtkPistonReference *other)
@ VTK_TRIANGLE_STRIP
Definition: vtkCellType.h:51
@ VTK_POLY_LINE
Definition: vtkCellType.h:49
@ VTK_TRIANGLE
Definition: vtkCellType.h:50
@ VTK_POLYGON
Definition: vtkCellType.h:52
@ VTK_LINE
Definition: vtkCellType.h:48
@ VTK_QUAD
Definition: vtkCellType.h:54
@ VTK_VERTEX
Definition: vtkCellType.h:46
@ VTK_POLY_VERTEX
Definition: vtkCellType.h:47
int vtkIdType
Definition: vtkType.h:287
#define VTK_POLY_DATA
Definition: vtkType.h:87