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 vtkIntArray;
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();
 
 
  vtkSetMacro(MaxPointsPerLeaf, int);
  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();
  vtkGetMacro(NumberOfNodes, int);
 
  vtkIdType FindClosestInsertedPoint(const double x[3]) override;
 
 
  void GenerateRepresentation(int level, vtkPolyData* polysData) override;
  void GenerateRepresentation(int level, vtkPolyData* polysData,
    bool (*UserGetBounds)(void* data, vtkIncrementalOctreeNode* node, double* bounds), void* data);
 
  // -------------------------------------------------------------------------
  // ---------------------------- Point  Location ----------------------------
  // -------------------------------------------------------------------------
 
  void BuildLocator() override;
 
  void ForceBuildLocator() 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);
 
  vtkIncrementalOctreeNode* GetRoot() const { return OctreeRootNode; }
 
  int GetNumberOfLevels();
 
protected:
  vtkIncrementalOctreePointLocator();
  ~vtkIncrementalOctreePointLocator() override;
 
private:
  vtkTypeBool BuildCubicOctree;
  int MaxPointsPerLeaf;
  double InsertTolerance2;
  double OctreeMaxDimSize;
  double FudgeFactor;
  vtkPoints* LocatorPoints;
  vtkIncrementalOctreeNode* OctreeRootNode;
  int NumberOfNodes;
 
  void BuildLocatorInternal() override;
 
  static void DeleteAllDescendants(vtkIncrementalOctreeNode* node);
 
  static void AddPolys(vtkIncrementalOctreeNode* node, vtkPoints* points, vtkCellArray* polygs,
    vtkIntArray* nodeIndexes, vtkIdType& cellIndex,
    bool (*GetBounds)(void* data, vtkIncrementalOctreeNode* node, double* bounds), void* data);
 
  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