vtkExplicitStructuredGrid.h

Go to the documentation of this file.

/*=========================================================================
 
  Program:   Visualization Toolkit
  Module:    vtkExplicitStructuredGrid.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 vtkExplicitStructuredGrid_h
#define vtkExplicitStructuredGrid_h
 
#include "vtkCommonDataModelModule.h" // For export macro
#include "vtkNew.h"                   // for vtkNew
#include "vtkPointSet.h"
#include "vtkStructuredData.h" // For static method usage
 
class vtkCellArray;
class vtkAbstractCellLinks;
class vtkEmptyCell;
class vtkHexahedron;
 
class VTKCOMMONDATAMODEL_EXPORT vtkExplicitStructuredGrid : public vtkPointSet
{
public:
 
  static vtkExplicitStructuredGrid* New();
  vtkTypeMacro(vtkExplicitStructuredGrid, vtkPointSet);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
  int GetDataObjectType() 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 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
  void GetCellNeighbors(vtkIdType cellId, vtkIdList* ptIds, vtkIdList* cellIds) override;
 
  void CopyStructure(vtkDataSet* ds) override;
 
 
  void ShallowCopy(vtkDataObject* src) override;
  void DeepCopy(vtkDataObject* src) override;
 
  inline 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() override { return VTK_3D_EXTENT; }
 
 
  void SetExtent(int x0, int x1, int y0, int y1, int z0, int z1);
  void SetExtent(int extent[6]);
  vtkGetVector6Macro(Extent, int);
 
 
  void SetCells(vtkCellArray* cells);
  vtkGetObjectMacro(Cells, vtkCellArray);
 
 
  void BuildLinks();
  vtkGetObjectMacro(Links, vtkAbstractCellLinks);
 
  vtkIdType* GetCellPoints(vtkIdType cellId);
 
  void GetCellPoints(vtkIdType cellId, vtkIdType& npts, vtkIdType*& pts);
 
  void GetCellNeighbors(vtkIdType cellId, vtkIdType neighbors[6], int* wholeExtent = 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) override;
  virtual void Crop(
    vtkExplicitStructuredGrid* input, const int* updateExtent, 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;
 
  virtual void ComputeScalarRange() override;
 
  virtual void InternalCopy(vtkExplicitStructuredGrid* src);
 
  void GetCell(vtkIdType, vtkCell*);
 
  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]);
 
  // Used by GetCell method
  vtkNew<vtkHexahedron> Hexahedron;
  vtkNew<vtkEmptyCell> EmptyCell;
 
  vtkCellArray* Cells;
  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);
  }
}
#endif