doxygen/html/vtkUnstructuredGrid_8h_source.html

/*=========================================================================


  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 "vtkCellArray.h"             //inline GetCellPoints()

#include "vtkCommonDataModelModule.h" // For export macro

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


  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;


  void GetCellTypes(vtkCellTypes* types) override;


  void GetCellPoints(vtkIdType cellId, vtkIdType& npts, vtkIdType const*& pts)

  {

    this->Connectivity->GetCellAtId(cellId, npts, pts);

  }


  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


  vtkUnsignedCharArray* GetCellTypesArray();


  void Squeeze() override;


  void Initialize() override;


  int GetMaxCellSize() override;


  void BuildLinks();


  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;


  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;

  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 represention. 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