/Users/mourrain/Devel/mmx/shape/include/shape/surface_parametric.hpp

Go to the documentation of this file.

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

# ifndef shape_surface_parametric_hpp
# define shape_surface_parametric_hpp

# include <shape/bounding_box.hpp>
# include <realroot/Seq.hpp>
# include <shape/point_set.hpp>
# include <shape/surface.hpp>

# define TMPL template<class C, class V>
# define TMPL1 template<class V>
# define Scalar double
# define SELF surface_parametric<C,V> 
# define Surface surface<V> 
//====================================================================
namespace mmx {
namespace shape {

TMPL struct surface_parametric;

// struct surface_parametric_def {};
// TMPL1 struct use<surface_parametric_def,V>
// {
//   typedef surface_parametric<V> ParametricSurface;
// };

template<class C, class V=default_env>
class surface_parametric : public surface<V>
{
public:
  
  typedef typename use<point_def,V>::Point          Point;
  typedef typename point_set<V>::PointIterator PointIterator;


  surface_parametric(void) {} ;
  //  surface_parametric(const BoundingBox & box): surface(box){}

  //  virtual void set_grid( int m, int n ) = 0;

  virtual Point* eval(double u, double v)            const = 0 ;
  virtual void   eval(Point& p, double u, double v)  const = 0 ;
  virtual Point* operator() (double u, double v)     const { return this->eval(u,v); }
  virtual void   eval(Scalar* lp, const Scalar* u, int n) const ;

  virtual void sample ( PointIterator lp, const Scalar* u, unsigned m, const Scalar* v, unsigned n ) const ;


  //  virtual void sample ( Point* lp, const double * uv, int n );
  virtual void sample ( PointIterator lp, unsigned m, unsigned n ) const ;
  virtual void sample ( Scalar* lp, unsigned m, unsigned n, Scalar* u, Scalar* v) const ;

  //  virtual ParametricCurve * iso_u( Scalar u )                                               const = 0;
  //  virtual ParametricCurve * iso_v( Scalar v )                                               const = 0;

  //  IParametricSurface * gauss_map() const = 0;
  //  virtual IGLGood * triangulate(void) = 0 ;

  virtual double umin(void) const = 0 ;
  virtual double umax(void) const = 0 ;
  virtual double vmin(void) const = 0 ;
  virtual double vmax(void) const = 0 ;
  virtual void   get_range(double & umin, double & umax, double & vmin, double & vmax )              const = 0;
  
} ;

TMPL void 
SELF::eval(Scalar* r, const Scalar* u, int n) const {
  Point p;
  for (int i=0; i<n;i++) {
    this->eval(p,u[0],u[1]);
    *r=p.x();r++; 
    *r=p.y();r++;
    *r=p.z();r++;
    u+=2;
  }
}


TMPL void
SELF::sample( PointIterator p, unsigned m, unsigned n ) const {
  assert(m>1 && n>1);
  Scalar 
    hu=(this->umax() - this->umin())/(m-1), u=umin(),
    hv=(this->vmax() - this->vmin())/(n-1), v;
  Point pp;
  for (unsigned i=0; i<m;i++) {
    v=vmin();
    for (unsigned j=0; j<n;j++,p++) {
      this->eval(*p,u,v);
      v+=hv;
    }
    u+=hu;
  }
}

TMPL void 
SELF::sample (Scalar* r, unsigned m,  unsigned n, Scalar* u, Scalar* v) const {
  assert(m>1 && n>1);
  Scalar 
    hu=(this->umax() - this->umin())/(m-1), 
    hv=(this->vmax() - this->vmin())/(n-1);
  Scalar * u0 =u, su=umin(), * v0=v, sv=vmin();
  for (unsigned i=0; i<m;i++){ *u=su; su+=hu; u++; }
  for (unsigned j=0; j<n;j++){ *v=sv; sv+=hv; v++; }

  Point p;
  u=u0;
  for (unsigned i=0; i<m;i++,u++) {
    v=v0;
    for (unsigned j=0; j<n;j++,v++) {
      this->eval(p,*u,*v);
      *r=p.x();r++; 
      *r=p.y();r++;
      *r=p.z();r++;
    }
  }
}

TMPL void 
SELF::sample (PointIterator p, const Scalar* u, unsigned m, const   Scalar* v, unsigned n) const {
  assert(m>1 && n>1);
  const Scalar * v0=v;

  for (unsigned i=0; i<m;i++,u++) {
    v=v0;
    for (unsigned j=0; j<n;j++,p++,v++) {
      this->eval(*p,*u,*v);
    }
  }
}


} ; // namespace shape
} ; // namespace mmx
# undef TMPL
# undef Point
# undef Scalar
# undef Surface
# undef SELF
# endif // PARAMETRICSURFACE_H