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);
 
  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() {return this->Min;}
  double *GetMaxBounds() {return this->Max;}
 
  void SetMinBounds(const double *mb);
 
  void SetMaxBounds(const double *mb);
 
 
  double *GetMinDataBounds() {return this->MinVal;}
  double *GetMaxDataBounds() {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=NULL);
 
 
  int ContainsBox(double x1,double x2,double y1,double y2,double z1,double z2,
                  int useDataBounds);
 
  int 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();
 
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&); // Not implemented
  void operator=(const vtkKdNode&); // Not implemented
};
 
#endif