vtkUnstructuredGrid.h

Go to the documentation of this file.

/*=========================================================================
 
  Program:   Visualization Toolkit
  Module:    vtkUnstructuredGrid.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 vtkUnstructuredGrid_h
#define vtkUnstructuredGrid_h
 
#include "vtkAbstractCellLinks.h"     // For vtkAbstractCellLinks
#include "vtkCellArray.h"             // inline GetCellPoints()
#include "vtkCommonDataModelModule.h" // For export macro
#include "vtkDeprecation.h"           // For deprecation
#include "vtkIdTypeArray.h"           // inline GetCellPoints()
#include "vtkUnstructuredGridBase.h"
 
#include "vtkSmartPointer.h" // for smart pointer
 
class vtkCellArray;
class vtkAbstractCellLinks;
class vtkBezierCurve;
class vtkBezierQuadrilateral;
class vtkBezierHexahedron;
class vtkBezierTriangle;
class vtkBezierTetra;
class vtkBezierWedge;
class vtkConvexPointSet;
class vtkEmptyCell;
class vtkHexahedron;
class vtkIdList;
class vtkIdTypeArray;
class vtkLagrangeCurve;
class vtkLagrangeQuadrilateral;
class vtkLagrangeHexahedron;
class vtkLagrangeTriangle;
class vtkLagrangeTetra;
class vtkLagrangeWedge;
class vtkLine;
class vtkPixel;
class vtkPolyLine;
class vtkPolyVertex;
class vtkPolygon;
class vtkPyramid;
class vtkPentagonalPrism;
class vtkHexagonalPrism;
class vtkQuad;
class vtkQuadraticEdge;
class vtkQuadraticHexahedron;
class vtkQuadraticWedge;
class vtkQuadraticPolygon;
class vtkQuadraticPyramid;
class vtkQuadraticQuad;
class vtkQuadraticTetra;
class vtkQuadraticTriangle;
class vtkTetra;
class vtkTriangle;
class vtkTriangleStrip;
class vtkUnsignedCharArray;
class vtkVertex;
class vtkVoxel;
class vtkWedge;
class vtkTriQuadraticHexahedron;
class vtkTriQuadraticPyramid;
class vtkQuadraticLinearWedge;
class vtkQuadraticLinearQuad;
class vtkBiQuadraticQuad;
class vtkBiQuadraticQuadraticWedge;
class vtkBiQuadraticQuadraticHexahedron;
class vtkBiQuadraticTriangle;
class vtkCubicLine;
class vtkPolyhedron;
class vtkIdTypeArray;
 
class VTKCOMMONDATAMODEL_EXPORT vtkUnstructuredGrid : public vtkUnstructuredGridBase
{
public:
  static vtkUnstructuredGrid* New();
  static vtkUnstructuredGrid* ExtendedNew();
 
 
  vtkTypeMacro(vtkUnstructuredGrid, vtkUnstructuredGridBase);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
  int GetDataObjectType() override { return VTK_UNSTRUCTURED_GRID; }
 
  bool AllocateEstimate(vtkIdType numCells, vtkIdType maxCellSize)
  {
    return this->AllocateExact(numCells, numCells * maxCellSize);
  }
 
  bool AllocateExact(vtkIdType numCells, vtkIdType connectivitySize);
 
  void Allocate(vtkIdType numCells = 1000, int vtkNotUsed(extSize) = 1000) override
  {
    this->AllocateExact(numCells, numCells);
  }
 
 
  void Reset();
  void CopyStructure(vtkDataSet* ds) override;
  vtkIdType GetNumberOfCells() override;
  using vtkDataSet::GetCell;
  vtkCell* GetCell(vtkIdType cellId) override;
  void GetCell(vtkIdType cellId, vtkGenericCell* cell) override;
  void GetCellBounds(vtkIdType cellId, double bounds[6]) override;
  void GetCellPoints(vtkIdType cellId, vtkIdList* ptIds) override;
  void GetPointCells(vtkIdType ptId, vtkIdList* cellIds) override;
  vtkCellIterator* NewCellIterator() override;
 
  int GetCellType(vtkIdType cellId) override;
 
  vtkIdType GetCellSize(vtkIdType cellId) override;
 
  VTK_DEPRECATED_IN_9_2_0("Please use GetDistinctCellTypesArray() instead.")
  void GetCellTypes(vtkCellTypes* types) override;
 
  vtkUnsignedCharArray* GetDistinctCellTypesArray();
 
  void GetCellPoints(vtkIdType cellId, vtkIdType& npts, vtkIdType const*& pts)
  {
    this->Connectivity->GetCellAtId(cellId, npts, pts);
  }
 
  void GetCellPoints(
    vtkIdType cellId, vtkIdType& npts, vtkIdType const*& pts, vtkIdList* ptIds) override
  {
    this->Connectivity->GetCellAtId(cellId, npts, pts, ptIds);
  }
 
 
  void GetPointCells(vtkIdType ptId, vtkIdType& ncells, vtkIdType*& cells)
    VTK_SIZEHINT(cells, ncells);
 
  vtkUnsignedCharArray* GetCellTypesArray();
 
  void Squeeze() override;
 
  void Initialize() override;
 
  int GetMaxCellSize() override;
 
  void BuildLinks();
 
 
  vtkSetSmartPointerMacro(Links, vtkAbstractCellLinks);
  vtkGetSmartPointerMacro(Links, vtkAbstractCellLinks);
 
  vtkAbstractCellLinks* GetCellLinks();
 
  void GetFaceStream(vtkIdType cellId, vtkIdList* ptIds);
 
  void GetFaceStream(vtkIdType cellId, vtkIdType& nfaces, vtkIdType const*& ptIds);
 
 
  void SetCells(int type, vtkCellArray* cells);
  void SetCells(int* types, vtkCellArray* cells);
  void SetCells(vtkUnsignedCharArray* cellTypes, vtkCellArray* cells);
  void SetCells(vtkUnsignedCharArray* cellTypes, vtkCellArray* cells, vtkIdTypeArray* faceLocations,
    vtkIdTypeArray* faces);
 
  vtkCellArray* GetCells() { return this->Connectivity; }
 
 
  void GetCellNeighbors(vtkIdType cellId, vtkIdList* ptIds, vtkIdList* cellIds) override
  {
    this->GetCellNeighbors(cellId, ptIds->GetNumberOfIds(), ptIds->GetPointer(0), cellIds);
  }
  void GetCellNeighbors(
    vtkIdType cellId, vtkIdType npts, const vtkIdType* ptIds, vtkIdList* cellIds);
 
 
  bool IsCellBoundary(vtkIdType cellId, vtkIdType npts, const vtkIdType* ptIds);
  bool IsCellBoundary(vtkIdType cellId, vtkIdType npts, const vtkIdType* ptIds, vtkIdList* cellIds);
 
 
  vtkIdType InsertNextLinkedCell(int type, int npts, const vtkIdType pts[]) VTK_SIZEHINT(pts, npts);
  void RemoveReferenceToCell(vtkIdType ptId, vtkIdType cellId);
  void AddReferenceToCell(vtkIdType ptId, vtkIdType cellId);
  void ResizeCellList(vtkIdType ptId, int size);
 
 
  virtual int GetPiece();
  virtual int GetNumberOfPieces();
 
  virtual int GetGhostLevel();
 
  unsigned long GetActualMemorySize() override;
 
 
  void ShallowCopy(vtkDataObject* src) override;
  void DeepCopy(vtkDataObject* src) override;
 
  void GetIdsOfCellsOfType(int type, vtkIdTypeArray* array) override;
 
  int IsHomogeneous() override;
 
  void RemoveGhostCells();
 
 
  static vtkUnstructuredGrid* GetData(vtkInformation* info);
  static vtkUnstructuredGrid* GetData(vtkInformationVector* v, int i = 0);
 
  vtkIdType* GetFaces(vtkIdType cellId);
 
 
  vtkIdTypeArray* GetFaces();
  vtkIdTypeArray* GetFaceLocations();
 
  int InitializeFacesRepresentation(vtkIdType numPrevCells);
 
  virtual vtkMTimeType GetMeshMTime();
 
  static void DecomposeAPolyhedronCell(vtkCellArray* polyhedronCellArray, vtkIdType& nCellpts,
    vtkIdType& nCellfaces, vtkCellArray* cellArray, vtkIdTypeArray* faces);
 
  static void DecomposeAPolyhedronCell(const vtkIdType* polyhedronCellStream, vtkIdType& nCellpts,
    vtkIdType& nCellfaces, vtkCellArray* cellArray, vtkIdTypeArray* faces);
 
  static void DecomposeAPolyhedronCell(vtkIdType nCellFaces, const vtkIdType* inFaceStream,
    vtkIdType& nCellpts, vtkCellArray* cellArray, vtkIdTypeArray* faces);
 
  static void ConvertFaceStreamPointIds(vtkIdList* faceStream, vtkIdType* idMap);
 
  static void ConvertFaceStreamPointIds(vtkIdType nfaces, vtkIdType* faceStream, vtkIdType* idMap);
 
  //====================== Begin Legacy Methods ================================
 
  vtkIdTypeArray* GetCellLocationsArray();
 
 
  void SetCells(
    vtkUnsignedCharArray* cellTypes, vtkIdTypeArray* cellLocations, vtkCellArray* cells);
  void SetCells(vtkUnsignedCharArray* cellTypes, vtkIdTypeArray* cellLocations, vtkCellArray* cells,
    vtkIdTypeArray* faceLocations, vtkIdTypeArray* faces);
 
  //====================== End Legacy Methods ==================================
 
protected:
  vtkUnstructuredGrid();
  ~vtkUnstructuredGrid() override;
 
  // These are all the cells that vtkUnstructuredGrid can represent. Used by
  // GetCell() (and similar) methods.
  vtkVertex* Vertex;
  vtkPolyVertex* PolyVertex;
  vtkBezierCurve* BezierCurve;
  vtkBezierQuadrilateral* BezierQuadrilateral;
  vtkBezierHexahedron* BezierHexahedron;
  vtkBezierTriangle* BezierTriangle;
  vtkBezierTetra* BezierTetra;
  vtkBezierWedge* BezierWedge;
  vtkLagrangeCurve* LagrangeCurve;
  vtkLagrangeQuadrilateral* LagrangeQuadrilateral;
  vtkLagrangeHexahedron* LagrangeHexahedron;
  vtkLagrangeTriangle* LagrangeTriangle;
  vtkLagrangeTetra* LagrangeTetra;
  vtkLagrangeWedge* LagrangeWedge;
  vtkLine* Line;
  vtkPolyLine* PolyLine;
  vtkTriangle* Triangle;
  vtkTriangleStrip* TriangleStrip;
  vtkPixel* Pixel;
  vtkQuad* Quad;
  vtkPolygon* Polygon;
  vtkTetra* Tetra;
  vtkVoxel* Voxel;
  vtkHexahedron* Hexahedron;
  vtkWedge* Wedge;
  vtkPyramid* Pyramid;
  vtkPentagonalPrism* PentagonalPrism;
  vtkHexagonalPrism* HexagonalPrism;
  vtkQuadraticEdge* QuadraticEdge;
  vtkQuadraticTriangle* QuadraticTriangle;
  vtkQuadraticQuad* QuadraticQuad;
  vtkQuadraticPolygon* QuadraticPolygon;
  vtkQuadraticTetra* QuadraticTetra;
  vtkQuadraticHexahedron* QuadraticHexahedron;
  vtkQuadraticWedge* QuadraticWedge;
  vtkQuadraticPyramid* QuadraticPyramid;
  vtkQuadraticLinearQuad* QuadraticLinearQuad;
  vtkBiQuadraticQuad* BiQuadraticQuad;
  vtkTriQuadraticHexahedron* TriQuadraticHexahedron;
  vtkTriQuadraticPyramid* TriQuadraticPyramid;
  vtkQuadraticLinearWedge* QuadraticLinearWedge;
  vtkBiQuadraticQuadraticWedge* BiQuadraticQuadraticWedge;
  vtkBiQuadraticQuadraticHexahedron* BiQuadraticQuadraticHexahedron;
  vtkBiQuadraticTriangle* BiQuadraticTriangle;
  vtkCubicLine* CubicLine;
  vtkConvexPointSet* ConvexPointSet;
  vtkPolyhedron* Polyhedron;
  vtkEmptyCell* EmptyCell;
 
  // Points derived from vtkPointSet.
  // Attribute data (i.e., point and cell data (i.e., scalars, vectors, normals, tcoords)
  // derived from vtkDataSet.
 
  // The heart of the data representation. The points are managed by the
  // superclass vtkPointSet. A cell is defined by its connectivity (i.e., the
  // point ids that define the cell) and the cell type, represented by the
  // Connectivity and Types arrays.
  // Finally, when certain topological information is needed (e.g.,
  // all the cells that use a point), the cell links array is built.
  vtkSmartPointer<vtkCellArray> Connectivity;
  vtkSmartPointer<vtkAbstractCellLinks> Links;
  vtkSmartPointer<vtkUnsignedCharArray> Types;
 
  // Set of all cell types present in the grid. All entries are unique.
  vtkSmartPointer<vtkCellTypes> DistinctCellTypes;
 
  // The DistinctCellTypes is cached, so we keep track of the last time it was
  // updated so we can compare it to the modified time of the Types array.
  vtkMTimeType DistinctCellTypesUpdateMTime;
 
  // Special support for polyhedra/cells with explicit face representations.
  // The Faces class represents polygonal faces using a modified vtkCellArray
  // structure. Each cell face list begins with the total number of faces in
  // the cell, followed by a vtkCellArray data organization
  // (n,i,j,k,n,i,j,k,...).
  vtkSmartPointer<vtkIdTypeArray> Faces;
  vtkSmartPointer<vtkIdTypeArray> FaceLocations;
 
  // Legacy support -- stores the old-style cell array locations.
  vtkSmartPointer<vtkIdTypeArray> CellLocations;
 
  vtkIdType InternalInsertNextCell(int type, vtkIdType npts, const vtkIdType ptIds[]) override;
  vtkIdType InternalInsertNextCell(int type, vtkIdList* ptIds) override;
  vtkIdType InternalInsertNextCell(int type, vtkIdType npts, const vtkIdType ptIds[],
    vtkIdType nfaces, const vtkIdType faces[]) override;
  void InternalReplaceCell(vtkIdType cellId, int npts, const vtkIdType pts[]) override;
 
private:
  // Hide these from the user and the compiler.
  vtkUnstructuredGrid(const vtkUnstructuredGrid&) = delete;
  void operator=(const vtkUnstructuredGrid&) = delete;
 
  void Cleanup();
};
 
#endif