dox/Filtering/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 "vtkObject.h"

class vtkCell;
class vtkPlanesIntersection;

class VTK_FILTERING_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(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(double *mb);

  void SetMaxBounds(double *mb);


  double *GetMinDataBounds() {return this->MinVal;}
  double *GetMaxDataBounds() {return this->MaxVal;}

  void SetMinDataBounds(double *mb);

  void SetMaxDataBounds(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