+
+ /**
+ * Construct absolute control points using relative control points to a bounding rectangle
+ * ie: If cpy is relative to bounds rectangle, this will be absolute
+ */
+ Bezier(const Bezier & cpy, const Rect & t = Rect(0,0,1,1)) : x0(cpy.x0), y0(cpy.y0), x1(cpy.x1), y1(cpy.y1), x2(cpy.x2),y2(cpy.y2), x3(cpy.x3), y3(cpy.y3), type(cpy.type)
+ {
+ x0 *= t.w;
+ y0 *= t.h;
+ x1 *= t.w;
+ y1 *= t.h;
+ x2 *= t.w;
+ y2 *= t.h;
+ x3 *= t.w;
+ y3 *= t.h;
+ x0 += t.x;
+ y0 += t.y;
+ x1 += t.x;
+ y1 += t.y;
+ x2 += t.x;
+ y2 += t.y;
+ x3 += t.x;
+ y3 += t.y;
+ }
+
+ Rect SolveBounds() const;
+
+ std::pair<Real,Real> GetTop() const;
+ std::pair<Real,Real> GetBottom() const;
+ std::pair<Real,Real> GetLeft() const;
+ std::pair<Real,Real> GetRight() const;
+
+ Bezier ToAbsolute(const Rect & bounds) const
+ {
+ return Bezier(*this, bounds);
+ }
+
+ /** Convert absolute control points to control points relative to bounds
+ * (This basically does the opposite of the Copy constructor)
+ * ie: If this is absolute, the returned Bezier will be relative to the bounds rectangle
+ */
+ Bezier ToRelative(const Rect & bounds) const
+ {
+ // x' <- (x - x0)/w etc
+ // special cases when w or h = 0
+ // (So can't just use the Copy constructor on the inverse of bounds)
+ // Rect inverse = {-bounds.x/bounds.w, -bounds.y/bounds.h, Real(1)/bounds.w, Real(1)/bounds.h};
+ Bezier result;
+ if (bounds.w == 0)
+ {
+ result.x0 = 0;
+ result.x1 = 0;
+ result.x2 = 0;
+ result.x3 = 0;
+ }
+ else
+ {
+ result.x0 = (x0 - bounds.x)/bounds.w;
+ result.x1 = (x1 - bounds.x)/bounds.w;
+ result.x2 = (x2 - bounds.x)/bounds.w;
+ result.x3 = (x3 - bounds.x)/bounds.w;
+ }
+
+ if (bounds.h == 0)
+ {
+ result.y0 = 0;
+ result.y1 = 0;
+ result.y2 = 0;
+ result.y3 = 0;
+ }
+ else
+ {
+ result.y0 = (y0 - bounds.y)/bounds.h;
+ result.y1 = (y1 - bounds.y)/bounds.h;
+ result.y2 = (y2 - bounds.y)/bounds.h;
+ result.y3 = (y3 - bounds.y)/bounds.h;
+ }
+ return result;
+ }
+
+ // Performs one round of De Casteljau subdivision and returns the [t,1] part.
+ Bezier DeCasteljauSubdivideRight(const Real& t)
+ {
+ Real one_minus_t = Real(1) - t;
+
+ // X Coordinates
+ Real x01 = x0*t + x1*one_minus_t;
+ Real x12 = x1*t + x2*one_minus_t;
+ Real x23 = x2*t + x3*one_minus_t;
+
+ Real x012 = x01*t + x12*one_minus_t;
+ Real x123 = x12*t + x23*one_minus_t;
+
+ Real x0123 = x012*t + x123*one_minus_t;
+
+ // Y Coordinates
+ Real y01 = y0*t + y1*one_minus_t;
+ Real y12 = y1*t + y2*one_minus_t;
+ Real y23 = y2*t + y3*one_minus_t;
+
+ Real y012 = y01*t + y12*one_minus_t;
+ Real y123 = y12*t + y23*one_minus_t;
+
+ Real y0123 = y012*t + y123*one_minus_t;
+
+ return Bezier(x0, y0, x01, y01, x012, y012, x0123, y0123);
+ }
+ // Performs one round of De Casteljau subdivision and returns the [0,t] part.
+ Bezier DeCasteljauSubdivideLeft(const Real& t)
+ {
+ Real one_minus_t = Real(1) - t;
+
+ // X Coordinates
+ Real x01 = x0*t + x1*one_minus_t;
+ Real x12 = x1*t + x2*one_minus_t;
+ Real x23 = x2*t + x3*one_minus_t;
+
+ Real x012 = x01*t + x12*one_minus_t;
+ Real x123 = x12*t + x23*one_minus_t;
+
+ Real x0123 = x012*t + x123*one_minus_t;
+
+ // Y Coordinates
+ Real y01 = y0*t + y1*one_minus_t;
+ Real y12 = y1*t + y2*one_minus_t;
+ Real y23 = y2*t + y3*one_minus_t;
+
+ Real y012 = y01*t + y12*one_minus_t;
+ Real y123 = y12*t + y23*one_minus_t;
+
+ Real y0123 = y012*t + y123*one_minus_t;
+
+ return Bezier(x0123, y0123, x123, y123, x23, y23, x3, y3);
+ }
+
+ Bezier ReParametrise(const Real& t0, const Real& t1)