synaps/shape/sisl-base-rep.h

#ifndef SYNAPS_SISL_REPRESENTATIONS_H
#define SYNAPS_SISL_REPRESENTATIONS_H
#include <synaps/init.h>
#include <synaps/base/shared_object.h>
#include <synaps/shape/sisl/sisl.h>
#include <synaps/shape/sisl/GoReadWrite.h>
#include <synaps/shape/IBSplineCurve.h>

__BEGIN_NAMESPACE_SYNAPS

struct sisl_curve_rep
{ 
  SISLCurve  * sisl_data_; 
  SISLCurve * operator->(){ return sisl_data_; };
  const SISLCurve * operator->() const { return sisl_data_; };
  sisl_curve_rep() : sisl_data_(0) {};
  sisl_curve_rep & operator=( const sisl_curve_rep & rep ) 
  { 
    if ( sisl_data_ )   freeCurve(sisl_data_);
    sisl_data_ = 0;
    if ( rep.sisl_data_ ) sisl_data_ = copyCurve(rep.sisl_data_); 
  };
  ~sisl_curve_rep() { if ( sisl_data_ ) freeCurve(sisl_data_); };
  SISLCurve * sisl_data() { assert(sisl_data_); return sisl_data_; };
  
  int ord()   { return sisl_data()->ik; };
  int nbp()   { return sisl_data()->in; };
  int nbk()   { return nbp()+ord();    };
  int dim()   { return sisl_data()->idim; };
};

struct sisl_surface_rep
{ 
  SISLSurf* sisl_data_; 
  SISLSurf * operator->(){ return sisl_data_; };
  const SISLSurf * operator->() const { return sisl_data_; };
  sisl_surface_rep():sisl_data_(0){};
  sisl_surface_rep & operator=( const sisl_surface_rep & rep ) 
  { 
    if ( sisl_data_ ) freeSurf(sisl_data_);
    sisl_data_ = 0;
    if ( rep.sisl_data_ ) sisl_data_ = copySurface(rep.sisl_data_); 
  };
  ~sisl_surface_rep() { if ( sisl_data_ ) freeSurf(sisl_data_); };
};

struct SISLBSplineCurve : sisl_curve_rep, wrapper<SISLBSplineCurve,IBSplineCurve> 
{
  
  typedef       fxv<double,3>         cp;           
  typedef       double                cp_value_type; 
  typedef       cp            *       cp_iterator;
  typedef const cp            * const_cp_iterator;
  typedef       double                kn_value_type;
  typedef       kn_value_type *       kn_iterator;
  typedef const kn_value_type * const_kn_iterator;
  
  // iterator access to knots values
  inline       kn_iterator kn_begin()       { return       (kn_iterator)(sisl_data()->et);         };
  inline const_kn_iterator kn_begin() const { return (const_kn_iterator)(sisl_data()->et);         };  
  inline       kn_iterator kn_end  ()       { return       (kn_iterator)(sisl_data()->et) + nbk(); };
  inline const_kn_iterator kn_end  () const { return (const_kn_iterator)(sisl_data()->et) + nbk(); };
  
  // iterator access to control points
  inline       cp_iterator cp_begin()       { return       (cp_iterator)(sisl_data()->ecoef);      };
  inline const_cp_iterator cp_begin() const { return (const_cp_iterator)(sisl_data()->ecoef);      };
  inline       cp_iterator cp_end  ()       { return       (cp_iterator)(sisl_data()->ecoef)+nbp();};
  inline const_cp_iterator cp_end  () const { return (const_cp_iterator)(sisl_data()->ecoef)+nbp();};
  
  // random access to control points
  inline const cp & operator[](int i) const { return cp_begin()[i]; };
  inline       cp & operator[](int i) const { return cp_begin()[i]; };

}

inline std::istream& operator>>( std::istream & ins, sisl_curve_rep & rep ) 
{ 
  rep.~sisl_curve_rep();
  rep.sisl_data_ = readGoCurve(ins); 
};



inline std::istream& operator>>( std::istream & ins, sisl_surface_rep & rep ) 
{ 
  rep.~sisl_surface_rep();
  rep.sisl_data_ = readGoSurface(ins); 
};

struct SISLcurve
{
  typedef SISLcurve               rep_t;
  typedef ParametricCurve<SISLcurve> view_t;
  shared_object<sisl_curve_rep> rep_;
  const sisl_curve_rep & rep() const { return *rep_; };
  sisl_curve_rep & rep() { return *rep_; };
  int nbctrl()  const { return (*rep_)->in;   };
  int order ()  const { return (*rep_)->ik;   };
  int dim   ()  const { return (*rep_)->idim; };
  bool closed() const { return (*rep_)->cuopen == -1 || (*rep_)->cuopen == 0; };
};

inline 
void domain( double & tmin, double & tmax, const SISLcurve & c )
{
  int stat;
  s1363(c.rep_->sisl_data_,&tmin,&tmax,&stat);
};

template<class C>
void domain( C & tmin, C & tmax, const SISLcurve & c )
{
  double tmin_, tmax_;
  domain(tmin_,tmax_,c);
  tmin = tmin_;
  tmax = tmax_;
};

inline
void eval( double * p, 
           const SISLcurve & c, 
           double  t )
{
  int    stat;
  int leftk;
  s1227(c.rep_->sisl_data_,0,t,&leftk,p,&stat);
};

template<unsigned N> inline
void eval( fxv<double,N> & p, const SISLcurve & c, 
           double t )
{
  eval(&p[0],c,t); 
};

template<class Point> inline
void eval( Point & p, const SISLcurve & c, const typename Point::value_type & t )
{
  double ptmp[c.dim()];
  double t_ = t;
  eval(ptmp,c,t_);
  for ( int i = 0; i < c.dim(); i ++ ) p[i] = ptmp[i];

};

double length( const SISLcurve & c, double eps )
{
  double result;
  int stat;
  s1240(c.rep_->sisl_data_,eps,&result,&stat);
  return result;
};


struct SISLSurface
{
  typedef SISLSurface                    rep_t;
  typedef ParametricSurface<SISLSurface> view_t;
  shared_object<sisl_surface_rep> rep_;
  int  nbctrlu()   const { return (*rep_)->in1;   };
  int  nbctrlv()   const { return (*rep_)->in2;   };
  int  orderu ()   const { return (*rep_)->ik1;   };
  int  orderv ()   const { return (*rep_)->ik2;   };
  int  dim    ()   const { return (*rep_)->idim;  };
  bool uclosed()   const { return (*rep_)->cuopen_1 == -1 || (*rep_)->cuopen_1 == 0; };
  bool vclosed()   const { return (*rep_)->cuopen_1 == -1 || (*rep_)->cuopen_1 == 0; };
};

inline
void eval( double * p, 
           const SISLSurface & s, 
           const double * prm )
{
  int    stat;
  int leftk;
  s1421(s.rep_->sisl_data_,0,(double*)prm,&leftk,&leftk,p,0,&stat);
};

inline
void eval( double * p, 
           const SISLSurface & s, 
           const double & u, 
           const double & v )
{
  double tmp[] = { u, v };
  eval(p,s,tmp);
};

template<unsigned N> inline
void eval( fxv<double,N>& p, const SISLSurface & s, const fxv<double,2>& prm ) { eval(&p[0],s,&prm[0]); };

template<class Point> inline
void eval( Point & p, 
           const SISLSurface & s, 
           const typename Point::value_type & u,
           const typename Point::value_type & v )
{
  double etmp[s.dim()];
  double u_,v_;
  u_ = u;
  v_ = v;
  eval(etmp,s,u_,v_);
  for ( int i = 0; i < s.dim(); i ++ ) p[i] = etmp[i];
};

inline
void domain( double & umin, double & umax, 
             double & vmin, double & vmax,
             const SISLSurface & s )
{
  int stat;
  s1603(s.rep_->sisl_data_, &umin, &vmin, &umax, &vmax, &stat );
};

template<class C>
void domain( C & umin, C & umax, C & vmin, C & vmax, const SISLSurface & s  )
{
  double umin_, umax_, vmin_, vmax_;
  domain(umin_,umax_,vmin_,vmax_,s);
  umin = umin_;
  vmin = vmin_;
  umax = umax_;
  vmax = vmax_;
};


inline
void sample( double * smp, 
             const SISLSurface & s, 
             const double * u, 
             const double * v, 
             int m, int n )
{
  int stat;
  s1506(s.rep_->sisl_data_,0,m,(double*)u,n,(double*)v,0,0,&stat);
};

template<unsigned N>
void sample( fxv<double,N> * smp, 
             const SISLSurface & s,
             const double * u,
             const double * v,
             int m,
             int n )
{
  assert(N==s.dim());
  sample((double*)smp,s,u,v,m,n);
};


/*
template<class Point>
void sample( Point * smp, 
             const SISLSurface & s, 
             const typename Point::value_type * u, 
             const typename Point::value_type * v, 
             int m, 
             int n )
{
  double * u = new double[m*n*s.dim() + m + n];
  double * v = u + m;
  double * p = v + n;
  sample(p,s,u,v,m,n);
  
};
*/




inline std::istream& operator>>( std::istream & in, SISLcurve & c )
{
  in >> (*c.rep_);
  return in;
};

inline std::istream& operator>>( std::istream & in, SISLSurface & s )
{
  in >> (*s.rep_);
  return in;
};



__END_NAMESPACE_SYNAPS;
#endif