geoalgo::Sphere Class Reference

#include "GeoSphere.h"

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

Protected Member Functions
void	compat (Point_t const &p, double const r=0) const
	3D point compatibility check More...
void	compat (double const &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	(	double const &	x,
		double const &	y,
		double const &	z,
		double const &	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	(	Point_t const &	center,
		double const	r = 0
	)

Altenartive ctor (1) - 1 Point.

Definition at line 22 of file GeoSphere.cxx.

References _center.

                                                      : _radius(r)
  {
    _center = center;
  }

geoalgo::Sphere::Sphere	(	Point_t const &	pt1,
		Point_t const &	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	(	Point_t const &	A,
		Point_t const &	B,
		Point_t const &	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	(	Point_t const &	A,
		Point_t const &	B,
		Point_t const &	C,
		Point_t const &	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 ( T const &  pt1, T const &  pt2  )

inline

Definition at line 91 of file GeoSphere.h.

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

template<class T >

geoalgo::Sphere::Sphere ( T const &  A, T const &  B, T const &  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 ( T const &  A, T const &  B, T const &  C, T const &  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 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

Point_t const & 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	(	double const	x,
		double const	y,
		double const	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

(

Point_t const &

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 ( T const &  pt )

inline

Definition at line 114 of file GeoSphere.h.

References Center().

    {
      Center(Point_t(pt));
    }

void geoalgo::Sphere::compat ( Point_t const &  p, double const  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 ( double const &  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

(

Point_t const &

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 ( T const &  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

(

double const &

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/v10_00_02/source/larcorealg/GeoAlgo/GeoSphere.h
• larcorealg/v10_00_02/source/larcorealg/GeoAlgo/GeoSphere.cxx