Common/Geom/Curve.h

Go to the documentation of this file.

//-------------------------------------------------------------------
// Copyright (c) 2004 Evan Sherbrooke and Michael Lauer 
// Portions copyright (c) 2007 Celeritive Technologies, Inc.
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
//-------------------------------------------------------------------
#pragma once
#ifndef VOLUMILL_CURVE_H
#define VOLUMILL_CURVE_H

#include <Geom/Points.h>
#include <Geom/PointAlg.h>
#include <Util/TypeStripper.h>
#include <Util/Params.h>
#include <boost/mpl/if.hpp>
#include <boost/type_traits/is_base_of.hpp>
#include <loki/Visitor.h>

namespace geom
{

template <typename R, typename Visited>
struct ThrowingCatchAll
{
   static R OnUnknownVisitor(Visited&, Loki::BaseVisitor&)
   {
      VALIDATE(0)("Unknown Visitor type not supported right now");
   }
};

template <int n>
class ParametricCurve : public Loki::BaseVisitable<void, Loki::DefaultCatchAll, true>, public util::Parameterized
{
   friend class boost::serialization::access;
   template<class Archive>
   void serialize(Archive &ar, const unsigned int version)
   {
      if (version > 0)
         ar & BOOST_SERIALIZATION_BASE_OBJECT_NVP(util::Parameterized);
   }
public:
   LOKI_DEFINE_CONST_VISITABLE();
   enum { Dim = n };
   typedef PointNd<n> Point;
   typedef VecNd<n> Vec;

   virtual ~ParametricCurve();

   virtual std::pair<double, double> getRange() const = 0;
   virtual bool isPeriodic() const = 0;
   virtual void evaluate(double param, Point *pPt, 
      int nderivs = 0, std::vector<Vec> *pDerivs = 0) const = 0;
   virtual shared_ptr<ParametricCurve<n> > clone() const = 0;
   virtual void reverse() = 0;
};

typedef shared_ptr<ParametricCurve<2> > CurvePtr2d;
typedef shared_ptr<ParametricCurve<3> > CurvePtr3d;
typedef std::vector<CurvePtr2d> CompositeCurve2d;
typedef std::vector<CurvePtr3d> CompositeCurve3d;

template <int n>
class ControlPointCurveBase : virtual public ParametricCurve<n>
{
public:
   virtual ~ControlPointCurveBase();

   virtual int getNumCpts() const = 0;

   // Control points
   // Return by VALUE, because may be computed from homogeneous coords!
   virtual PointNd<n> getControlPoint(int i) const = 0;
   virtual void setControlPoint(int i, const PointNd<n> &pt) = 0;
   virtual double getWeight(int i) const = 0;
};

namespace detail
{
   template<class Curve>
   struct CurveEndpointAccessor
   {
      typedef PointNd<Curve::Dim> Point;
      inline Point getStartPoint (const Curve& c)
      {
         Point pt;
         c.evaluate (0.0, &pt);
         return pt;
      }
      inline Point getEndPoint (const Curve& c)
      {
         Point pt;
         c.evaluate (1.0, &pt);
         return pt;
      }
   };

   template<int n>
   struct CurveEndpointAccessor<ControlPointCurveBase<n> >
   {
      typedef PointNd<n> Point;
      typedef ControlPointCurveBase<n> Curve;
      inline Point getStartPoint (const Curve& c)
      {
         return c.getControlPoint (0);
      }
      inline Point getEndPoint (const Curve& c)
      {
         return c.getControlPoint (c.getNumCpts() - 1);
      }
      inline void setStartPoint (Curve& c, const Point& pt)
      {
         c.setControlPoint (0, pt);
      }
      inline void setEndPoint (Curve& c, const Point& pt)
      {
         c.setControlPoint (c.getNumCpts() - 1, pt);
      }
   };
}

template<class T>
inline PointNd<util::TypeStripper<T>::base_type::Dim>
getStartPoint (T curve)
{
   typedef typename util::TypeStripper<T>::base_type Derived;
   typedef ControlPointCurveBase<Derived::Dim> Base;
   typedef typename boost::mpl::if_<boost::is_base_of<Base, Derived>,
      Base,
      Derived>::type Arg;
   detail::CurveEndpointAccessor<Arg> cea;
   return cea.getStartPoint (util::TypeStripper<T>::cstrip (curve));
}

template<class T>
inline PointNd<util::TypeStripper<T>::base_type::Dim>
getEndPoint (T curve)
{
   typedef typename util::TypeStripper<T>::base_type Derived;
   typedef ControlPointCurveBase<Derived::Dim> Base;
   typedef typename boost::mpl::if_<boost::is_base_of<Base, Derived>,
      Base,
      Derived>::type Arg;
   detail::CurveEndpointAccessor<Arg> cea;
   return cea.getEndPoint (util::TypeStripper<T>::cstrip (curve));
}

template<class T, class P>
inline void setStartPoint (T curve, const P& pt)
{
   typedef typename util::TypeStripper<T>::base_type Derived;
   typedef ControlPointCurveBase<Derived::Dim> Base;
   typedef typename boost::mpl::if_<boost::is_base_of<Base, Derived>,
      Base,
      Derived>::type Arg;
   detail::CurveEndpointAccessor<Arg> cea;
   cea.setStartPoint (util::TypeStripper<T>::strip (curve), pt);
}

template<class T, class P>
inline void setEndPoint (T curve, const P& pt)
{
   typedef typename util::TypeStripper<T>::base_type Derived;
   typedef ControlPointCurveBase<Derived::Dim> Base;
   typedef typename boost::mpl::if_<boost::is_base_of<Base, Derived>,
      Base,
      Derived>::type Arg;
   detail::CurveEndpointAccessor<Arg> cea;
   cea.setEndPoint (util::TypeStripper<T>::strip (curve), pt);
}

template <int n>
class Line : virtual public ControlPointCurveBase<n>
{
public:
   // GCC bug
   typedef void ReturnType;
   LOKI_DEFINE_CONST_VISITABLE();
};

template<int n>
shared_ptr<Line<n> > makeLine ();

template <int n>
inline shared_ptr<Line<n> > makeLine (const PointNd<n>& start, const PointNd<n>& end)
{
   shared_ptr<Line<n> > pLine (makeLine<n>());
   setStartPoint (pLine, start);
   setEndPoint (pLine, end);
//   WARN (length (VecNd<n> (end-start)) > util::doubleEps);
   return pLine;
}


typedef Line<2> Line2d;
typedef Line<3> Line3d;

template <int n>
class Polyline : virtual public ControlPointCurveBase<n>
{
public:
   // GCC bug
   typedef void ReturnType;
   LOKI_DEFINE_CONST_VISITABLE();

   virtual int getSpan (double param) const = 0;
   virtual const std::vector<geom::PointNd<n> >& getPts() const = 0;
};

template<int n>
shared_ptr<Polyline<n> > makePolyline (const std::vector<geom::PointNd<n> >& pts);

typedef Polyline<2> Polyline2d;
typedef Polyline<3> Polyline3d;

template <int n>
class Arc
{
};

template<>
class Arc<2> : virtual public ParametricCurve<2>
{
public:
   LOKI_DEFINE_CONST_VISITABLE();
   virtual const Point2d& getCenter() const = 0;
   virtual double getRadius() const = 0;
   virtual const std::pair<double, double>& getAngleRange() const = 0;
   virtual bool isCCW() const = 0;

   virtual void assign (const Arc<2>& otherArc) = 0;
};

shared_ptr<Arc<2> > makeArc (const Point2d& center, double radius, double startAngle, double endAngle);
shared_ptr<Arc<2> > makeCCWArcCenter (const Point2d& center, const Point2d& startPt, const Point2d& endPt);
shared_ptr<Arc<2> > makeCCWArcCenterRadius (
   const Point2d& center, const Point2d& startPt, const Point2d& endPt, double radius);
shared_ptr<Arc<2> > makeCWArcCenter (const Point2d& center, const Point2d& startPt, const Point2d& endPt);
shared_ptr<Arc<2> > makeCircle (const Point2d& center, double radius);
CurvePtr2d makeArcTangents (const Point2d& startPt, const Point2d& commonTan, const Point2d& endPt);
typedef Arc<2> Arc2d;
typedef Arc<3> Arc3d;

}

BOOST_IS_ABSTRACT (geom::ParametricCurve<2>);
BOOST_IS_ABSTRACT (geom::ParametricCurve<3>);

BOOST_CLASS_VERSION (geom::ParametricCurve<2>, 1);
BOOST_CLASS_VERSION (geom::ParametricCurve<3>, 1);
#endif

---