vtkHyperTreeGridGeometryLevelEntry.h

Go to the documentation of this file.

/*=========================================================================
 
  Program:   Visualization Toolkit
  Module:    vtkHyperTreeGridGeometryLevelEntry.h
 
  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
  All rights reserved.
  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
 
     This software is distributed WITHOUT ANY WARRANTY; without even
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
     PURPOSE.  See the above copyright notice for more information.
 
=========================================================================*/
#ifndef vtkHyperTreeGridGeometryLevelEntry_h
#define vtkHyperTreeGridGeometryLevelEntry_h
 
#ifndef __VTK_WRAP__
 
#include "assert.h"
 
#include "vtkObject.h"
#include "vtkSmartPointer.h"
 
#include "vtkHyperTreeGridNonOrientedGeometryCursor.h"
#include "vtkHyperTreeGridOrientedGeometryCursor.h"
 
class vtkHyperTree;
class vtkHyperTreeGrid;
 
class vtkHyperTreeGridGeometryLevelEntry
{
public:
  void PrintSelf(ostream& os, vtkIndent indent);
 
  vtkHyperTreeGridGeometryLevelEntry()
  {
    this->Tree = nullptr;
    this->Level = 0;
    this->Index = 0;
    for (unsigned int d = 0; d < 3; ++d)
    {
      this->Origin[d] = 0.;
    }
  }
 
  ~vtkHyperTreeGridGeometryLevelEntry() = default;
 
  void Dump(ostream& os);
 
  void Initialize(vtkHyperTree* tree, unsigned int level, vtkIdType index, const double* origin)
  {
    this->Tree = tree;
    this->Level = level;
    this->Index = index;
    for (unsigned int d = 0; d < 3; ++d)
    {
      this->Origin[d] = origin[d];
    }
  }
 
  vtkHyperTree* Initialize(vtkHyperTreeGrid* grid, vtkIdType treeIndex, bool create = false);
 
  void Reset()
  {
    this->Tree = nullptr;
    this->Index = 0;
  }
 
  void Copy(const vtkHyperTreeGridGeometryLevelEntry* entry)
  {
    this->Initialize(entry->Tree, entry->Level, entry->Index, entry->Origin);
  }
 
  vtkSmartPointer<vtkHyperTreeGridOrientedGeometryCursor> GetHyperTreeGridOrientedGeometryCursor(
    vtkHyperTreeGrid* grid)
  {
    vtkSmartPointer<vtkHyperTreeGridOrientedGeometryCursor> cursor =
      vtkSmartPointer<vtkHyperTreeGridOrientedGeometryCursor>::New();
    cursor->Initialize(grid, this->Tree, this->Level, this->Index, this->Origin);
    return cursor;
  }
 
  vtkSmartPointer<vtkHyperTreeGridNonOrientedGeometryCursor>
  GetHyperTreeGridNonOrientedGeometryCursor(vtkHyperTreeGrid* grid)
  {
    assert("pre: level==0" && this->Level == 0);
    vtkSmartPointer<vtkHyperTreeGridNonOrientedGeometryCursor> cursor =
      vtkSmartPointer<vtkHyperTreeGridNonOrientedGeometryCursor>::New();
    cursor->Initialize(grid, this->Tree, this->Level, this->Index, this->Origin);
    return cursor;
  }
 
  vtkIdType GetVertexId() const { return this->Index; }
 
  vtkIdType GetGlobalNodeIndex() const;
 
  void SetGlobalIndexStart(vtkIdType index);
 
  void SetGlobalIndexFromLocal(vtkIdType index);
 
  void SetMask(const vtkHyperTreeGrid* grid, bool state);
 
  bool IsMasked(const vtkHyperTreeGrid* grid) const;
 
  bool IsLeaf(const vtkHyperTreeGrid* grid) const;
 
  void SubdivideLeaf(const vtkHyperTreeGrid* grid);
 
  bool IsTerminalNode(const vtkHyperTreeGrid* grid) const;
 
  bool IsRoot() { return (this->Index == 0); }
 
  void ToChild(const vtkHyperTreeGrid* grid, unsigned char ichild);
 
  vtkHyperTree* GetTree() const { return this->Tree; }
 
  unsigned int GetLevel() const { return this->Level; }
 
  double* GetOrigin() { return this->Origin; }
  const double* GetOrigin() const { return this->Origin; }
 
  void GetBounds(double bounds[6]) const;
 
  void GetPoint(double point[3]) const;
 
private:
  vtkHyperTree* Tree;
 
  unsigned int Level;
 
  vtkIdType Index;
 
  double Origin[3];
};
 
#endif // __VTK_WRAP__
 
#endif // vtkHyperTreeGridGeometryLevelEntry
// VTK-HeaderTest-Exclude: vtkHyperTreeGridGeometryLevelEntry.h