Fix PistonDevelopers#199 - properly iterate through contours starting with off-curve point

Author: rbrich

src/outline.rs

@@ -46,9 +46,19 @@ impl<'a> Outline<'a> {
     }
 }
 
+const TAG_MASK: c_char = 0x03;
 const TAG_ONCURVE: c_char = 0x01;
+const TAG_BEZIER2: c_char = 0x00;
 const TAG_BEZIER3: c_char = 0x02;
 
+#[inline]
+fn middle_point(pt1: Vector, pt2: Vector) -> Vector {
+    ffi::FT_Vector {
+        x: (pt1.x + pt2.x) / 2,
+        y: (pt1.y + pt2.y) / 2,
+    }
+}
+
 pub struct CurveIterator<'a> {
     start_point: *const Vector,
     start_tag: *const c_char,
@@ -64,15 +74,27 @@ impl<'a> CurveIterator<'a> {
         CurveIterator {
             start_point: outline.points.offset(start_idx),
             start_tag: outline.tags.offset(start_idx),
-            idx: 0,
+            // If the first tag is off-curve, start at -1 and return last or interpolated point as start()
+            idx: if *outline.tags.offset(start_idx) & TAG_MASK == TAG_BEZIER2 { -1 } else { 0 },
             length: end_idx - start_idx + 1,
             marker: PhantomData
         }
     }
 
-    pub fn start(&self) -> &'a Vector {
+    pub fn start(&self) -> Vector {
         unsafe {
-            &*self.start_point
+            // Check if starting point is off-curve, use last point in that case
+            if *self.start_tag & TAG_MASK == TAG_BEZIER2 {
+                match *self.start_tag.offset(self.length - 1) {
+                    TAG_ONCURVE => *self.start_point.offset(self.length - 1),
+                    // If last point is also off-curve, then interpolate
+                    TAG_BEZIER2 => middle_point(*self.start_point.offset(self.length - 1),
+                                                *self.start_point),
+                    _ => panic!("Unexpected curve tag"),
+                }
+            } else {
+                *self.start_point
+            }
         }
     }
 
@@ -103,28 +125,35 @@ impl<'a> Iterator for CurveIterator<'a> {
             None
         } else {
             unsafe {
-                let tag1 = self.tg(1);
-
-                let (shift, curve) = if (tag1 & TAG_ONCURVE) == TAG_ONCURVE {
-                    (1, Curve::Line(self.pt(1)))
-                } else if (tag1 & TAG_BEZIER3) == TAG_BEZIER3 {
-                    (3, Curve::Bezier3(self.pt(1), self.pt(2), self.pt(3)))
-                } else {
-                    // We are some kind of quadratic Bezier.
-                    // Quadratic Bezier curves have a special treatment in TTF outlines:
-                    // as an optimization, curves are often constructed from sequences
-                    // of off-curve control points. In this case, there are implied on-curve
-                    // points in between each pair of off-curve points.
-                    if (self.tg(2) & TAG_ONCURVE) == TAG_ONCURVE {
-                        (2, Curve::Bezier2(self.pt(1), self.pt(2)))
-                    } else {
-                        let pt = ffi::FT_Vector {
-                            x: (self.pt(1).x + self.pt(2).x) / 2,
-                            y: (self.pt(1).y + self.pt(2).y) / 2,
-                        };
-
-                        (1, Curve::Bezier2(self.pt(1), pt))
-                    }
+                let (shift, curve) =
+                match self.tg(1) {
+                    TAG_ONCURVE => (1, Curve::Line(self.pt(1))),
+                    TAG_BEZIER2 => {
+                        // We are some kind of quadratic Bezier.
+                        // Quadratic Bezier curves have a special treatment in TTF outlines:
+                        // as an optimization, curves are often constructed from sequences
+                        // of off-curve control points. In this case, there are implied on-curve
+                        // points in between each pair of off-curve points.
+
+                        // If we are at last point and checking first point (in circular fashion),
+                        // and it's off-curve, then stop iterating. The last point was already
+                        // reported by start() method.
+                        if self.idx == self.length - 1 {
+                            return None;
+                        }
+
+                        match self.tg(2) {
+                            TAG_ONCURVE => (2, Curve::Bezier2(self.pt(1), self.pt(2))),
+                            TAG_BEZIER2 => (1, Curve::Bezier2(self.pt(1), middle_point(self.pt(1), self.pt(2)))),
+                            _ => panic!("Unexpected curve tag"),
+                        }
+                    },
+                    TAG_BEZIER3 => {
+                        debug_assert!(self.tg(2) == TAG_BEZIER3);
+                        debug_assert!(self.tg(3) == TAG_ONCURVE);
+                        (3, Curve::Bezier3(self.pt(1), self.pt(2), self.pt(3)))
+                    },
+                    _ => panic!("Unexpected curve tag"),
                 };
 
                 self.idx += shift;