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