dox/Filtering/vtkOctreePointLocatorNode.h

Go to the documentation of this file.

/*=========================================================================

  Program:   Visualization Toolkit
  Module:    vtkOctreePointLocatorNode.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 __vtkOctreePointLocatorNode_h
#define __vtkOctreePointLocatorNode_h

#include "vtkObject.h"

class vtkCell;
class vtkPlanesIntersection;

class VTK_FILTERING_EXPORT vtkOctreePointLocatorNode : public vtkObject
{
public:
  vtkTypeMacro(vtkOctreePointLocatorNode, vtkObject);
  void PrintSelf(ostream& os, vtkIndent indent);

  static vtkOctreePointLocatorNode *New();


  void SetNumberOfPoints(int numberOfPoints)
  {
    this->NumberOfPoints = numberOfPoints;
  }
  vtkGetMacro(NumberOfPoints, int);


  void SetBounds(double xMin, double xMax, double yMin,
                 double yMax, double zMin, double zMax);
  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 xMin, double xMax, double yMin,
                     double yMax, double zMin, double zMax);
  void GetDataBounds(double *b) const;


  vtkGetMacro(MinBounds, double*);
  vtkGetMacro(MaxBounds, double*);
//ETX


  void SetMinBounds(double minBounds[3])
  {
    this->MinBounds[0] = minBounds[0];
    this->MinBounds[1] = minBounds[1];
    this->MinBounds[2] = minBounds[2];
  }


  void SetMaxBounds(double maxBounds[3])
  {
    this->MaxBounds[0] = maxBounds[0];
    this->MaxBounds[1] = maxBounds[1];
    this->MaxBounds[2] = maxBounds[2];
  }


  vtkGetMacro(MinDataBounds, double*);
  vtkGetMacro(MaxDataBounds, double*);
//ETX


  void SetMinDataBounds(double minDataBounds[3])
  {
    this->MinDataBounds[0] = minDataBounds[0];
    this->MinDataBounds[1] = minDataBounds[1];
    this->MinDataBounds[2] = minDataBounds[2];
  }


  void SetMaxDataBounds(double maxDataBounds[3])
  {
    this->MaxDataBounds[0] = maxDataBounds[0];
    this->MaxDataBounds[1] = maxDataBounds[1];
    this->MaxDataBounds[2] = maxDataBounds[2];
  }


  vtkGetMacro(ID, int);


  vtkGetMacro(MinID, int);

  void CreateChildNodes();

  void DeleteChildNodes();

  vtkOctreePointLocatorNode* GetChild(int i);

  int IntersectsRegion(vtkPlanesIntersection *pi, int useDataBounds);

  int ContainsPoint(double x, double y, double z, int useDataBounds);


  double GetDistance2ToBoundary(double x, double y, double z, 
                                vtkOctreePointLocatorNode* top, int useDataBounds);


  double GetDistance2ToBoundary(double x, double y, double z, 
                                double *boundaryPt, vtkOctreePointLocatorNode* top,
                                int useDataBounds);


  double GetDistance2ToInnerBoundary(double x, double y, double z,
                                     vtkOctreePointLocatorNode* top);

  int GetSubOctantIndex(double* point, int CheckContainment);


  void ComputeOctreeNodeInformation(vtkOctreePointLocatorNode* Parent, 
                                    int& NextLeafId, int & NextMinId,
                                    float* coordinates);

protected:
  vtkOctreePointLocatorNode();
  ~vtkOctreePointLocatorNode();

private:

  double _GetDistance2ToBoundary(
    double x, double y, double z, double *boundaryPt,
    int innerBoundaryOnly, vtkOctreePointLocatorNode* top,
    int useDataBounds);

  double MinBounds[3];

  double MaxBounds[3];

  double MinDataBounds[3];   

  double MaxDataBounds[3];

  int NumberOfPoints;
  
  vtkOctreePointLocatorNode** Children;

  int ID;

  int MinID;

  vtkOctreePointLocatorNode(const vtkOctreePointLocatorNode&); // Not implemented
  void operator=(const vtkOctreePointLocatorNode&); // Not implemented
};

#endif

---