#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 27 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 31 of file GeoSphere.h.

References Center(), compat(), Contain(), pt, pt1, pt2, r, 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 14 of file GeoSphere.cxx.

References _center, _radius, r, 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 22 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 27 of file GeoSphere.cxx.

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

   {
     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 38 of file GeoSphere.cxx.

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

   {
     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 189 of file GeoSphere.cxx.

References _center, _radius, Center(), compat(), Contain(), d, geoalgo::Vector::Dist(), geoalgo::Vector::Dot(), pt, Radius(), 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 321 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.

91 : Sphere(Point_t(pt1), Point_t(pt2))

92 {}

pt2

TText * pt2

Definition: plot.C:64

geoalgo::Point_t

Vector Point_t

Definition: GeoVector.h:204

pt1

TText * pt1

Definition: plot.C:61

geoalgo::Sphere::Sphere

Sphere()

Default ctor.

Definition: GeoSphere.cxx:8

template<class T >

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

inline

Definition at line 95 of file GeoSphere.h.

95 : Sphere(Point_t(A), Point_t(B), Point_t(C))

96 {}

geoalgo::Point_t

Vector Point_t

Definition: GeoVector.h:204

geoalgo::Sphere::Sphere

Sphere()

Default ctor.

Definition: GeoSphere.cxx:8

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.

100 : Sphere(Point_t(A), Point_t(B), Point_t(C), Point_t(D))

101 {}

geoalgo::Point_t

Vector Point_t

Definition: GeoVector.h:204

geoalgo::Sphere::Sphere

Sphere()

Default ctor.

Definition: GeoSphere.cxx:8

template<class T >

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

inline

Definition at line 104 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 336 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 346 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 353 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 114 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 371 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 377 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 365 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 120 of file GeoSphere.h.

References Contain().

     {
       return Contain(Point_t(p));
     }

double geoalgo::Sphere::Radius ( ) const

Radius getter.

Definition at line 341 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 359 of file GeoSphere.cxx.

References _radius, compat(), and r.

   {
     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:

larcorealg/v09_13_01/source/larcorealg/GeoAlgo/GeoSphere.h
larcorealg/v09_13_01/source/larcorealg/GeoAlgo/GeoSphere.cxx

Public Member Functions

Protected Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation