dox/Filtering/vtkIncrementalOctreePointLocator.h

Go to the documentation of this file.

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

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

#include "vtkIncrementalPointLocator.h"

class vtkPoints;
class vtkIdList;
class vtkPolyData;
class vtkCellArray;
class vtkIncrementalOctreeNode;

class VTK_FILTERING_EXPORT vtkIncrementalOctreePointLocator : public vtkIncrementalPointLocator
{
public:
 
  vtkTypeMacro( vtkIncrementalOctreePointLocator, vtkIncrementalPointLocator );
  void PrintSelf( ostream & os, vtkIndent indent );

  static vtkIncrementalOctreePointLocator * New();
  

  vtkSetClampMacro( MaxPointsPerLeaf, int, 16, 256 );
  vtkGetMacro( MaxPointsPerLeaf, int );
  

  vtkSetMacro( BuildCubicOctree, int );
  vtkGetMacro( BuildCubicOctree, int );
  vtkBooleanMacro( BuildCubicOctree, int );
  

  vtkGetObjectMacro( LocatorPoints, vtkPoints );
  
  virtual void Initialize() { this->FreeSearchStructure(); }
  
  virtual void FreeSearchStructure();
  
  virtual void GetBounds( double * bounds );
  

  virtual double * GetBounds()
    { this->GetBounds( this->Bounds );  return this->Bounds; }
  
  int GetNumberOfPoints();
  
  virtual vtkIdType FindClosestInsertedPoint( const double x[3] );
  
  virtual void GenerateRepresentation( int nodeLevel, vtkPolyData * polysData );
  
  // -------------------------------------------------------------------------
  // ---------------------------- Point  Location ----------------------------
  // -------------------------------------------------------------------------
  
  virtual void BuildLocator();
  
  virtual vtkIdType FindClosestPoint( const double x[3] );
  
  virtual vtkIdType FindClosestPoint( double x, double y, double z );
  
  virtual vtkIdType FindClosestPoint( const double x[3], double * miniDist2 );
  
  virtual vtkIdType FindClosestPoint( double x, double y, double z, double * miniDist2 );
  

  virtual vtkIdType FindClosestPointWithinRadius
    ( double radius, const double x[3], double & dist2 );
    

  vtkIdType FindClosestPointWithinSquaredRadius
    ( double radius2, const double x[3], double & dist2 );
    

  virtual void FindPointsWithinRadius
    ( double R, const double x[3], vtkIdList * result );
  

  void FindPointsWithinSquaredRadius
    ( double R2, const double x[3], vtkIdList * result );
                                      

  virtual void FindClosestNPoints
    ( int N, const double x[3], vtkIdList * result );
                       
  // -------------------------------------------------------------------------
  // ---------------------------- Point Insertion ----------------------------
  // -------------------------------------------------------------------------
  
  virtual int InitPointInsertion( vtkPoints * points, const double bounds[6] );


  virtual int InitPointInsertion( vtkPoints * points, const double bounds[6], 
                                  vtkIdType estSize );                            
  
  virtual vtkIdType IsInsertedPoint( const double x[3] );
  
  virtual vtkIdType IsInsertedPoint( double x, double  y, double z );
  
  virtual int InsertUniquePoint( const double point[3], vtkIdType & pntId );
  
  virtual void InsertPoint( vtkIdType ptId, const double x[3] );
  
  virtual vtkIdType InsertNextPoint( const double x[3] );
  

  void InsertPointWithoutChecking
    ( const double point[3], vtkIdType  & pntId, int insert );

//BTX
protected:

  vtkIncrementalOctreePointLocator();
  virtual ~vtkIncrementalOctreePointLocator();
  
private:

  int         BuildCubicOctree;
  int         MaxPointsPerLeaf;
  double      InsertTolerance2;
  double      OctreeMaxDimSize;
  double      FudgeFactor;
  vtkPoints * LocatorPoints;
  vtkIncrementalOctreeNode * OctreeRootNode;
  
  static void DeleteAllDescendants( vtkIncrementalOctreeNode * node );
  

  static void AddPolys( vtkIncrementalOctreeNode * node, 
                        vtkPoints * points, vtkCellArray * polygs );
  

  vtkIncrementalOctreeNode * GetLeafContainer( vtkIncrementalOctreeNode * node,
    const double pnt[3] ); 
  

  vtkIdType FindClosestPointInLeafNode( vtkIncrementalOctreeNode * leafNode, 
                                        const double point[3], double * dist2 );


  vtkIdType FindClosestPointInSphere
    ( const double point[3], double radius2, vtkIncrementalOctreeNode * maskNode,
      double * minDist2, const double * refDist2 );
      
      
  // -------------------------------------------------------------------------
  // ---------------------------- Point  Location ----------------------------
  // -------------------------------------------------------------------------
  

  vtkIdType FindClosestPointInSphereWithoutTolerance( const double point[3],
    double radius2, vtkIncrementalOctreeNode * maskNode, double * minDist2 );
    

  void FindPointsWithinSquaredRadius( vtkIncrementalOctreeNode * node, 
    double radius2, const double point[3], vtkIdList * idList );
  
  // -------------------------------------------------------------------------
  // ---------------------------- Point Insertion ----------------------------
  // -------------------------------------------------------------------------
  

  vtkIdType FindClosestPointInSphereWithTolerance( const double point[3],
    double radius2, vtkIncrementalOctreeNode * maskNode, double * minDist2 );
    

  vtkIdType IsInsertedPoint( const double x[3], 
                             vtkIncrementalOctreeNode ** leafContainer );
  

  vtkIdType IsInsertedPointForZeroTolerance
    ( const double x[3], vtkIncrementalOctreeNode ** leafContainer );
    

  vtkIdType IsInsertedPointForNonZeroTolerance
    ( const double x[3], vtkIncrementalOctreeNode ** leafContainer );
                              

  vtkIdType FindDuplicatePointInLeafNode( vtkIncrementalOctreeNode * leafNode, 
                                          const double point[3] );


  vtkIdType FindDuplicateFloatTypePointInVisitedLeafNode
    ( vtkIncrementalOctreeNode * leafNode, const double point[3] );


  vtkIdType FindDuplicateDoubleTypePointInVisitedLeafNode
    ( vtkIncrementalOctreeNode * leafNode, const double point[3] );
                         
  vtkIncrementalOctreePointLocator
    ( const vtkIncrementalOctreePointLocator & ); // Not implemented
  void operator = ( const vtkIncrementalOctreePointLocator & );// Not implemented
//ETX
};
#endif