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:
  static vtkHyperTreeGrid* New();
 
  vtkTypeMacro(vtkHyperTreeGrid, vtkDataObject);
  void PrintSelf(ostream& os, vtkIndent indent) override;

  static constexpr vtkIdType InvalidIndex = ~0;

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


  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*);
  virtual vtkDataArray* GetXCoordinates();


  virtual void SetYCoordinates(vtkDataArray*);
  virtual vtkDataArray* GetYCoordinates();


  virtual void SetZCoordinates(vtkDataArray*);
  virtual vtkDataArray* GetZCoordinates();


  virtual void CopyCoordinates(const vtkHyperTreeGrid* output);
  virtual void SetFixedCoordinates(unsigned int axis, double value);


  void SetMask(vtkBitArray*);
  virtual vtkBitArray* GetMask();

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

  virtual void GenerateGhostArray(int zeroExt[6]);
 
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
 
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;


  vtkSmartPointer<vtkUnsignedCharArray> TreeGhostArray;
  bool TreeGhostArrayCached = false;
 
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;
  vtkSmartPointer<vtkDataArray> XCoordinates;
  vtkSmartPointer<vtkDataArray> YCoordinates;
  vtkSmartPointer<vtkDataArray> ZCoordinates;
  // --------------------------------
 
  vtkSmartPointer<vtkBitArray> Mask;
  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