geoalgo::Sphere Class Reference

#include "GeoSphere.h"

Public Member Functions
	Sphere ()
	Default ctor. More...
virtual	~Sphere ()
	Default dtor. More...
	Sphere (const double &x, const double &y, const double &z, const double &r)
	Alternative ctor (0) More...
	Sphere (const Point_t &center, const double r=0)
	Altenartive ctor (1) - 1 Point. More...
	Sphere (const Point_t &pt1, const Point_t &pt2)
	Alternative ctor (2) - 2 Points. More...
	Sphere (const Point_t &A, const Point_t &B, const Point_t &C)
	Alternative ctor (3) - 3 Points. More...
	Sphere (const Point_t &A, const Point_t &B, const Point_t &C, const Point_t &D)
	Sphere (const std::vector< ::geoalgo::Point_t > &pts)
const Point_t &	Center () const
	Center getter. More...
double	Radius () const
	Radius getter. More...
void	Center (const double x, const double y, const double z)
	Center setter. More...
void	Center (const Point_t &pt)
	Center setter. More...
void	Radius (const double &r)
	Radius setter. More...
bool	Contain (const Point_t &p) const
	Judge if a point is contained within a sphere. More...
template<class T >
	Sphere (const T &pt1, const T &pt2)
template<class T >
	Sphere (const T &A, const T &B, const T &C)
template<class T >
	Sphere (const T &A, const T &B, const T &C, const T &D)
template<class T >
	Sphere (const std::vector< T > &pts)
template<class T >
void	Center (const T &pt)
template<class T >
bool	Contain (const T &p) const

Protected Member Functions
void	compat (const Point_t &p, const double r=0) const
	3D point compatibility check More...
void	compat (const double &r) const
	Positive radius compatibility check. More...

Protected Attributes
Point_t	_center
	Center of Sphere. More...
double	_radius
	Radius of Sphere. More...

Detailed Description

Definition at line 25 of file GeoSphere.h.

Constructor & Destructor Documentation

geoalgo::Sphere::Sphere

(

)

Default ctor.

Definition at line 8 of file GeoSphere.cxx.

References _center.

Referenced by Sphere(), and ~Sphere().

                 : _center (3)
                   , _radius (0)
  { for(auto& v : _center) v=0; }

virtual geoalgo::Sphere::~Sphere ( )

inlinevirtual

Default dtor.

Definition at line 30 of file GeoSphere.h.

References B, Center(), compat(), Contain(), pt, Radius(), Sphere(), x, y, and z.

geoalgo::Sphere::Sphere	(	const double &	x,
		const double &	y,
		const double &	z,
		const double &	r
	)

Alternative ctor (0)

Definition at line 12 of file GeoSphere.cxx.

References _center, _radius, x, y, and z.

    : Sphere()
  { _center[0] = x; _center[1] = y; _center[2] = z; _radius = r; }

geoalgo::Sphere::Sphere	(	const Point_t &	center,
		const double	r = 0
	)

Altenartive ctor (1) - 1 Point.

Definition at line 16 of file GeoSphere.cxx.

References _center.

    : _radius (r)
  {_center = center;}

geoalgo::Sphere::Sphere	(	const Point_t &	pt1,
		const Point_t &	pt2
	)

Alternative ctor (2) - 2 Points.

Definition at line 20 of file GeoSphere.cxx.

References _center, _radius, compat(), and geoalgo::Vector::Dist().

  {
    compat(pt1);
    compat(pt2);
    _center = (pt1+pt2)/2.;
    _radius = pt1.Dist(pt2)/2.;
  }

geoalgo::Sphere::Sphere	(	const Point_t &	A,
		const Point_t &	B,
		const Point_t &	C
	)

Alternative ctor (3) - 3 Points.

Definition at line 31 of file GeoSphere.cxx.

References _center, _radius, B, compat(), d, geoalgo::Vector::Dist(), geoalgo::Vector::Dot(), geoalgo::Vector::Length(), and s.

  {
    compat(A);
    compat(B);
    compat(C);
    // any three points are co-planar
    // (if collinear no sphere passing  through all 3)
    // These 3 points make a triangle
    // find the perpendicular bi-sectors to the segments
    // making up the triangle. They will intersect
    // at the sphere's center
    
    // check if collinear. If so return exception
    Vector_t AB(B-A);
    Vector_t AC(C-A);
    Vector_t BC(C-B);
    
    double dABAB = AB.Dot(AB);
    double dACAC = AC.Dot(AC);
    double dABAC = AB.Dot(AC);
    
    double d = dABAB * dACAC - dABAC * dABAC;
    double s,t;
    
    // if d == 0 they lie on one line
    if (d == 0){
      std::cout << "d is 0!" << std::endl;
      double lenAB = AB.Length();
      double lenAC = AC.Length();
      double lenBC = BC.Length();
      // which segment is longest?
      if ( (lenAB > lenAC) && (lenAB > lenBC) ){
        _center = (A+B)/2.;
        _radius = _center.Dist(A);
      }
      else if( lenAC > lenBC ){
        _center = (A+C)/2.;
        _radius = _center.Dist(A);
      }
      else{
        _center = (B+C)/2;
        _radius = _center.Dist(B);
      }
    }// if d == 0
    
    else{
      s = 0.5 * ( dABAB * dACAC - dACAC * dABAC ) / d;
      t = 0.5 * ( dACAC * dABAB - dABAB * dABAC ) / d;
      
      // if s & t both > 0 && 1-s-t also > 0 then P = A + s*(B-A) + t*(C-A) is the center
      if ( (s > 0) && (t > 0) && ((1-s-t) > 0) ){
        _center = A+(B-A)*s+(C-A)*t;
        _radius = _center.Dist(A);
      }
      
      // otherwise only one will be negative. The side it belongs on will be
      // the longest side and will determine the side to take as diameter
      else if (s <= 0){
        // side AB is the one
        _center = (A+C)/2.;
        _radius = _center.Dist(A);
      }
      else if (t <= 0){
        // AC is the side
        _center = (A+B)/2.;
        _radius = _center.Dist(A);
      }
      else{
        _center = (B+C)/2;
        _radius = _center.Dist(B);
      }
    }// else (if d not equal to 0)
    
  }

geoalgo::Sphere::Sphere	(	const Point_t &	A,
		const Point_t &	B,
		const Point_t &	C,
		const Point_t &	D
	)

Definition at line 183 of file GeoSphere.cxx.

References _center, _radius, B, Center(), compat(), Contain(), d, geoalgo::Vector::Dist(), geoalgo::Vector::Dot(), pt, Radius(), s, Sphere(), and tmp.

                                                                                      {

    compat(A);
    compat(B);
    compat(C);
    compat(D);

    // let's make sure there aren't duplicates...if so -> call a
    // different constructor
    std::vector<geoalgo::Point_t> valid_points = {A};
    bool duplicate = false;
    for (auto const& pt : valid_points){
      if (pt.SqDist(B) < 0.0001)
        duplicate = true;
    }
    if (duplicate == false)
      valid_points.push_back(B);
    duplicate = false;
    for (auto const& pt : valid_points){
      if (pt.SqDist(C) < 0.0001)
        duplicate = true;
    }
    if (duplicate == false)
      valid_points.push_back(C);
    duplicate = false;
    for (auto const& pt : valid_points){
      if (pt.SqDist(D) < 0.0001)
        duplicate = true;
    }
    if (duplicate == false)
      valid_points.push_back(D);
    
    // if we have less then 4 points -> call the appropriate constructor
    if (valid_points.size() < 4){
      (*this) = Sphere(valid_points);
      return;
    }

    // get sphere from 3 points (A,B,C)
    Vector_t AB(B-A);
    Vector_t AC(C-A);
    Vector_t AD(D-A);

    double dABAB = AB.Dot(AB);
    double dACAC = AC.Dot(AC);
    double dADAD = AD.Dot(AD);
    double dABAC = AB.Dot(AC);
    double dABAD = AB.Dot(AD);
    double dACAD = AC.Dot(AD);
    
    double d = 4*dABAC*dABAD*dACAD;

    if (d==0){
      // are any points duplicates? if so 
      // find the points that are collinear and call constructor
      // for the
      throw GeoAlgoException("GeoSphere Exception: I think it means 3 points collinear. Find out which and call 3 point constructor - TO DO");
    }
    
    double s = (dABAC*dACAD*dADAD + dABAD*dACAC*dACAD - dABAB*dACAD*dACAD)/d;
    double t = (dABAB*dACAD*dABAD + dABAD*dABAC*dADAD - dABAD*dABAD*dACAC)/d;
    double u = (dABAB*dABAC*dACAD + dABAC*dABAD*dACAC - dABAC*dABAC*dADAD)/d;
    
    // if everything positive! P = A + s(B-A) + t(C-A) + u(D-A)
    if ( (s > 0) && (t > 0) && (u > 0) && ((1-s-t-u) > 0) ){
      _center = A + AB*s + AC*t + AD*u;
      _radius = _center.Dist(A);
    }
    else{
      // take the largest side and use it as the diameter
      double maxdist = A.Dist(B);
      Vector_t max1 = A;
      Vector_t max2 = B;
      if (A.Dist(C) > maxdist){
        maxdist = A.Dist(C);
        max1 = A;
        max2 = C;
      }
      if (A.Dist(D) > maxdist){
        maxdist = A.Dist(D);
        max1 = A;
        max2 = D;
      }
      if (B.Dist(C) > maxdist){
        maxdist = B.Dist(C);
        max1 = B;
        max2 = C;
      }
      if (B.Dist(D) > maxdist){
        maxdist = B.Dist(D);
        max1 = B;
        max2 = D;
      }
      if (C.Dist(D) > maxdist){
        maxdist = C.Dist(D);
        max1 = C;
        max2 = D;
      }
      _center = (max1+max2)/2.;
      _radius = max1.Dist(max2)/2.;
    }
      

    // TEMPORARY
    // otherwise find the 4 possible sphere combinations,
    // which contains the 4th point,
    // and if multiple ones choose the one with the smallest radius
    Sphere tmp = Sphere(A,B,C);
    //_radius = kINVALID_DOUBLE;
    if (tmp.Contain(D)){
      _center = tmp.Center();
      _radius = tmp.Radius();
    }
    tmp = Sphere(A,B,D);
    if (tmp.Contain(C)){
      if (tmp.Radius() < _radius){
        _center = tmp.Center();
        _radius = tmp.Radius();
      }
    }
    tmp = Sphere(A,C,D);
    if (tmp.Contain(B)){
        if (tmp.Radius() < _radius){
          _center = tmp.Center();
          _radius = tmp.Radius();
        }
    }
    tmp = Sphere(B,C,D);
    if (tmp.Contain(A)){
      if (tmp.Radius() < _radius){
        _center = tmp.Center();
        _radius = tmp.Radius();
      }
    }

  }

geoalgo::Sphere::Sphere

(

const std::vector< ::geoalgo::Point_t > &

pts

)

Definition at line 322 of file GeoSphere.cxx.

References _center, and Sphere().

    : _center(0,0,0)
    , _radius(0)
  {

    switch(pts.size()) {
    case 0:
      break;
    case 1: _center = pts.front();
      break;
    case 2: (*this) = Sphere(pts[0],pts[1]);
      break;
    case 3: (*this) = Sphere(pts[0],pts[1],pts[2]);
      break;
    case 4: (*this) = Sphere(pts[0],pts[1],pts[2],pts[3]);
      break;
    default:
      throw GeoAlgoException("Cannot call Sphere constructor with more than 4 points. Something went wront");   
    }

  }

template<class T >

geoalgo::Sphere::Sphere ( const T &  pt1, const T &  pt2  )

inline

Definition at line 91 of file GeoSphere.h.

      : Sphere(Point_t(pt1), Point_t(pt2))
    {}

template<class T >

geoalgo::Sphere::Sphere ( const T &  A, const T &  B, const T &  C  )

inline

Definition at line 95 of file GeoSphere.h.

      : Sphere(Point_t(A), Point_t(B), Point_t(C))
    {}

template<class T >

geoalgo::Sphere::Sphere ( const T &  A, const T &  B, const T &  C, const T &  D  )

inline

Definition at line 99 of file GeoSphere.h.

      : Sphere(Point_t(A), Point_t(B), Point_t(C), Point_t(D))
    {}

template<class T >

geoalgo::Sphere::Sphere ( const std::vector< T > &  pts )

inline

Definition at line 103 of file GeoSphere.h.

References Sphere().

    {
      std::vector< ::geoalgo::Vector> geo_pts;
      geo_pts.reserve(pts);
      for(auto const& p : pts) geo_pts.emplace_back(p);
      (*this) = Sphere(geo_pts);
    }

Member Function Documentation

const Point_t & geoalgo::Sphere::Center

(

)

const

Center getter.

Definition at line 344 of file GeoSphere.cxx.

References _center.

Referenced by geoalgo::GeoAlgo::_RemainingPoints_(), geoalgo::GeoObjCollection::Add(), Center(), Sphere(), and ~Sphere().

{ return _center; }

void geoalgo::Sphere::Center	(	const double	x,
		const double	y,
		const double	z
	)

Center setter.

Definition at line 348 of file GeoSphere.cxx.

References _center, x, y, and z.

  { _center[0] = x; _center[1] = y; _center[2] = z; }

void geoalgo::Sphere::Center

(

const Point_t &

pt

)

Center setter.

Definition at line 351 of file GeoSphere.cxx.

References _center, and compat().

  { compat(center); _center = center; }

template<class T >

void geoalgo::Sphere::Center ( const T &  pt )

inline

Definition at line 111 of file GeoSphere.h.

References Center().

    { Center(Point_t(pt)); }

void geoalgo::Sphere::compat ( const Point_t &  p, const double  r = 0  ) const

protected

3D point compatibility check

Definition at line 363 of file GeoSphere.cxx.

Referenced by geoalgo::GeoAlgo::boundingSphere(), Center(), Radius(), Sphere(), and ~Sphere().

  { 
    if(p.size()!=3) throw GeoAlgoException("Only 3D points allowed for sphere"); 
    compat(r);
  }

void geoalgo::Sphere::compat ( const double &  r ) const

protected

Positive radius compatibility check.

Definition at line 369 of file GeoSphere.cxx.

  { if(r<0) throw GeoAlgoException("Only positive value allowed for radius"); }

bool geoalgo::Sphere::Contain

(

const Point_t &

p

)

const

Judge if a point is contained within a sphere.

Definition at line 357 of file GeoSphere.cxx.

References _center, geoalgo::Vector::_Dist_(), _radius, and geoalgo::Vector::compat().

Referenced by geoalgo::GeoAlgo::_RemainingPoints_(), geoalgo::GeoAlgo::_WelzlSphere_(), Contain(), Sphere(), and ~Sphere().

  {
    _center.compat(p);
    return ( p._Dist_(_center) < _radius );
  }

template<class T >

bool geoalgo::Sphere::Contain ( const T &  p ) const

inline

Definition at line 114 of file GeoSphere.h.

References Contain().

    { return Contain(Point_t(p)); }

double geoalgo::Sphere::Radius

(

)

const

Radius getter.

Definition at line 346 of file GeoSphere.cxx.

References _radius.

Referenced by geoalgo::GeoAlgo::_RemainingPoints_(), Sphere(), and ~Sphere().

{ return _radius; }

void geoalgo::Sphere::Radius

(

const double &

r

)

Radius setter.

Definition at line 354 of file GeoSphere.cxx.

References _radius, and compat().

  { compat(r); _radius = r; }

Member Data Documentation

Point_t geoalgo::Sphere::_center

protected

Center of Sphere.

Definition at line 74 of file GeoSphere.h.

Referenced by Center(), Contain(), and Sphere().

double geoalgo::Sphere::_radius

protected

Radius of Sphere.

Definition at line 77 of file GeoSphere.h.

Referenced by Contain(), Radius(), and Sphere().

---

The documentation for this class was generated from the following files:

• /cvmfs/larsoft.opensciencegrid.org/products/larcorealg/v07_03_00/source/larcorealg/GeoAlgo/GeoSphere.h
• /cvmfs/larsoft.opensciencegrid.org/products/larcorealg/v07_03_00/source/larcorealg/GeoAlgo/GeoSphere.cxx