vtkHyperTree.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 vtkHyperTree_h
#define vtkHyperTree_h
 
#include "vtkCommonDataModelModule.h" // For export macro
#include "vtkDeprecation.h"           // Include the macros.
#include "vtkObject.h"
 
#include <cassert> // Used internally
#include <memory>  // std::shared_ptr
 
VTK_ABI_NAMESPACE_BEGIN
class vtkBitArray;
class vtkIdList;
class vtkHyperTreeGridScales;
class vtkTypeInt64Array;
 
//=============================================================================
struct vtkHyperTreeData
{
  // Index of this tree in the hypertree grid
  vtkIdType TreeIndex;
 
  // Number of levels in the tree
  unsigned int NumberOfLevels;
 
  // Number of vertices in this tree (coarse and leaves)
  vtkIdType NumberOfVertices;
 
  // Number of nodes (non-leaf vertices) in the tree
  vtkIdType NumberOfNodes;
 
  // Offset start for the implicit global index mapping fixed by
  // SetGlobalIndexStart after create a tree.
  // If you don't choose implicit global index mapping then this
  // value is -1. Then, you must to descrieb explicit global index
  // mapping by using then SetGlobalIndexFromLocal for each cell
  // in tree.
  // The extra cost is equivalent to the cost of a field of values
  // of cells.
  vtkIdType GlobalIndexStart;
 
  // Storage to record the parent of each tree vertex
  std::vector<unsigned int> ParentToElderChild;
 
  // Storage to record the local to global id mapping
  std::vector<vtkIdType> GlobalIndexTable;
};
 
//=============================================================================
class VTKCOMMONDATAMODEL_EXPORT vtkHyperTree : public vtkObject
{
public:
  static vtkHyperTree* New();
  vtkTypeMacro(vtkHyperTree, vtkObject);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
  VTK_DEPRECATED_IN_9_6_0(
    "Use bool Initialize(unsigned char branchFactor, unsigned char dimension) instead.")
  void Initialize(
    unsigned char branchFactor, unsigned char dimension, unsigned char numberOfChildren);
 
  bool Initialize(unsigned char branchFactor, unsigned char dimension);
 
  virtual void InitializeForReader(vtkIdType numberOfLevels, vtkIdType nbVertices,
    vtkIdType nbVerticesOfLastLevel, vtkBitArray* isParent, vtkBitArray* isMasked,
    vtkBitArray* outIsMasked);
 
  virtual void BuildFromBreadthFirstOrderDescriptor(
    vtkBitArray* descriptor, vtkIdType numberOfBits, vtkIdType startIndex = 0);
 
  virtual void ComputeBreadthFirstOrderDescriptor(unsigned int depthLimiter, vtkBitArray* inputMask,
    vtkTypeInt64Array* numberOfVerticesPerDepth, vtkBitArray* descriptor,
    vtkIdList* breadthFirstIdMap);
 
  void CopyStructure(vtkHyperTree* ht);
 
  VTK_DEPRECATED_IN_9_6_0("No effect, do not use.")
  virtual vtkHyperTree* Freeze(const char* vtkNotUsed(mode)) { return this; };
 
 
  void SetTreeIndex(vtkIdType treeIndex)
  {
    assert("pre: datas_non_nullptr" && this->Datas != nullptr);
    this->Datas->TreeIndex = treeIndex;
  }
  vtkIdType GetTreeIndex() const
  {
    assert("pre: datas_non_nullptr" && this->Datas != nullptr);
    return this->Datas->TreeIndex;
  }
 
  unsigned int GetNumberOfLevels() const
  {
    assert("pre: datas_non_nullptr" && this->Datas != nullptr);
    assert("post: result_greater_or_equal_to_one" && this->Datas->NumberOfLevels >= 1);
    return this->Datas->NumberOfLevels;
  }
 
  vtkIdType GetNumberOfVertices() const
  {
    assert("pre: datas_non_nullptr" && this->Datas != nullptr);
    return this->Datas->NumberOfVertices;
  }
 
  vtkIdType GetNumberOfNodes() const
  {
    assert("pre: datas_non_nullptr" && this->Datas != nullptr);
    return this->Datas->NumberOfNodes;
  }
 
  vtkIdType GetNumberOfLeaves() const
  {
    assert("pre: datas_non_nullptr" && this->Datas != nullptr);
    return this->Datas->NumberOfVertices - this->Datas->NumberOfNodes;
  }
 
  int GetBranchFactor() const { return this->BranchFactor; }
 
  int GetDimension() const { return this->Dimension; }
 
  vtkIdType GetNumberOfChildren() const { return this->NumberOfChildren; }
 
 
  void GetScale(double s[3]) const;
  double GetScale(unsigned int d) const;
 
  std::shared_ptr<vtkHyperTreeGridScales> InitializeScales(
    const double* scales, bool reinitialize = false);
 
  VTK_NEWINSTANCE
  VTK_DEPRECATED_IN_9_6_0("Use vtkNew<vtkHyperTree> and Initialize instead.")
  static vtkHyperTree* CreateInstance(unsigned char branchFactor, unsigned char dimension);
  virtual unsigned long GetActualMemorySizeBytes();
 
  unsigned int GetActualMemorySize()
  {
    // in kilibytes
    return static_cast<unsigned int>(this->GetActualMemorySizeBytes() / 1024);
  }
 
  virtual bool IsGlobalIndexImplicit();
 
  virtual void SetGlobalIndexStart(vtkIdType start);
 
  vtkIdType GetGlobalIndexStart() const
  {
    assert("pre: datas_non_nullptr" && this->Datas != nullptr);
    return this->Datas->GlobalIndexStart;
  }
 
  virtual void SetGlobalIndexFromLocal(vtkIdType index, vtkIdType global);
 
  virtual vtkIdType GetGlobalIndexFromLocal(vtkIdType index) const;
 
  virtual vtkIdType GetGlobalNodeIndexMax() const;
 
  virtual bool IsLeaf(vtkIdType index) const;
 
  virtual void SubdivideLeaf(vtkIdType index, unsigned int level);
 
  virtual bool IsTerminalNode(vtkIdType index) const;
 
  virtual vtkIdType GetElderChildIndex(unsigned int index_parent) const;
 
  virtual const unsigned int* GetElderChildIndexArray(size_t& nbElements) const;
 
 
  void SetScales(std::shared_ptr<vtkHyperTreeGridScales> scales) { this->Scales = scales; }
 
 
  bool HasScales() const { return (this->Scales != nullptr); }
 
 
  std::shared_ptr<vtkHyperTreeGridScales> GetScales() const
  {
    assert(this->Scales != nullptr);
    return this->Scales;
  }
 
protected:
  vtkHyperTree();
  ~vtkHyperTree() override = default;
 
private:
  vtkHyperTree(const vtkHyperTree&) = delete;
  void operator=(const vtkHyperTree&) = delete;
 
  bool IsChildLeaf(vtkIdType index_parent, unsigned int ichild) const;
 
  void ComputeBreadthFirstOrderDescriptorImpl(unsigned int depthLimiter, vtkBitArray* inputMask,
    unsigned int depth, vtkIdType index, std::vector<std::vector<bool>>& descriptorPerDepth,
    std::vector<std::vector<vtkIdType>>& breadthFirstOrderIdMapPerDepth);
 
  //-- Global information
 
  // Branching factor of tree (2 or 3)
  unsigned char BranchFactor;
 
  // Dimension of tree (1, 2, or 3)
  unsigned char Dimension;
 
  // Number of children for coarse cell
  unsigned char NumberOfChildren;
 
  //-- Local information
  std::shared_ptr<vtkHyperTreeData> Datas;
 
  // Storage of pre-computed per-level cell scales
  // In hypertree grid, one description by hypertree.
  // In Uniform hypertree grid, one description by hypertree grid
  // (all cells, different hypertree, are identical by level).
  std::shared_ptr<vtkHyperTreeGridScales> Scales;
};
 
VTK_ABI_NAMESPACE_END
#endif