Bring GX point interpolation further into standards compliance

* src/sfnt.c (sfnt_infer_deltas_2): New function; factor much of
sfnt_infer_deltas_1 into this function, then modify its
treatment of untouched points positioned at their reference
points to align with standard GX treatment.
(sfnt_infer_deltas_1): Remove all code not concerning anchor
point discovery.
(main): Adjust tests.

1 files changed, 182 insertions, 269 deletions

diff --git a/src/sfnt.c b/src/sfnt.c
index 7625254d0bd..deafaec31e7 100644
--- a/src/sfnt.c
+++ b/src/sfnt.c
@@ -15314,322 +15314,235 @@ sfnt_compute_tuple_scale (struct sfnt_blend *blend, bool intermediate_p,
   return scale;
 }
 
-/* Infer point positions for points that have been partially moved
-   within the contour in GLYPH denoted by START and END.  */
+/* Move each point in the simple glyph GLYPH between PAIR_START and
+   PAIR_END to agree with the positions of those two anchor points as
+   compared with their initial positions recorded within the arrays X
+   and Y.
+
+   The range formed between PAIR_START and PAIR_END may encompass the
+   upper extreme of the contour between START and END.  */
 
 static void
-sfnt_infer_deltas_1 (struct sfnt_glyph *glyph, size_t start,
-		     size_t end, bool *touched, sfnt_fword *x,
-		     sfnt_fword *y)
+sfnt_infer_deltas_2 (struct sfnt_glyph *glyph, size_t pair_start,
+		     size_t pair_end, size_t start, size_t end,
+		     sfnt_fword *x, sfnt_fword *y)
 {
-  size_t i, pair_start, pair_end, pair_first, j;
-  sfnt_fword min_pos, max_pos, position;
+  size_t j;
+  sfnt_fword min_pos, max_pos, position, d1, d2;
   sfnt_fixed ratio, delta;
 
-  pair_start = pair_first = -1;
-
-  /* Look for pairs of touched points.  */
+  j = pair_start + 1;
 
-  for (i = start; i <= end; ++i)
+  while (j != pair_end)
     {
-      if (!touched[i])
-	continue;
+      /* Reset j to the contour's start position if it is about to
+	 overrun this contour.  */
 
-      if (pair_start == -1)
+      if (j > end)
 	{
-	  pair_first = i;
-	  goto next;
+	  /* The start of the contour might also be the end of this
+	     reference point.  */
+	  if (start == pair_end)
+	    return;
+
+	  j = start;
 	}
 
-      pair_end = i;
+      /* Consider the X axis.  Set min_pos and max_pos to the
+	 smallest and greatest values along that axis.  */
+      min_pos = MIN (x[pair_start], x[pair_end]);
+      max_pos = MAX (x[pair_start], x[pair_end]);
 
-      /* pair_start to pair_end are now a pair of points, where points
-	 in between should be interpolated.  */
+      /* Now see if the current point lies between min and
+	 max...
 
-      for (j = pair_start + 1; j < pair_end; ++j)
+         GX interpolation differs from IUP in one important detail:
+         points are shifted to follow the movement of their reference
+         points if their positions are identical to those of any of
+         their reference points, whereas IUP considers such points to
+         fall within their reference points.  */
+      if (x[j] > min_pos && x[j] < max_pos)
+	{
+	  /* Interpolate between min_pos and max_pos.  */
+	  ratio = sfnt_div_fixed ((sfnt_sub (x[j], min_pos)
+				   * 65536),
+				  (sfnt_sub (max_pos, min_pos)
+				   * 65536));
+
+	  /* Load the current positions of pair_start and pair_end
+	     along this axis.  */
+	  min_pos = MIN (glyph->simple->x_coordinates[pair_start],
+			 glyph->simple->x_coordinates[pair_end]);
+	  max_pos = MAX (glyph->simple->x_coordinates[pair_start],
+			 glyph->simple->x_coordinates[pair_end]);
+
+	  /* Lerp in between.  */
+	  delta = sfnt_sub (max_pos, min_pos);
+	  delta = sfnt_mul_fixed (ratio, delta);
+	  glyph->simple->x_coordinates[j] = min_pos + delta;
+	}
+      else
 	{
-	  /* Consider the X axis.  Set min_pos and max_pos to the
-	     smallest and greatest values along that axis.  */
-	  min_pos = MIN (x[pair_start], x[pair_end]);
-	  max_pos = MAX (x[pair_start], x[pair_end]);
-
-	  /* Now see if the current point lies between min and
-	     max... */
-	  if (x[j] >= min_pos && x[j] <= max_pos)
+	  /* ... otherwise, move point j by the delta of the
+	     nearest touched point.  */
+
+	  /* If min_pos and max_pos are the same, apply
+	     pair_start's delta if it is identical to that of
+	     pair_end, or apply nothing at all otherwise.  */
+
+	  if (min_pos == max_pos)
 	    {
-	      /* If min_pos and max_pos are the same, apply
-		 pair_start's delta if it is identical to that of
-		 pair_end, or apply nothing at all otherwise.  */
+	      d1 = (glyph->simple->x_coordinates[pair_start]
+		    - x[pair_start]);
+	      d2 = (glyph->simple->x_coordinates[pair_end]
+		    - x[pair_start]);
 
-	      if (min_pos == max_pos)
-		{
-		  if ((glyph->simple->x_coordinates[pair_start]
-		       - x[pair_start])
-		      == (glyph->simple->x_coordinates[pair_end]
-			  - x[pair_end]))
-		    glyph->simple->x_coordinates[j]
-		      += (glyph->simple->x_coordinates[pair_start]
-			  - x[pair_start]);
+	      if (d1 == d2)
+		glyph->simple->x_coordinates[j] += d1;
 
-		  continue;
-		}
+	      goto consider_y;
+	    }
 
-	      /* Interpolate between min_pos and max_pos.  */
-	      ratio = sfnt_div_fixed ((sfnt_sub (x[j], min_pos)
-				       * 65536),
-				      (sfnt_sub (max_pos, min_pos)
-				       * 65536));
-
-	      /* Load the current positions of pair_start and pair_end
-	         along this axis.  */
-	      min_pos = MIN (glyph->simple->x_coordinates[pair_start],
-			     glyph->simple->x_coordinates[pair_end]);
-	      max_pos = MAX (glyph->simple->x_coordinates[pair_start],
-			     glyph->simple->x_coordinates[pair_end]);
-
-	      /* Lerp in between.  */
-	      delta = sfnt_sub (max_pos, min_pos);
-	      delta = sfnt_mul_fixed (ratio, delta);
-	      glyph->simple->x_coordinates[j] = min_pos + delta;
+	  if (x[j] >= max_pos)
+	    {
+	      position = MAX (glyph->simple->x_coordinates[pair_start],
+			      glyph->simple->x_coordinates[pair_end]);
+	      delta = position - max_pos;
 	    }
 	  else
 	    {
-	      /* ... otherwise, move point j by the delta of the
-		 nearest touched point.  */
+	      position = MIN (glyph->simple->x_coordinates[pair_start],
+			      glyph->simple->x_coordinates[pair_end]);
+	      delta = position - min_pos;
+	    }
 
-	      if (x[j] >= max_pos)
-		{
-		  position = MAX (glyph->simple->x_coordinates[pair_start],
-				  glyph->simple->x_coordinates[pair_end]);
-		  delta = position - max_pos;
-		}
-	      else
-		{
-		  position = MIN (glyph->simple->x_coordinates[pair_start],
-				  glyph->simple->x_coordinates[pair_end]);
-		  delta = position - min_pos;
-		}
+	  glyph->simple->x_coordinates[j] = x[j] + delta;
+	}
 
-	      glyph->simple->x_coordinates[j] = x[j] + delta;
-	    }
+    consider_y:
+
+      /* Now, consider the Y axis.  */
+      min_pos = MIN (y[pair_start], y[pair_end]);
+      max_pos = MAX (y[pair_start], y[pair_end]);
 
-	  /* Now, consider the Y axis.  */
-	  min_pos = MIN (y[pair_start], y[pair_end]);
-	  max_pos = MAX (y[pair_start], y[pair_end]);
+      /* Now see if the current point lies between min and
+	 max...
 
-	  /* Now see if the current point lies between min and
-	     max... */
-	  if (y[j] >= min_pos && y[j] <= max_pos)
+         GX interpolation differs from IUP in one important detail:
+         points are shifted to follow the movement of their reference
+         points if their positions are identical to those of any of
+         their reference points, whereas IUP considers such points to
+         fall within their reference points.  */
+      if (y[j] > min_pos && y[j] < max_pos)
+	{
+	  /* Interpolate between min_pos and max_pos.  */
+	  ratio = sfnt_div_fixed ((sfnt_sub (y[j], min_pos)
+				   * 65536),
+				  (sfnt_sub (max_pos, min_pos)
+				   * 65536));
+
+	  /* Load the current positions of pair_start and pair_end
+	     along this axis.  */
+	  min_pos = MIN (glyph->simple->y_coordinates[pair_start],
+			 glyph->simple->y_coordinates[pair_end]);
+	  max_pos = MAX (glyph->simple->y_coordinates[pair_start],
+			 glyph->simple->y_coordinates[pair_end]);
+
+	  /* Lerp in between.  */
+	  delta = sfnt_sub (max_pos, min_pos);
+	  delta = sfnt_mul_fixed (ratio, delta);
+	  glyph->simple->y_coordinates[j] = min_pos + delta;
+	}
+      else
+	{
+	  /* ... otherwise, move point j by the delta of the
+	     nearest touched point.  */
+
+	  /* If min_pos and max_pos are the same, apply
+	     pair_start's delta if it is identical to that of
+	     pair_end, or apply nothing at all otherwise.  */
+
+	  if (min_pos == max_pos)
 	    {
-	      /* If min_pos and max_pos are the same, apply
-		 pair_start's delta if it is identical to that of
-		 pair_end, or apply nothing at all otherwise.  */
+	      d1 = (glyph->simple->y_coordinates[pair_start]
+		    - y[pair_start]);
+	      d2 = (glyph->simple->y_coordinates[pair_end]
+		    - y[pair_start]);
 
-	      if (min_pos == max_pos)
-		{
-		  if ((glyph->simple->y_coordinates[pair_start]
-		       - y[pair_start])
-		      == (glyph->simple->y_coordinates[pair_end]
-			  - y[pair_end]))
-		    glyph->simple->y_coordinates[j]
-		      += (glyph->simple->y_coordinates[pair_start]
-			  - y[pair_start]);
+	      if (d1 == d2)
+		glyph->simple->y_coordinates[j] += d1;
 
-		  continue;
-		}
+	      goto next;
+	    }
 
-	      /* Interpolate between min_pos and max_pos.  */
-	      ratio = sfnt_div_fixed ((sfnt_sub (y[j], min_pos)
-				       * 65536),
-				      (sfnt_sub (max_pos, min_pos)
-				       * 65536));
-
-	      /* Load the current positions of pair_start and pair_end
-	         along this axis.  */
-	      min_pos = MIN (glyph->simple->y_coordinates[pair_start],
-			     glyph->simple->y_coordinates[pair_end]);
-	      max_pos = MAX (glyph->simple->y_coordinates[pair_start],
-			     glyph->simple->y_coordinates[pair_end]);
-
-	      /* Lerp in between.  */
-	      delta = sfnt_sub (max_pos, min_pos);
-	      delta = sfnt_mul_fixed (ratio, delta);
-	      glyph->simple->y_coordinates[j] = min_pos + delta;
+	  if (y[j] >= max_pos)
+	    {
+	      position = MAX (glyph->simple->y_coordinates[pair_start],
+			      glyph->simple->y_coordinates[pair_end]);
+	      delta = position - max_pos;
 	    }
 	  else
 	    {
-	      /* ... otherwise, move point j by the delta of the
-		 nearest touched point.  */
-
-	      if (y[j] >= max_pos)
-		{
-		  position = MAX (glyph->simple->y_coordinates[pair_start],
-				  glyph->simple->y_coordinates[pair_end]);
-		  delta = position - max_pos;
-		}
-	      else
-		{
-		  position = MIN (glyph->simple->y_coordinates[pair_start],
-				  glyph->simple->y_coordinates[pair_end]);
-		  delta = position - min_pos;
-		}
-
-	      glyph->simple->y_coordinates[j] = y[j] + delta;
+	      position = MIN (glyph->simple->y_coordinates[pair_start],
+			      glyph->simple->y_coordinates[pair_end]);
+	      delta = position - min_pos;
 	    }
+
+	  glyph->simple->y_coordinates[j] = y[j] + delta;
 	}
 
     next:
-      pair_start = i;
+      j++;
     }
+}
 
-  /* If pair_start is set, then lerp points between it and
-     pair_first.  */
-
-  if (pair_start != (size_t) -1)
-    {
-      j = pair_start + 1;
-
-      if (j > end)
-	j = start;
-
-      pair_end = pair_first;
-
-      while (j != pair_first)
-	{
-	  /* Consider the X axis.  Set min_pos and max_pos to the
-	     smallest and greatest values along that axis.  */
-	  min_pos = MIN (x[pair_start], x[pair_end]);
-	  max_pos = MAX (x[pair_start], x[pair_end]);
-
-	  /* Now see if the current point lies between min and
-	     max... */
-	  if (x[j] >= min_pos && x[j] <= max_pos)
-	    {
-	      /* If min_pos and max_pos are the same, apply
-		 pair_start's delta if it is identical to that of
-		 pair_end, or apply nothing at all otherwise.  */
+/* Infer point positions for points that have been partially moved
+   within the contour in GLYPH denoted by START and END.  */
 
-	      if (min_pos == max_pos)
-		{
-		  if ((glyph->simple->x_coordinates[pair_start]
-		       - x[pair_start])
-		      == (glyph->simple->x_coordinates[pair_end]
-			  - x[pair_end]))
-		    glyph->simple->x_coordinates[j]
-		      += (glyph->simple->x_coordinates[pair_start]
-			  - x[pair_start]);
-
-		  goto next_1;
-		}
+static void
+sfnt_infer_deltas_1 (struct sfnt_glyph *glyph, size_t start,
+		     size_t end, bool *touched, sfnt_fword *x,
+		     sfnt_fword *y)
+{
+  size_t i, pair_start, pair_end, pair_first;
 
-	      /* Interpolate between min_pos and max_pos.  */
-	      ratio = sfnt_div_fixed ((sfnt_sub (x[j], min_pos)
-				       * 65536),
-				      (sfnt_sub (max_pos, min_pos)
-				       * 65536));
-
-	      /* Load the current positions of pair_start and pair_end
-	         along this axis.  */
-	      min_pos = MIN (glyph->simple->x_coordinates[pair_start],
-			     glyph->simple->x_coordinates[pair_end]);
-	      max_pos = MAX (glyph->simple->x_coordinates[pair_start],
-			     glyph->simple->x_coordinates[pair_end]);
-
-	      /* Lerp in between.  */
-	      delta = sfnt_sub (max_pos, min_pos);
-	      delta = sfnt_mul_fixed (ratio, delta);
-	      glyph->simple->x_coordinates[j] = min_pos + delta;
-	    }
-	  else
-	    {
-	      /* ... otherwise, move point j by the delta of the
-		 nearest touched point.  */
+  pair_start = pair_first = -1;
 
-	      if (x[j] >= max_pos)
-		{
-		  position = MAX (glyph->simple->x_coordinates[pair_start],
-				  glyph->simple->x_coordinates[pair_end]);
-		  delta = position - max_pos;
-		}
-	      else
-		{
-		  position = MIN (glyph->simple->x_coordinates[pair_start],
-				  glyph->simple->x_coordinates[pair_end]);
-		  delta = position - min_pos;
-		}
+  /* Look for pairs of touched points.  */
 
-	      glyph->simple->x_coordinates[j] = x[j] + delta;
-	    }
+  for (i = start; i <= end; ++i)
+    {
+      if (!touched[i])
+	continue;
 
-	  /* Now, consider the Y axis.  */
-	  min_pos = MIN (y[pair_start], y[pair_end]);
-	  max_pos = MAX (y[pair_start], y[pair_end]);
+      if (pair_start == -1)
+	{
+	  pair_first = i;
+	  goto next;
+	}
 
-	  /* Now see if the current point lies between min and
-	     max... */
-	  if (y[j] >= min_pos && y[j] <= max_pos)
-	    {
-	      /* If min_pos and max_pos are the same, apply
-		 pair_start's delta if it is identical to that of
-		 pair_end, or apply nothing at all otherwise.  */
+      pair_end = i;
 
-	      if (min_pos == max_pos)
-		{
-		  if ((glyph->simple->y_coordinates[pair_start]
-		       - y[pair_start])
-		      == (glyph->simple->y_coordinates[pair_end]
-			  - y[pair_end]))
-		    glyph->simple->y_coordinates[j]
-		      += (glyph->simple->y_coordinates[pair_start]
-			  - y[pair_start]);
-
-		  goto next_1;
-		}
+      /* pair_start to pair_end are now a pair of points whose
+	 intermediates should be interpolated.  */
+      sfnt_infer_deltas_2 (glyph, pair_start, pair_end,
+			   start, end, x, y);
 
-	      /* Interpolate between min_pos and max_pos.  */
-	      ratio = sfnt_div_fixed ((sfnt_sub (y[j], min_pos)
-				       * 65536),
-				      (sfnt_sub (max_pos, min_pos)
-				       * 65536));
-
-	      /* Load the current positions of pair_start and pair_end
-	         along this axis.  */
-	      min_pos = MIN (glyph->simple->y_coordinates[pair_start],
-			     glyph->simple->y_coordinates[pair_end]);
-	      max_pos = MAX (glyph->simple->y_coordinates[pair_start],
-			     glyph->simple->y_coordinates[pair_end]);
-
-	      /* Lerp in between.  */
-	      delta = sfnt_sub (max_pos, min_pos);
-	      delta = sfnt_mul_fixed (ratio, delta);
-	      glyph->simple->y_coordinates[j] = min_pos + delta;
-	    }
-	  else
-	    {
-	      /* ... otherwise, move point j by the delta of the
-		 nearest touched point.  */
+    next:
+      pair_start = i;
+    }
 
-	      if (y[j] >= max_pos)
-		{
-		  position = MAX (glyph->simple->y_coordinates[pair_start],
-				  glyph->simple->y_coordinates[pair_end]);
-		  delta = position - max_pos;
-		}
-	      else
-		{
-		  position = MIN (glyph->simple->y_coordinates[pair_start],
-				  glyph->simple->y_coordinates[pair_end]);
-		  delta = position - min_pos;
-		}
+  /* If pair_start is set, then lerp points between it and
+     pair_first.  */
 
-	      glyph->simple->y_coordinates[j] = y[j] + delta;
-	    }
+  if (pair_start != (size_t) -1)
+    {
+      pair_end = pair_first;
 
-	next_1:
-	  j++;
-	  if (j > end)
-	    j = start;
-	}
+      /* pair_start to pair_end are now a pair of points whose
+	 intermediates should be interpolated.  */
+      sfnt_infer_deltas_2 (glyph, pair_start, pair_end,
+			   start, end, x, y);
     }
 }
 
@@ -20696,8 +20609,8 @@ main (int argc, char **argv)
       return 1;
     }
 
-#define FANCY_PPEM 30
-#define EASY_PPEM  30
+#define FANCY_PPEM 44
+#define EASY_PPEM  44
 
   interpreter = NULL;
   head = sfnt_read_head_table (fd, font);