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 "vtkCommonDataModelModule.h" // For export macro
#include "vtkIncrementalPointLocator.h"
 
class vtkPoints;
class vtkIdList;
class vtkPolyData;
class vtkCellArray;
class vtkIncrementalOctreeNode;
 
class VTKCOMMONDATAMODEL_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