vtkHyperTreeGrid.h

Go to the documentation of this file.

/*=========================================================================
 
  Program:   Visualization Toolkit
  Module:    vtkHyperTreeGrid.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 vtkHyperTreeGrid_h
#define vtkHyperTreeGrid_h
 
#include "vtkCommonDataModelModule.h" // For export macro
#include "vtkDataSet.h"
#include <map> // STL header for dual point coordinates ajustment
 
class vtkHyperTreeCursor;
class vtkHyperTree;
 
class vtkBitArray;
class vtkCellLinks;
class vtkCollection;
class vtkDataArray;
class vtkDataSetAttributes;
class vtkIdTypeArray;
class vtkLine;
class vtkPixel;
class vtkPoints;
class vtkVoxel;
 
class VTKCOMMONDATAMODEL_EXPORT vtkHyperTreeGrid : public vtkDataSet
{
public:
//BTX
  class vtkHyperTreeSimpleCursor;
  class vtkHyperTreeIterator;
  struct vtkHyperTreeGridSuperCursor;
//ETX
 
  static vtkInformationIntegerKey* LEVELS();
  static vtkInformationIntegerKey* DIMENSION();
  static vtkInformationDoubleVectorKey* SIZES();
  static vtkHyperTreeGrid* New();
 
  vtkTypeMacro(vtkHyperTreeGrid, vtkDataSet);
  void PrintSelf( ostream&, vtkIndent );
 
  int GetDataObjectType();
 
  void CopyStructure( vtkDataSet* );
 
 
  void SetGridSize( unsigned int[3] );
  void SetGridSize( unsigned int i, unsigned int j, unsigned int k );
  vtkGetVector3Macro(GridSize, unsigned int);
 
 
  void SetGridExtent(int extent[6]);
  void SetGridExtent(int iMin, int iMax, int jMin, int jMax,
                     int kMin, int kMax);
 
 
  vtkSetMacro(TransposedRootIndexing, bool);
  vtkGetMacro(TransposedRootIndexing, bool);
  void SetIndexingModeToKJI()
    { this->SetTransposedRootIndexing( false ); }
  void SetIndexingModeToIJK()
    { this->SetTransposedRootIndexing( true ); }
 
 
  void SetBranchFactor( unsigned int );
  vtkGetMacro(BranchFactor, unsigned int);
 
 
  void SetDimension( unsigned int );
  vtkGetMacro(Dimension, unsigned int);
 
  vtkIdType GetNumberOfCells();
 
  vtkIdType GetNumberOfPoints();
 
  vtkIdType GetNumberOfLeaves();
 
  vtkIdType GetNumberOfLevels( vtkIdType );
 
  vtkIdType GetNumberOfTrees();
 
 
  void SetXCoordinates( vtkDataArray* );
  vtkGetObjectMacro(XCoordinates, vtkDataArray);
 
 
  void SetYCoordinates( vtkDataArray* );
  vtkGetObjectMacro(YCoordinates, vtkDataArray);
 
 
  void SetZCoordinates( vtkDataArray* );
  vtkGetObjectMacro(ZCoordinates, vtkDataArray);
 
 
  void SetMaterialMask( vtkBitArray* );
  vtkGetObjectMacro(MaterialMask, vtkBitArray);
 
 
  virtual void SetMaterialMaskIndex( vtkIdTypeArray* );
  vtkGetObjectMacro(MaterialMaskIndex, vtkIdTypeArray);
 
  virtual void GenerateTrees();
 
  vtkHyperTreeCursor* NewCursor( vtkIdType );
 
  void SubdivideLeaf( vtkHyperTreeCursor*, vtkIdType );
 
  virtual double* GetPoint( vtkIdType );
 
  virtual void GetPoint( vtkIdType, double[3] );
 
  virtual vtkCell* GetCell( vtkIdType );
 
  virtual void GetCell( vtkIdType, vtkGenericCell* );
 
  virtual int GetCellType( vtkIdType );
 
  virtual void GetCellPoints( vtkIdType, vtkIdList* );
 
  virtual void GetCellPoints( vtkIdType, vtkIdType&, vtkIdType*& );
 
  virtual void GetPointCells( vtkIdType, vtkIdList* );
 
  virtual void GetCellNeighbors( vtkIdType, vtkIdList*, vtkIdList* );
 
  virtual vtkIdType FindPoint( double x[3] );
 
 
  virtual vtkIdType FindCell( double x[3], vtkCell *cell, vtkIdType cellId,
                              double tol2, int& subId, double pcoords[3],
                              double *weights );
 
 
  virtual vtkIdType FindCell( double x[3], vtkCell *cell,
                              vtkGenericCell *gencell, vtkIdType cellId,
                              double tol2, int& subId, double pcoords[3],
                              double *weights );
 
  void Initialize();
 
  void InitializeTreeIterator( vtkHyperTreeIterator& );
 
  virtual int GetMaxCellSize();
 
 
  void ShallowCopy( vtkDataObject* );
  void DeepCopy( vtkDataObject* );
 
  int GetExtentType() { return VTK_3D_EXTENT; }
 
  unsigned long GetActualMemorySize();
 
  void GenerateSuperCursorTraversalTable();
 
//BTX
#ifndef __WRAP__
 
 
  void InitializeSuperCursor( vtkHyperTreeGridSuperCursor*,
                              unsigned int,
                              unsigned int,
                              unsigned int,
                              vtkIdType );
  void InitializeSuperCursor( vtkHyperTreeGridSuperCursor*,
                              vtkIdType );
 
 
  void InitializeSuperCursorChild( vtkHyperTreeGridSuperCursor* parent,
                                   vtkHyperTreeGridSuperCursor* child,
                                   unsigned int childIdx );
#endif
//ETX
 
 
  vtkGetMacro(NumberOfChildren, unsigned int);
 
 
  void GetLevelZeroCoordsFromIndex( vtkIdType index,
                                    unsigned int &i,
                                    unsigned int &j,
                                    unsigned int &k );
 
protected:
  // Constructor with default bounds (0,1, 0,1, 0,1).
  vtkHyperTreeGrid();
  ~vtkHyperTreeGrid();
 
  void ComputeBounds();
 
  void GetCell( vtkIdType, vtkCell* );
 
  void ComputeDualGrid();
  vtkPoints* GetPoints();
  vtkIdTypeArray* GetConnectivity();
 
  unsigned int Dimension;    // 1, 2 or 3.
  unsigned int GridSize[3];
  int Extent[6];
  unsigned int BranchFactor;
  unsigned int NumberOfChildren;
  bool TransposedRootIndexing;
 
  vtkBitArray* MaterialMask;
  vtkIdTypeArray* MaterialMaskIndex;
 
  vtkDataArray* XCoordinates;
  vtkDataArray* YCoordinates;
  vtkDataArray* ZCoordinates;
 
  std::map<vtkIdType, vtkHyperTree*> HyperTrees;
 
  vtkPoints* Points;
  vtkIdTypeArray* Connectivity;
  std::map<vtkIdType, bool> PointShifted;
  std::map<vtkIdType, double> PointShifts[3];
  std::map<vtkIdType, double> ReductionFactors;
 
  void DeleteInternalArrays();
  void DeleteTrees();
 
//BTX
#if !defined(__WRAP__) && !defined(__WRAP_GCCXML__)
  void TraverseDualRecursively( vtkHyperTreeGridSuperCursor*, unsigned int );
 
  void TraverseDualMaskedLeaf( vtkHyperTreeGridSuperCursor* );
 
  void TraverseDualLeaf( vtkHyperTreeGridSuperCursor* );
 
  void EvaluateDualCorner( vtkHyperTreeSimpleCursor* );
#endif
//ETX
 
  // Used to advance the super cursor; One Entry per cursor node.
  // Private.
  struct vtkSuperCursorEntry
  {
    // For the new node, start with the node in super cursor as parent.
    unsigned char Parent;
    // Traverse to this child.
    unsigned char Child;
  };
 
  // Generalizing for 27 tree. Cannot use 3 bits to encode the child to move to.
  // Input: root in supercursor(3x3x3=27), child(3x3x3=27)
  // Output: root, child
  // It is easier to abstract dimensions when we use a single array.
  vtkSuperCursorEntry SuperCursorTraversalTable[27*27];
 
  // for the GetCell method
  vtkLine* Line;
  vtkPixel* Pixel;
  vtkVoxel* Voxel;
 
  // I would like to get rid of this.
  // Is it a part of the vtkDataSet API?
  vtkCellLinks* Links;
  void BuildLinks();
 
//BTX
  vtkIdType RecursiveFindPoint( double x[3],
                                vtkHyperTreeSimpleCursor* cursor,
                                double* origin, double* size);
//ETX
 
public:
 
//BTX
  // A simplified hyper tree cursor, to be used by the hyper tree
  // grid supercursor.
  class VTKCOMMONDATAMODEL_EXPORT vtkHyperTreeSimpleCursor
  {
  public:
    vtkHyperTreeSimpleCursor();
 
    void Clear();
    void Initialize( vtkHyperTreeGrid*, vtkIdType, int[3] );
    void ToRoot();
    void ToChild( int );
    bool IsLeaf();
    vtkHyperTree* GetTree() { return this->Tree; }
    vtkIdType GetLeafIndex() { return this->Index; } // Only valid for leaves.
    vtkIdType GetGlobalNodeIndex();
    unsigned short GetLevel() { return this->Level; }
 
  private:
    vtkHyperTree* Tree;
    vtkIdType Index;
    unsigned short Level;
    bool Leaf;
  };
 
  class VTKCOMMONDATAMODEL_EXPORT vtkHyperTreeIterator
  {
  public:
    vtkHyperTreeIterator() {}
 
    void Initialize( vtkHyperTreeGrid* );
 
    vtkHyperTree* GetNextTree( vtkIdType &index );
 
    vtkHyperTree* GetNextTree();
 
  protected:
    std::map<vtkIdType, vtkHyperTree*>::iterator Iterator;
    vtkHyperTreeGrid* Tree;
  };
 
  // Public structure filters use to move around the tree.
  // The super cursor keeps neighbor cells so filters can
  // easily access neighbor to leaves.
  // The super cursor is 'const'.  Methods in vtkHyperTreeGrid
  // initialize and compute children for moving toward leaves.
  struct vtkHyperTreeGridSuperCursor
  {
    double Origin[3];
    double Size[3];
    int NumberOfCursors;
    int MiddleCursorId;
    vtkHyperTreeSimpleCursor Cursors[3*3*3];
 
    vtkHyperTreeSimpleCursor* GetCursor( int idx )
    {
      return this->Cursors + this->MiddleCursorId + idx;
    }
  };
//ETX
 
private:
  vtkHyperTreeGrid(const vtkHyperTreeGrid&);  // Not implemented.
  void operator=(const vtkHyperTreeGrid&);    // Not implemented.
};
 
#endif