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 "vtkDeprecation.h"  // for deprecation macro
#include "vtkNew.h"          // vtkSmartPointer
#include "vtkSmartPointer.h" // vtkSmartPointer
 
#include <cassert> // std::assert
#include <limits>  // limits
#include <map>     // std::map
 
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:
 
  VTK_DEPRECATED_IN_9_6_0("Unused key.")
  static vtkInformationIntegerKey* LEVELS();
  VTK_DEPRECATED_IN_9_6_0("Unused key.")
  static vtkInformationIntegerKey* DIMENSION();
  VTK_DEPRECATED_IN_9_6_0("Unused key.")
  static vtkInformationIntegerKey* ORIENTATION();
  VTK_DEPRECATED_IN_9_6_0("Unused key.")
  static vtkInformationDoubleVectorKey* SIZES();
 
  static vtkHyperTreeGrid* New();
 
  vtkTypeMacro(vtkHyperTreeGrid, vtkDataObject);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
  static constexpr vtkIdType InvalidIndex = ~0;
 
  VTK_DEPRECATED_IN_9_6_0("No effect anymore, do not use.")
  void SetModeSqueeze(const char* vtkNotUsed(vtksqueeze)){};
  VTK_DEPRECATED_IN_9_6_0("No effect anymore, do not use.")
  char* GetModeSqueeze() { return nullptr; }
 
  VTK_DEPRECATED_IN_9_6_0("No effect anymore, do not use.")
  virtual void Squeeze(){};
 
  int GetDataObjectType() VTK_FUTURE_CONST 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; }
 
  VTK_DEPRECATED_IN_9_6_0("No effect, do not use.")
  bool GetFreezeState() { return false; };
 
 
  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 index, bool create = false);
 
  void SetTree(vtkIdType, vtkHyperTree*);
 
  size_t RemoveTree(vtkIdType index);
 
  void ShallowCopy(vtkDataObject*) override;
 
  void DeepCopy(vtkDataObject*) override;
 
  int GetExtentType() VTK_FUTURE_CONST 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* grid);
 
    vtkHyperTree* GetNextTree(vtkIdType& index);
 
    vtkHyperTree* GetNextTree();
 
  protected:
    std::map<vtkIdType, vtkSmartPointer<vtkHyperTree>>::iterator Iterator;
    vtkHyperTreeGrid* Grid = nullptr;
  };
 
  void InitializeTreeIterator(vtkHyperTreeGridIterator& it);
 
 
  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;
 
  double Bounds[6];                  // (xmin,xmax, ymin,ymax, zmin,zmax) geometric bounds
  double Center[3]{ 0.0, 0.0, 0.0 }; // geometric center
 
  unsigned int BranchFactor = 0; // 2 or 3, 0 for invalid
  unsigned int Dimension = 0;    // 1, 2, or 3, 0 for invalid
 
 
  vtkUnsignedCharArray* TreeGhostArray = nullptr;
  bool TreeGhostArrayCached = false;
private:
  // Invalid default grid parameters to force actual initialization
  unsigned int Orientation = std::numeric_limits<unsigned int>::max(); // 0, 1, or 2
  unsigned int Axis[2] = { std::numeric_limits<unsigned int>::max(),
    std::numeric_limits<unsigned int>::max() };
 
  vtkTimeStamp ComputeTime;
 
protected:
  unsigned int NumberOfChildren = 0;
  bool TransposedRootIndexing = false;
 
  // --------------------------------
  // RectilinearGrid common fields
  // --------------------------------
private:
  unsigned int Dimensions[3] = { 0, 0, 0 }; // Just for GetDimensions
  unsigned int CellDims[3] = { 0, 0, 0 };   // Just for GetCellDims
protected:
  int DataDescription;
  int Extent[6] = { 0, -1, 0, -1, 0, -1 };
 
  bool WithCoordinates = false;
  vtkDataArray* XCoordinates = nullptr;
  vtkDataArray* YCoordinates = nullptr;
  vtkDataArray* ZCoordinates = nullptr;
  // --------------------------------
 
  vtkBitArray* Mask = nullptr;
  vtkBitArray* PureMask = nullptr;
 
  bool HasInterface = false;
  char* InterfaceNormalsName = nullptr;
  char* InterfaceInterceptsName = nullptr;
 
  std::map<vtkIdType, vtkSmartPointer<vtkHyperTree>> HyperTrees;
 
  vtkNew<vtkCellData> CellData; // Scalars, vectors, etc. associated w/ each point
 
  unsigned int DepthLimiter = std::numeric_limits<unsigned int>::max();
 
private:
  vtkHyperTreeGrid(const vtkHyperTreeGrid&) = delete;
  void operator=(const vtkHyperTreeGrid&) = delete;
};
 
VTK_ABI_NAMESPACE_END
#endif