vtkKdNode.h

Go to the documentation of this file.

/*=========================================================================
 
  Program:   Visualization Toolkit
  Module:    vtkKdNode.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.
 
=========================================================================*/
/*----------------------------------------------------------------------------
 Copyright (c) Sandia Corporation
 See Copyright.txt or http://www.paraview.org/HTML/Copyright.html for details.
----------------------------------------------------------------------------*/
 
#ifndef vtkKdNode_h
#define vtkKdNode_h
 
#include "vtkCommonDataModelModule.h" // For export macro
#include "vtkObject.h"
 
class vtkCell;
class vtkPlanesIntersection;
 
class VTKCOMMONDATAMODEL_EXPORT vtkKdNode : public vtkObject
{
public:
  vtkTypeMacro(vtkKdNode, vtkObject);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
  static vtkKdNode* New();
 
 
  vtkSetMacro(Dim, int);
  vtkGetMacro(Dim, int);
 
  virtual double GetDivisionPosition();
 
 
  vtkSetMacro(NumberOfPoints, int);
  vtkGetMacro(NumberOfPoints, int);
 
 
  void SetBounds(double x1, double x2, double y1, double y2, double z1, double z2);
  void SetBounds(const double b[6]) { this->SetBounds(b[0], b[1], b[2], b[3], b[4], b[5]); }
  void GetBounds(double* b) const;
 
 
  void SetDataBounds(double x1, double x2, double y1, double y2, double z1, double z2);
  void GetDataBounds(double* b) const;
 
  void SetDataBounds(float* v);
 
  double* GetMinBounds() VTK_SIZEHINT(3) { return this->Min; }
  double* GetMaxBounds() VTK_SIZEHINT(3) { return this->Max; }
 
  void SetMinBounds(const double* mb);
 
  void SetMaxBounds(const double* mb);
 
  double* GetMinDataBounds() VTK_SIZEHINT(3) { return this->MinVal; }
  double* GetMaxDataBounds() VTK_SIZEHINT(3) { return this->MaxVal; }
 
  void SetMinDataBounds(const double* mb);
 
  void SetMaxDataBounds(const double* mb);
 
 
  vtkSetMacro(ID, int);
  vtkGetMacro(ID, int);
 
 
  vtkGetMacro(MinID, int);
  vtkGetMacro(MaxID, int);
  vtkSetMacro(MinID, int);
  vtkSetMacro(MaxID, int);
 
  void AddChildNodes(vtkKdNode* left, vtkKdNode* right);
 
  void DeleteChildNodes();
 
 
  vtkGetObjectMacro(Left, vtkKdNode);
  void SetLeft(vtkKdNode* left);
 
 
  vtkGetObjectMacro(Right, vtkKdNode);
  void SetRight(vtkKdNode* right);
 
 
  vtkGetObjectMacro(Up, vtkKdNode);
  void SetUp(vtkKdNode* up);
 
  int IntersectsBox(
    double x1, double x2, double y1, double y2, double z1, double z2, int useDataBounds);
 
  int IntersectsSphere2(double x, double y, double z, double rSquared, int useDataBounds);
 
  int IntersectsRegion(vtkPlanesIntersection* pi, int useDataBounds);
 
  int IntersectsCell(
    vtkCell* cell, int useDataBounds, int cellRegion = -1, double* cellBounds = nullptr);
 
  int ContainsBox(
    double x1, double x2, double y1, double y2, double z1, double z2, int useDataBounds);
 
  vtkTypeBool ContainsPoint(double x, double y, double z, int useDataBounds);
 
  double GetDistance2ToBoundary(double x, double y, double z, int useDataBounds);
 
  double GetDistance2ToBoundary(
    double x, double y, double z, double* boundaryPt, int useDataBounds);
 
  double GetDistance2ToInnerBoundary(double x, double y, double z);
 
 
  void PrintNode(int depth);
  void PrintVerboseNode(int depth);
 
protected:
  vtkKdNode();
  ~vtkKdNode() override;
 
private:
  double _GetDistance2ToBoundary(
    double x, double y, double z, double* boundaryPt, int innerBoundaryOnly, int useDataBounds);
 
  double Min[3];    // spatial bounds of node
  double Max[3];    // spatial bounds of node
  double MinVal[3]; // spatial bounds of data within node
  double MaxVal[3]; // spatial bounds of data within node
  int NumberOfPoints;
 
  vtkKdNode* Up;
 
  vtkKdNode* Left;
  vtkKdNode* Right;
 
  int Dim;
 
  int ID; // region id
 
  int MinID;
  int MaxID;
 
  vtkKdNode(const vtkKdNode&) = delete;
  void operator=(const vtkKdNode&) = delete;
};
 
#endif