vtkIncrementalOctreeNode.h

Go to the documentation of this file.

/*=========================================================================

  Program:   Visualization Toolkit
  Module:    vtkIncrementalOctreeNode.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 vtkIncrementalOctreeNode_h
#define vtkIncrementalOctreeNode_h

#include "vtkCommonDataModelModule.h" // For export macro
#include "vtkObject.h"

class vtkPoints;
class vtkIdList;

class VTKCOMMONDATAMODEL_EXPORT vtkIncrementalOctreeNode : public vtkObject
{
public:
  vtkTypeMacro( vtkIncrementalOctreeNode, vtkObject );
  void PrintSelf( ostream & os, vtkIndent indent ) VTK_OVERRIDE;

  static vtkIncrementalOctreeNode * New();


  vtkGetMacro( NumberOfPoints, int );


  vtkGetObjectMacro( PointIdSet, vtkIdList );

  void DeleteChildNodes();

  void SetBounds( double x1, double x2, double y1,
                  double y2, double z1, double z2 );

  void GetBounds( double bounds[6] ) const;


  vtkGetVector3Macro( MinBounds, double );


  vtkGetVector3Macro( MaxBounds, double );

  double * GetMinDataBounds()
  { return this->NumberOfPoints ? this->MinDataBounds : this->MinBounds; }

  double * GetMaxDataBounds()
  { return this->NumberOfPoints ? this->MaxDataBounds : this->MaxBounds; }

  int IsLeaf() { return ( this->Children == NULL ) ? 1 : 0; }

  int GetChildIndex( const double point[3] );

  vtkIncrementalOctreeNode * GetChild( int i ) { return this->Children[i]; }

  int  ContainsPoint( const double pnt[3] );

  int  ContainsPointByData( const double pnt[3] );

  int InsertPoint( vtkPoints * points, const double newPnt[3],
                   int maxPts, vtkIdType * pntId, int ptMode );

  double GetDistance2ToInnerBoundary( const double point[3],
                                      vtkIncrementalOctreeNode * rootNode );

  double GetDistance2ToBoundary( const double point[3],
    vtkIncrementalOctreeNode * rootNode, int checkData );

  double GetDistance2ToBoundary( const double point[3], double closest[3],
    vtkIncrementalOctreeNode * rootNode, int checkData );

  void ExportAllPointIdsByInsertion( vtkIdList * idList );

  void ExportAllPointIdsByDirectSet( vtkIdType * pntIdx, vtkIdList * idList );

protected:

  vtkIncrementalOctreeNode();
  ~vtkIncrementalOctreeNode() VTK_OVERRIDE;

private:

  int  NumberOfPoints;

  double MinBounds[3];

  double MaxBounds[3];

  double MinDataBounds[3];

  double MaxDataBounds[3];

  vtkIdList * PointIdSet;

  vtkIncrementalOctreeNode *  Parent;

  vtkIncrementalOctreeNode ** Children;

  virtual void SetParent( vtkIncrementalOctreeNode * );

  virtual void SetPointIdSet( vtkIdList * );

  int CreateChildNodes( vtkPoints * points, vtkIdList * pntIds,
    const double newPnt[3], vtkIdType * pntIdx, int maxPts, int ptMode );

  void CreatePointIdSet( int initSize, int growSize );

  void DeletePointIdSet();

  void UpdateCounterAndDataBounds( const double point[3] );

  int UpdateCounterAndDataBounds
    ( const double point[3], int nHits, int updateData );

  int UpdateCounterAndDataBoundsRecursively( const double point[3], int nHits,
    int updateData, vtkIncrementalOctreeNode * endNode );

  int  ContainsDuplicatePointsOnly( const double pnt[3] );

  void SeperateExactlyDuplicatePointsFromNewInsertion( vtkPoints * points,
    vtkIdList * pntIds, const double newPnt[3],
    vtkIdType * pntIdx, int maxPts, int ptMode );

  double GetDistance2ToBoundary( const double point[3], double closest[3],
    int innerOnly, vtkIncrementalOctreeNode* rootNode, int checkData = 0 );

  vtkIncrementalOctreeNode( const vtkIncrementalOctreeNode & ) VTK_DELETE_FUNCTION;
  void operator = ( const vtkIncrementalOctreeNode & ) VTK_DELETE_FUNCTION;

};

// In-lined for performance
inline int vtkIncrementalOctreeNode::GetChildIndex( const double point[3] )
{
  // Children[0]->MaxBounds[] is exactly the center point of this node.
  return int( point[0] > this->Children[0]->MaxBounds[0] ) +
    (  ( int( point[1] > this->Children[0]->MaxBounds[1] ) ) << 1  ) +
    (  ( int( point[2] > this->Children[0]->MaxBounds[2] ) ) << 2  );
}

// In-lined for performance
inline int vtkIncrementalOctreeNode::ContainsPoint( const double pnt[3] )
{
  return (
            ( this->MinBounds[0] < pnt[0] && pnt[0] <= this->MaxBounds[0] &&
              this->MinBounds[1] < pnt[1] && pnt[1] <= this->MaxBounds[1] &&
              this->MinBounds[2] < pnt[2] && pnt[2] <= this->MaxBounds[2]
            ) ? 1 : 0
         );
}

// In-lined for performance
inline int vtkIncrementalOctreeNode::ContainsPointByData( const double pnt[3] )
{
  return
  (
     ( this->MinDataBounds[0] <= pnt[0] && pnt[0] <= this->MaxDataBounds[0] &&
       this->MinDataBounds[1] <= pnt[1] && pnt[1] <= this->MaxDataBounds[1] &&
       this->MinDataBounds[2] <= pnt[2] && pnt[2] <= this->MaxDataBounds[2]
     ) ? 1 : 0
  );
}

// In-lined for performance
inline int vtkIncrementalOctreeNode::ContainsDuplicatePointsOnly
  ( const double pnt[3] )
{
  return
  (
     ( this->MinDataBounds[0] == pnt[0] && pnt[0] == this->MaxDataBounds[0] &&
       this->MinDataBounds[1] == pnt[1] && pnt[1] == this->MaxDataBounds[1] &&
       this->MinDataBounds[2] == pnt[2] && pnt[2] == this->MaxDataBounds[2]
     ) ? 1 : 0
  );
}

// In-lined for performance
inline void vtkIncrementalOctreeNode::UpdateCounterAndDataBounds
  ( const double point[3] )
{
  this->NumberOfPoints ++;

  this->MinDataBounds[0] = ( point[0] < this->MinDataBounds[0] )
                           ? point[0] : this->MinDataBounds[0];
  this->MinDataBounds[1] = ( point[1] < this->MinDataBounds[1] )
                           ? point[1] : this->MinDataBounds[1];
  this->MinDataBounds[2] = ( point[2] < this->MinDataBounds[2] )
                           ? point[2] : this->MinDataBounds[2];
  this->MaxDataBounds[0] = ( point[0] > this->MaxDataBounds[0] )
                           ? point[0] : this->MaxDataBounds[0];
  this->MaxDataBounds[1] = ( point[1] > this->MaxDataBounds[1] )
                           ? point[1] : this->MaxDataBounds[1];
  this->MaxDataBounds[2] = ( point[2] > this->MaxDataBounds[2] )
                           ? point[2] : this->MaxDataBounds[2];
}

// In-lined for performance
inline int vtkIncrementalOctreeNode::UpdateCounterAndDataBoundsRecursively
  ( const double point[3], int nHits, int updateData,
    vtkIncrementalOctreeNode * endNode )
{
  int  updated = this->UpdateCounterAndDataBounds
                       ( point, nHits, updateData );

  return (    ( this->Parent == endNode )
           ?  updated
           :  this->Parent->UpdateCounterAndDataBoundsRecursively
                            ( point, nHits, updated, endNode )
         );
}
#endif