vtkExplicitStructuredGrid.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 vtkExplicitStructuredGrid_h
#define vtkExplicitStructuredGrid_h

#include "vtkAbstractCellLinks.h"     // For vtkAbstractCellLinks
#include "vtkCellArray.h"             // For vtkCellArray
#include "vtkCommonDataModelModule.h" // For export macro
#include "vtkNew.h"                   // for vtkNew
#include "vtkPointSet.h"
#include "vtkStructuredData.h" // For static method usage

VTK_ABI_NAMESPACE_BEGIN
class vtkCellArray;

class VTKCOMMONDATAMODEL_EXPORT vtkExplicitStructuredGrid : public vtkPointSet
{
public:

  static vtkExplicitStructuredGrid* New();
  vtkTypeMacro(vtkExplicitStructuredGrid, vtkPointSet);
  void PrintSelf(ostream& os, vtkIndent indent) override;

  int GetDataObjectType() VTK_FUTURE_CONST override { return VTK_EXPLICIT_STRUCTURED_GRID; }


  void Initialize() override;
  using vtkDataSet::GetCell;
  vtkCell* GetCell(vtkIdType cellId) override;
  void GetCell(vtkIdType cellId, vtkGenericCell* cell) override;
  void GetCellBounds(vtkIdType cellId, double bounds[6]) override;
  int GetCellType(vtkIdType cellId) override;
  vtkIdType GetCellSize(vtkIdType cellId) override;
  vtkIdType GetNumberOfCells() override;
  void GetCellPoints(vtkIdType cellId, vtkIdList* ptIds) override;
  void GetPointCells(vtkIdType ptId, vtkIdList* cellIds) override;
  int GetMaxCellSize() override { return 8; } // hexahedron is the largest
  int GetMaxSpatialDimension() override { return 3; }
  int GetMinSpatialDimension() override { return 3; }
  void GetCellNeighbors(vtkIdType cellId, vtkIdList* ptIds, vtkIdList* cellIds) override;

  void CopyStructure(vtkDataSet* ds) override;


  void ShallowCopy(vtkDataObject* src) override;
  void DeepCopy(vtkDataObject* src) override;

  int GetDataDimension() { return 3; }


  void SetDimensions(int i, int j, int k);
  void SetDimensions(int dim[3]);
  void GetDimensions(int dim[3]);

  void GetCellDims(int cellDims[3]);

  int GetExtentType() VTK_FUTURE_CONST override { return VTK_3D_EXTENT; }


  void SetExtent(int x0, int x1, int y0, int y1, int z0, int z1);
  void SetExtent(VTK_FUTURE_CONST int extent[6]);
  vtkGetVector6Macro(Extent, int);


  vtkSetSmartPointerMacro(Cells, vtkCellArray);
  vtkGetSmartPointerMacro(Cells, vtkCellArray);

  void BuildLinks();


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

  vtkIdType* GetCellPoints(vtkIdType cellId);

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

  void GetCellPoints(
    vtkIdType cellId, vtkIdType& npts, vtkIdType const*& pts, vtkIdList* ptIds) override;

  void GetCellNeighbors(
    vtkIdType cellId, vtkIdType neighbors[6], VTK_FUTURE_CONST int wholeExtent[6] = nullptr);

  void ComputeCellStructuredCoords(
    vtkIdType cellId, int& i, int& j, int& k, bool adjustForExtent = true);

  vtkIdType ComputeCellId(int i, int j, int k, bool adjustForExtent = true);

  void ComputeFacesConnectivityFlagsArray();


  vtkSetStringMacro(FacesConnectivityFlagsArrayName);
  vtkGetStringMacro(FacesConnectivityFlagsArrayName);


  void BlankCell(vtkIdType cellId);
  void UnBlankCell(vtkIdType cellId);

  bool HasAnyBlankCells() override;

  unsigned char IsCellVisible(vtkIdType cellId);

  unsigned char IsCellGhost(vtkIdType cellId);

  bool HasAnyGhostCells();


  void Crop(const int updateExtent[6]) override;
  virtual void Crop(
    vtkExplicitStructuredGrid* input, const int updateExtent[6], bool generateOriginalCellIds);


  static vtkExplicitStructuredGrid* GetData(vtkInformation* info);
  static vtkExplicitStructuredGrid* GetData(vtkInformationVector* v, int i = 0);

  unsigned long GetActualMemorySize() override;

  void CheckAndReorderFaces();


  using vtkDataSet::GenerateGhostArray;
  void GenerateGhostArray(int zeroExt[6], bool cellOnly) override;

protected:
  vtkExplicitStructuredGrid();
  ~vtkExplicitStructuredGrid() override;

  void ReportReferences(vtkGarbageCollector*) override;

  void ComputeScalarRange() override;

  virtual void InternalCopy(vtkExplicitStructuredGrid* src);

  void InternalCheckAndReorderFaces(bool swap);

  int FindConnectedFaces(int foundFaces[3]);

  static void CheckConnectedFaces(int& nFoundFaces, int foundFaces[3]);

  static void ComputeSwapFlag(int foundFaces[3], int swap[3]);

  static void ComputeMirrorFlag(int foundFaces[3], int mirror[3]);

  void ReorderCellsPoints(const int* ptsMap, const int transformFlag[3]);

  vtkSmartPointer<vtkCellArray> Cells;
  vtkSmartPointer<vtkAbstractCellLinks> Links;
  int Extent[6];
  char* FacesConnectivityFlagsArrayName;

private:
  vtkExplicitStructuredGrid(const vtkExplicitStructuredGrid&) = delete;
  void operator=(const vtkExplicitStructuredGrid&) = delete;
};

//----------------------------------------------------------------------------
inline void vtkExplicitStructuredGrid::GetDimensions(int dim[3])
{
  vtkStructuredData::GetDimensionsFromExtent(this->Extent, dim);
}

//----------------------------------------------------------------------------
inline void vtkExplicitStructuredGrid::GetCellDims(int cellDims[3])
{
  vtkStructuredData::GetCellDimensionsFromExtent(this->Extent, cellDims);
}

//----------------------------------------------------------------------------
inline void vtkExplicitStructuredGrid::ComputeCellStructuredCoords(
  vtkIdType cellId, int& i, int& j, int& k, bool adjustForExtent)
{
  int ijk[3];
  if (adjustForExtent)
  {
    vtkStructuredData::ComputeCellStructuredCoordsForExtent(cellId, this->Extent, ijk);
  }
  else
  {
    int dims[3];
    this->GetDimensions(dims);
    vtkStructuredData::ComputeCellStructuredCoords(cellId, dims, ijk);
  }
  i = ijk[0];
  j = ijk[1];
  k = ijk[2];
}

//----------------------------------------------------------------------------
inline vtkIdType vtkExplicitStructuredGrid::ComputeCellId(int i, int j, int k, bool adjustForExtent)
{
  int ijk[] = { i, j, k };
  if (adjustForExtent)
  {
    return vtkStructuredData::ComputeCellIdForExtent(this->Extent, ijk);
  }
  else
  {
    int dims[3];
    this->GetDimensions(dims);
    return vtkStructuredData::ComputeCellId(dims, ijk);
  }
}
VTK_ABI_NAMESPACE_END
#endif