vsr_cga3D_round.h

#ifndef  vsr_cga3D_round_INC
#define  vsr_cga3D_round_INC


#include "detail/vsr_generic_op.h"
#include "space/vsr_cga3D_types.h"

namespace vsr { namespace cga {
  
 struct Round {                          


   static  Point null ( const Vec& v); 

   static  Point null ( const Point& v); 

   static  Point null(VSR_PRECISION x, VSR_PRECISION y, VSR_PRECISION z);
 
   static  Point point(VSR_PRECISION x, VSR_PRECISION y, VSR_PRECISION z);


   static DualSphere dualSphere( VSR_PRECISION r, VSR_PRECISION x, VSR_PRECISION y, VSR_PRECISION z);

   static DualSphere dls( VSR_PRECISION r, VSR_PRECISION x, VSR_PRECISION y, VSR_PRECISION z ){
      return dualSphere(r,x,y,z);
   }

   static DualSphere dls( const Vec& v, VSR_PRECISION r = 1.0 );
        
    static DualSphere sphere( const Point& v, VSR_PRECISION r = 1.0 );

    static DualSphere dls( const Point& p, VSR_PRECISION r = 1.0 );


    static  Point center( const DualSphere& s);
   /*
    Simple Center of A Pair (not normalized -- use loc or location method instead)
   */
    static  Point center( const Pair& s);
   /*
    Simple Center of A Circle (not normalized -- use loc or location method instead)
   */
    static  Point center( const Circle& s);
   /*
    Simple Center of A Sphere (not normalized -- use loc or location method instead)
   */
    static  Point center( const Sphere& s);  
    template<class A>
    static Point cen( const A& s) { return center(s); }    
 
    template<class A>
    static  Point location(const A& s){ return null( cen(s) ); }
 
    template<class A>
    static  Point loc(const A& s){ return location(s); }   
  

    static VSR_PRECISION size( const DualSphere& s, bool bDual =true);
 
    static VSR_PRECISION size( const Pair& s, bool bDual=true);

    static VSR_PRECISION size( const Circle& s, bool bDual=false);

    static VSR_PRECISION size( const Sphere& s, bool bDual = false);        
 
    static VSR_PRECISION dsize( const Point& dls );
    
   
    static VSR_PRECISION radius( const DualSphere& s );

    static VSR_PRECISION radius( const Pair& s );

    static VSR_PRECISION radius( const Circle& s );

    static VSR_PRECISION radius( const Sphere& s );

    
    template<class T> static VSR_PRECISION rad( const T& t) { return radius(t); }
   
    template<class A>
    static VSR_PRECISION 
    curvature(const A& s){
        VSR_PRECISION r = rad( s );     
        return (r==0) ? 10000 : 1.0 / rad(s);
    }
    
    template<class T> 
    static VSR_PRECISION cur( const T& t) { return curvature(t); }

    

    static VSR_PRECISION squaredDistance(const Point& a, const Point b);


    static VSR_PRECISION sqd(const Point& a, const Point b) { return squaredDistance(a,b); }
    
    static VSR_PRECISION distance(const Point& a, const Point b);
 
    static VSR_PRECISION dist( const Point& a, const Point& b) { return distance(a,b); }


    static std::vector<Point> split(const Pair& pp);
    
    static std::vector<Point> splitLocation(const Pair& pp);
       
     static Point split(const Pair& pp, bool bFirst);
     
    static std::vector<Point> split( const Circle& nc ){
      return split( nc.dual() );
    }


    static  DirectionVector direction( const Pair& p );

    static  DirectionBivector direction( const Circle& c );


    static  DirectionBivector direction( const Sphere& c );
    
    template<class A>
    static  auto dir( const A&s ) -> decltype(direction(s)) { return direction(s); }


    static  Line carrier(const Pair& p);

    static  Plane carrier(const Circle& c);    
    
    template<class A>
    static  auto car( const A& s) -> decltype(carrier(s)) { return carrier(s); }

    
    static  DualSphere surround( const Pair& s);
    
    static  DualSphere surround( const Circle& s);    
    
    template <class A>
    static  DualSphere sur( const A& s) { return surround(s); }
    
     static  Pair produce(const DualSphere& dls, const Vec& v);     

     static  Circle produce(const DualSphere& dls, const Biv& b);     

//    /*
//      Creates a real / imaginary round from an imaginary / real round
//     */
//     template<class A>
//     auto
//     real(const A& s) RETURNS (
//         produce( 
//                Round::dls( Round::loc( s ), -Round::rad( Round::sur( s ) ) ), 
//                typename A::space::origin(-1) <= Round::dir( s ) 
//              )
//     )
//
//
//    /*
//      Creates an imaginary round from an real round
//     */
//     template<class A>
//     auto
//     imag(const A& s) RETURNS (
//         produce( 
//                Round::dls( Round::loc( s ), Round::rad( Round::sur( s ) ) ), 
//                typename A::space::origin(-1) <= Round::dir( s ) 
//              )
//     )
     
    static DualSphere at( const Point& c, const Point& p);  

    static Point point(const DualSphere & dls, const Vec& flat);
    
    static Vec vec(const Circle& c, VSR_PRECISION theta = 0);

    static Pair pair(const Circle& c, VSR_PRECISION t);    
  
    static Point point(const Circle& c, VSR_PRECISION t);

 };
          
 
  struct Flat {          


      static DirectionVector direction( const Line& f);
 
      static DirectionBivector direction( const Plane& f);
      
      template<class A> static auto dir( const A& s ) -> decltype( direction(s) ) { return direction(s); }
      
   

      static Point location(const DualLine& f, const Point& p, bool dual=true);

      static Point location(const Line& f, const Point& p, bool dual=false);

      static Point location(const DualPlane& f, const Point& p, bool dual=true);

      static Point location(const Plane& f, const Point& p, bool dual=false);

      template<class A> static Point loc( const A& a, const Point& p, bool dual )  { return location(a,p); }      
      
     static VSR_PRECISION wt(const DualLine& f, bool bDual=true);
     
     
      static DualPlane plane( const Point& pnt, const DirectionVector& drv);
     
      static Line line( VSR_PRECISION x, VSR_PRECISION y, VSR_PRECISION z );

      static Circle dline(  VSR_PRECISION x, VSR_PRECISION y, VSR_PRECISION z );

  };
   


   struct Tangent {

    static Pair at( const Circle& r, const Point& p);  
    

    static Circle at( const Sphere& r, const Point& p); 
    
    static VSR_PRECISION wt(const TangentVector& s);

    
    static VSR_PRECISION wt(const TangentBivector& s);   
    
    static VSR_PRECISION wt(const TangentTrivector& s);         
         
          
   };

 
  
}} //vsr::cga::

#endif   /* ----- #ifndef vsr_cga3D_round_INC  ----- */