include/shape/parametric_curve.hpp

Go to the documentation of this file.

/*****************************************************************************
 * M a t h e m a g i x
 *****************************************************************************
 * ParametricCurve
 * 2008-03-28
 * Julien Wintz
 *****************************************************************************
 *               Copyright (C) 2006 INRIA Sophia-Antipolis
 *****************************************************************************
 * Comments :
 ****************************************************************************/

# ifndef PARAMETRICCURVE_H
# define PARAMETRICCURVE_H

# include <realroot/Seq.hpp>
# include <shape/vertex.hpp>
# include <shape/edge.hpp>
# include <shape/curve.hpp>
# include <shape/curve_pl.hpp>

# undef  SELF
# define TMPL template<class C, class V>
# define SELF parametric_curve<C,V>
# define REF  REF_OF(V)
# define PLCurve  curve_pl<C,REF>
//====================================================================
namespace mmx {
namespace shape {

// TMPL struct parametric_curve;

// TMPL struct with_parametric_curve {
//   typedef parametric_curve<K> ParametricCurve;
// };

// TMPL struct parametric_curve_def 
//   :public curve_def<K>
//   ,public with_point<K> 
//   ,public with_point_set<K> 
//   ,public with_parametric_curve<K> {};

TMPL
class parametric_curve : public curve<V> {
public:
  typedef C                                  Scalar;
  typedef typename use<point_def,C,V>::Point Point;  
  typedef curve<REF>                         Curve;
  typedef bounding_box<C,REF>                BoundingBox;
  typedef typename point_set<C,3,REF>::PointIterator PointIterator;

           parametric_curve(void) {} ;
           parametric_curve(const BoundingBox box) : Curve(box) {}
  virtual ~parametric_curve(void){} ;
  
  virtual double tmin(void) const = 0 ;
  virtual double tmax(void) const = 0 ;
  virtual void   set_range(double tmin, double tmax) = 0;

  virtual Point* eval   (const double& t) const = 0 ;
  virtual Point* operator() (double t) const { return this->eval(t); }

  virtual void   eval   (Point&, Scalar) const = 0 ;
  virtual void   sample (PointIterator, int)    const;
  virtual void   sample (Point*, const Scalar*, int) const;

  virtual void   subdivide(SELF*& a, SELF*& b, double t ) const = 0;

  virtual Seq<Point *> critical_points(void) = 0 ;
  virtual Seq<Point *> extremal_points(void) = 0 ;
  virtual Seq<Point *> singular_points(void) = 0 ;

} ;

TMPL void 
SELF::sample(PointIterator p, int n) const {
  assert(n>1);
  Scalar h=(this->tmax() - this->tmin())/(n-1), t=tmin();
  for (int i=0; i<n; i++, p++) {
    this->eval(*p, t);   // SEGFAULT ?
    t+=h;
  }
}

TMPL void 
SELF::sample(Point* res, const Scalar* t, int n) const {
  for ( Point * o = res; o != res + n; o++, t++  )
    this->eval(*o,*t);
}


TMPL PLCurve*  
mesh(SELF*  pc ) {
  typedef typename PLCurve::Edge Edge;
  int n = 500;
  PLCurve* res = new PLCurve;//n,n-1,0,0,false);
  pc->sample(res->begin(), n);
  for ( int i = 0; i < n-1; i ++ ) {
    res->push_edge(new Edge(&res->vertex(i),&res->vertex(i+1)));
  }
  return res;
}
  
} // namespace shape
} // namespace mmx
# undef TMPL
# undef TMPL_DEF
# undef REF
# undef PLCurve
# undef SELF
# endif // PARAMETRICCURVE_H

---