summaryrefslogtreecommitdiffstats
path: root/src/cython/_cy_curves.pyx
diff options
context:
space:
mode:
Diffstat (limited to 'src/cython/_cy_curves.pyx')
-rw-r--r--src/cython/_cy_curves.pyx1945
1 files changed, 1945 insertions, 0 deletions
diff --git a/src/cython/_cy_curves.pyx b/src/cython/_cy_curves.pyx
new file mode 100644
index 0000000..3584a87
--- /dev/null
+++ b/src/cython/_cy_curves.pyx
@@ -0,0 +1,1945 @@
+from numbers import Number
+
+from cython.operator cimport dereference as deref
+
+from _cy_rectangle cimport cy_OptInterval, wrap_OptInterval, wrap_Rect, OptRect, wrap_OptRect
+from _cy_rectangle cimport cy_Interval, wrap_Interval
+
+from _cy_affine cimport cy_Translate, cy_Rotate, cy_Scale
+from _cy_affine cimport cy_VShear, cy_HShear, cy_Zoom
+from _cy_affine cimport cy_Affine, wrap_Affine, get_Affine, is_transform
+
+
+cdef class cy_Curve:
+
+ """Class representing generic curve.
+
+ Curve maps unit interval to real plane. All curves should implement
+ these methods.
+
+ This class corresponds to Curve class in 2geom. It's children in cython
+ aren't actually derived from it, it would make code more unreadable.
+ """
+
+ def __cinit__(self):
+ """Create new Curve.
+
+ You shouldn't create Curve this way, it usually wraps existing
+ curves (f. e. in Path).
+ """
+ self.thisptr = <Curve *> new SBasisCurve(D2[SBasis]( SBasis(0), SBasis(0) ))
+
+ def __call__(self, Coord t):
+ """Get point at time value t."""
+ return wrap_Point( deref(self.thisptr)(t) )
+
+ def initial_point(self):
+ """Get self(0)."""
+ return wrap_Point(self.thisptr.initialPoint())
+
+ def final_point(self):
+ """Get self(1)."""
+ return wrap_Point(self.thisptr.finalPoint())
+ def is_degenerate(self):
+ """Curve is degenerate if it's length is zero."""
+ return self.thisptr.isDegenerate()
+
+ def point_at(self, Coord t):
+ """Equivalent to self(t)."""
+ return wrap_Point(self.thisptr.pointAt(t))
+
+ def value_at(self, Coord t, Dim2 d):
+ """Equivalent to self(t)[d]."""
+ return self.thisptr.valueAt(t, d)
+
+ def point_and_derivatives(self, Coord t, unsigned int n):
+ """Return point and at least first n derivatives at point t in list."""
+ return wrap_vector_point(self.thisptr.pointAndDerivatives(t, n))
+
+ def set_initial(self, cy_Point v):
+ """Set initial point of curve."""
+ self.thisptr.setInitial(deref( v.thisptr ))
+
+ def set_final(self, cy_Point v):
+ """Set final point of curve."""
+ self.thisptr.setFinal(deref( v.thisptr ))
+
+ def bounds_fast(self):
+ """Return bounding rectangle for curve.
+
+ This method is fast, but does not guarantee to give smallest
+ rectangle.
+ """
+ return wrap_Rect(self.thisptr.boundsFast())
+
+ def bounds_exact(self):
+ """Return exact bounding rectangle for curve.
+
+ This may take a while.
+ """
+ return wrap_Rect(self.thisptr.boundsExact())
+
+ def bounds_local(self, cy_OptInterval i, unsigned int deg=0):
+ """Return bounding rectangle to portion of curve."""
+ return wrap_OptRect(self.thisptr.boundsLocal(deref( i.thisptr ), deg))
+
+ #TODO rewrite all duplicates to copy."""
+ def duplicate(self):
+ """Duplicate the curve."""
+ return wrap_Curve_p( self.thisptr.duplicate() )
+
+ def transformed(self, m):
+ """Transform curve by affine transform."""
+ cdef Affine at
+ if is_transform(m):
+ at = get_Affine(m)
+ return wrap_Curve_p( self.thisptr.transformed(at) )
+
+ def portion(self, Coord fr=0, Coord to=1, cy_Interval interval=None):
+ """Return portion of curve, specified by endpoints or interval."""
+ if interval is None:
+ return wrap_Curve_p( self.thisptr.portion(deref( interval.thisptr )) )
+ else:
+ return wrap_Curve_p( self.thisptr.portion(fr, to) )
+
+ def reverse(self):
+ """Return curve with reversed time."""
+ return wrap_Curve_p( self.thisptr.reverse() )
+
+ def derivative(self):
+ """Return curve's derivative."""
+ return wrap_Curve_p( self.thisptr.derivative() )
+
+ def nearest_time(self, cy_Point p, Coord fr=0, Coord to=1, cy_Interval interval=None):
+ """Return such t that |self(t) - point| is minimized."""
+ if interval is None:
+ return self.thisptr.nearestTime(deref( p.thisptr ), fr, to)
+ else:
+ return self.thisptr.nearestTime(deref( p.thisptr ), deref( interval.thisptr ))
+
+ def all_nearest_times(self, cy_Point p, Coord fr=0, Coord to=1, cy_Interval interval=None):
+ """Return all values of t that |self(t) - point| is minimized."""
+ if interval is None:
+ return wrap_vector_double(self.thisptr.allNearestTimes(deref( p.thisptr ), fr, to))
+ else:
+ return wrap_vector_double(self.thisptr.allNearestTimes(deref( p.thisptr ),
+ deref( interval.thisptr )))
+
+ def length(self, Coord tolerance):
+ """Return length of curve, within give tolerance."""
+ return self.thisptr.length(tolerance)
+
+ def roots(self, Coord v, Dim2 d):
+ """Find time values where self(t)[d] == v."""
+ return wrap_vector_double(self.thisptr.roots(v, d))
+
+ def winding(self, cy_Point p):
+ """Return winding number around specified point."""
+ return self.thisptr.winding(deref( p.thisptr ))
+
+ def unit_tangent_at(self, Coord t, unsigned int n):
+ """Return tangent at self(t).
+
+ Parameter n specifies how many derivatives to take into account."""
+ return wrap_Point(self.thisptr.unitTangentAt(t, n))
+
+ def to_SBasis(self):
+ """Return tuple of SBasis functions."""
+ cdef D2[SBasis] ret = self.thisptr.toSBasis()
+ return ( wrap_SBasis(ret[0]), wrap_SBasis(ret[1]) )
+
+ def degrees_of_freedom(self):
+ """Return number of independent parameters needed to specify the curve."""
+ return self.thisptr.degreesOfFreedom()
+#~ def operator==(self, cy_Curve c):
+#~ return deref( self.thisptr ) == deref( c.thisptr )
+
+#~ cdef cy_Curve wrap_Curve(Curve & p):
+#~ cdef Curve * retp = <Curve *> new SBasisCurve(D2[SBasis]( SBasis(), SBasis() ))
+#~ retp[0] = p
+#~ cdef cy_Curve r = cy_Curve.__new__(cy_Curve)
+#~ r.thisptr = retp
+#~ return r
+
+cdef cy_Curve wrap_Curve_p(Curve * p):
+ cdef cy_Curve r = cy_Curve.__new__(cy_Curve)
+ r.thisptr = p
+ return r
+
+cdef class cy_Linear:
+ """Function mapping linearly between two values.
+
+ Corresponds to Linear class in 2geom.
+ """
+
+ cdef Linear* thisptr
+
+ def __cinit__(self, aa = None, b = None):
+ """Create new Linear from two end values.
+
+ No arguments create zero constant, one value creates constant.
+ """
+ if aa is None:
+ self.thisptr = new Linear()
+ elif b is None:
+ self.thisptr = new Linear(float(aa))
+ else:
+ self.thisptr = new Linear(float(aa), float(b))
+
+ def __dealloc__(self):
+ del self.thisptr
+
+ def __call__(self, Coord t):
+ """Get value at time value t."""
+ return deref(self.thisptr)(t)
+
+ def __getitem__(self, i):
+ """Get end values."""
+ return deref( self.thisptr ) [i]
+
+ def __richcmp__(cy_Linear self, cy_Linear other, int op):
+ if op == 2:
+ return deref(self.thisptr) == deref(other.thisptr)
+ elif op == 3:
+ return deref(self.thisptr) != deref(other.thisptr)
+
+
+ def __neg__(cy_Linear self):
+ """Negate all values of self."""
+ return wrap_Linear( L_neg(deref(self.thisptr)) )
+
+
+ def __add__(cy_Linear self, other):
+ """Add number or other linear."""
+ if isinstance(other, Number):
+ return wrap_Linear( deref(self.thisptr) + float(other) )
+ elif isinstance(other, cy_Linear):
+ return wrap_Linear( deref(self.thisptr) + deref( (<cy_Linear> other).thisptr ) )
+
+ def __sub__(cy_Linear self, other):
+ """Substract number or other linear."""
+ if isinstance(other, Number):
+ return wrap_Linear( L_sub_Ld(deref(self.thisptr), float(other)) )
+ elif isinstance(other, cy_Linear):
+ return wrap_Linear( L_sub_LL(deref(self.thisptr), deref( (<cy_Linear> other).thisptr )) )
+
+
+ def __mul__(cy_Linear self, double b):
+ """Multiply linear by number."""
+ return wrap_Linear(deref( self.thisptr ) * b)
+
+ def __div__(cy_Linear self, double b):
+ """Divide linear by value."""
+ return wrap_Linear(deref( self.thisptr ) / b)
+
+ def is_zero(self, double eps = EPSILON):
+ """Test whether linear is zero within given tolerance."""
+ return self.thisptr.isZero(eps)
+
+ def is_constant(self, double eps = EPSILON):
+ """Test whether linear is constant within given tolerance."""
+ return self.thisptr.isConstant(eps)
+
+ def is_finite(self):
+ """Test whether linear is finite."""
+ return self.thisptr.isFinite()
+
+ def at0(self):
+ """Equivalent to self(0)."""
+ return self.thisptr.at0()
+
+ def at1(self):
+ """Equivalent to self(1)."""
+ return self.thisptr.at1()
+
+ def value_at(self, double t):
+ """Equivalent to self(t)."""
+ return self.thisptr.valueAt(t)
+
+ def to_SBasis(self):
+ """Convert to SBasis."""
+ return wrap_SBasis(self.thisptr.toSBasis())
+
+ def bounds_exact(self):
+ """Return exact bounding interval
+
+ This may take a while.
+ """
+ return wrap_OptInterval(self.thisptr.bounds_exact())
+
+ def bounds_fast(self):
+ """Return bounding interval
+
+ This method is fast, but does not guarantee to give smallest
+ interval.
+ """
+ return wrap_OptInterval(self.thisptr.bounds_fast())
+
+ def bounds_local(self, double u, double v):
+ """Return bounding interval to the portion of Linear."""
+ return wrap_OptInterval(self.thisptr.bounds_local(u, v))
+
+ def tri(self):
+ """Return difference between end values."""
+ return self.thisptr.tri()
+
+ def hat(self):
+ """Return value at (0.5)."""
+ return self.thisptr.hat()
+
+ @classmethod
+ def sin(cls, cy_Linear bo, int k):
+ """Return sine of linear."""
+ return wrap_SBasis(sin(deref( bo.thisptr ), k))
+
+ @classmethod
+ def cos(cls, cy_Linear bo, int k):
+ """Return cosine of linear."""
+ return wrap_SBasis(cos(deref( bo.thisptr ), k))
+
+ @classmethod
+ def reciprocal(cls, cy_Linear a, int k):
+ """Return reciprocical of linear."""
+ return wrap_SBasis(reciprocal(deref( a.thisptr ), k))
+
+ @classmethod
+ def shift(cls, cy_Linear a, int sh):
+ """Multiply by x**sh."""
+ return wrap_SBasis(shift(deref( a.thisptr ), sh))
+
+#leave these in cy2geom napespace?
+def cy_lerp(double t, double a, double b):
+ return lerp(t, a, b)
+
+cdef cy_Linear wrap_Linear(Linear p):
+ cdef Linear * retp = new Linear()
+ retp[0] = p
+ cdef cy_Linear r = cy_Linear.__new__(cy_Linear)
+ r.thisptr = retp
+ return r
+
+cdef vector[Linear] make_vector_linear(object l):
+ cdef vector[Linear] ret
+ for i in l:
+ ret.push_back( deref( (<cy_Linear> i).thisptr ) )
+ return ret
+
+
+cdef class cy_SBasis:
+
+ """Class representing SBasis polynomial.
+
+ Corresponds to SBasis class in 2geom."""
+
+ def __cinit__(self, a=None, b=None):
+ """Create new SBasis.
+
+ This constructor only creates linear SBasis, specifying endpoints.
+ """
+ if a is None:
+ self.thisptr = new SBasis()
+ elif b is None:
+ self.thisptr = new SBasis( float(a) )
+ else:
+ self.thisptr = new SBasis( float(a), float(b) )
+
+ def __dealloc__(self):
+ del self.thisptr
+
+ @classmethod
+ def from_linear(cls, cy_Linear l):
+ """Create SBasis from Linear."""
+ return wrap_SBasis( SBasis(deref( l.thisptr )) )
+
+ @classmethod
+ def from_linears(cls, lst):
+ """Create SBasis from list of Linears."""
+ return wrap_SBasis( SBasis( make_vector_linear(lst) ) )
+
+ def size(self):
+ """Return number of linears SBasis consists of."""
+ return self.thisptr.size()
+
+ def __call__(self, o):
+ """Get point at time value t."""
+ if isinstance(o, Number):
+ return deref(self.thisptr)(float(o))
+ elif isinstance(self, cy_SBasis):
+ return wrap_SBasis(deref(self.thisptr)( deref( (<cy_SBasis> o).thisptr ) ))
+
+ def __getitem__(self, unsigned int i):
+ """Get Linear at i th position."""
+ if i>=self.size():
+ raise IndexError
+ else:
+ return wrap_Linear(deref( self.thisptr ) [i])
+
+ def __neg__(self):
+ """Return SBasis with negated values."""
+ return wrap_SBasis( SB_neg(deref(self.thisptr)) )
+
+ #cython doesn't use __rmul__, it switches the arguments instead
+ def __add__(cy_SBasis self, other):
+ """Add number or other SBasis to SBasis."""
+ if isinstance(other, Number):
+ return wrap_SBasis( deref(self.thisptr) + float(other) )
+ elif isinstance(other, cy_SBasis):
+ return wrap_SBasis( deref(self.thisptr) + deref( (<cy_SBasis> other).thisptr ) )
+
+ def __sub__(cy_SBasis self, other):
+ """Substract number or other SBasis from SBasis."""
+ if isinstance(other, Number):
+ return wrap_SBasis( SB_sub_Sd(deref(self.thisptr), float(other) ) )
+ elif isinstance(other, cy_SBasis):
+ return wrap_SBasis( SB_sub_SS(deref(self.thisptr), deref( (<cy_SBasis> other).thisptr ) ) )
+
+ def __mul__(self, other):
+ """Multiply SBasis by number or other SBasis."""
+ if isinstance(other, Number):
+ return wrap_SBasis( deref( (<cy_SBasis> self).thisptr ) * float(other) )
+ elif isinstance(other, cy_SBasis):
+ if isinstance(self, cy_SBasis):
+ return wrap_SBasis( deref( (<cy_SBasis> self).thisptr ) * deref( (<cy_SBasis> other).thisptr ) )
+ elif isinstance(self, Number):
+ return wrap_SBasis( float(self) * deref( (<cy_SBasis> other).thisptr ) )
+
+ def __div__(cy_SBasis self, double other):
+ """Divide SBasis by number."""
+ return wrap_SBasis( deref(self.thisptr)/other )
+
+
+ def empty(self):
+ """Test whether SBasis has no linears."""
+ return self.thisptr.empty()
+
+ def back(self):
+ """Return last linear in SBasis."""
+ return wrap_Linear(self.thisptr.back())
+
+ def pop_back(self):
+ """Remove last linear in SBasis."""
+ self.thisptr.pop_back()
+
+ def resize(self, unsigned int n, cy_Linear l = None):
+ """Resize SBasis, optionally filling created slots with linear."""
+ if l is None:
+ self.thisptr.resize(n)
+ else:
+ self.thisptr.resize(n, deref( l.thisptr ))
+
+#~ def reserve(self, unsigned int n):
+#~ self.thisptr.reserve(n)
+
+ def clear(self):
+ """Make SBasis empty."""
+ self.thisptr.clear()
+#~ def insert(self, cy_::__gnu_cxx::__normal_iterator<Geom::Linear*, std::vector<Geom::Linear, std::allocator<Geom::Linear> > > before, cy_::__gnu_cxx::__normal_iterator<Geom::Linear const*, std::vector<Geom::Linear, std::allocator<Geom::Linear> > > src_begin, cy_::__gnu_cxx::__normal_iterator<Geom::Linear const*, std::vector<Geom::Linear, std::allocator<Geom::Linear> > > src_end):
+#~ self.thisptr.insert(deref( before.thisptr ), deref( src_begin.thisptr ), deref( src_end.thisptr ))
+
+ def at(self, unsigned int i):
+ """Equivalent to self[i]."""
+ return wrap_Linear(self.thisptr.at(i))
+
+ def __richcmp__(cy_SBasis self, cy_SBasis B, int op):
+ if op == 2:
+ return deref( self.thisptr ) == deref( B.thisptr )
+ elif op == 3:
+ return deref( self.thisptr ) != deref( B.thisptr )
+
+ def is_zero(self, double eps = EPSILON):
+ """Test whether linear is zero within given tolerance."""
+ return self.thisptr.isZero(eps)
+
+ def is_constant(self, double eps = EPSILON):
+ """Test whether linear is constant within given tolerance."""
+ return self.thisptr.isConstant(eps)
+
+ def is_finite(self):
+ """Test whether linear is finite."""
+ return self.thisptr.isFinite()
+
+ def at0(self):
+ """Equivalent to self(0)."""
+ return self.thisptr.at0()
+
+ def at1(self):
+ """Equivalent to self(1)."""
+ return self.thisptr.at1()
+
+ def degrees_of_freedom(self):
+ """Return number of independent parameters needed to specify the curve."""
+ return self.thisptr.degreesOfFreedom()
+
+ def value_at(self, double t):
+ """Equivalent to self(t)[d]."""
+ return self.thisptr.valueAt(t)
+
+ def value_and_derivatives(self, double t, unsigned int n):
+ """Return value and at least n derivatives at time t."""
+ return wrap_vector_double (self.thisptr.valueAndDerivatives(t, n))
+
+ def to_SBasis(self):
+ """Just return self."""
+ return wrap_SBasis(self.thisptr.toSBasis())
+
+ def tail_error(self, unsigned int tail):
+ """Return largest error after truncating linears from tail."""
+ return self.thisptr.tailError(tail)
+
+ def normalize(self):
+ """Remove zero linears at the end."""
+ self.thisptr.normalize()
+
+ def truncate(self, unsigned int k):
+ """Truncate SBasis to have k elements."""
+ self.thisptr.truncate(k)
+
+ @classmethod
+ def sqrt(cls, cy_SBasis a, int k):
+ """Return square root of SBasis.
+
+ Use k to specify degree of resulting SBasis.
+ """
+ return wrap_SBasis(sqrt(deref( a.thisptr ), k))
+
+ @classmethod
+ def inverse(cls, cy_SBasis a, int k):
+ """Return inverse function to SBasis.
+
+ Passed SBasis must be function [1-1] -> [1-1] bijection.
+ """
+ return wrap_SBasis(inverse(deref( a.thisptr ), k))
+
+ @classmethod
+ def valuation(cls, cy_SBasis a, double tol = 0):
+ """Return the degree of the first non zero coefficient."""
+ return valuation(deref( a.thisptr ), tol)
+
+ #call with level_set(SBasis(1, 5), 2, a = 0.2, b = 0.4, tol = 0.02)
+ @classmethod
+ def level_set(cls, cy_SBasis f, level, a = 0, b = 1, tol = 1e-5, vtol = 1e-5):
+ """Return intervals where SBasis is in specified level.
+
+ Specify range and tolerance in other arguments.
+ """
+ if isinstance(level, cy_Interval):
+ return wrap_vector_interval(level_set(deref( f.thisptr ), deref( (<cy_Interval> level).thisptr ), a, b, tol)) #a, b, tol
+ else:
+ return wrap_vector_interval(level_set(deref( f.thisptr ), float(level), vtol, a, b, tol)) #vtol, a, b, tol
+
+ @classmethod
+ def shift(cls, cy_SBasis a, int sh):
+ """Multiply by x**sh."""
+ return wrap_SBasis(shift(deref( a.thisptr ), sh))
+
+ @classmethod
+ def compose(cls, cy_SBasis a, cy_SBasis b, k = None):
+ """Compose two SBasis.
+
+ Specify order of resulting SBasis by parameter k.
+ """
+ if k is None:
+ return wrap_SBasis(compose(deref( a.thisptr ), deref( b.thisptr )))
+ else:
+ return wrap_SBasis(compose(deref( a.thisptr ), deref( b.thisptr ), int(k)))
+
+ @classmethod
+ def roots(cls, cy_SBasis s, cy_Interval inside = None):
+ """Return time values where self equals 0.
+
+ inside intervals specifies subset of domain.
+ """
+ if inside is None:
+ return wrap_vector_double(roots(deref( s.thisptr )))
+ else:
+ return wrap_vector_double(roots(deref( s.thisptr ), deref( inside.thisptr )))
+
+ @classmethod
+ def multi_roots(cls, cy_SBasis f, levels, double htol = 1e-7, double vtol = 1e-7, double a = 0, double b = 1):
+ """Return lists of roots for different levels."""
+ cdef vector[double] l = make_vector_double(levels)
+ cdef vector[ vector[double] ] r = multi_roots(deref( f.thisptr ), l, htol, vtol, a, b)
+ lst = []
+ for i in range(r.size()):
+ lst.append( wrap_vector_double(r[i]) )
+ return lst
+
+ @classmethod
+ def multiply_add(cls, cy_SBasis a, cy_SBasis b, cy_SBasis c):
+ """Return a*b+c."""
+ return wrap_SBasis(multiply_add(deref( a.thisptr ), deref( b.thisptr ), deref( c.thisptr )))
+
+ @classmethod
+ def divide(cls, cy_SBasis a, cy_SBasis b, int k):
+ """Divide two SBasis functions.
+
+ Use k to specify degree of resulting SBasis.
+ """
+ return wrap_SBasis(divide(deref( a.thisptr ), deref( b.thisptr ), k))
+
+ @classmethod
+ def compose_inverse(cls, cy_SBasis f, cy_SBasis g, unsigned int order, double tol):
+ """Compose f with g's inverse.
+
+ Requires g to be bijection g: [0, 1] -> [0, 1]
+ """
+ return wrap_SBasis(compose_inverse(deref( f.thisptr ), deref( g.thisptr ), order, tol))
+
+ @classmethod
+ def multiply(cls, cy_SBasis a, cy_SBasis b):
+ """Multiply two SBasis functions."""
+ return wrap_SBasis(multiply(deref( (<cy_SBasis> a).thisptr ), deref( (<cy_SBasis> b).thisptr )))
+
+ @classmethod
+ def derivative(cls, cy_SBasis a):
+ """Return derivative os SBasis."""
+ return wrap_SBasis(derivative(deref( (<cy_SBasis> a).thisptr )))
+
+ @classmethod
+ def integral(cls, a):
+ """Return integral of SBasis."""
+ return wrap_SBasis(integral(deref( (<cy_SBasis> a).thisptr )))
+
+ @classmethod
+ def portion(cls, cy_SBasis a, Coord fr=0, Coord to=1, cy_Interval interval=None):
+ """Return portion of SBasis, specified by endpoints or interval."""
+ if interval is None:
+ return wrap_SBasis( portion( deref( a.thisptr ), fr, to ) )
+ else:
+ return wrap_SBasis( portion( deref( a.thisptr ), deref( interval.thisptr ) ) )
+
+ @classmethod
+ def bounds_fast(cls, cy_SBasis a, int order = 0):
+ """Return bounding interval
+
+ This method is fast, but does not guarantee to give smallest
+ interval.
+ """
+ return wrap_OptInterval(bounds_fast(deref( a.thisptr ), order))
+
+ @classmethod
+ def bounds_exact(cls, cy_SBasis a):
+ """Return exact bounding interval
+
+ This may take a while.
+ """
+ return wrap_OptInterval(bounds_exact(deref( a.thisptr )))
+
+ @classmethod
+ def bounds_local(cls, cy_SBasis a, cy_OptInterval t, int order = 0):
+ """Return bounding interval to the portion of SBasis."""
+ return wrap_OptInterval(bounds_local(deref( a.thisptr ), deref( t.thisptr ), order))
+
+#~ def cy_level_sets(cy_SBasis f, vector[Interval] levels, double a, double b, double tol):
+#~ return wrap_::std::vector<std::vector<Geom::Interval, std::allocator<Geom::Interval> >,std::allocator<std::vector<Geom::Interval, std::allocator<Geom::Interval> > > >(level_sets(deref( f.thisptr ), deref( levels.thisptr ), a, b, tol))
+#~ def cy_level_sets(cy_SBasis f, vector[vector] levels, double a, double b, double vtol, double tol):
+#~ return wrap_::std::vector<std::vector<Geom::Interval, std::allocator<Geom::Interval> >,std::allocator<std::vector<Geom::Interval, std::allocator<Geom::Interval> > > >(level_sets(deref( f.thisptr ), deref( levels.thisptr ), a, b, vtol, tol))
+
+def cy_reverse(a):
+ if isinstance(a, cy_Linear):
+ return wrap_Linear( reverse(deref( (<cy_Linear> a).thisptr )))
+ elif isinstance(a, cy_SBasis):
+ return wrap_SBasis( reverse(deref( (<cy_SBasis> a).thisptr )))
+ elif isinstance(a, cy_Bezier):
+ return wrap_Bezier( reverse(deref( (<cy_Bezier> a).thisptr )))
+
+#already implemented
+#~ def cy_truncate(cy_SBasis a, unsigned int terms):
+#~ return wrap_SBasis(truncate(deref( a.thisptr ), terms))
+
+cdef cy_SBasis wrap_SBasis(SBasis p):
+ cdef SBasis * retp = new SBasis()
+ retp[0] = p
+ cdef cy_SBasis r = cy_SBasis.__new__(cy_SBasis, 0, 0)
+ r.thisptr = retp
+ return r
+
+
+cdef class cy_SBasisCurve:
+
+ """Curve mapping two SBasis functions to point (s1(t), s2(t)).
+
+ Corresponds to SBasisCurve in 2geom.
+ """
+
+ cdef SBasisCurve* thisptr
+
+#~ def __init__(self, cy_Curve other):
+#~ self.thisptr = self.thisptr.SBasisCurve(deref( other.thisptr ))
+
+ def __cinit__(self, cy_SBasis s1, cy_SBasis s2):
+ """Create new SBasisCurve from two SBasis functions."""
+ self.thisptr = new SBasisCurve( D2[SBasis](
+ deref( s1.thisptr ),
+ deref( s2.thisptr ) ) )
+
+ def __dealloc__(self):
+ del self.thisptr
+
+ def __call__(self, double t):
+ """Get point at time value t."""
+ return wrap_Point(deref(self.thisptr)(t))
+
+ def duplicate(self):
+ """Duplicate the curve."""
+ return wrap_SBasisCurve( <SBasisCurve> deref(self.thisptr.duplicate()) )
+
+ def initial_point(self):
+ """Get self(0)."""
+ return wrap_Point(self.thisptr.initialPoint())
+
+ def final_point(self):
+ """Get self(1)."""
+ return wrap_Point(self.thisptr.finalPoint())
+
+ def is_degenerate(self):
+ """Curve is degenerate if it's length is zero."""
+ return self.thisptr.isDegenerate()
+
+ def point_at(self, Coord t):
+ """Equivalent to self(t)."""
+ return wrap_Point(self.thisptr.pointAt(t))
+
+ def point_and_derivatives(self, Coord t, unsigned int n):
+ """Return point and at least first n derivatives at point t in list."""
+ return wrap_vector_point(self.thisptr.pointAndDerivatives(t, n))
+
+ def value_at(self, Coord t, Dim2 d):
+ """Equivalent to self(t)[d]."""
+ return self.thisptr.valueAt(t, d)
+
+ def set_initial(self, cy_Point v):
+ """Set initial point of curve."""
+ self.thisptr.setInitial(deref( v.thisptr ))
+
+ def set_final(self, cy_Point v):
+ """Set final point of curve."""
+ self.thisptr.setFinal(deref( v.thisptr ))
+
+ def bounds_fast(self):
+ """Return bounding rectangle for curve.
+
+ This method is fast, but does not guarantee to give smallest
+ rectangle.
+ """
+ return wrap_Rect(self.thisptr.boundsFast())
+
+ def bounds_exact(self):
+ """Return exact bounding rectangle for curve.
+
+ This may take a while.
+ """
+ return wrap_Rect(self.thisptr.boundsExact())
+
+ def bounds_local(self, cy_OptInterval i, unsigned int deg):
+ """Return bounding rectangle to portion of curve."""
+ return wrap_OptRect(self.thisptr.boundsLocal(deref( i.thisptr ), deg))
+
+ def roots(self, Coord v, Dim2 d):
+ """Find time values where self(t)[d] == v."""
+ return wrap_vector_double( self.thisptr.roots(v, d) )
+
+ def nearest_time(self, cy_Point p, Coord fr=0, Coord to=1, cy_Interval interval=None):
+ """Return such t that |self(t) - point| is minimized."""
+ if interval is None:
+ return self.thisptr.nearestTime(deref( p.thisptr ), fr, to)
+ else:
+ return (<Curve *> self.thisptr).nearestTime(deref( p.thisptr ), deref( interval.thisptr ) )
+
+ def all_nearest_times(self, cy_Point p, Coord fr=0, Coord to=1, cy_Interval interval=None):
+ """Return all values of t that |self(t) - point| is minimized."""
+ if interval is None:
+ return wrap_vector_double(self.thisptr.allNearestTimes(deref( p.thisptr ), fr, to))
+ else:
+ return wrap_vector_double((<Curve *> self.thisptr).allNearestTimes(deref( p.thisptr ),
+ deref( interval.thisptr ) ))
+
+ def length(self, Coord tolerance = 0.01):
+ """Return length of curve, within give tolerance."""
+ return self.thisptr.length(tolerance)
+
+
+ def portion(self, Coord fr=0, Coord to=1, cy_Interval interval=None):
+ """Return portion of curve, specified by endpoints or interval."""
+ if interval is None:
+ return wrap_SBasisCurve( <SBasisCurve> deref(self.thisptr.portion( fr, to ) ) )
+ else:
+ return wrap_SBasisCurve( <SBasisCurve>
+ deref( (<Curve *> self.thisptr).portion( deref( interval.thisptr ))) )
+
+ def transformed(self, t):
+ """Transform curve by affine transform."""
+ cdef Affine at
+ if is_transform(t):
+ at = get_Affine(t)
+ return wrap_SBasisCurve( <SBasisCurve> deref(self.thisptr.transformed( at )))
+
+ def reverse(self):
+ """Return curve with reversed time."""
+ return wrap_SBasisCurve( <SBasisCurve> deref( (<Curve *> self.thisptr).reverse() ) )
+
+ def derivative(self):
+ """Return curve's derivative."""
+ return wrap_SBasisCurve( <SBasisCurve> deref(self.thisptr.derivative()) )
+
+
+ def winding(self, cy_Point p):
+ """Return winding number around specified point."""
+ return (<Curve *> self.thisptr).winding(deref(p.thisptr))
+
+ def unit_tangent_at(self, Coord t, int n = 3):
+ """Return tangent at self(t).
+
+ Parameter n specifies how many derivatives to take into account."""
+ return wrap_Point((<Curve *> self.thisptr).unitTangentAt(t, n))
+
+ def to_SBasis(self):
+ """Return tuple containing it's SBasis functions."""
+ return wrap_D2_SBasis(self.thisptr.toSBasis())
+
+ def degrees_of_freedom(self):
+ """Return number of independent parameters needed to specify the curve."""
+ return self.thisptr.degreesOfFreedom()
+
+cdef object wrap_D2_SBasis(D2[SBasis] p):
+ return ( wrap_SBasis(p[0]), wrap_SBasis(p[1]) )
+
+cdef cy_SBasisCurve wrap_SBasisCurve(SBasisCurve p):
+ cdef SBasisCurve * retp = new SBasisCurve(D2[SBasis]( SBasis(), SBasis() ))
+ retp[0] = p
+ cdef cy_SBasisCurve r = cy_SBasisCurve.__new__(cy_SBasisCurve, cy_SBasis(), cy_SBasis())
+ r.thisptr = retp
+ return r
+
+
+cdef class cy_Bezier:
+
+ """Bezier polynomial.
+
+ Corresponds to Bezier class in 2geom.
+ """
+
+ cdef Bezier* thisptr
+
+ def __cinit__(self, *args):
+ """Create Bezier polynomial specifying it's coeffincients
+
+ This constructor takes up to four coefficients.
+ """
+ if len(args) == 0:
+ #new Bezier() causes segfault
+ self.thisptr = new Bezier(0)
+ elif len(args) == 1:
+ self.thisptr = new Bezier( float(args[0]) )
+ elif len(args) == 2:
+ self.thisptr = new Bezier( float(args[0]), float(args[1]) )
+ elif len(args) == 3:
+ self.thisptr = new Bezier( float(args[0]), float(args[1]), float(args[2]) )
+ elif len(args) == 4:
+ self.thisptr = new Bezier( float(args[0]), float(args[1]), float(args[2]), float(args[3]) )
+ else:
+ raise ValueError("Passed list has too many points")
+
+ def __dealloc__(self):
+ del self.thisptr
+
+ def __call__(self, double t):
+ """Get point at time value t."""
+ return deref( self.thisptr ) (t)
+
+
+ def __getitem__(self, unsigned int ix):
+ """Get coefficient by accessing list."""
+ if ix >= self.size():
+ raise IndexError
+ return deref( self.thisptr ) [ix]
+
+ def order(self):
+ """Return order of Bezier."""
+ return self.thisptr.order()
+
+ def size(self):
+ """Return number of coefficients."""
+ return self.thisptr.size()
+
+ def __mul__( cy_Bezier self, double v):
+ """Multiply Bezier by number."""
+ return wrap_Bezier(deref( self.thisptr ) * v)
+
+ def __add__( cy_Bezier self, double v):
+ """Add number to Bezier."""
+ return wrap_Bezier(deref( self.thisptr ) + v)
+
+ def __sub__( cy_Bezier self, double v):
+ """Substract number from Bezier."""
+ return wrap_Bezier(deref( self.thisptr ) - v)
+
+ def __div__( cy_Bezier self, double v):
+ """Divide Bezier number."""
+ return wrap_Bezier(deref( self.thisptr ) / v)
+
+
+ def resize(self, unsigned int n, Coord v):
+ """Change order of Bezier."""
+ self.thisptr.resize(n, v)
+
+ def clear(self):
+ """Create empty Bezier."""
+ self.thisptr.clear()
+
+ def degree(self):
+ """Return degree of Bezier polynomial."""
+ return self.thisptr.degree()
+
+ def is_zero(self, double eps = EPSILON):
+ """Test whether linear is zero within given tolerance."""
+ return self.thisptr.isZero(eps)
+
+ def is_constant(self, double eps = EPSILON):
+ """Test whether linear is constant within given tolerance."""
+ return self.thisptr.isConstant(eps)
+
+ def is_finite(self):
+ """Test whether linear is finite."""
+ return self.thisptr.isFinite()
+
+ def at0(self):
+ """Equivalent to self(0)."""
+ return self.thisptr.at0()
+
+ def at1(self):
+ """Equivalent to self(1)."""
+ return self.thisptr.at1()
+
+ def value_at(self, double t):
+ """Equivalent to self(t)."""
+ return self.thisptr.valueAt(t)
+
+ def to_SBasis(self):
+ """Convert to SBasis."""
+ return wrap_SBasis(self.thisptr.toSBasis())
+
+ def set_point(self, unsigned int ix, double val):
+ """Set self[ix] to val."""
+ self.thisptr.setPoint(ix, val)
+
+ def value_and_derivatives(self, Coord t, unsigned int n_derivs):
+ """Return value and at least n derivatives at time t."""
+ return wrap_vector_double(self.thisptr.valueAndDerivatives(t, n_derivs))
+
+ def subdivide(self, Coord t):
+ """Get two beziers, from 0 to t and from t to 1."""
+ cdef pair[Bezier, Bezier] p = self.thisptr.subdivide(t)
+ return ( wrap_Bezier(p.first), wrap_Bezier(p.second) )
+
+ def roots(self, cy_Interval ivl = None):
+ """Find time values where self(t)[d] == v."""
+ if ivl is None:
+ return wrap_vector_double(self.thisptr.roots())
+ else:
+ return wrap_vector_double(self.thisptr.roots(deref( ivl.thisptr )))
+
+ def forward_difference(self, unsigned int k):
+#TODO: ask someone what this function does.
+#~ """Compute forward difference of degree k.
+#~
+#~ First forward difference of B is roughly function B'(t) = B(t+h)-B(t)
+#~ for fixed step h"""
+ return wrap_Bezier(self.thisptr.forward_difference(k))
+
+ def elevate_degree(self):
+ """Increase degree of Bezier by 1."""
+ return wrap_Bezier(self.thisptr.elevate_degree())
+
+ def reduce_degree(self):
+ """Decrease degree of Bezier by 1."""
+ return wrap_Bezier(self.thisptr.reduce_degree())
+
+ def elevate_to_degree(self, unsigned int new_degree):
+ """Increase degree of Bezier to new_degree."""
+ return wrap_Bezier(self.thisptr.elevate_to_degree(new_degree))
+
+ def deflate(self):
+#TODO: ask someone what this function does.
+ #It looks like integral(self)*self.size()
+ return wrap_Bezier(self.thisptr.deflate())
+
+ @classmethod
+ def bezier_points(cls, cy_Bezier a, cy_Bezier b):
+ """Return control points of BezierCurve consisting of two beziers.
+
+ Passed bezier must have same degree."""
+ return wrap_vector_point(bezier_points( D2[Bezier]( deref(a.thisptr), deref(b.thisptr) ) ))
+
+ @classmethod
+ def multiply(cls, cy_Bezier a, cy_Bezier b):
+ """Multiply two Bezier functions."""
+ return wrap_Bezier(multiply(deref( (<cy_Bezier> a).thisptr ),
+ deref( (<cy_Bezier> b).thisptr )))
+
+ @classmethod
+ def portion(cls, cy_Bezier a, Coord fr=0, Coord to=1, interval=None):
+ """Return portion of bezier, specified by endpoints or interval."""
+ if interval is None:
+ return wrap_Bezier(portion(deref( a.thisptr ), fr, to))
+ else:
+ return wrap_Bezier(portion(deref( a.thisptr ), float(interval.min()),
+ float(interval.max()) ))
+
+ @classmethod
+ def derivative(cls, cy_Bezier a):
+ """Return derivative of a bezier."""
+ return wrap_Bezier(derivative(deref( a.thisptr )))
+
+ @classmethod
+ def integral(cls, cy_Bezier a):
+ """Return derivative of a bezier."""
+ return wrap_Bezier(integral(deref( a.thisptr )))
+
+ @classmethod
+ def bounds_fast(cls, cy_Bezier a):
+ """Return bounding interval
+
+ This method is fast, but does not guarantee to give smallest
+ interval.
+ """
+ return wrap_OptInterval(bounds_fast(deref( a.thisptr )))
+
+ @classmethod
+ def bounds_exact(cls, cy_Bezier a):
+ """Return exact bounding interval
+
+ This may take a while.
+ """
+ return wrap_OptInterval(bounds_exact(deref( a.thisptr )))
+
+ @classmethod
+ def bounds_local(cls, cy_Bezier a, cy_OptInterval t):
+ """Return bounding interval to the portion of bezier."""
+ return wrap_OptInterval(bounds_local(deref( a.thisptr ), deref( t.thisptr )))
+
+#This is the same as bz.to_SBasis()
+#~ def cy_bezier_to_sbasis(cy_SBasis sb, cy_Bezier bz):
+#~ bezier_to_sbasis(deref( sb.thisptr ), deref( bz.thisptr ))
+
+#These are look like internal functions.
+#~ def cy_casteljau_subdivision(Coord t, cy_Coord * v, cy_Coord * left, cy_Coord * right, unsigned int order):
+#~ return subdivideArr(t, v.thisptr, left.thisptr, right.thisptr, order)
+#~ def cy_bernsteinValueAt(double t, cy_double * c_, unsigned int n):
+#~ return bernsteinValueAt(t, c_.thisptr, n)
+
+cdef cy_Bezier wrap_Bezier(Bezier p):
+ cdef Bezier * retp = new Bezier()
+ retp[0] = p
+ cdef cy_Bezier r = cy_Bezier.__new__(cy_Bezier)
+ r.thisptr = retp
+ return r
+
+
+cdef class cy_BezierCurve:
+
+ """Bezier curve, consisting of two Bezier functions.
+
+ Corresponds to BezierCurve class in 2geom.
+ """
+
+ #This flag is due to this class children
+ def __cinit__(self, *args, **kwargs):
+ """Don't use this constructor, use create instead."""
+ pass
+
+ def __dealloc__(self):
+ del self.thisptr
+
+ def __call__(self, Coord t):
+ """Get point at time value t."""
+ return wrap_Point(deref( <Curve *> self.thisptr )(t))
+
+ def __getitem__(self, unsigned int ix):
+ """Get control point by list access."""
+ return wrap_Point(deref( self.thisptr ) [ix])
+
+ @classmethod
+ def create(cls, pts):
+ """Create new BezierCurve from control points."""
+ return wrap_BezierCurve( deref( create( make_vector_point(pts) ) ) )
+
+ def order(self):
+ """Get order of curve."""
+ return self.thisptr.order()
+
+ def control_points(self):
+ """Get control points."""
+ return wrap_vector_point(self.thisptr.controlPoints())
+
+ def set_point(self, unsigned int ix, cy_Point v):
+ """Set control point."""
+ self.thisptr.setPoint(ix, deref( v.thisptr ))
+
+ def set_points(self, ps):
+ """Set control points"""
+ self.thisptr.setPoints( make_vector_point(ps) )
+
+ def initial_point(self):
+ """Get self(0)."""
+ return wrap_Point(self.thisptr.initialPoint())
+
+ def final_point(self):
+ """Get self(1)."""
+ return wrap_Point(self.thisptr.finalPoint())
+
+ def is_degenerate(self):
+ """Curve is degenerate if it's length is zero."""
+ return self.thisptr.isDegenerate()
+
+ def set_initial(self, cy_Point v):
+ """Set initial point of curve."""
+ self.thisptr.setInitial(deref( v.thisptr ))
+
+ def set_final(self, cy_Point v):
+ """Set final point of curve."""
+ self.thisptr.setFinal(deref( v.thisptr ))
+
+ def bounds_fast(self):
+ """Return bounding rectangle for curve.
+
+ This method is fast, but does not guarantee to give smallest
+ rectangle.
+ """
+ return wrap_Rect(self.thisptr.boundsFast())
+
+ def bounds_exact(self):
+ """Return exact bounding rectangle for curve.
+
+ This may take a while.
+ """
+ return wrap_Rect(self.thisptr.boundsExact())
+
+ def bounds_local(cy_BezierCurve self, cy_OptInterval i, unsigned int deg):
+ """Return bounding rectangle to portion of curve."""
+ return wrap_OptRect(self.thisptr.boundsLocal(deref( i.thisptr ), deg))
+
+ def nearest_time(self, cy_Point p, Coord fr=0, Coord to=1, cy_Interval interval=None):
+ """Return such t that |self(t) - point| is minimized."""
+ if interval is None:
+ return (<Curve *> self.thisptr).nearestTime(deref( p.thisptr ), fr, to)
+ else:
+ return (<Curve *> self.thisptr).nearestTime(deref( p.thisptr ), deref( interval.thisptr ) )
+
+ def all_nearest_times(self, cy_Point p, Coord fr=0, Coord to=1, cy_Interval interval=None):
+ """Return all values of t that |self(t) - point| is minimized."""
+ if interval is None:
+ return wrap_vector_double((<Curve *> self.thisptr).allNearestTimes(deref( p.thisptr ), fr, to))
+ else:
+ return wrap_vector_double((<Curve *> self.thisptr).allNearestTimes(deref( p.thisptr ),
+ deref( interval.thisptr ) ))
+
+ def portion(self, Coord fr=0, Coord to=1, cy_Interval interval=None):
+ """Return portion of curve, specified by endpoints or interval."""
+ if interval is None:
+ return wrap_BezierCurve( <BezierCurve> deref(<BezierCurve *>
+ (<Curve *> self.thisptr).portion( fr, to )
+ ) )
+ else:
+ return wrap_BezierCurve( <BezierCurve> deref(<BezierCurve *>
+ (<Curve *> self.thisptr).portion(deref( interval.thisptr ))
+ ) )
+
+ def duplicate(self):
+ """Duplicate the curve."""
+ return wrap_BezierCurve( deref( <BezierCurve *> self.thisptr.duplicate()))
+
+ def reverse(self):
+ """Return curve with reversed time."""
+ return wrap_BezierCurve( deref( <BezierCurve *> self.thisptr.reverse()))
+
+ def transformed(self, t):
+ """Transform curve by affine transform."""
+ cdef Affine at
+ if is_transform(t):
+ at = get_Affine(t)
+ return wrap_BezierCurve( deref( <BezierCurve *> self.thisptr.transformed( at )))
+
+ def derivative(self):
+ """Return curve's derivative."""
+ return wrap_BezierCurve( deref( <BezierCurve *> self.thisptr.derivative()))
+
+ def degrees_of_freedom(self):
+ """Return number of independent parameters needed to specify the curve."""
+ return self.thisptr.degreesOfFreedom()
+
+ def roots(self, Coord v, Dim2 d):
+ """Find time values where self(t)[d] == v."""
+ return wrap_vector_double(self.thisptr.roots(v, d))
+
+ def length(self, Coord tolerance = 0.01):
+ """Return length of curve, within give tolerance."""
+ return self.thisptr.length(tolerance)
+
+ def point_at(self, Coord t):
+ """Equivalent to self(t)."""
+ return wrap_Point(self.thisptr.pointAt(t))
+
+ def point_and_derivatives(self, Coord t, unsigned int n):
+ """Return point and at least first n derivatives at point t in list."""
+ return wrap_vector_point(self.thisptr.pointAndDerivatives(t, n))
+
+ def value_at(self, Coord t, Dim2 d):
+ """Equivalent to self(t)[d]."""
+ return self.thisptr.valueAt(t, d)
+
+ def to_SBasis(self):
+ """Convert self to pair of SBasis functions."""
+ return wrap_D2_SBasis(self.thisptr.toSBasis())
+
+ def winding(self, cy_Point p):
+ """Return winding number around specified point."""
+ return (<Curve *> self.thisptr).winding(deref(p.thisptr))
+
+ def unit_tangent_at(self, Coord t, int n = 3):
+ """Return tangent at self(t).
+
+ Parameter n specifies how many derivatives to take into account."""
+ return wrap_Point((<Curve *> self.thisptr).unitTangentAt(t, n))
+
+cdef cy_BezierCurve wrap_BezierCurve(BezierCurve p):
+ cdef vector[Point] points = make_vector_point([cy_Point(), cy_Point()])
+ cdef BezierCurve * retp = create(p.controlPoints())
+ cdef cy_BezierCurve r = cy_BezierCurve.__new__(cy_BezierCurve, [cy_Point(), cy_Point()])
+ r.thisptr = retp
+ return r
+
+
+cdef class cy_LineSegment(cy_BezierCurve):
+
+ """Bezier curve with fixed order 1.
+
+ This class inherits from BezierCurve.
+
+ Corresponds to LineSegment in 2geom. BezierCurveN is not wrapped.
+ """
+
+ def __cinit__(self, cy_Point p0=None,
+ cy_Point p1=cy_Point()):
+ """Create new LineSegment from it's endpoints."""
+ if p0 is None:
+ self.thisptr = <BezierCurve *> new LineSegment()
+ else:
+ self.thisptr = <BezierCurve *> new LineSegment( deref(p0.thisptr),
+ deref(p1.thisptr))
+
+ @classmethod
+ def from_beziers(cls, cy_Bezier b0, cy_Bezier b1):
+ """Create LineSegment from two linear beziers."""
+ return wrap_LineSegment( LineSegment(deref(b0.thisptr), deref(b1.thisptr)) )
+
+ def subdivide(self, Coord t):
+ """Get two LineSegments, from 0 to t and from t to 1."""
+ cdef pair[LineSegment, LineSegment] p = (<LineSegment *> self.thisptr).subdivide(t)
+ return ( wrap_LineSegment(p.first), wrap_LineSegment(p.second) )
+
+ def duplicate(self):
+ """Duplicate the curve."""
+ return wrap_LineSegment( deref( <LineSegment *> self.thisptr.duplicate()))
+
+ def portion(self, double fr=0, double to=1, cy_Interval interval=None):
+ """Return portion of curve, specified by endpoints or interval."""
+ if interval is None:
+ return wrap_LineSegment( deref( <LineSegment *> self.thisptr.portion( fr, to ) ) )
+ else:
+ return wrap_LineSegment( deref( <LineSegment *>
+ (<Curve *> self.thisptr).portion( deref( interval.thisptr ))
+ ) )
+
+ def reverse(self):
+ """Return curve with reversed time."""
+ return wrap_LineSegment( deref( <LineSegment *> self.thisptr.reverse()))
+
+ def transformed(self, t):
+ """Transform curve by affine transform."""
+ cdef Affine at
+ if is_transform(t):
+ at = get_Affine(t)
+ return wrap_LineSegment( deref( <LineSegment *> self.thisptr.transformed( at )))
+
+ def derivative(self):
+ """Return curve's derivative."""
+ return wrap_LineSegment( deref( <LineSegment *> self.thisptr.derivative()))
+
+cdef cy_LineSegment wrap_LineSegment(LineSegment p):
+ cdef LineSegment * retp = new LineSegment()
+ retp[0] = p
+ cdef cy_LineSegment r = cy_LineSegment.__new__(cy_LineSegment)
+ r.thisptr = <BezierCurve* > retp
+ return r
+
+
+cdef class cy_QuadraticBezier(cy_BezierCurve):
+
+ """Bezier curve with fixed order 2.
+
+ This class inherits from BezierCurve.
+
+ Corresponds to QuadraticBezier in 2geom. BezierCurveN is not wrapped.
+ """
+
+ def __cinit__(self, cy_Point p0=None,
+ cy_Point p1=cy_Point(),
+ cy_Point p2=cy_Point()):
+ """Create new QuadraticBezier from three control points."""
+ if p0 is None:
+ self.thisptr = <BezierCurve *> new QuadraticBezier()
+ else:
+ self.thisptr = <BezierCurve *> new QuadraticBezier( deref( p0.thisptr ),
+ deref( p1.thisptr ),
+ deref( p2.thisptr ) )
+
+ @classmethod
+ def from_beziers(cls, cy_Bezier b0, cy_Bezier b1):
+ """Create QuadraticBezier from two quadratic bezier functions."""
+ return wrap_QuadraticBezier( QuadraticBezier(deref(b0.thisptr), deref(b1.thisptr)) )
+
+ def subdivide(self, Coord t):
+ """Get two QuadraticBeziers, from 0 to t and from t to 1."""
+ cdef pair[QuadraticBezier, QuadraticBezier] p = (<QuadraticBezier *> self.thisptr).subdivide(t)
+ return ( wrap_QuadraticBezier(p.first), wrap_QuadraticBezier(p.second) )
+
+ def duplicate(self):
+ """Duplicate the curve."""
+ return wrap_QuadraticBezier( deref( <QuadraticBezier *> self.thisptr.duplicate()))
+
+ def portion(self, double fr=0, double to=1, cy_Interval interval=None):
+ """Return portion of curve, specified by endpoints or interval."""
+ if interval is None:
+ return wrap_QuadraticBezier( deref( <QuadraticBezier *> self.thisptr.portion( fr, to ) ) )
+ else:
+ return wrap_QuadraticBezier( deref( <QuadraticBezier *>
+ (<Curve *> self.thisptr).portion( deref( interval.thisptr ))
+ ) )
+
+ def reverse(self):
+ """Return curve with reversed time."""
+ return wrap_QuadraticBezier( deref( <QuadraticBezier *> self.thisptr.reverse()))
+
+ def transformed(self, t):
+ """Transform curve by affine transform."""
+ cdef Affine at
+ if is_transform(t):
+ at = get_Affine(t)
+ return wrap_QuadraticBezier( deref( <QuadraticBezier *> self.thisptr.transformed( at )))
+
+ def derivative(self):
+ """Return curve's derivative."""
+ return wrap_LineSegment( deref( <LineSegment *> self.thisptr.derivative()))
+
+cdef cy_QuadraticBezier wrap_QuadraticBezier(QuadraticBezier p):
+ cdef QuadraticBezier * retp = new QuadraticBezier()
+ retp[0] = p
+ cdef cy_QuadraticBezier r = cy_QuadraticBezier.__new__(cy_QuadraticBezier)
+ r.thisptr = <BezierCurve* > retp
+ return r
+
+cdef class cy_CubicBezier(cy_BezierCurve):
+
+ """Bezier curve with fixed order 2.
+
+ This class inherits from BezierCurve.
+
+ Corresponds to QuadraticBezier in 2geom. BezierCurveN is not wrapped.
+ """
+
+ def __cinit__(self, cy_Point p0=None,
+ cy_Point p1=cy_Point(),
+ cy_Point p2=cy_Point(),
+ cy_Point p3=cy_Point()):
+ """Create new CubicBezier from four control points."""
+ if p0 is None:
+ self.thisptr = <BezierCurve *> new CubicBezier()
+ else:
+ self.thisptr = <BezierCurve *> new CubicBezier( deref( p0.thisptr ),
+ deref( p1.thisptr ),
+ deref( p2.thisptr ),
+ deref( p3.thisptr ) )
+
+ @classmethod
+ def from_beziers(cls, cy_Bezier b0, cy_Bezier b1):
+ """Create CubicBezier from two cubic bezier functions."""
+ return wrap_CubicBezier( CubicBezier(deref(b0.thisptr), deref(b1.thisptr)) )
+
+ def subdivide(self, Coord t):
+ """Get two CubicBeziers, from 0 to t and from t to 1."""
+ cdef pair[CubicBezier, CubicBezier] p = (<CubicBezier *> self.thisptr).subdivide(t)
+ return ( wrap_CubicBezier(p.first), wrap_CubicBezier(p.second) )
+
+ def duplicate(self):
+ """Duplicate the curve."""
+ return wrap_CubicBezier( deref( <CubicBezier *> self.thisptr.duplicate()))
+
+ def portion(self, double fr=0, double to=1, cy_Interval interval=None):
+ """Return portion of curve, specified by endpoints or interval."""
+ if interval is None:
+ return wrap_CubicBezier( deref( <CubicBezier *> self.thisptr.portion( fr, to ) ) )
+ else:
+ return wrap_CubicBezier( deref( <CubicBezier *>
+ (<Curve *> self.thisptr).portion( deref( interval.thisptr ))
+ ) )
+
+ def reverse(self):
+ """Return curve with reversed time."""
+ return wrap_CubicBezier( deref( <CubicBezier *> self.thisptr.reverse()))
+
+ def transformed(self, t):
+ """Transform curve by affine transform."""
+ cdef Affine at
+ if is_transform(t):
+ at = get_Affine(t)
+ return wrap_CubicBezier( deref( <CubicBezier *> self.thisptr.transformed( at )))
+
+ def derivative(self):
+ """Return curve's derivative."""
+ return wrap_QuadraticBezier( deref( <QuadraticBezier *> self.thisptr.derivative()))
+
+cdef cy_CubicBezier wrap_CubicBezier(CubicBezier p):
+ cdef CubicBezier * retp = new CubicBezier()
+ retp[0] = p
+ cdef cy_CubicBezier r = cy_CubicBezier.__new__(cy_CubicBezier)
+ r.thisptr = <BezierCurve* > retp
+ return r
+
+#~ cdef class cy_BezierCurveN(cy_BezierCurve):
+
+
+cdef class cy_HLineSegment(cy_LineSegment):
+
+ """Horizontal line segment.
+
+ This class corresponds to HLineSegment in 2geom.
+ """
+
+ def __cinit__(self, cy_Point p0=None, cy_Point p1=cy_Point()):
+ """Create HLineSegment from it's endpoints."""
+ if p0 is None:
+ self.thisptr = <BezierCurve *> new HLineSegment()
+ else:
+ self.thisptr = <BezierCurve *> new HLineSegment( deref( p0.thisptr ), deref( p1.thisptr ) )
+
+ @classmethod
+ def from_points(cls, cy_Point p0, cy_Point p1):
+ """Create HLineSegment from it's endpoints."""
+ return wrap_HLineSegment( HLineSegment( deref(p0.thisptr),
+ deref(p1.thisptr)) )
+
+ @classmethod
+ def from_point_length(cls, cy_Point p, Coord length):
+ return wrap_HLineSegment( HLineSegment( deref( p.thisptr ), length ) )
+
+ def set_initial(self, cy_Point p):
+ """Set initial point of curve."""
+ (<AxisLineSegment_X *> self.thisptr).setInitial( deref(p.thisptr) )
+
+ def set_final(self, cy_Point p):
+ """Set final point of curve."""
+ (<AxisLineSegment_X *> self.thisptr).setFinal( deref(p.thisptr) )
+
+ def bounds_fast(self):
+ """Return bounding rectangle for curve.
+
+ This method is fast, but does not guarantee to give smallest
+ rectangle.
+ """
+ return wrap_Rect( (<AxisLineSegment_X *> self.thisptr).boundsFast() )
+
+ def bounds_exact(self):
+ """Return exact bounding rectangle for curve.
+
+ This may take a while.
+ """
+ return wrap_Rect( (<AxisLineSegment_X *> self.thisptr).boundsExact() )
+
+ def degrees_of_freedom(self):
+ """Return number of independent parameters needed to specify the curve."""
+ return (<AxisLineSegment_X *> self.thisptr).degreesOfFreedom()
+
+ def roots(self, Coord v, Dim2 d):
+ """Find time values where self(t)[d] == v."""
+ return wrap_vector_double( (<AxisLineSegment_X *> self.thisptr).roots(v, d) )
+
+ def nearest_time(self, cy_Point p, Coord fr=0, Coord to=1, cy_Interval interval=None):
+ """Return such t that |self(t) - point| is minimized."""
+ if interval is None:
+ return (<AxisLineSegment_X *> self.thisptr).nearestTime(deref( p.thisptr ), fr, to)
+ else:
+ return (<Curve *> self.thisptr).nearestTime(deref( p.thisptr ),
+ deref( ( interval.thisptr ) ) )
+
+ def point_at(self, Coord t):
+ """Equivalent to self(t)."""
+ return wrap_Point((<AxisLineSegment_X *> self.thisptr).pointAt(t))
+
+ def value_at(self, Coord t, Dim2 d):
+ """Equivalent to self(t)[d]."""
+ return (<AxisLineSegment_X *> self.thisptr).valueAt(t, d)
+
+ def point_and_derivatives(self, Coord t, unsigned n):
+ """Return point and at least first n derivatives at point t in list."""
+ return wrap_vector_point( (<AxisLineSegment_X *> self.thisptr).pointAndDerivatives(t, n) )
+
+ def get_Y(self):
+ """Get distance of self from y-axis."""
+ return (<HLineSegment *> self.thisptr).getY()
+
+ def set_initial_X(self, Coord x):
+ """Set initial point's X coordinate."""
+ (<HLineSegment *> self.thisptr).setInitialX(x)
+
+ def set_final_X(self, Coord x):
+ """Set final point's X coordinate."""
+ (<HLineSegment *> self.thisptr).setFinalX(x)
+
+ def set_Y(self, Coord y):
+ """Set Y coordinate of points."""
+ (<HLineSegment *> self.thisptr).setY(y)
+
+ def subdivide(self, Coord t):
+ """Return two HLineSegments subdivided at t."""
+ cdef pair[HLineSegment, HLineSegment] p = (<HLineSegment *> self.thisptr).subdivide(t)
+ return (wrap_HLineSegment(p.first), wrap_HLineSegment(p.second))
+
+ def duplicate(self):
+ """Duplicate the curve."""
+ return wrap_HLineSegment( deref(<HLineSegment *> self.thisptr.duplicate()) )
+
+ def portion(self, Coord fr=0, Coord to=1, cy_Interval interval=None):
+ """Return portion of curve, specified by endpoints or interval."""
+ if interval is None:
+ return wrap_HLineSegment( deref( <HLineSegment *> self.thisptr.portion( fr, to ) ) )
+ else:
+ return wrap_HLineSegment( deref( <HLineSegment *>
+ (<Curve *> self.thisptr).portion( deref( interval.thisptr ) )
+ ) )
+
+ def reverse(self):
+ """Return curve with reversed time."""
+ return wrap_HLineSegment( deref(<HLineSegment *> self.thisptr.reverse()) )
+
+ def transformed(self, t):
+ """Transform curve by affine transform."""
+ cdef Affine at
+ if is_transform(t):
+ at = get_Affine(t)
+ return wrap_LineSegment( deref(<LineSegment *> self.thisptr.transformed( at )) )
+
+ def derivative(self):
+ """Return curve's derivative."""
+ return wrap_HLineSegment( deref(<HLineSegment *> self.thisptr.derivative()) )
+
+cdef cy_HLineSegment wrap_HLineSegment(HLineSegment p):
+ cdef HLineSegment * retp = new HLineSegment()
+ retp[0] = p
+ cdef cy_HLineSegment r = cy_HLineSegment.__new__(cy_HLineSegment)
+ r.thisptr = <BezierCurve *> retp
+ return r
+
+cdef class cy_VLineSegment(cy_LineSegment):
+
+ """Vertical line segment.
+
+ This class corresponds to HLineSegment in 2geom.
+ """
+
+ def __cinit__(self, cy_Point p0=None, cy_Point p1=cy_Point()):
+ """Create VLineSegment from it's endpoints."""
+ if p0 is None:
+ self.thisptr = <BezierCurve *> new VLineSegment()
+ else:
+ self.thisptr = <BezierCurve *> new VLineSegment( deref( p0.thisptr ), deref( p1.thisptr ) )
+
+ @classmethod
+ def from_points(cls, cy_Point p0, cy_Point p1):
+ """Create VLineSegment from it's endpoints."""
+ return wrap_VLineSegment( VLineSegment( deref(p0.thisptr),
+ deref(p1.thisptr)) )
+
+ @classmethod
+ def from_point_length(cls, cy_Point p, Coord length):
+ return wrap_VLineSegment( VLineSegment( deref( p.thisptr ), length ) )
+
+ def set_initial(self, cy_Point p):
+ """Set initial point of curve."""
+ (<AxisLineSegment_Y *> self.thisptr).setInitial( deref(p.thisptr) )
+
+ def set_final(self, cy_Point p):
+ """Set final point of curve."""
+ (<AxisLineSegment_Y *> self.thisptr).setFinal( deref(p.thisptr) )
+
+ def bounds_fast(self):
+ """Return bounding rectangle for curve.
+
+ This method is fast, but does not guarantee to give smallest
+ rectangle.
+ """
+ return wrap_Rect( (<AxisLineSegment_Y *> self.thisptr).boundsFast() )
+
+ def bounds_exact(self):
+ """Return exact bounding rectangle for curve.
+
+ This may take a while.
+ """
+ return wrap_Rect( (<AxisLineSegment_Y *> self.thisptr).boundsExact() )
+
+ def degrees_of_freedom(self):
+ """Return number of independent parameters needed to specify the curve."""
+ return (<AxisLineSegment_Y *> self.thisptr).degreesOfFreedom()
+
+ def roots(self, Coord v, Dim2 d):
+ """Find time values where self(t)[d] == v."""
+ return wrap_vector_double( (<AxisLineSegment_Y *> self.thisptr).roots(v, d) )
+
+ def nearest_time(self, cy_Point p, Coord fr=0, Coord to=1, cy_Interval interval=None):
+ """Return such t that |self(t) - point| is minimized."""
+ if interval is None:
+ return (<AxisLineSegment_Y *> self.thisptr).nearestTime(deref( p.thisptr ), fr, to)
+ else:
+ return (<Curve *> self.thisptr).nearestTime(deref( p.thisptr ),
+ deref( ( interval.thisptr ) ) )
+
+ def point_at(self, Coord t):
+ """Equivalent to self(t)."""
+ return wrap_Point((<AxisLineSegment_Y *> self.thisptr).pointAt(t))
+
+ def value_at(self, Coord t, Dim2 d):
+ """Equivalent to self(t)[d]."""
+ return (<AxisLineSegment_Y *> self.thisptr).valueAt(t, d)
+
+ def point_and_derivatives(self, Coord t, unsigned n):
+ """Return point and at least first n derivatives at point t in list."""
+ return wrap_vector_point( (<AxisLineSegment_Y *> self.thisptr).pointAndDerivatives(t, n) )
+
+ def get_X(self):
+ return (<VLineSegment *> self.thisptr).getX()
+
+ def set_initial_Y(self, Coord y):
+ (<VLineSegment *> self.thisptr).setInitialY(y)
+
+ def set_final_Y(self, Coord y):
+ (<VLineSegment *> self.thisptr).setFinalY(y)
+
+ def set_X(self, Coord x):
+ (<VLineSegment *> self.thisptr).setX(x)
+
+ def subdivide(self, Coord t):
+ """Return two HLineSegments subdivided at t."""
+ cdef pair[VLineSegment, VLineSegment] p = (<VLineSegment *> self.thisptr).subdivide(t)
+ return (wrap_VLineSegment(p.first), wrap_VLineSegment(p.second))
+
+ def duplicate(self):
+ """Duplicate the curve."""
+ return wrap_VLineSegment( deref(<VLineSegment *> self.thisptr.duplicate()) )
+
+ def portion(self, Coord fr=0, Coord to=1, cy_Interval interval=None):
+ """Return portion of curve, specified by endpoints or interval."""
+ if interval is None:
+ return wrap_VLineSegment( deref( <VLineSegment *> self.thisptr.portion( fr, to ) ) )
+ else:
+ return wrap_VLineSegment( deref( <VLineSegment *>
+ (<Curve *> self.thisptr).portion( deref( interval.thisptr ) )
+ ) )
+
+ def reverse(self):
+ """Return curve with reversed time."""
+ return wrap_VLineSegment( deref(<VLineSegment *> self.thisptr.reverse()) )
+
+ def transformed(self, t):
+ """Transform curve by affine transform."""
+ cdef Affine at
+ if is_transform(t):
+ at = get_Affine(t)
+ return wrap_LineSegment( deref(<LineSegment *> self.thisptr.transformed( at )) )
+
+ def derivative(self):
+ """Return curve's derivative."""
+ return wrap_VLineSegment( deref(<VLineSegment *> self.thisptr.derivative()) )
+
+cdef cy_VLineSegment wrap_VLineSegment(VLineSegment p):
+ cdef VLineSegment * retp = new VLineSegment()
+ retp[0] = p
+ cdef cy_VLineSegment r = cy_VLineSegment.__new__(cy_VLineSegment)
+ r.thisptr = <BezierCurve *> retp
+ return r
+
+cdef class cy_EllipticalArc:
+
+ """Elliptical arc.
+
+ Corresponds to EllipticalArc class in 2geom.
+ """
+
+ def __cinit__(self, cy_Point ip = cy_Point(0, 0),
+ Coord rx = 0,
+ Coord ry = 0,
+ Coord rot_angle = 0,
+ bint large_arc = True,
+ bint sweep = True,
+ cy_Point fp = cy_Point(0, 0)):
+ """Create Elliptical arc from it's major axis and rays."""
+ self.thisptr = new EllipticalArc(deref( ip.thisptr ), rx, ry, rot_angle, large_arc, sweep, deref( fp.thisptr ))
+
+ def __dealloc__(self):
+ del self.thisptr
+
+ def __call__(self, Coord t):
+ """Get point at time value t."""
+ return wrap_Point( deref(<Curve *> self.thisptr)(t) )
+ #Curve methods
+
+ def length(self, Coord tolerance = 0.01):
+ """Return length of curve, within give tolerance."""
+ return (<Curve *> self.thisptr).length(tolerance)
+
+ #AngleInterval methods
+
+ def initial_angle(self):
+ """Get initial Angle of arc."""
+ return wrap_Angle((<AngleInterval *> self.thisptr).initialAngle())
+
+ def final_angle(self):
+ """Get final Angle of arc."""
+ return wrap_Angle((<AngleInterval *> self.thisptr).finalAngle())
+
+ def angle_at(self, Coord t):
+ """Get Angle from time value."""
+ return wrap_Angle((<AngleInterval *> self.thisptr).angleAt(t))
+
+ def contains(self, cy_Angle a):
+ """Test whether arc contains angle."""
+ return (<AngleInterval *> self.thisptr).contains(deref( a.thisptr ))
+
+ def extent(self):
+ """Get extent of angle interval."""
+ return (<AngleInterval *> self.thisptr).extent()
+
+ def angle_interval(self):
+ """Get underlying angle Interval."""
+ return wrap_Interval(self.thisptr.angleInterval())
+
+ def rotation_angle(self):
+ """Return rotation angle of major axis."""
+ return wrap_Angle(self.thisptr.rotationAngle())
+
+ def ray(self, Dim2 d):
+ """Access rays with X or Y."""
+ return self.thisptr.ray(d)
+
+ def rays(self):
+ """Get rays as a point."""
+ return wrap_Point(self.thisptr.rays())
+
+ def large_arc(self):
+ """Check if large arc flag is set."""
+ return self.thisptr.largeArc()
+
+ def sweep(self):
+ """Check if sweep flag is set."""
+ return self.thisptr.sweep()
+
+ def chord(self):
+ """Return chord of arc."""
+ return wrap_LineSegment(self.thisptr.chord())
+
+ def set(self, cy_Point ip, double rx, double ry, double rot_angle, bint large_arc, bint sweep, cy_Point fp):
+ """Set arc's properties."""
+ self.thisptr.set(deref( ip.thisptr ), rx, ry, rot_angle, large_arc, sweep, deref( fp.thisptr ))
+
+ def set_extremes(self, cy_Point ip, cy_Point fp):
+ """Set endpoints of arc."""
+ self.thisptr.setExtremes(deref( ip.thisptr ), deref( fp.thisptr ))
+
+ def center(self, coordinate=None):
+ """Return center of ellipse, or it's coordinate."""
+ if coordinate is None:
+ return wrap_Point(self.thisptr.center())
+ else:
+ return self.thisptr.center(int(coordinate))
+
+ def sweep_angle(self):
+ """Equivalent to self.extent()"""
+ return self.thisptr.sweepAngle()
+
+ def contains_angle(self, Coord angle):
+ """Test whether arc contains angle.
+
+ Equivalent to self.contains(Angle(a))
+ """
+ return self.thisptr.containsAngle(angle)
+
+ def point_at_angle(self, Coord a):
+ """Get point of arc at specified angle."""
+ return wrap_Point(self.thisptr.pointAtAngle(a))
+
+ def value_at_angle(self, Coord a, Dim2 d):
+ """Equivalent to self.point_at_angle(a)[d]"""
+ return self.thisptr.valueAtAngle(a, d)
+
+ def unit_circle_transform(self):
+ """Get Affine transform needed to transform unit circle to ellipse."""
+ return wrap_Affine(self.thisptr.unitCircleTransform())
+
+ def is_SVG_compliant(self):
+ """Check whether arc is SVG compliant
+
+ SVG has special specification for degenerated ellipse."""
+ return self.thisptr.isSVGCompliant()
+
+ def subdivide(self, Coord t):
+ """Return two arcs, subdivided at time t."""
+ cdef pair[EllipticalArc, EllipticalArc] r = self.thisptr.subdivide(t)
+ return (wrap_EllipticalArc(r.first), wrap_EllipticalArc(r.second))
+
+ def initial_point(self):
+ """Get self(0)."""
+ return wrap_Point(self.thisptr.initialPoint())
+
+ def final_point(self):
+ """Get self(1)."""
+ return wrap_Point(self.thisptr.finalPoint())
+
+ def duplicate(self):
+ """Duplicate the curve."""
+ return wrap_EllipticalArc( deref(<EllipticalArc *> self.thisptr.duplicate()) )
+
+ def set_initial(self, cy_Point p):
+ """Set initial point of curve."""
+ self.thisptr.setInitial(deref( p.thisptr ))
+
+ def set_final(self, cy_Point p):
+ """Set final point of curve."""
+ self.thisptr.setFinal(deref( p.thisptr ))
+
+ def is_degenerate(self):
+ """Curve is degenerate if its length is zero."""
+ return self.thisptr.isDegenerate()
+
+ def bounds_fast(self):
+ """Return bounding rectangle for curve.
+
+ This method is fast, but does not guarantee to give smallest
+ rectangle.
+ """
+ return wrap_Rect(self.thisptr.boundsFast())
+
+ def bounds_exact(self):
+ """Return exact bounding rectangle for curve.
+
+ This may take a while.
+ """
+ return wrap_Rect(self.thisptr.boundsExact())
+
+ def bounds_local(self, cy_OptInterval i, unsigned int deg):
+ """Return bounding rectangle to portion of curve."""
+ return wrap_OptRect(self.thisptr.boundsLocal(deref( i.thisptr ), deg))
+
+ def roots(self, double v, Dim2 d):
+ """Find time values where self(t)[d] == v."""
+ return wrap_vector_double(self.thisptr.roots(v, d))
+
+ def nearest_time(self, cy_Point p, Coord fr=0, Coord to=1, cy_Interval interval=None):
+ """Return such t that |self(t) - point| is minimized."""
+ if interval is None:
+ return self.thisptr.nearestTime(deref( p.thisptr ), fr, to)
+ else:
+ return (<Curve *> self.thisptr).nearestTime(deref( p.thisptr ),
+ deref( interval.thisptr ) )
+
+ def all_nearest_times(self, cy_Point p, Coord fr=0, Coord to=1, cy_Interval interval=None):
+ """Return all values of t that |self(t) - point| is minimized."""
+ if interval is None:
+ return wrap_vector_double( (<Curve *> self.thisptr).allNearestTimes(deref( p.thisptr ), fr, to))
+ else:
+ return wrap_vector_double( (<Curve *> self.thisptr).allNearestTimes(deref( p.thisptr ), deref( interval.thisptr ) ))
+
+ def degrees_of_freedom(self):
+ """Return number of independent parameters needed to specify the curve."""
+ return self.thisptr.degreesOfFreedom()
+
+ def derivative(self):
+ """Return curve's derivative."""
+ return wrap_EllipticalArc( deref(<EllipticalArc *> self.thisptr.derivative()) )
+
+ def transformed(self, cy_Affine m):
+ """Transform curve by affine transform."""
+ return wrap_EllipticalArc( deref(<EllipticalArc *> self.thisptr.transformed(deref( m.thisptr ))) )
+
+ def point_and_derivatives(self, Coord t, unsigned int n):
+ """Return point and at least first n derivatives at point t in list."""
+ return wrap_vector_point(self.thisptr.pointAndDerivatives(t, n))
+
+ def to_SBasis(self):
+ """Convert to pair of SBasis polynomials."""
+ cdef D2[SBasis] r = self.thisptr.toSBasis()
+ return ( wrap_SBasis(r[0]), wrap_SBasis(r[1]) )
+
+ def value_at(self, Coord t, Dim2 d):
+ """Equivalent to self(t)[d]."""
+ return self.thisptr.valueAt(t, d)
+
+ def point_at(self, Coord t):
+ """Equivalent to self(t)."""
+ return wrap_Point(self.thisptr.pointAt(t))
+
+
+ def portion(self, Coord fr=0, Coord to=1, cy_Interval interval=None):
+ """Return portion of curve, specified by endpoints or interval."""
+ if interval is None:
+ return wrap_EllipticalArc( deref( <EllipticalArc *> self.thisptr.portion( fr, to ) ) )
+ else:
+ return wrap_EllipticalArc( deref( <EllipticalArc *> (<Curve *> self.thisptr).portion( deref( interval.thisptr ) ) ) )
+
+ def reverse(self):
+ """Return curve with reversed time."""
+ return wrap_EllipticalArc( deref(<EllipticalArc *> self.thisptr.reverse()) )
+
+ def winding(self, cy_Point p):
+ """Return winding number around specified point."""
+ return (<Curve *> self.thisptr).winding(deref(p.thisptr))
+
+ def unit_tangent_at(self, Coord t, int n = 3):
+ """Return tangent at self(t).
+
+ Parameter n specifies how many derivatives to take into account."""
+ return wrap_Point((<Curve *> self.thisptr).unitTangentAt(t, n))
+
+cdef cy_EllipticalArc wrap_EllipticalArc(EllipticalArc p):
+ cdef EllipticalArc * retp = new EllipticalArc()
+ retp[0] = p
+ cdef cy_EllipticalArc r = cy_EllipticalArc.__new__(cy_EllipticalArc)
+ r.thisptr = retp
+ return r
+
+#TODO move somewhere else
+
+cdef object wrap_vector_interval(vector[Interval] v):
+ r = []
+ cdef unsigned int i
+ for i in range(v.size()):
+ r.append( wrap_Interval(v[i]))
+ return r
+
+
+cdef bint is_Curve(object c):
+ return any([
+ isinstance(c, cy_Curve),
+ isinstance(c, cy_SBasisCurve),
+ isinstance(c, cy_BezierCurve),
+ isinstance(c, cy_EllipticalArc)])
+
+cdef Curve * get_Curve_p(object c):
+ if isinstance(c, cy_Curve):
+ return (<cy_Curve> c).thisptr
+ elif isinstance(c, cy_SBasisCurve):
+ return <Curve *> (<cy_SBasisCurve> c).thisptr
+ elif isinstance(c, cy_BezierCurve):
+ return <Curve *> (<cy_BezierCurve> c).thisptr
+ elif isinstance(c, cy_EllipticalArc):
+ return <Curve *> (<cy_EllipticalArc> c).thisptr
+ return NULL
+
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-21 11:40:32 +0000