vtkUnstructuredGrid.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
// SPDX-License-Identifier: BSD-3-Clause
 
#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"           // VTK_DEPRECATED_IN_9_6_0()
#include "vtkSmartPointer.h"          // for smart pointer
#include "vtkUnstructuredGridBase.h"
#include "vtkWrappingHints.h" // For VTK_MARSHALMANUAL
 
VTK_ABI_NAMESPACE_BEGIN
class vtkIdList;
class vtkIdTypeArray;
class vtkUnsignedCharArray;
 
class VTKCOMMONDATAMODEL_EXPORT VTK_MARSHALMANUAL vtkUnstructuredGrid
  : public vtkUnstructuredGridBase
{
public:
  static vtkUnstructuredGrid* New();
  static vtkUnstructuredGrid* ExtendedNew();


  vtkTypeMacro(vtkUnstructuredGrid, vtkUnstructuredGridBase);
  void PrintSelf(ostream& os, vtkIndent indent) override;

  int GetDataObjectType() VTK_FUTURE_CONST 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;


  void GetDistinctCellTypes(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);


  using vtkDataSet::GetCellTypes;
  vtkDataArray* GetCellTypes() { return this->Types; }
  VTK_DEPRECATED_IN_9_6_0("Use GetCellTypes() instead")
  vtkUnsignedCharArray* GetCellTypesArray();

  void Squeeze() override;

  void Initialize() override;

  int GetMaxCellSize() override;


  int GetMaxSpatialDimension() override;
  int GetMinSpatialDimension() override;

  void BuildLinks();


  vtkSetSmartPointerMacro(Links, vtkAbstractCellLinks);
  vtkGetSmartPointerMacro(Links, vtkAbstractCellLinks);

  void GetFaceStream(vtkIdType cellId, vtkIdList* ptIds);

  void SetCells(int type, vtkCellArray* cells);


  void SetCells(int* types, vtkCellArray* cells);
  void SetCells(vtkDataArray* cellTypes, vtkCellArray* cells);
  void SetPolyhedralCells(
    vtkDataArray* cellTypes, vtkCellArray* cells, vtkCellArray* faceLocations, vtkCellArray* faces);
  VTK_DEPRECATED_IN_9_6_0("This function is deprecated, use SetPolyhedralCells")
  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);

  int GetCellNumberOfFaces(
    vtkIdType cellId, unsigned char& cellType, vtkGenericCell* cell) override;


  bool IsCellBoundary(
    vtkIdType cellId, vtkIdType npts, const vtkIdType* ptIds, vtkIdType& neighborCellId);
  bool IsCellBoundary(vtkIdType cellId, vtkIdType npts, const vtkIdType* ptIds)
  {
    vtkIdType neighborCellId;
    return this->IsCellBoundary(cellId, npts, ptIds, neighborCellId);
  }


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

  void GetPolyhedronFaces(vtkIdType cellId, vtkCellArray* faces);


  vtkCellArray* GetPolyhedronFaces();
  vtkCellArray* GetPolyhedronFaceLocations();

  int InitializeFacesRepresentation(vtkIdType numPrevCells);

  vtkMTimeType GetMeshMTime() override;

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

  static void ConvertFaceStreamPointIds(vtkCellArray* faces, vtkIdType* idMap);
 
  //====================== Begin Legacy Methods ================================

  VTK_DEPRECATED_IN_9_6_0("CellLocations is not longer used")
  vtkIdTypeArray* GetCellLocationsArray();


  VTK_DEPRECATED_IN_9_6_0("CellLocations is not longer used, use other SetCells methods")
  void SetCells(
    vtkUnsignedCharArray* cellTypes, vtkIdTypeArray* cellLocations, vtkCellArray* cells);
  VTK_DEPRECATED_IN_9_6_0("This function is deprecated, use SetPolyhedralCells")
  void SetCells(vtkUnsignedCharArray* cellTypes, vtkIdTypeArray* cellLocations, vtkCellArray* cells,
    vtkIdTypeArray* faceLocations, vtkIdTypeArray* faces);
 
  //====================== End Legacy Methods ==================================
 
protected:
  vtkUnstructuredGrid();
  ~vtkUnstructuredGrid() override;
 
  void ReportReferences(vtkGarbageCollector*) override;
 
  // 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<vtkDataArray> 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;

  vtkSmartPointer<vtkCellArray> Faces;
  vtkSmartPointer<vtkCellArray> FaceLocations;
 
  // VTK_DEPRECATED_IN_9_6_0()
  // 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[]);
  vtkIdType InternalInsertNextCell(
    int type, vtkIdType npts, const vtkIdType pts[], vtkCellArray* faces) override;
  void InternalReplaceCell(vtkIdType cellId, int npts, const vtkIdType pts[]) override;

  static void DecomposeAPolyhedronCell(const vtkIdType* cellStream, vtkIdType& numCellPts,
    vtkIdType& nCellFaces, vtkCellArray* cellArray, vtkCellArray* faces);
 
  static void DecomposeAPolyhedronCell(vtkIdType nCellFaces, const vtkIdType* cellStream,
    vtkIdType& numCellPts, vtkCellArray* cellArray, vtkCellArray* facesArray);
 
  static void DecomposeAPolyhedronCell(vtkCellArray* polyhedronCell, vtkIdType& numCellPts,
    vtkIdType& nCellfaces, vtkCellArray* cellArray, vtkCellArray* faces);
 
  static void DecomposeAPolyhedronCell(const vtkIdType* cellStream, vtkIdType& numCellPts,
    vtkIdType& nCellFaces, vtkCellArray* cellArray, vtkCellArray* faces,
    vtkCellArray* faceLocations);
 
  static void DecomposeAPolyhedronCell(vtkIdType nCellFaces, const vtkIdType* cellStream,
    vtkIdType& numCellPts, vtkCellArray* cellArray, vtkCellArray* faces,
    vtkCellArray* faceLocations);
 
private:
  // Hide these from the user and the compiler.
  vtkUnstructuredGrid(const vtkUnstructuredGrid&) = delete;
  void operator=(const vtkUnstructuredGrid&) = delete;
 
  void Cleanup();
};
 
VTK_ABI_NAMESPACE_END
#endif