vtkIncrementalOctreeNode.h

Go to the documentation of this file.

/*=========================================================================
 
  Program:   Visualization Toolkit
  Module:    vtkIncrementalOctreeNode.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 vtkIncrementalOctreeNode_h
#define vtkIncrementalOctreeNode_h
 
#include "vtkCommonDataModelModule.h" // For export macro
#include "vtkDeprecation.h"           // For VTK_DEPRECATED_IN_9_1_0
#include "vtkObject.h"
 
class vtkPoints;
class vtkIdList;
 
class VTKCOMMONDATAMODEL_EXPORT vtkIncrementalOctreeNode : public vtkObject
{
public:
  vtkTypeMacro(vtkIncrementalOctreeNode, vtkObject);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
  static vtkIncrementalOctreeNode* New();
 
 
  vtkGetMacro(NumberOfPoints, int);
 
 
  vtkGetObjectMacro(PointIdSet, vtkIdList);
 
  void DeleteChildNodes();
 
  void SetBounds(double x1, double x2, double y1, double y2, double z1, double z2);
 
  void GetBounds(double bounds[6]) const;
 
 
  vtkGetVector3Macro(MinBounds, double);
 
 
  vtkGetVector3Macro(MaxBounds, double);
 
  double* GetMinDataBounds()
  {
    return this->NumberOfPoints ? this->MinDataBounds : this->MinBounds;
  }
 
  double* GetMaxDataBounds()
  {
    return this->NumberOfPoints ? this->MaxDataBounds : this->MaxBounds;
  }
 
  int IsLeaf() { return (this->Children == nullptr) ? 1 : 0; }
 
  int GetChildIndex(const double point[3]);
 
  vtkIncrementalOctreeNode* GetChild(int i) { return this->Children[i]; }
 
  vtkTypeBool ContainsPoint(const double pnt[3]);
 
  vtkTypeBool ContainsPointByData(const double pnt[3]);
 
 
  VTK_DEPRECATED_IN_9_1_0("Use the version with numberOfNodes parameter instead.")
  int InsertPoint(
    vtkPoints* points, const double newPnt[3], int maxPts, vtkIdType* pntId, int ptMode);
  int InsertPoint(vtkPoints* points, const double newPnt[3], int maxPts, vtkIdType* pntId,
    int ptMode, int& numberOfNodes);
 
  double GetDistance2ToInnerBoundary(const double point[3], vtkIncrementalOctreeNode* rootNode);
 
  double GetDistance2ToBoundary(
    const double point[3], vtkIncrementalOctreeNode* rootNode, int checkData);
 
  double GetDistance2ToBoundary(
    const double point[3], double closest[3], vtkIncrementalOctreeNode* rootNode, int checkData);
 
  void ExportAllPointIdsByInsertion(vtkIdList* idList);
 
  void ExportAllPointIdsByDirectSet(vtkIdType* pntIdx, vtkIdList* idList);
 
  int GetNumberOfLevels() const;
  int GetID() const { return this->ID; }
  vtkIdList* GetPointIds() const { return this->PointIdSet; }
 
protected:
  vtkIncrementalOctreeNode();
  ~vtkIncrementalOctreeNode() override;
 
private:
  int NumberOfPoints;
 
  double MinBounds[3];
 
  double MaxBounds[3];
 
  double MinDataBounds[3];
 
  double MaxDataBounds[3];
 
  vtkIdList* PointIdSet;
 
  int ID;
 
  vtkIncrementalOctreeNode* Parent;
 
  vtkIncrementalOctreeNode** Children;
 
  virtual void SetParent(vtkIncrementalOctreeNode*);
 
  virtual void SetPointIdSet(vtkIdList*);
 
  int CreateChildNodes(vtkPoints* points, vtkIdList* pntIds, const double newPnt[3],
    vtkIdType* pntIdx, int maxPts, int ptMode, int& numberOfNodes);
 
  void CreatePointIdSet(int initSize, int growSize);
 
  void DeletePointIdSet();
 
  void UpdateCounterAndDataBounds(const double point[3]);
 
  int UpdateCounterAndDataBounds(const double point[3], int nHits, int updateData);
 
  int UpdateCounterAndDataBoundsRecursively(
    const double point[3], int nHits, int updateData, vtkIncrementalOctreeNode* endNode);
 
  int ContainsDuplicatePointsOnly(const double pnt[3]);
 
  void SeperateExactlyDuplicatePointsFromNewInsertion(vtkPoints* points, vtkIdList* pntIds,
    const double newPnt[3], vtkIdType* pntIdx, int maxPts, int ptMode);
 
  double GetDistance2ToBoundary(const double point[3], double closest[3], int innerOnly,
    vtkIncrementalOctreeNode* rootNode, int checkData = 0);
 
  vtkIncrementalOctreeNode(const vtkIncrementalOctreeNode&) = delete;
  void operator=(const vtkIncrementalOctreeNode&) = delete;
};
 
// In-lined for performance
inline int vtkIncrementalOctreeNode::GetChildIndex(const double point[3])
{
  // Children[0]->MaxBounds[] is exactly the center point of this node.
  return int(point[0] > this->Children[0]->MaxBounds[0]) +
    ((int(point[1] > this->Children[0]->MaxBounds[1])) << 1) +
    ((int(point[2] > this->Children[0]->MaxBounds[2])) << 2);
}
 
// In-lined for performance
inline vtkTypeBool vtkIncrementalOctreeNode::ContainsPoint(const double pnt[3])
{
  return (
    (this->MinBounds[0] < pnt[0] && pnt[0] <= this->MaxBounds[0] && this->MinBounds[1] < pnt[1] &&
      pnt[1] <= this->MaxBounds[1] && this->MinBounds[2] < pnt[2] && pnt[2] <= this->MaxBounds[2])
      ? 1
      : 0);
}
 
// In-lined for performance
inline vtkTypeBool vtkIncrementalOctreeNode::ContainsPointByData(const double pnt[3])
{
  return ((this->MinDataBounds[0] <= pnt[0] && pnt[0] <= this->MaxDataBounds[0] &&
            this->MinDataBounds[1] <= pnt[1] && pnt[1] <= this->MaxDataBounds[1] &&
            this->MinDataBounds[2] <= pnt[2] && pnt[2] <= this->MaxDataBounds[2])
      ? 1
      : 0);
}
 
// In-lined for performance
inline int vtkIncrementalOctreeNode::ContainsDuplicatePointsOnly(const double pnt[3])
{
  return ((this->MinDataBounds[0] == pnt[0] && pnt[0] == this->MaxDataBounds[0] &&
            this->MinDataBounds[1] == pnt[1] && pnt[1] == this->MaxDataBounds[1] &&
            this->MinDataBounds[2] == pnt[2] && pnt[2] == this->MaxDataBounds[2])
      ? 1
      : 0);
}
 
// In-lined for performance
inline void vtkIncrementalOctreeNode::UpdateCounterAndDataBounds(const double point[3])
{
  this->NumberOfPoints++;
 
  this->MinDataBounds[0] = (point[0] < this->MinDataBounds[0]) ? point[0] : this->MinDataBounds[0];
  this->MinDataBounds[1] = (point[1] < this->MinDataBounds[1]) ? point[1] : this->MinDataBounds[1];
  this->MinDataBounds[2] = (point[2] < this->MinDataBounds[2]) ? point[2] : this->MinDataBounds[2];
  this->MaxDataBounds[0] = (point[0] > this->MaxDataBounds[0]) ? point[0] : this->MaxDataBounds[0];
  this->MaxDataBounds[1] = (point[1] > this->MaxDataBounds[1]) ? point[1] : this->MaxDataBounds[1];
  this->MaxDataBounds[2] = (point[2] > this->MaxDataBounds[2]) ? point[2] : this->MaxDataBounds[2];
}
 
// In-lined for performance
inline int vtkIncrementalOctreeNode::UpdateCounterAndDataBoundsRecursively(
  const double point[3], int nHits, int updateData, vtkIncrementalOctreeNode* endNode)
{
  int updated = this->UpdateCounterAndDataBounds(point, nHits, updateData);
 
  return ((this->Parent == endNode)
      ? updated
      : this->Parent->UpdateCounterAndDataBoundsRecursively(point, nHits, updated, endNode));
}
#endif