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 vtkHyperTree;
class vtkHyperTreeCursor;
class vtkHyperTreeGridCursor;

class vtkBitArray;
class vtkBoundingBox;
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:
  class vtkHyperTreeSimpleCursor;
  class vtkHyperTreePositionCursor;
  class vtkHyperTreeGridIterator;
  struct vtkHyperTreeGridSuperCursor;

  static vtkInformationIntegerKey* LEVELS();
  static vtkInformationIntegerKey* DIMENSION();
  static vtkInformationIntegerKey* ORIENTATION();
  static vtkInformationDoubleVectorKey* SIZES();
  static vtkHyperTreeGrid* New();

  vtkTypeMacro(vtkHyperTreeGrid, vtkDataSet);
  void PrintSelf( ostream&, vtkIndent ) override;

  int GetDataObjectType() override;

  void CopyStructure( vtkDataSet* ) override;


  void SetGridSize( unsigned int[3] );
  void SetGridSize( unsigned int, unsigned int, unsigned int );
  vtkGetVector3Macro(GridSize, unsigned int);


  void SetGridExtent(int extent[6]);
  void SetGridExtent(int, int, int, int, int, int );


  vtkSetMacro(TransposedRootIndexing, bool);
  vtkGetMacro(TransposedRootIndexing, bool);
  void SetIndexingModeToKJI()
    { this->SetTransposedRootIndexing( false ); }
  void SetIndexingModeToIJK()
    { this->SetTransposedRootIndexing( true ); }


  void SetDimension( unsigned int );
  vtkGetMacro(Dimension, unsigned int);


  virtual void SetOrientation(unsigned int);
  vtkGetMacro(Orientation, unsigned int);


  void SetBranchFactor( unsigned int );
  vtkGetMacro(BranchFactor, unsigned int);

  vtkIdType GetNumberOfTrees();

  vtkIdType GetNumberOfVertices();

  vtkIdType GetNumberOfLeaves();

  vtkIdType GetNumberOfCells() override;

  vtkIdType GetNumberOfPoints() override;

  vtkIdType GetNumberOfLevels( vtkIdType );

  vtkIdType GetNumberOfLevels();


  void SetXCoordinates( vtkDataArray* );
  vtkGetObjectMacro(XCoordinates, vtkDataArray);


  void SetYCoordinates( vtkDataArray* );
  vtkGetObjectMacro(YCoordinates, vtkDataArray);


  void SetZCoordinates( vtkDataArray* );
  vtkGetObjectMacro(ZCoordinates, vtkDataArray);


  void SetMaterialMask( vtkBitArray* );
  vtkGetObjectMacro(MaterialMask, vtkBitArray);

  bool HasMaterialMask();


  virtual void SetMaterialMaskIndex( vtkIdTypeArray* );
  vtkGetObjectMacro(MaterialMaskIndex, vtkIdTypeArray);


  vtkSetMacro( HasInterface, bool );
  vtkGetMacro( HasInterface, bool );
  vtkBooleanMacro( HasInterface, bool );


  vtkSetStringMacro(InterfaceNormalsName);
  vtkGetStringMacro(InterfaceNormalsName);


  vtkSetStringMacro(InterfaceInterceptsName);
  vtkGetStringMacro(InterfaceInterceptsName);

  virtual void GenerateTrees();

  vtkHyperTreeCursor* NewCursor( vtkIdType, bool create=false );

  vtkHyperTreeGridCursor* NewGridCursor( vtkIdType,
                                         bool create=false );

  vtkHyperTreeGridCursor* NewGeometricCursor( vtkIdType,
                                              bool create=false );

  vtkHyperTreeGridCursor* NewVonNeumannSuperCursor( vtkIdType,
                                                    bool create=false );

  vtkHyperTreeGridCursor* NewMooreSuperCursor( vtkIdType,
                                               bool create=false );

  void SubdivideLeaf( vtkHyperTreeCursor*, vtkIdType );

  double* GetPoint( vtkIdType ) override;

  void GetPoint( vtkIdType, double[3] ) override;

  vtkCell* GetCell( vtkIdType ) override;

  vtkCell* GetCell( int i, int j, int k) override {
    return this->Superclass::GetCell(i,j,k);
  };

  void GetCell( vtkIdType, vtkGenericCell* ) override;

  int GetCellType( vtkIdType ) override;

  void GetCellPoints( vtkIdType, vtkIdList* ) override;

  void GetCellPoints( vtkIdType, vtkIdType&, vtkIdType*& );

  void GetPointCells( vtkIdType, vtkIdList* ) override;

  void GetCellNeighbors( vtkIdType, vtkIdList*, vtkIdList* ) override;

  vtkIdType FindPoint( double x[3] ) override;

  vtkIdType FindCell( double x[3], vtkCell *cell, vtkIdType cellId,
                      double tol2, int& subId, double pcoords[3],
                      double *weights ) override;

  vtkIdType FindCell( double x[3], vtkCell *cell,
                      vtkGenericCell *gencell, vtkIdType cellId,
                      double tol2, int& subId, double pcoords[3],
                      double *weights ) override;

  void Initialize() override;

  vtkHyperTree* GetTree( vtkIdType );

  void SetTree( vtkIdType, vtkHyperTree* );

  void InitializeTreeIterator( vtkHyperTreeGridIterator& );

  int GetMaxCellSize() override;

  void ShallowCopy( vtkDataObject* ) override;

  void DeepCopy( vtkDataObject* ) override;

  int GetExtentType() override { return VTK_3D_EXTENT; }

  unsigned long GetActualMemorySize() override;


  vtkGetMacro(NumberOfChildren, unsigned int);

  bool RecursivelyInitializePureMaterialMask( vtkHyperTreeGridCursor* cursor );

  vtkBitArray* GetPureMaterialMask();

  unsigned int GetChildMask( unsigned int );

  void GetLevelZeroCoordinatesFromIndex( vtkIdType,
                                         unsigned int&,
                                         unsigned int&,
                                         unsigned int& );

  void GetIndexFromLevelZeroCoordinates( vtkIdType&,
                                         unsigned int,
                                         unsigned int,
                                         unsigned int );

  unsigned int GetShiftedLevelZeroIndex( vtkIdType,
                                         int,
                                         int,
                                         int );


  class VTKCOMMONDATAMODEL_EXPORT vtkHyperTreeSimpleCursor
  {
  public:
    vtkHyperTreeSimpleCursor();
    ~vtkHyperTreeSimpleCursor();


    vtkHyperTree* GetTree() { return this->Tree; }

    vtkIdType GetLeafIndex() { return this->Index; }

    unsigned short GetLevel() { return this->Level; }

  private:
    vtkHyperTree* Tree;
    vtkIdType Index;
    unsigned short Level;
  };

  struct vtkHyperTreeGridSuperCursor
  {
    double Origin[3];
    double Size[3];
    int NumberOfCursors;
    int MiddleCursorId;
    vtkHyperTreeSimpleCursor Cursors[3*3*3];
    vtkHyperTreeSimpleCursor* GetCursor( int );
  };

  class VTKCOMMONDATAMODEL_EXPORT vtkHyperTreeGridIterator
  {
  public:
    vtkHyperTreeGridIterator() {}

    void Initialize( vtkHyperTreeGrid* );

    vtkHyperTree* GetNextTree( vtkIdType& index );

    vtkHyperTree* GetNextTree();

  protected:
    std::map<vtkIdType, vtkHyperTree*>::iterator Iterator;
    vtkHyperTreeGrid* Tree;
  };


  static vtkHyperTreeGrid* GetData( vtkInformation* info );
  static vtkHyperTreeGrid* GetData( vtkInformationVector* v, int i=0);

protected:
  vtkHyperTreeGrid();

  ~vtkHyperTreeGrid() override;

  void ComputeBounds() override;

  void ComputeDualGrid();

  vtkPoints* GetPoints();
  vtkIdTypeArray* GetConnectivity();

  unsigned int BranchFactor; // 2 or 3
  unsigned int Dimension;    // 1, 2, or 3
  unsigned int Orientation;  // 0, 1, or 2
  unsigned int GridSize[3];
  int Extent[6];
  unsigned int NumberOfChildren;
  bool TransposedRootIndexing;

  vtkBitArray* MaterialMask;
  vtkBitArray* PureMaterialMask;
  vtkIdTypeArray* MaterialMaskIndex;
  bool InitPureMaterialMask;

  bool HasInterface;
  char* InterfaceNormalsName;
  char* InterfaceInterceptsName;

  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 DeepCopyCursors( vtkHyperTreeCursor*, vtkHyperTreeCursor* );

  void DeleteTrees();

  void ResetDual();

  void ResetSuperCursor();

  void TraverseDualRecursively( vtkHyperTreeGridCursor* );

  void TraverseDualRecursively( vtkHyperTreeGridCursor*, vtkBitArray* );

  void GenerateDualCornerFromLeaf1D( vtkHyperTreeGridCursor* );

  void GenerateDualCornerFromLeaf1D( vtkHyperTreeGridCursor*, vtkBitArray* );

  void GenerateDualCornerFromLeaf2D( vtkHyperTreeGridCursor* );

  void GenerateDualCornerFromLeaf2D( vtkHyperTreeGridCursor*, vtkBitArray* );

  void GenerateDualCornerFromLeaf3D( vtkHyperTreeGridCursor* );

  void GenerateDualCornerFromLeaf3D( vtkHyperTreeGridCursor*, vtkBitArray* );

  void ShiftDualCornerFromMaskedLeaf2D( vtkHyperTreeGridCursor*, vtkBitArray* );

  void ShiftDualCornerFromMaskedLeaf3D( vtkHyperTreeGridCursor*, vtkBitArray* );

  vtkIdType RecursivelyFindPoint( double x[3],
                                  vtkHyperTreeGridCursor*,
                                  double*,
                                  double* );

#if !defined(__VTK_WRAP__) && !defined(__WRAP_GCCXML__)
  void EvaluateDualCorner( vtkHyperTreeSimpleCursor* );
#endif


  vtkLine* Line;
  vtkPixel* Pixel;
  vtkVoxel* Voxel;


  vtkCellLinks* Links;
  void BuildLinks();

private:
  vtkHyperTreeGrid(const vtkHyperTreeGrid&) = delete;
  void operator=(const vtkHyperTreeGrid&) = delete;

  void GetCellImplementation( vtkIdType, vtkCell* );
};

#endif