Update to 2Geom rev. 1113

(bzr r3622)

1 files changed, 21 insertions, 91 deletions

diff --git a/src/2geom/d2.h b/src/2geom/d2.h
index 82070519c..696ad0191 100644
--- a/src/2geom/d2.h
+++ b/src/2geom/d2.h
@@ -83,6 +83,15 @@ class D2{
     Point valueAt(double t) const {

         boost::function_requires<FragmentConcept<T> >();

         return (*this)(t);

+    }
+    std::vector<Point > valueAndDerivatives(double t, unsigned count) const {
+        std::vector<Coord> x = f[X].valueAndDerivatives(t, count),
+                           y = f[Y].valueAndDerivatives(t, count);
+        std::vector<Point> res;
+        for(unsigned i = 0; i < count; i++) {
+            res.push_back(Point(x[i], y[i]));
+        }
+        return res;
     }

     D2<SBasis> toSBasis() const {

         boost::function_requires<FragmentConcept<T> >();

@@ -91,13 +100,18 @@ class D2{
 

     Point operator()(double t) const;

     Point operator()(double x, double y) const;

-};

-

+};


 template <typename T>

-D2<T> reverse(const D2<T> &a) {

+inline D2<T> reverse(const D2<T> &a) {

     boost::function_requires<FragmentConcept<T> >();

     return D2<T>(reverse(a[X]), reverse(a[Y]));

 }

+
+template <typename T>
+inline D2<T> portion(const D2<T> &a, Coord f, Coord t) {
+    boost::function_requires<FragmentConcept<T> >();
+    return D2<T>(portion(a[X], f, t), portion(a[Y], f, t));
+}
 

 //IMPL: boost::EqualityComparableConcept

 template <typename T>

@@ -347,24 +361,16 @@ D2<T>::operator()(double x, double y) const {
 template<typename T>

 D2<T> derivative(D2<T> const & a) {

     return D2<T>(derivative(a[X]), derivative(a[Y]));

-}

-

+}


 template<typename T>

 D2<T> integral(D2<T> const & a) {

     return D2<T>(integral(a[X]), integral(a[Y]));

-}

+}
 

 } //end namespace Geom

 

-

-

-//TODO: implement intersect

-

-

 #include "rect.h"

-#include "sbasis.h"

-#include "sbasis-2d.h"

-#include "piecewise.h"

+#include "d2-sbasis.h"

 

 namespace Geom{

 

@@ -383,83 +389,7 @@ template <typename T>
 Rect bounds_local(const D2<T> &a, const Interval &t) {

     boost::function_requires<FragmentConcept<T> >();        

     return Rect(bounds_local(a[X], t), bounds_local(a[Y], t));

-}

-

-//D2<SBasis> specific decls:

-

-inline D2<SBasis> compose(D2<SBasis> const & a, SBasis const & b) {

-    return D2<SBasis>(compose(a[X], b), compose(a[Y], b));

-}

-

-SBasis L2(D2<SBasis> const & a, unsigned k);

-double L2(D2<double> const & a);

-

-inline D2<SBasis> portion(D2<SBasis> const &M, double t0, double t1){

-    return D2<SBasis>(portion(M[0],t0,t1),portion(M[1],t0,t1));

-}

-

-D2<SBasis> multiply(Linear const & a, D2<SBasis> const & b);

-inline D2<SBasis> operator*(Linear const & a, D2<SBasis> const & b) { return multiply(a, b); }

-D2<SBasis> multiply(SBasis const & a, D2<SBasis> const & b);

-inline D2<SBasis> operator*(SBasis const & a, D2<SBasis> const & b) { return multiply(a, b); }

-D2<SBasis> truncate(D2<SBasis> const & a, unsigned terms);

-

-unsigned sbasis_size(D2<SBasis> const & a);

-double tail_error(D2<SBasis> const & a, unsigned tail);

-

-//Piecewise<D2<SBasis> > specific decls:

-

-Piecewise<D2<SBasis> > sectionize(D2<Piecewise<SBasis> > const &a);

-D2<Piecewise<SBasis> > make_cuts_independant(Piecewise<D2<SBasis> > const &a);

-Piecewise<D2<SBasis> > rot90(Piecewise<D2<SBasis> > const &a);

-Piecewise<SBasis> dot(Piecewise<D2<SBasis> > const &a, Piecewise<D2<SBasis> > const &b);

-Piecewise<SBasis> cross(Piecewise<D2<SBasis> > const &a, Piecewise<D2<SBasis> > const &b);

-

-Piecewise<D2<SBasis> > force_continuity(Piecewise<D2<SBasis> > const &f, 

-                                        double tol=0,

-                                        bool closed=false);

-

-class CoordIterator

-: public std::iterator<std::input_iterator_tag, SBasis const>

-{

-public:

-  CoordIterator(std::vector<D2<SBasis> >::const_iterator const &iter, unsigned d) : impl_(iter), ix_(d) {}

-

-  inline bool operator==(CoordIterator const &other) { return other.impl_ == impl_; }

-  inline bool operator!=(CoordIterator const &other) { return other.impl_ != impl_; }

-

-  inline SBasis operator*() const {

-        return (*impl_)[ix_];

-  }

-

-  inline CoordIterator &operator++() {

-    ++impl_;

-    return *this;

-  }

-  inline CoordIterator operator++(int) {

-    CoordIterator old=*this;

-    ++(*this);

-    return old;

-  }

-

-private:

-  std::vector<D2<SBasis> >::const_iterator impl_;

-  unsigned ix_;

-};

-

-inline CoordIterator iterateCoord(Piecewise<D2<SBasis> > const &a, unsigned d) {

-    return CoordIterator(a.segs.begin(), d);

-}

-

-//bounds specializations with order

-inline Rect bounds_fast(D2<SBasis> const & s, unsigned order=0) {

-    return Rect(bounds_fast(s[X], order),

-                bounds_fast(s[Y], order));

-}

-inline Rect bounds_local(D2<SBasis> const & s, Interval i, unsigned order=0) {

-    return Rect(bounds_local(s[X], i, order),

-                bounds_local(s[Y], i, order));

-}

+}


 };

 

 /*