vtkHyperTreeGrid.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 vtkHyperTreeGrid_h
#define vtkHyperTreeGrid_h
 
#include "vtkCommonDataModelModule.h" // For export macro
#include "vtkDataObject.h"
 
#include "vtkNew.h"          // vtkSmartPointer
#include "vtkSmartPointer.h" // vtkSmartPointer
 
#include <cassert> // std::assert
#include <map>     // std::map
#include <memory>  // std::shared_ptr
 
VTK_ABI_NAMESPACE_BEGIN
class vtkBitArray;
class vtkBoundingBox;
class vtkCellLinks;
class vtkCollection;
class vtkDataArray;
class vtkHyperTree;
class vtkHyperTreeGridOrientedCursor;
class vtkHyperTreeGridOrientedGeometryCursor;
class vtkHyperTreeGridNonOrientedCursor;
class vtkHyperTreeGridNonOrientedGeometryCursor;
class vtkHyperTreeGridNonOrientedUnlimitedGeometryCursor;
class vtkHyperTreeGridNonOrientedVonNeumannSuperCursor;
class vtkHyperTreeGridNonOrientedVonNeumannSuperCursorLight;
class vtkHyperTreeGridNonOrientedMooreSuperCursor;
class vtkHyperTreeGridNonOrientedMooreSuperCursorLight;
class vtkHyperTreeGridNonOrientedUnlimitedMooreSuperCursor;
class vtkDoubleArray;
class vtkDataSetAttributes;
class vtkIdTypeArray;
class vtkLine;
class vtkPixel;
class vtkPoints;
class vtkCellData;
class vtkUnsignedCharArray;
 
class VTKCOMMONDATAMODEL_EXPORT vtkHyperTreeGrid : public vtkDataObject
{
public:
  static vtkInformationIntegerKey* LEVELS();
  static vtkInformationIntegerKey* DIMENSION();
  static vtkInformationIntegerKey* ORIENTATION();
  static vtkInformationDoubleVectorKey* SIZES();
  static vtkHyperTreeGrid* New();
 
  vtkTypeMacro(vtkHyperTreeGrid, vtkDataObject);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
  static constexpr vtkIdType InvalidIndex = ~0;
 
  vtkSetStringMacro(ModeSqueeze); // By copy
  vtkGetStringMacro(ModeSqueeze);
 
  virtual void Squeeze();
 
  int GetDataObjectType() override { return VTK_HYPER_TREE_GRID; }
 
  virtual void CopyStructure(vtkDataObject*);
 
  virtual void CopyEmptyStructure(vtkDataObject*);
 
  // --------------------------------------------------------------------------
  // RectilinearGrid common API
  // --------------------------------------------------------------------------
 
 
  void SetDimensions(const unsigned int dims[3]);
  void SetDimensions(const int dims[3]);
  void SetDimensions(unsigned int i, unsigned int j, unsigned int k);
  void SetDimensions(int i, int j, int k);
 
 
  const unsigned int* GetDimensions() const VTK_SIZEHINT(3);
  void GetDimensions(int dim[3]) const;
  void GetDimensions(unsigned int dim[3]) const;
 
 
  void SetExtent(const int extent[6]);
  void SetExtent(int x1, int x2, int y1, int y2, int z1, int z2);
  vtkGetVector6Macro(Extent, int);
 
 
  const unsigned int* GetCellDims() const VTK_SIZEHINT(3);
  void GetCellDims(int cellDims[3]) const;
  void GetCellDims(unsigned int cellDims[3]) const;
 
  // --------------------------------------------------------------------------
 
 
  unsigned int GetDimension() const { return this->Dimension; }
 
 
  void Get1DAxis(unsigned int& axis) const
  {
    assert("pre: valid_dim" && this->GetDimension() == 1);
    axis = this->Axis[0];
  }
 
 
  void Get2DAxes(unsigned int& axis1, unsigned int& axis2) const
  {
    assert("pre: valid_dim" && this->GetDimension() == 2);
    axis1 = this->Axis[0];
    axis2 = this->Axis[1];
  }
 
 
  const unsigned int* GetAxes() const { return this->Axis; }
 
 
  // vtkGetMacro(NumberOfChildren, unsigned int); not const
  unsigned int GetNumberOfChildren() const { return this->NumberOfChildren; }
 
 
  vtkSetMacro(TransposedRootIndexing, bool);
  vtkGetMacro(TransposedRootIndexing, bool);
  void SetIndexingModeToKJI() { this->SetTransposedRootIndexing(false); }
  void SetIndexingModeToIJK() { this->SetTransposedRootIndexing(true); }
 
 
  unsigned int GetOrientation() const { return this->Orientation; }
 
 
  vtkGetMacro(FreezeState, bool);
 
 
  void SetBranchFactor(unsigned int);
  unsigned int GetBranchFactor() const { return this->BranchFactor; }
 
  vtkIdType GetMaxNumberOfTrees() const;
 
  vtkIdType GetNumberOfNonEmptyTrees();
 
  vtkIdType GetNumberOfLeaves();
 
  unsigned int GetNumberOfLevels(vtkIdType);
 
  unsigned int GetNumberOfLevels();
 
 
  virtual void SetXCoordinates(vtkDataArray*);
  vtkGetObjectMacro(XCoordinates, vtkDataArray);
 
 
  virtual void SetYCoordinates(vtkDataArray*);
  vtkGetObjectMacro(YCoordinates, vtkDataArray);
 
 
  virtual void SetZCoordinates(vtkDataArray*);
  vtkGetObjectMacro(ZCoordinates, vtkDataArray);
 
 
  virtual void CopyCoordinates(const vtkHyperTreeGrid* output);
  virtual void SetFixedCoordinates(unsigned int axis, double value);
 
 
  void SetMask(vtkBitArray*);
  vtkGetObjectMacro(Mask, vtkBitArray);
 
  bool HasMask();
 
 
  vtkSetMacro(HasInterface, bool);
  vtkGetMacro(HasInterface, bool);
  vtkBooleanMacro(HasInterface, bool);
 
 
  vtkSetStringMacro(InterfaceNormalsName);
  vtkGetStringMacro(InterfaceNormalsName);
 
 
  vtkSetStringMacro(InterfaceInterceptsName);
  vtkGetStringMacro(InterfaceInterceptsName);
 
 
  vtkSetMacro(DepthLimiter, unsigned int);
  vtkGetMacro(DepthLimiter, unsigned int);
 
 
  void InitializeOrientedCursor(
    vtkHyperTreeGridOrientedCursor* cursor, vtkIdType index, bool create = false);
  VTK_NEWINSTANCE
  vtkHyperTreeGridOrientedCursor* NewOrientedCursor(vtkIdType index, bool create = false);
 
  void InitializeOrientedGeometryCursor(
    vtkHyperTreeGridOrientedGeometryCursor* cursor, vtkIdType index, bool create = false);
  VTK_NEWINSTANCE
  vtkHyperTreeGridOrientedGeometryCursor* NewOrientedGeometryCursor(
    vtkIdType index, bool create = false);
 
  void InitializeNonOrientedCursor(
    vtkHyperTreeGridNonOrientedCursor* cursor, vtkIdType index, bool create = false);
  VTK_NEWINSTANCE
  vtkHyperTreeGridNonOrientedCursor* NewNonOrientedCursor(vtkIdType index, bool create = false);
 
  void InitializeNonOrientedGeometryCursor(
    vtkHyperTreeGridNonOrientedGeometryCursor* cursor, vtkIdType index, bool create = false);
  VTK_NEWINSTANCE
  vtkHyperTreeGridNonOrientedGeometryCursor* NewNonOrientedGeometryCursor(
    vtkIdType index, bool create = false);
 
  void InitializeNonOrientedUnlimitedGeometryCursor(
    vtkHyperTreeGridNonOrientedUnlimitedGeometryCursor* cursor, vtkIdType index,
    bool create = false);
  VTK_NEWINSTANCE
  vtkHyperTreeGridNonOrientedUnlimitedGeometryCursor* NewNonOrientedUnlimitedGeometryCursor(
    vtkIdType index, bool create = false);
 
  vtkHyperTreeGridNonOrientedGeometryCursor* FindNonOrientedGeometryCursor(double x[3]);
 
private:
  unsigned int RecurseDichotomic(
    double value, vtkDoubleArray* coord, double tol, unsigned int ideb, unsigned int ifin) const;
 
  unsigned int FindDichotomic(double value, vtkDataArray* coord, double tol) const;
 
public:
  virtual unsigned int FindDichotomicX(double value, double tol = 0.0) const;
  virtual unsigned int FindDichotomicY(double value, double tol = 0.0) const;
  virtual unsigned int FindDichotomicZ(double value, double tol = 0.0) const;
 
 
  void InitializeNonOrientedVonNeumannSuperCursor(
    vtkHyperTreeGridNonOrientedVonNeumannSuperCursor* cursor, vtkIdType index, bool create = false);
  VTK_NEWINSTANCE
  vtkHyperTreeGridNonOrientedVonNeumannSuperCursor* NewNonOrientedVonNeumannSuperCursor(
    vtkIdType index, bool create = false);
 
  void InitializeNonOrientedVonNeumannSuperCursorLight(
    vtkHyperTreeGridNonOrientedVonNeumannSuperCursorLight* cursor, vtkIdType index,
    bool create = false);
  VTK_NEWINSTANCE
  vtkHyperTreeGridNonOrientedVonNeumannSuperCursorLight* NewNonOrientedVonNeumannSuperCursorLight(
    vtkIdType index, bool create = false);
 
  void InitializeNonOrientedMooreSuperCursor(
    vtkHyperTreeGridNonOrientedMooreSuperCursor* cursor, vtkIdType index, bool create = false);
  VTK_NEWINSTANCE
  vtkHyperTreeGridNonOrientedMooreSuperCursor* NewNonOrientedMooreSuperCursor(
    vtkIdType index, bool create = false);
 
  void InitializeNonOrientedMooreSuperCursorLight(
    vtkHyperTreeGridNonOrientedMooreSuperCursorLight* cursor, vtkIdType index, bool create = false);
  VTK_NEWINSTANCE
  vtkHyperTreeGridNonOrientedMooreSuperCursorLight* NewNonOrientedMooreSuperCursorLight(
    vtkIdType index, bool create = false);
 
  void InitializeNonOrientedUnlimitedMooreSuperCursor(
    vtkHyperTreeGridNonOrientedUnlimitedMooreSuperCursor* cursor, vtkIdType index,
    bool create = false);
  VTK_NEWINSTANCE
  vtkHyperTreeGridNonOrientedUnlimitedMooreSuperCursor* NewNonOrientedUnlimitedMooreSuperCursor(
    vtkIdType index, bool create = false);
 
  void Initialize() override;
 
  virtual vtkHyperTree* GetTree(vtkIdType, bool create = false);
 
  void SetTree(vtkIdType, vtkHyperTree*);
 
  size_t RemoveTree(vtkIdType index);
 
  void ShallowCopy(vtkDataObject*) override;
 
  void DeepCopy(vtkDataObject*) override;
 
  int GetExtentType() override { return VTK_3D_EXTENT; }
 
  virtual unsigned long GetActualMemorySizeBytes();
 
  unsigned long GetActualMemorySize() override;
 
  bool SupportsGhostArray(int type) override;
 
private:
  bool RecursivelyInitializePureMask(vtkHyperTreeGridNonOrientedCursor*, vtkDataArray*);
 
  void CleanPureMask();
 
public:
  vtkBitArray* GetPureMask();
 
  unsigned int GetChildMask(unsigned int);
 
  void GetIndexFromLevelZeroCoordinates(vtkIdType&, unsigned int, unsigned int, unsigned int) const;
 
  vtkIdType GetShiftedLevelZeroIndex(vtkIdType, int, int, int) const;
 
  void GetLevelZeroCoordinatesFromIndex(
    vtkIdType, unsigned int&, unsigned int&, unsigned int&) const;
 
  virtual void GetLevelZeroOriginAndSizeFromIndex(vtkIdType, double*, double*);
 
  virtual void GetLevelZeroOriginFromIndex(vtkIdType, double*);
 
  vtkIdType GetGlobalNodeIndexMax();
 
  void InitializeLocalIndexNode();
 
  bool HasAnyGhostCells() const;
 
  vtkUnsignedCharArray* GetGhostCells();
 
  vtkUnsignedCharArray* GetTreeGhostArray();
 
  vtkUnsignedCharArray* AllocateTreeGhostArray();
 
  class VTKCOMMONDATAMODEL_EXPORT vtkHyperTreeGridIterator
  {
  public:
    vtkHyperTreeGridIterator() = default;
 
    void Initialize(vtkHyperTreeGrid*);
 
    vtkHyperTree* GetNextTree(vtkIdType& index);
 
    vtkHyperTree* GetNextTree();
 
  protected:
    std::map<vtkIdType, vtkSmartPointer<vtkHyperTree>>::iterator Iterator;
    vtkHyperTreeGrid* Grid;
  };
 
  void InitializeTreeIterator(vtkHyperTreeGridIterator&);
 
 
  static vtkHyperTreeGrid* GetData(vtkInformation* info);
  static vtkHyperTreeGrid* GetData(vtkInformationVector* v, int i = 0);
 
  virtual void ComputeBounds();
 
 
  virtual double* GetBounds() VTK_SIZEHINT(6);
  void GetBounds(double bounds[6]);
 
  virtual void GetGridBounds(double bounds[6]);
 
  double* GetCenter() VTK_SIZEHINT(3);
 
  void GetCenter(double center[3]);
 
  vtkCellData* GetCellData();
 
  vtkFieldData* GetAttributesAsFieldData(int type) override;
 
  vtkIdType GetNumberOfElements(int type) override;
 
  vtkIdType GetNumberOfCells();
 
protected:
  vtkHyperTreeGrid();
 
  ~vtkHyperTreeGrid() override;
 
  char* ModeSqueeze;
 
  double Bounds[6]; // (xmin,xmax, ymin,ymax, zmin,zmax) geometric bounds
  double Center[3]; // geometric center
 
  bool FreezeState;
  unsigned int BranchFactor; // 2 or 3
  unsigned int Dimension;    // 1, 2, or 3
 
 
  vtkUnsignedCharArray* TreeGhostArray;
  bool TreeGhostArrayCached;
private:
  unsigned int Orientation; // 0, 1, or 2
  unsigned int Axis[2];
 
  vtkTimeStamp ComputeTime;
 
protected:
  unsigned int NumberOfChildren;
  bool TransposedRootIndexing;
 
  // --------------------------------
  // RectilinearGrid common fields
  // --------------------------------
private:
  unsigned int Dimensions[3]; // Just for GetDimensions
  unsigned int CellDims[3];   // Just for GetCellDims
protected:
  int DataDescription;
  int Extent[6];
 
  bool WithCoordinates;
  vtkDataArray* XCoordinates;
  vtkDataArray* YCoordinates;
  vtkDataArray* ZCoordinates;
  // --------------------------------
 
  vtkBitArray* Mask;
  vtkBitArray* PureMask;
 
  bool HasInterface;
  char* InterfaceNormalsName;
  char* InterfaceInterceptsName;
 
  std::map<vtkIdType, vtkSmartPointer<vtkHyperTree>> HyperTrees;
 
  vtkNew<vtkCellData> CellData; // Scalars, vectors, etc. associated w/ each point
 
  unsigned int DepthLimiter;
 
private:
  vtkHyperTreeGrid(const vtkHyperTreeGrid&) = delete;
  void operator=(const vtkHyperTreeGrid&) = delete;
};
 
VTK_ABI_NAMESPACE_END
#endif