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 ) override;

  static vtkIncrementalOctreePointLocator * New();


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


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


  vtkGetObjectMacro( LocatorPoints, vtkPoints );

  void Initialize() override { this->FreeSearchStructure(); }

  void FreeSearchStructure() override;

  void GetBounds( double * bounds ) override;

  double * GetBounds() override
    { this->GetBounds( this->Bounds );  return this->Bounds; }

  int GetNumberOfPoints();

  vtkIdType FindClosestInsertedPoint( const double x[3] ) override;

  void GenerateRepresentation( int nodeLevel, vtkPolyData * polysData ) override;

  // -------------------------------------------------------------------------
  // ---------------------------- Point  Location ----------------------------
  // -------------------------------------------------------------------------

  void BuildLocator() override;

  vtkIdType FindClosestPoint( const double x[3] ) override;

  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 );

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

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

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

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

  void FindClosestNPoints
    ( int N, const double x[3], vtkIdList * result ) override;

  // -------------------------------------------------------------------------
  // ---------------------------- Point Insertion ----------------------------
  // -------------------------------------------------------------------------

  int InitPointInsertion
    ( vtkPoints * points, const double bounds[6] ) override;

  int InitPointInsertion( vtkPoints * points, const double bounds[6],
                          vtkIdType estSize ) override;

  vtkIdType IsInsertedPoint( const double x[3] ) override;

  vtkIdType IsInsertedPoint( double x, double y, double z ) override;

  int InsertUniquePoint( const double point[3], vtkIdType & pntId ) override;

  void InsertPoint( vtkIdType ptId, const double x[3] ) override;

  vtkIdType InsertNextPoint( const double x[3] ) override;

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

protected:

  vtkIncrementalOctreePointLocator();
  ~vtkIncrementalOctreePointLocator() override;

private:

  vtkTypeBool         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 & ) = delete;
  void operator = ( const vtkIncrementalOctreePointLocator & ) = delete;

};
#endif