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 "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;
};
 
//=============================================================================
class VTKCOMMONDATAMODEL_EXPORT vtkHyperTree : public vtkObject
{
public:
  vtkTypeMacro(vtkHyperTree, vtkObject);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
  void Initialize(
    unsigned char branchFactor, unsigned char dimension, unsigned char numberOfChildren);
 
  virtual void InitializeForReader(vtkIdType numberOfLevels, vtkIdType nbVertices,
    vtkIdType nbVerticesOfLastLevel, vtkBitArray* isParent, vtkBitArray* isMasked,
    vtkBitArray* outIsMasked) = 0;
 
  virtual void BuildFromBreadthFirstOrderDescriptor(
    vtkBitArray* descriptor, vtkIdType numberOfBits, vtkIdType startIndex = 0) = 0;
 
  virtual void ComputeBreadthFirstOrderDescriptor(vtkBitArray* inputMask,
    vtkTypeInt64Array* numberOfVerticesPerDepth, vtkBitArray* descriptor,
    vtkIdList* breadthFirstIdMap) = 0;
 
  void CopyStructure(vtkHyperTree* ht);
 
  virtual vtkHyperTree* Freeze(const char* mode) = 0;
 
 
  void SetTreeIndex(vtkIdType treeIndex) { this->Datas->TreeIndex = treeIndex; }
  vtkIdType GetTreeIndex() const { return this->Datas->TreeIndex; }
 
  unsigned int GetNumberOfLevels() const
  {
    assert("post: result_greater_or_equal_to_one" && this->Datas->NumberOfLevels >= 1);
    return this->Datas->NumberOfLevels;
  }
 
  vtkIdType GetNumberOfVertices() const { return this->Datas->NumberOfVertices; }
 
  vtkIdType GetNumberOfNodes() const { return this->Datas->NumberOfNodes; }
 
  vtkIdType GetNumberOfLeaves() const
  {
    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) const;
 
  VTK_NEWINSTANCE
  static vtkHyperTree* CreateInstance(unsigned char branchFactor, unsigned char dimension);
  virtual unsigned long GetActualMemorySizeBytes() = 0;
 
  unsigned int GetActualMemorySize()
  {
    // in kilibytes
    return static_cast<unsigned int>(this->GetActualMemorySizeBytes() / 1024);
  }
 
  virtual bool IsGlobalIndexImplicit() = 0;
 
  virtual void SetGlobalIndexStart(vtkIdType start) = 0;
 
  vtkIdType GetGlobalIndexStart() const { return this->Datas->GlobalIndexStart; }
 
  virtual void SetGlobalIndexFromLocal(vtkIdType index, vtkIdType global) = 0;
 
  virtual vtkIdType GetGlobalIndexFromLocal(vtkIdType index) const = 0;
 
  virtual vtkIdType GetGlobalNodeIndexMax() const = 0;
 
  virtual bool IsLeaf(vtkIdType index) const = 0;
 
  virtual void SubdivideLeaf(vtkIdType index, unsigned int level) = 0;
 
  virtual bool IsTerminalNode(vtkIdType index) const = 0;
 
  virtual vtkIdType GetElderChildIndex(unsigned int index_parent) const = 0;
 
  virtual const unsigned int* GetElderChildIndexArray(size_t& nbElements) const = 0;
 
 
  void SetScales(std::shared_ptr<vtkHyperTreeGridScales> scales) const { 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;
 
  virtual void InitializePrivate() = 0;
  virtual void PrintSelfPrivate(ostream& os, vtkIndent indent) = 0;
  virtual void CopyStructurePrivate(vtkHyperTree* ht) = 0;
 
  //-- 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, differents hypertree, are identicals by level).
  mutable std::shared_ptr<vtkHyperTreeGridScales> Scales;
 
private:
  void InitializeBase(
    unsigned char branchFactor, unsigned char dimension, unsigned char numberOfChildren);
  vtkHyperTree(const vtkHyperTree&) = delete;
  void operator=(const vtkHyperTree&) = delete;
};
 
VTK_ABI_NAMESPACE_END
#endif