vtkPointLocator.h

Go to the documentation of this file.

/*=========================================================================
 
  Program:   Visualization Toolkit
  Module:    vtkPointLocator.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 vtkPointLocator_h
#define vtkPointLocator_h
 
#include "vtkCommonDataModelModule.h" // For export macro
#include "vtkIncrementalPointLocator.h"
 
class vtkCellArray;
class vtkIdList;
class vtkNeighborPoints;
class vtkPoints;
 
class VTKCOMMONDATAMODEL_EXPORT vtkPointLocator : public vtkIncrementalPointLocator
{
public:
  static vtkPointLocator *New();
 
  vtkTypeMacro(vtkPointLocator,vtkIncrementalPointLocator);
  void PrintSelf(ostream& os, vtkIndent indent);
 
 
  vtkSetVector3Macro(Divisions,int);
  vtkGetVectorMacro(Divisions,int,3);
 
 
  vtkSetClampMacro(NumberOfPointsPerBucket,int,1,VTK_INT_MAX);
  vtkGetMacro(NumberOfPointsPerBucket,int);
 
  virtual vtkIdType FindClosestPoint(const double x[3]);
 
 
  virtual vtkIdType FindClosestPointWithinRadius(
    double radius, const double x[3], double& dist2);
  virtual vtkIdType FindClosestPointWithinRadius(double radius, const double x[3],
                                         double inputDataLength, double& dist2);
 
  virtual int InitPointInsertion(vtkPoints *newPts, const double bounds[6]);
 
 
  virtual int InitPointInsertion(vtkPoints *newPts, const double bounds[6],
                                 vtkIdType estSize);
 
  virtual void InsertPoint(vtkIdType ptId, const double x[3]);
 
  virtual vtkIdType InsertNextPoint(const double x[3]);
 
 
  vtkIdType IsInsertedPoint(double x, double  y, double z)
    {
    double xyz[3];
    xyz[0] = x; xyz[1] = y; xyz[2] = z;
    return this->IsInsertedPoint (xyz);
    };
  virtual vtkIdType IsInsertedPoint(const double x[3]);
 
  virtual int InsertUniquePoint(const double x[3], vtkIdType &ptId);
 
  virtual vtkIdType FindClosestInsertedPoint(const double x[3]);
 
  virtual void FindClosestNPoints(int N, const double x[3], vtkIdList *result);
 
 
  virtual void FindDistributedPoints(int N, const double x[3],
                                     vtkIdList *result, int M);
  virtual void FindDistributedPoints(int N, double x, double y,
                                     double z, vtkIdList *result, int M);
 
 
  virtual void FindPointsWithinRadius(double R, const double x[3],
                                      vtkIdList *result);
 
  virtual vtkIdList *GetPointsInBucket(const double x[3], int ijk[3]);
 
 
  vtkGetObjectMacro(Points, vtkPoints);
 
 
  void Initialize();
  void FreeSearchStructure();
  void BuildLocator();
  void GenerateRepresentation(int level, vtkPolyData *pd);
 
protected:
  vtkPointLocator();
  virtual ~vtkPointLocator();
 
  // place points in appropriate buckets
  void GetBucketNeighbors(vtkNeighborPoints* buckets,
                          const int ijk[3], const int ndivs[3], int level);
  void GetOverlappingBuckets(vtkNeighborPoints* buckets,
                             const double x[3], const int ijk[3], double dist,
                             int level);
  void GetOverlappingBuckets(vtkNeighborPoints* buckets,
                             const double x[3], double dist,
                             int prevMinLevel[3],
                             int prevMaxLevel[3]);
  void GenerateFace(int face, int i, int j, int k,
                    vtkPoints *pts, vtkCellArray *polys);
  double Distance2ToBucket(const double x[3], const int nei[3]);
  double Distance2ToBounds(const double x[3], const double bounds[6]);
 
 
  vtkIdType GetBucketIndex(const double x[3]);
  void GetBucketIndices(const double x[3], int ijk[3]);
 
  vtkPoints *Points; // Used for merging points
  int Divisions[3]; // Number of sub-divisions in x-y-z directions
  int NumberOfPointsPerBucket; //Used with previous boolean to control subdivide
  vtkIdList **HashTable; // lists of point ids in buckets
  vtkIdType NumberOfBuckets; // total size of hash table
  double H[3]; // width of each bucket in x-y-z directions
 
  double InsertionTol2;
  vtkIdType InsertionPointId;
 
  double InsertionLevel;
private:
  vtkPointLocator(const vtkPointLocator&);  // Not implemented.
  void operator=(const vtkPointLocator&);  // Not implemented.
};
 
#endif