summaryrefslogtreecommitdiffstats
path: root/app/vectors/gimpbezierstroke.c
diff options
context:
space:
mode:
Diffstat (limited to 'app/vectors/gimpbezierstroke.c')
-rw-r--r--app/vectors/gimpbezierstroke.c2309
1 files changed, 2309 insertions, 0 deletions
diff --git a/app/vectors/gimpbezierstroke.c b/app/vectors/gimpbezierstroke.c
new file mode 100644
index 0000000..3cfe735
--- /dev/null
+++ b/app/vectors/gimpbezierstroke.c
@@ -0,0 +1,2309 @@
+/* GIMP - The GNU Image Manipulation Program
+ * Copyright (C) 1995 Spencer Kimball and Peter Mattis
+ *
+ * gimpbezierstroke.c
+ * Copyright (C) 2002 Simon Budig <simon@gimp.org>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include "config.h"
+
+#include <glib-object.h>
+#include <cairo.h>
+
+#include "libgimpmath/gimpmath.h"
+
+#include "vectors-types.h"
+
+#include "core/gimp-transform-utils.h"
+#include "core/gimpbezierdesc.h"
+#include "core/gimpcoords.h"
+#include "core/gimpcoords-interpolate.h"
+
+#include "gimpanchor.h"
+#include "gimpbezierstroke.h"
+
+
+/* local prototypes */
+
+static gdouble
+ gimp_bezier_stroke_nearest_point_get (GimpStroke *stroke,
+ const GimpCoords *coord,
+ gdouble precision,
+ GimpCoords *ret_point,
+ GimpAnchor **ret_segment_start,
+ GimpAnchor **ret_segment_end,
+ gdouble *ret_pos);
+static gdouble
+ gimp_bezier_stroke_segment_nearest_point_get
+ (const GimpCoords *beziercoords,
+ const GimpCoords *coord,
+ gdouble precision,
+ GimpCoords *ret_point,
+ gdouble *ret_pos,
+ gint depth);
+static gdouble
+ gimp_bezier_stroke_nearest_tangent_get (GimpStroke *stroke,
+ const GimpCoords *coord1,
+ const GimpCoords *coord2,
+ gdouble precision,
+ GimpCoords *nearest,
+ GimpAnchor **ret_segment_start,
+ GimpAnchor **ret_segment_end,
+ gdouble *ret_pos);
+static gdouble
+ gimp_bezier_stroke_segment_nearest_tangent_get
+ (const GimpCoords *beziercoords,
+ const GimpCoords *coord1,
+ const GimpCoords *coord2,
+ gdouble precision,
+ GimpCoords *ret_point,
+ gdouble *ret_pos);
+static void
+ gimp_bezier_stroke_anchor_move_relative
+ (GimpStroke *stroke,
+ GimpAnchor *anchor,
+ const GimpCoords *deltacoord,
+ GimpAnchorFeatureType feature);
+static void
+ gimp_bezier_stroke_anchor_move_absolute
+ (GimpStroke *stroke,
+ GimpAnchor *anchor,
+ const GimpCoords *coord,
+ GimpAnchorFeatureType feature);
+static void
+ gimp_bezier_stroke_anchor_convert (GimpStroke *stroke,
+ GimpAnchor *anchor,
+ GimpAnchorFeatureType feature);
+static void
+ gimp_bezier_stroke_anchor_delete (GimpStroke *stroke,
+ GimpAnchor *anchor);
+static gboolean
+ gimp_bezier_stroke_point_is_movable (GimpStroke *stroke,
+ GimpAnchor *predec,
+ gdouble position);
+static void
+ gimp_bezier_stroke_point_move_relative (GimpStroke *stroke,
+ GimpAnchor *predec,
+ gdouble position,
+ const GimpCoords *deltacoord,
+ GimpAnchorFeatureType feature);
+static void
+ gimp_bezier_stroke_point_move_absolute (GimpStroke *stroke,
+ GimpAnchor *predec,
+ gdouble position,
+ const GimpCoords *coord,
+ GimpAnchorFeatureType feature);
+
+static void gimp_bezier_stroke_close (GimpStroke *stroke);
+
+static GimpStroke *
+ gimp_bezier_stroke_open (GimpStroke *stroke,
+ GimpAnchor *end_anchor);
+static gboolean
+ gimp_bezier_stroke_anchor_is_insertable
+ (GimpStroke *stroke,
+ GimpAnchor *predec,
+ gdouble position);
+static GimpAnchor *
+ gimp_bezier_stroke_anchor_insert (GimpStroke *stroke,
+ GimpAnchor *predec,
+ gdouble position);
+static gboolean
+ gimp_bezier_stroke_is_extendable (GimpStroke *stroke,
+ GimpAnchor *neighbor);
+static gboolean
+ gimp_bezier_stroke_connect_stroke (GimpStroke *stroke,
+ GimpAnchor *anchor,
+ GimpStroke *extension,
+ GimpAnchor *neighbor);
+static GArray *
+ gimp_bezier_stroke_interpolate (GimpStroke *stroke,
+ gdouble precision,
+ gboolean *closed);
+static GimpBezierDesc *
+ gimp_bezier_stroke_make_bezier (GimpStroke *stroke);
+static void gimp_bezier_stroke_transform (GimpStroke *stroke,
+ const GimpMatrix3 *matrix,
+ GQueue *ret_strokes);
+
+static void gimp_bezier_stroke_finalize (GObject *object);
+
+
+static GList * gimp_bezier_stroke_get_anchor_listitem
+ (GList *list);
+
+
+G_DEFINE_TYPE (GimpBezierStroke, gimp_bezier_stroke, GIMP_TYPE_STROKE)
+
+#define parent_class gimp_bezier_stroke_parent_class
+
+
+static void
+gimp_bezier_stroke_class_init (GimpBezierStrokeClass *klass)
+{
+ GObjectClass *object_class = G_OBJECT_CLASS (klass);
+ GimpStrokeClass *stroke_class = GIMP_STROKE_CLASS (klass);
+
+ object_class->finalize = gimp_bezier_stroke_finalize;
+
+ stroke_class->nearest_point_get = gimp_bezier_stroke_nearest_point_get;
+ stroke_class->nearest_tangent_get = gimp_bezier_stroke_nearest_tangent_get;
+ stroke_class->nearest_intersection_get = NULL;
+ stroke_class->anchor_move_relative = gimp_bezier_stroke_anchor_move_relative;
+ stroke_class->anchor_move_absolute = gimp_bezier_stroke_anchor_move_absolute;
+ stroke_class->anchor_convert = gimp_bezier_stroke_anchor_convert;
+ stroke_class->anchor_delete = gimp_bezier_stroke_anchor_delete;
+ stroke_class->point_is_movable = gimp_bezier_stroke_point_is_movable;
+ stroke_class->point_move_relative = gimp_bezier_stroke_point_move_relative;
+ stroke_class->point_move_absolute = gimp_bezier_stroke_point_move_absolute;
+ stroke_class->close = gimp_bezier_stroke_close;
+ stroke_class->open = gimp_bezier_stroke_open;
+ stroke_class->anchor_is_insertable = gimp_bezier_stroke_anchor_is_insertable;
+ stroke_class->anchor_insert = gimp_bezier_stroke_anchor_insert;
+ stroke_class->is_extendable = gimp_bezier_stroke_is_extendable;
+ stroke_class->extend = gimp_bezier_stroke_extend;
+ stroke_class->connect_stroke = gimp_bezier_stroke_connect_stroke;
+ stroke_class->interpolate = gimp_bezier_stroke_interpolate;
+ stroke_class->make_bezier = gimp_bezier_stroke_make_bezier;
+ stroke_class->transform = gimp_bezier_stroke_transform;
+}
+
+static void
+gimp_bezier_stroke_init (GimpBezierStroke *stroke)
+{
+}
+
+static void
+gimp_bezier_stroke_finalize (GObject *object)
+{
+ G_OBJECT_CLASS (parent_class)->finalize (object);
+}
+
+
+/* Bezier specific functions */
+
+GimpStroke *
+gimp_bezier_stroke_new (void)
+{
+ return g_object_new (GIMP_TYPE_BEZIER_STROKE, NULL);
+}
+
+
+GimpStroke *
+gimp_bezier_stroke_new_from_coords (const GimpCoords *coords,
+ gint n_coords,
+ gboolean closed)
+{
+ GimpStroke *stroke;
+ GimpAnchor *last_anchor;
+ gint count;
+
+ g_return_val_if_fail (coords != NULL, NULL);
+ g_return_val_if_fail (n_coords >= 3, NULL);
+ g_return_val_if_fail ((n_coords % 3) == 0, NULL);
+
+ stroke = gimp_bezier_stroke_new ();
+
+ last_anchor = NULL;
+
+ for (count = 0; count < n_coords; count++)
+ last_anchor = gimp_bezier_stroke_extend (stroke,
+ &coords[count],
+ last_anchor,
+ EXTEND_SIMPLE);
+
+ if (closed)
+ gimp_stroke_close (stroke);
+
+ return stroke;
+}
+
+static void
+gimp_bezier_stroke_anchor_delete (GimpStroke *stroke,
+ GimpAnchor *anchor)
+{
+ GList *list;
+ GList *list2;
+ gint i;
+
+ /* Anchors always are surrounded by two handles that have to
+ * be deleted too
+ */
+
+ list2 = g_queue_find (stroke->anchors, anchor);
+ list = g_list_previous (list2);
+
+ for (i = 0; i < 3; i++)
+ {
+ g_return_if_fail (list != NULL);
+
+ list2 = g_list_next (list);
+ gimp_anchor_free (list->data);
+ g_queue_delete_link (stroke->anchors, list);
+ list = list2;
+ }
+}
+
+static GimpStroke *
+gimp_bezier_stroke_open (GimpStroke *stroke,
+ GimpAnchor *end_anchor)
+{
+ GList *list;
+ GList *list2;
+ GimpStroke *new_stroke = NULL;
+
+ list = g_queue_find (stroke->anchors, end_anchor);
+
+ g_return_val_if_fail (list != NULL && list->next != NULL, NULL);
+
+ list = g_list_next (list); /* protect the handle... */
+
+ list2 = list->next;
+ list->next = NULL;
+
+ if (list2 != NULL)
+ {
+ GList *tail = stroke->anchors->tail;
+
+ stroke->anchors->tail = list;
+ stroke->anchors->length -= g_list_length (list2);
+
+ list2->prev = NULL;
+
+ if (stroke->closed)
+ {
+ GList *l;
+
+ for (l = tail; l; l = g_list_previous (l))
+ g_queue_push_head (stroke->anchors, l->data);
+
+ g_list_free (list2);
+ }
+ else
+ {
+ new_stroke = gimp_bezier_stroke_new ();
+ new_stroke->anchors->head = list2;
+ new_stroke->anchors->tail = g_list_last (list2);
+ new_stroke->anchors->length = g_list_length (list2);
+ }
+ }
+
+ stroke->closed = FALSE;
+ g_object_notify (G_OBJECT (stroke), "closed");
+
+ return new_stroke;
+}
+
+static gboolean
+gimp_bezier_stroke_anchor_is_insertable (GimpStroke *stroke,
+ GimpAnchor *predec,
+ gdouble position)
+{
+ return (g_queue_find (stroke->anchors, predec) != NULL);
+}
+
+
+static GimpAnchor *
+gimp_bezier_stroke_anchor_insert (GimpStroke *stroke,
+ GimpAnchor *predec,
+ gdouble position)
+{
+ GList *segment_start;
+ GList *list;
+ GList *list2;
+ GimpCoords subdivided[8];
+ GimpCoords beziercoords[4];
+ gint i;
+
+ segment_start = g_queue_find (stroke->anchors, predec);
+
+ if (! segment_start)
+ return NULL;
+
+ list = segment_start;
+
+ for (i = 0; i <= 3; i++)
+ {
+ beziercoords[i] = GIMP_ANCHOR (list->data)->position;
+ list = g_list_next (list);
+ if (! list)
+ list = stroke->anchors->head;
+ }
+
+ subdivided[0] = beziercoords[0];
+ subdivided[6] = beziercoords[3];
+
+ gimp_coords_mix (1-position, &(beziercoords[0]),
+ position, &(beziercoords[1]),
+ &(subdivided[1]));
+
+ gimp_coords_mix (1-position, &(beziercoords[1]),
+ position, &(beziercoords[2]),
+ &(subdivided[7]));
+
+ gimp_coords_mix (1-position, &(beziercoords[2]),
+ position, &(beziercoords[3]),
+ &(subdivided[5]));
+
+ gimp_coords_mix (1-position, &(subdivided[1]),
+ position, &(subdivided[7]),
+ &(subdivided[2]));
+
+ gimp_coords_mix (1-position, &(subdivided[7]),
+ position, &(subdivided[5]),
+ &(subdivided[4]));
+
+ gimp_coords_mix (1-position, &(subdivided[2]),
+ position, &(subdivided[4]),
+ &(subdivided[3]));
+
+ /* subdivided 0-6 contains the bezier segment subdivided at <position> */
+
+ list = segment_start;
+
+ for (i = 0; i <= 6; i++)
+ {
+ if (i >= 2 && i <= 4)
+ {
+ list2 = g_list_append (NULL,
+ gimp_anchor_new ((i == 3 ?
+ GIMP_ANCHOR_ANCHOR:
+ GIMP_ANCHOR_CONTROL),
+ &(subdivided[i])));
+ /* insert it *before* list manually. */
+ list2->next = list;
+ list2->prev = list->prev;
+ if (list->prev)
+ list->prev->next = list2;
+ list->prev = list2;
+
+ list = list2;
+
+ if (i == 3)
+ segment_start = list;
+ }
+ else
+ {
+ GIMP_ANCHOR (list->data)->position = subdivided[i];
+ }
+
+ list = g_list_next (list);
+ if (! list)
+ list = stroke->anchors->head;
+ }
+
+ stroke->anchors->head = g_list_first (list);
+ stroke->anchors->tail = g_list_last (list);
+ stroke->anchors->length += 3;
+
+ return GIMP_ANCHOR (segment_start->data);
+}
+
+
+static gboolean
+gimp_bezier_stroke_point_is_movable (GimpStroke *stroke,
+ GimpAnchor *predec,
+ gdouble position)
+{
+ return (g_queue_find (stroke->anchors, predec) != NULL);
+}
+
+
+static void
+gimp_bezier_stroke_point_move_relative (GimpStroke *stroke,
+ GimpAnchor *predec,
+ gdouble position,
+ const GimpCoords *deltacoord,
+ GimpAnchorFeatureType feature)
+{
+ GimpCoords offsetcoords[2];
+ GList *segment_start;
+ GList *list;
+ gint i;
+ gdouble feel_good;
+
+ segment_start = g_queue_find (stroke->anchors, predec);
+
+ g_return_if_fail (segment_start != NULL);
+
+ /* dragging close to endpoints just moves the handle related to
+ * the endpoint. Just make sure that feel_good is in the range from
+ * 0 to 1. The 1.0 / 6.0 and 5.0 / 6.0 are duplicated in
+ * tools/gimpvectortool.c.
+ */
+ if (position <= 1.0 / 6.0)
+ feel_good = 0;
+ else if (position <= 0.5)
+ feel_good = (pow((6 * position - 1) / 2.0, 3)) / 2;
+ else if (position <= 5.0 / 6.0)
+ feel_good = (1 - pow((6 * (1-position) - 1) / 2.0, 3)) / 2 + 0.5;
+ else
+ feel_good = 1;
+
+ gimp_coords_scale ((1-feel_good)/(3*position*
+ (1-position)*(1-position)),
+ deltacoord,
+ &(offsetcoords[0]));
+ gimp_coords_scale (feel_good/(3*position*position*(1-position)),
+ deltacoord,
+ &(offsetcoords[1]));
+
+ list = segment_start;
+ list = g_list_next (list);
+ if (! list)
+ list = stroke->anchors->head;
+
+ for (i = 0; i <= 1; i++)
+ {
+ gimp_stroke_anchor_move_relative (stroke, GIMP_ANCHOR (list->data),
+ &(offsetcoords[i]), feature);
+ list = g_list_next (list);
+ if (! list)
+ list = stroke->anchors->head;
+ }
+}
+
+
+static void
+gimp_bezier_stroke_point_move_absolute (GimpStroke *stroke,
+ GimpAnchor *predec,
+ gdouble position,
+ const GimpCoords *coord,
+ GimpAnchorFeatureType feature)
+{
+ GimpCoords deltacoord;
+ GimpCoords tmp1, tmp2, abs_pos;
+ GimpCoords beziercoords[4];
+ GList *segment_start;
+ GList *list;
+ gint i;
+
+ segment_start = g_queue_find (stroke->anchors, predec);
+
+ g_return_if_fail (segment_start != NULL);
+
+ list = segment_start;
+
+ for (i = 0; i <= 3; i++)
+ {
+ beziercoords[i] = GIMP_ANCHOR (list->data)->position;
+ list = g_list_next (list);
+ if (! list)
+ list = stroke->anchors->head;
+ }
+
+ gimp_coords_mix ((1-position)*(1-position)*(1-position), &(beziercoords[0]),
+ 3*(1-position)*(1-position)*position, &(beziercoords[1]),
+ &tmp1);
+ gimp_coords_mix (3*(1-position)*position*position, &(beziercoords[2]),
+ position*position*position, &(beziercoords[3]),
+ &tmp2);
+ gimp_coords_add (&tmp1, &tmp2, &abs_pos);
+
+ gimp_coords_difference (coord, &abs_pos, &deltacoord);
+
+ gimp_bezier_stroke_point_move_relative (stroke, predec, position,
+ &deltacoord, feature);
+}
+
+static void
+gimp_bezier_stroke_close (GimpStroke *stroke)
+{
+ GList *start;
+ GList *end;
+ GimpAnchor *anchor;
+
+ start = stroke->anchors->head;
+ end = stroke->anchors->tail;
+
+ g_return_if_fail (start->next != NULL && end->prev != NULL);
+
+ if (start->next != end->prev)
+ {
+ if (gimp_coords_equal (&(GIMP_ANCHOR (start->next->data)->position),
+ &(GIMP_ANCHOR (start->data)->position)) &&
+ gimp_coords_equal (&(GIMP_ANCHOR (start->data)->position),
+ &(GIMP_ANCHOR (end->data)->position)) &&
+ gimp_coords_equal (&(GIMP_ANCHOR (end->data)->position),
+ &(GIMP_ANCHOR (end->prev->data)->position)))
+ {
+ /* redundant segment */
+
+ gimp_anchor_free (stroke->anchors->tail->data);
+ g_queue_delete_link (stroke->anchors, stroke->anchors->tail);
+
+ gimp_anchor_free (stroke->anchors->tail->data);
+ g_queue_delete_link (stroke->anchors, stroke->anchors->tail);
+
+ anchor = stroke->anchors->tail->data;
+ g_queue_delete_link (stroke->anchors, stroke->anchors->tail);
+
+ gimp_anchor_free (stroke->anchors->head->data);
+ stroke->anchors->head->data = anchor;
+ }
+ }
+
+ GIMP_STROKE_CLASS (parent_class)->close (stroke);
+}
+
+static gdouble
+gimp_bezier_stroke_nearest_point_get (GimpStroke *stroke,
+ const GimpCoords *coord,
+ gdouble precision,
+ GimpCoords *ret_point,
+ GimpAnchor **ret_segment_start,
+ GimpAnchor **ret_segment_end,
+ gdouble *ret_pos)
+{
+ gdouble min_dist, dist, pos;
+ GimpCoords point = { 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 };
+ GimpCoords segmentcoords[4];
+ GList *anchorlist;
+ GimpAnchor *segment_start;
+ GimpAnchor *segment_end = NULL;
+ GimpAnchor *anchor;
+ gint count;
+
+ if (g_queue_is_empty (stroke->anchors))
+ return -1.0;
+
+ count = 0;
+ min_dist = -1;
+ pos = 0;
+
+ for (anchorlist = stroke->anchors->head;
+ GIMP_ANCHOR (anchorlist->data)->type != GIMP_ANCHOR_ANCHOR;
+ anchorlist = g_list_next (anchorlist));
+
+ segment_start = anchorlist->data;
+
+ for ( ; anchorlist; anchorlist = g_list_next (anchorlist))
+ {
+ anchor = anchorlist->data;
+
+ segmentcoords[count] = anchor->position;
+ count++;
+
+ if (count == 4)
+ {
+ segment_end = anchorlist->data;
+ dist = gimp_bezier_stroke_segment_nearest_point_get (segmentcoords,
+ coord, precision,
+ &point, &pos,
+ 10);
+
+ if (dist < min_dist || min_dist < 0)
+ {
+ min_dist = dist;
+
+ if (ret_pos)
+ *ret_pos = pos;
+ if (ret_point)
+ *ret_point = point;
+ if (ret_segment_start)
+ *ret_segment_start = segment_start;
+ if (ret_segment_end)
+ *ret_segment_end = segment_end;
+ }
+
+ segment_start = anchorlist->data;
+ segmentcoords[0] = segmentcoords[3];
+ count = 1;
+ }
+ }
+
+ if (stroke->closed && stroke->anchors->head)
+ {
+ anchorlist = stroke->anchors->head;
+
+ while (count < 3)
+ {
+ segmentcoords[count] = GIMP_ANCHOR (anchorlist->data)->position;
+ count++;
+ }
+
+ anchorlist = g_list_next (anchorlist);
+
+ if (anchorlist)
+ {
+ segment_end = GIMP_ANCHOR (anchorlist->data);
+ segmentcoords[3] = segment_end->position;
+ }
+
+ dist = gimp_bezier_stroke_segment_nearest_point_get (segmentcoords,
+ coord, precision,
+ &point, &pos,
+ 10);
+
+ if (dist < min_dist || min_dist < 0)
+ {
+ min_dist = dist;
+
+ if (ret_pos)
+ *ret_pos = pos;
+ if (ret_point)
+ *ret_point = point;
+ if (ret_segment_start)
+ *ret_segment_start = segment_start;
+ if (ret_segment_end)
+ *ret_segment_end = segment_end;
+ }
+ }
+
+ return min_dist;
+}
+
+
+static gdouble
+gimp_bezier_stroke_segment_nearest_point_get (const GimpCoords *beziercoords,
+ const GimpCoords *coord,
+ gdouble precision,
+ GimpCoords *ret_point,
+ gdouble *ret_pos,
+ gint depth)
+{
+ /*
+ * beziercoords has to contain four GimpCoords with the four control points
+ * of the bezier segment. We subdivide it at the parameter 0.5.
+ */
+
+ GimpCoords subdivided[8];
+ gdouble dist1, dist2;
+ GimpCoords point1, point2;
+ gdouble pos1, pos2;
+
+ gimp_coords_difference (&beziercoords[1], &beziercoords[0], &point1);
+ gimp_coords_difference (&beziercoords[3], &beziercoords[2], &point2);
+
+ if (! depth || (gimp_coords_bezier_is_straight (beziercoords, precision) &&
+ gimp_coords_length_squared (&point1) < precision &&
+ gimp_coords_length_squared (&point2) < precision))
+ {
+ GimpCoords line, dcoord;
+ gdouble length2, scalar;
+ gint i;
+
+ gimp_coords_difference (&(beziercoords[3]),
+ &(beziercoords[0]),
+ &line);
+
+ gimp_coords_difference (coord,
+ &(beziercoords[0]),
+ &dcoord);
+
+ length2 = gimp_coords_scalarprod (&line, &line);
+ scalar = gimp_coords_scalarprod (&line, &dcoord) / length2;
+
+ scalar = CLAMP (scalar, 0.0, 1.0);
+
+ /* lines look the same as bezier curves where the handles
+ * sit on the anchors, however, they are parametrized
+ * differently. Hence we have to do some weird approximation. */
+
+ pos1 = pos2 = 0.5;
+
+ for (i = 0; i <= 15; i++)
+ {
+ pos2 *= 0.5;
+
+ if (3 * pos1 * pos1 * (1-pos1) + pos1 * pos1 * pos1 < scalar)
+ pos1 += pos2;
+ else
+ pos1 -= pos2;
+ }
+
+ *ret_pos = pos1;
+
+ gimp_coords_mix (1.0, &(beziercoords[0]),
+ scalar, &line,
+ ret_point);
+
+ gimp_coords_difference (coord, ret_point, &dcoord);
+
+ return gimp_coords_length (&dcoord);
+ }
+
+ /* ok, we have to subdivide */
+
+ subdivided[0] = beziercoords[0];
+ subdivided[6] = beziercoords[3];
+
+ /* if (!depth) g_printerr ("Hit recursion depth limit!\n"); */
+
+ gimp_coords_average (&(beziercoords[0]), &(beziercoords[1]),
+ &(subdivided[1]));
+
+ gimp_coords_average (&(beziercoords[1]), &(beziercoords[2]),
+ &(subdivided[7]));
+
+ gimp_coords_average (&(beziercoords[2]), &(beziercoords[3]),
+ &(subdivided[5]));
+
+ gimp_coords_average (&(subdivided[1]), &(subdivided[7]),
+ &(subdivided[2]));
+
+ gimp_coords_average (&(subdivided[7]), &(subdivided[5]),
+ &(subdivided[4]));
+
+ gimp_coords_average (&(subdivided[2]), &(subdivided[4]),
+ &(subdivided[3]));
+
+ /*
+ * We now have the coordinates of the two bezier segments in
+ * subdivided [0-3] and subdivided [3-6]
+ */
+
+ dist1 = gimp_bezier_stroke_segment_nearest_point_get (&(subdivided[0]),
+ coord, precision,
+ &point1, &pos1,
+ depth - 1);
+
+ dist2 = gimp_bezier_stroke_segment_nearest_point_get (&(subdivided[3]),
+ coord, precision,
+ &point2, &pos2,
+ depth - 1);
+
+ if (dist1 <= dist2)
+ {
+ *ret_point = point1;
+ *ret_pos = 0.5 * pos1;
+ return dist1;
+ }
+ else
+ {
+ *ret_point = point2;
+ *ret_pos = 0.5 + 0.5 * pos2;
+ return dist2;
+ }
+}
+
+
+static gdouble
+gimp_bezier_stroke_nearest_tangent_get (GimpStroke *stroke,
+ const GimpCoords *coord1,
+ const GimpCoords *coord2,
+ gdouble precision,
+ GimpCoords *nearest,
+ GimpAnchor **ret_segment_start,
+ GimpAnchor **ret_segment_end,
+ gdouble *ret_pos)
+{
+ gdouble min_dist, dist, pos;
+ GimpCoords point;
+ GimpCoords segmentcoords[4];
+ GList *anchorlist;
+ GimpAnchor *segment_start;
+ GimpAnchor *segment_end = NULL;
+ GimpAnchor *anchor;
+ gint count;
+
+ if (g_queue_is_empty (stroke->anchors))
+ return -1.0;
+
+ count = 0;
+ min_dist = -1;
+
+ for (anchorlist = stroke->anchors->head;
+ GIMP_ANCHOR (anchorlist->data)->type != GIMP_ANCHOR_ANCHOR;
+ anchorlist = g_list_next (anchorlist));
+
+ segment_start = anchorlist->data;
+
+ for ( ; anchorlist; anchorlist = g_list_next (anchorlist))
+ {
+ anchor = anchorlist->data;
+
+ segmentcoords[count] = anchor->position;
+ count++;
+
+ if (count == 4)
+ {
+ segment_end = anchorlist->data;
+ dist = gimp_bezier_stroke_segment_nearest_tangent_get (segmentcoords,
+ coord1, coord2,
+ precision,
+ &point, &pos);
+
+ if (dist >= 0 && (dist < min_dist || min_dist < 0))
+ {
+ min_dist = dist;
+
+ if (ret_pos)
+ *ret_pos = pos;
+ if (nearest)
+ *nearest = point;
+ if (ret_segment_start)
+ *ret_segment_start = segment_start;
+ if (ret_segment_end)
+ *ret_segment_end = segment_end;
+ }
+
+ segment_start = anchorlist->data;
+ segmentcoords[0] = segmentcoords[3];
+ count = 1;
+ }
+ }
+
+ if (stroke->closed && ! g_queue_is_empty (stroke->anchors))
+ {
+ anchorlist = stroke->anchors->head;
+
+ while (count < 3)
+ {
+ segmentcoords[count] = GIMP_ANCHOR (anchorlist->data)->position;
+ count++;
+ }
+
+ anchorlist = g_list_next (anchorlist);
+
+ if (anchorlist)
+ {
+ segment_end = GIMP_ANCHOR (anchorlist->data);
+ segmentcoords[3] = segment_end->position;
+ }
+
+ dist = gimp_bezier_stroke_segment_nearest_tangent_get (segmentcoords,
+ coord1, coord2,
+ precision,
+ &point, &pos);
+
+ if (dist >= 0 && (dist < min_dist || min_dist < 0))
+ {
+ min_dist = dist;
+
+ if (ret_pos)
+ *ret_pos = pos;
+ if (nearest)
+ *nearest = point;
+ if (ret_segment_start)
+ *ret_segment_start = segment_start;
+ if (ret_segment_end)
+ *ret_segment_end = segment_end;
+ }
+ }
+
+ return min_dist;
+}
+
+static gdouble
+gimp_bezier_stroke_segment_nearest_tangent_get (const GimpCoords *beziercoords,
+ const GimpCoords *coord1,
+ const GimpCoords *coord2,
+ gdouble precision,
+ GimpCoords *ret_point,
+ gdouble *ret_pos)
+{
+ GArray *ret_coords;
+ GArray *ret_params;
+ GimpCoords dir, line, dcoord, min_point;
+ gdouble min_dist = -1;
+ gdouble dist, length2, scalar, ori, ori2;
+ gint i;
+
+ gimp_coords_difference (coord2, coord1, &line);
+
+ ret_coords = g_array_new (FALSE, FALSE, sizeof (GimpCoords));
+ ret_params = g_array_new (FALSE, FALSE, sizeof (gdouble));
+
+ g_printerr ("(%.2f, %.2f)-(%.2f,%.2f): ", coord1->x, coord1->y,
+ coord2->x, coord2->y);
+
+ gimp_coords_interpolate_bezier (beziercoords, precision,
+ ret_coords, ret_params);
+
+ g_return_val_if_fail (ret_coords->len == ret_params->len, -1.0);
+
+ if (ret_coords->len < 2)
+ return -1;
+
+ gimp_coords_difference (&g_array_index (ret_coords, GimpCoords, 1),
+ &g_array_index (ret_coords, GimpCoords, 0),
+ &dir);
+ ori = dir.x * line.y - dir.y * line.x;
+
+ for (i = 2; i < ret_coords->len; i++)
+ {
+ gimp_coords_difference (&g_array_index (ret_coords, GimpCoords, i),
+ &g_array_index (ret_coords, GimpCoords, i-1),
+ &dir);
+ ori2 = dir.x * line.y - dir.y * line.x;
+
+ if (ori * ori2 <= 0)
+ {
+ gimp_coords_difference (&g_array_index (ret_coords, GimpCoords, i),
+ coord1,
+ &dcoord);
+
+ length2 = gimp_coords_scalarprod (&line, &line);
+ scalar = gimp_coords_scalarprod (&line, &dcoord) / length2;
+
+ if (scalar >= 0 && scalar <= 1)
+ {
+ gimp_coords_mix (1.0, coord1,
+ scalar, &line,
+ &min_point);
+ gimp_coords_difference (&min_point,
+ &g_array_index (ret_coords, GimpCoords, i),
+ &dcoord);
+ dist = gimp_coords_length (&dcoord);
+
+ if (dist < min_dist || min_dist < 0)
+ {
+ min_dist = dist;
+ *ret_point = g_array_index (ret_coords, GimpCoords, i);
+ *ret_pos = g_array_index (ret_params, gdouble, i);
+ }
+ }
+ }
+ ori = ori2;
+ }
+
+ if (min_dist < 0)
+ g_printerr ("-\n");
+ else
+ g_printerr ("%f: (%.2f, %.2f) /%.3f/\n", min_dist,
+ (*ret_point).x, (*ret_point).y, *ret_pos);
+
+ g_array_free (ret_coords, TRUE);
+ g_array_free (ret_params, TRUE);
+
+ return min_dist;
+}
+
+static gboolean
+gimp_bezier_stroke_is_extendable (GimpStroke *stroke,
+ GimpAnchor *neighbor)
+{
+ GList *listneighbor;
+ gint loose_end;
+
+ if (stroke->closed)
+ return FALSE;
+
+ if (g_queue_is_empty (stroke->anchors))
+ return TRUE;
+
+ /* assure that there is a neighbor specified */
+ g_return_val_if_fail (neighbor != NULL, FALSE);
+
+ loose_end = 0;
+ listneighbor = stroke->anchors->tail;
+
+ /* Check if the neighbor is at an end of the control points */
+ if (listneighbor->data == neighbor)
+ {
+ loose_end = 1;
+ }
+ else
+ {
+ listneighbor = g_list_first (stroke->anchors->head);
+
+ if (listneighbor->data == neighbor)
+ {
+ loose_end = -1;
+ }
+ else
+ {
+ /*
+ * It isn't. If we are on a handle go to the nearest
+ * anchor and see if we can find an end from it.
+ * Yes, this is tedious.
+ */
+
+ listneighbor = g_queue_find (stroke->anchors, neighbor);
+
+ if (listneighbor && neighbor->type == GIMP_ANCHOR_CONTROL)
+ {
+ if (listneighbor->prev &&
+ GIMP_ANCHOR (listneighbor->prev->data)->type == GIMP_ANCHOR_ANCHOR)
+ {
+ listneighbor = listneighbor->prev;
+ }
+ else if (listneighbor->next &&
+ GIMP_ANCHOR (listneighbor->next->data)->type == GIMP_ANCHOR_ANCHOR)
+ {
+ listneighbor = listneighbor->next;
+ }
+ else
+ {
+ loose_end = 0;
+ listneighbor = NULL;
+ }
+ }
+
+ if (listneighbor)
+ /* we found a suitable ANCHOR_ANCHOR now, lets
+ * search for its loose end.
+ */
+ {
+ if (listneighbor->prev &&
+ listneighbor->prev->prev == NULL)
+ {
+ loose_end = -1;
+ }
+ else if (listneighbor->next &&
+ listneighbor->next->next == NULL)
+ {
+ loose_end = 1;
+ }
+ }
+ }
+ }
+
+ return (loose_end != 0);
+}
+
+GimpAnchor *
+gimp_bezier_stroke_extend (GimpStroke *stroke,
+ const GimpCoords *coords,
+ GimpAnchor *neighbor,
+ GimpVectorExtendMode extend_mode)
+{
+ GimpAnchor *anchor = NULL;
+ GList *listneighbor;
+ gint loose_end, control_count;
+
+ if (g_queue_is_empty (stroke->anchors))
+ {
+ /* assure that there is no neighbor specified */
+ g_return_val_if_fail (neighbor == NULL, NULL);
+
+ anchor = gimp_anchor_new (GIMP_ANCHOR_CONTROL, coords);
+
+ g_queue_push_tail (stroke->anchors, anchor);
+
+ switch (extend_mode)
+ {
+ case EXTEND_SIMPLE:
+ break;
+
+ case EXTEND_EDITABLE:
+ anchor = gimp_bezier_stroke_extend (stroke,
+ coords, anchor,
+ EXTEND_SIMPLE);
+
+ /* we return the GIMP_ANCHOR_ANCHOR */
+ gimp_bezier_stroke_extend (stroke,
+ coords, anchor,
+ EXTEND_SIMPLE);
+
+ break;
+
+ default:
+ anchor = NULL;
+ }
+
+ return anchor;
+ }
+ else
+ {
+ /* assure that there is a neighbor specified */
+ g_return_val_if_fail (neighbor != NULL, NULL);
+
+ loose_end = 0;
+ listneighbor = stroke->anchors->tail;
+
+ /* Check if the neighbor is at an end of the control points */
+ if (listneighbor->data == neighbor)
+ {
+ loose_end = 1;
+ }
+ else
+ {
+ listneighbor = stroke->anchors->head;
+
+ if (listneighbor->data == neighbor)
+ {
+ loose_end = -1;
+ }
+ else
+ {
+ /*
+ * It isn't. If we are on a handle go to the nearest
+ * anchor and see if we can find an end from it.
+ * Yes, this is tedious.
+ */
+
+ listneighbor = g_queue_find (stroke->anchors, neighbor);
+
+ if (listneighbor && neighbor->type == GIMP_ANCHOR_CONTROL)
+ {
+ if (listneighbor->prev &&
+ GIMP_ANCHOR (listneighbor->prev->data)->type == GIMP_ANCHOR_ANCHOR)
+ {
+ listneighbor = listneighbor->prev;
+ }
+ else if (listneighbor->next &&
+ GIMP_ANCHOR (listneighbor->next->data)->type == GIMP_ANCHOR_ANCHOR)
+ {
+ listneighbor = listneighbor->next;
+ }
+ else
+ {
+ loose_end = 0;
+ listneighbor = NULL;
+ }
+ }
+
+ if (listneighbor)
+ /* we found a suitable ANCHOR_ANCHOR now, lets
+ * search for its loose end.
+ */
+ {
+ if (listneighbor->next &&
+ listneighbor->next->next == NULL)
+ {
+ loose_end = 1;
+ listneighbor = listneighbor->next;
+ }
+ else if (listneighbor->prev &&
+ listneighbor->prev->prev == NULL)
+ {
+ loose_end = -1;
+ listneighbor = listneighbor->prev;
+ }
+ }
+ }
+ }
+
+ if (loose_end)
+ {
+ GimpAnchorType type;
+
+ /* We have to detect the type of the point to add... */
+
+ control_count = 0;
+
+ if (loose_end == 1)
+ {
+ while (listneighbor &&
+ GIMP_ANCHOR (listneighbor->data)->type == GIMP_ANCHOR_CONTROL)
+ {
+ control_count++;
+ listneighbor = listneighbor->prev;
+ }
+ }
+ else
+ {
+ while (listneighbor &&
+ GIMP_ANCHOR (listneighbor->data)->type == GIMP_ANCHOR_CONTROL)
+ {
+ control_count++;
+ listneighbor = listneighbor->next;
+ }
+ }
+
+ switch (extend_mode)
+ {
+ case EXTEND_SIMPLE:
+ switch (control_count)
+ {
+ case 0:
+ type = GIMP_ANCHOR_CONTROL;
+ break;
+ case 1:
+ if (listneighbor) /* only one handle in the path? */
+ type = GIMP_ANCHOR_CONTROL;
+ else
+ type = GIMP_ANCHOR_ANCHOR;
+ break;
+ case 2:
+ type = GIMP_ANCHOR_ANCHOR;
+ break;
+ default:
+ g_warning ("inconsistent bezier curve: "
+ "%d successive control handles", control_count);
+ type = GIMP_ANCHOR_ANCHOR;
+ }
+
+ anchor = gimp_anchor_new (type, coords);
+
+ if (loose_end == 1)
+ g_queue_push_tail (stroke->anchors, anchor);
+
+ if (loose_end == -1)
+ g_queue_push_head (stroke->anchors, anchor);
+ break;
+
+ case EXTEND_EDITABLE:
+ switch (control_count)
+ {
+ case 0:
+ neighbor = gimp_bezier_stroke_extend (stroke,
+ &(neighbor->position),
+ neighbor,
+ EXTEND_SIMPLE);
+ case 1:
+ neighbor = gimp_bezier_stroke_extend (stroke,
+ coords,
+ neighbor,
+ EXTEND_SIMPLE);
+ case 2:
+ anchor = gimp_bezier_stroke_extend (stroke,
+ coords,
+ neighbor,
+ EXTEND_SIMPLE);
+
+ neighbor = gimp_bezier_stroke_extend (stroke,
+ coords,
+ anchor,
+ EXTEND_SIMPLE);
+ break;
+ default:
+ g_warning ("inconsistent bezier curve: "
+ "%d successive control handles", control_count);
+ }
+ }
+
+ return anchor;
+ }
+
+ return NULL;
+ }
+}
+
+static gboolean
+gimp_bezier_stroke_connect_stroke (GimpStroke *stroke,
+ GimpAnchor *anchor,
+ GimpStroke *extension,
+ GimpAnchor *neighbor)
+{
+ GList *list1;
+ GList *list2;
+
+ list1 = g_queue_find (stroke->anchors, anchor);
+ list1 = gimp_bezier_stroke_get_anchor_listitem (list1);
+ list2 = g_queue_find (extension->anchors, neighbor);
+ list2 = gimp_bezier_stroke_get_anchor_listitem (list2);
+
+ g_return_val_if_fail (list1 != NULL && list2 != NULL, FALSE);
+
+ if (stroke == extension)
+ {
+ g_return_val_if_fail ((list1->prev && list1->prev->prev == NULL &&
+ list2->next && list2->next->next == NULL) ||
+ (list1->next && list1->next->next == NULL &&
+ list2->prev && list2->prev->prev == NULL), FALSE);
+ gimp_stroke_close (stroke);
+ return TRUE;
+ }
+
+ if (list1->prev && list1->prev->prev == NULL)
+ {
+ g_queue_reverse (stroke->anchors);
+ }
+
+ g_return_val_if_fail (list1->next && list1->next->next == NULL, FALSE);
+
+ if (list2->next && list2->next->next == NULL)
+ {
+ g_queue_reverse (extension->anchors);
+ }
+
+ g_return_val_if_fail (list2->prev && list2->prev->prev == NULL, FALSE);
+
+ for (list1 = extension->anchors->head; list1; list1 = g_list_next (list1))
+ g_queue_push_tail (stroke->anchors, list1->data);
+
+ g_queue_clear (extension->anchors);
+
+ return TRUE;
+}
+
+
+static void
+gimp_bezier_stroke_anchor_move_relative (GimpStroke *stroke,
+ GimpAnchor *anchor,
+ const GimpCoords *deltacoord,
+ GimpAnchorFeatureType feature)
+{
+ GimpCoords delta, coord1, coord2;
+ GList *anchor_list;
+
+ delta = *deltacoord;
+ delta.pressure = 0;
+ delta.xtilt = 0;
+ delta.ytilt = 0;
+ delta.wheel = 0;
+
+ gimp_coords_add (&(anchor->position), &delta, &coord1);
+ anchor->position = coord1;
+
+ anchor_list = g_queue_find (stroke->anchors, anchor);
+ g_return_if_fail (anchor_list != NULL);
+
+ if (anchor->type == GIMP_ANCHOR_ANCHOR)
+ {
+ if (g_list_previous (anchor_list))
+ {
+ coord2 = GIMP_ANCHOR (g_list_previous (anchor_list)->data)->position;
+ gimp_coords_add (&coord2, &delta, &coord1);
+ GIMP_ANCHOR (g_list_previous (anchor_list)->data)->position = coord1;
+ }
+
+ if (g_list_next (anchor_list))
+ {
+ coord2 = GIMP_ANCHOR (g_list_next (anchor_list)->data)->position;
+ gimp_coords_add (&coord2, &delta, &coord1);
+ GIMP_ANCHOR (g_list_next (anchor_list)->data)->position = coord1;
+ }
+ }
+ else
+ {
+ if (feature == GIMP_ANCHOR_FEATURE_SYMMETRIC)
+ {
+ GList *neighbour = NULL, *opposite = NULL;
+
+ /* search for opposite control point. Sigh. */
+ neighbour = g_list_previous (anchor_list);
+ if (neighbour &&
+ GIMP_ANCHOR (neighbour->data)->type == GIMP_ANCHOR_ANCHOR)
+ {
+ opposite = g_list_previous (neighbour);
+ }
+ else
+ {
+ neighbour = g_list_next (anchor_list);
+ if (neighbour &&
+ GIMP_ANCHOR (neighbour->data)->type == GIMP_ANCHOR_ANCHOR)
+ {
+ opposite = g_list_next (neighbour);
+ }
+ }
+ if (opposite &&
+ GIMP_ANCHOR (opposite->data)->type == GIMP_ANCHOR_CONTROL)
+ {
+ gimp_coords_difference (&(GIMP_ANCHOR (neighbour->data)->position),
+ &(anchor->position), &delta);
+ gimp_coords_add (&(GIMP_ANCHOR (neighbour->data)->position),
+ &delta, &coord1);
+ GIMP_ANCHOR (opposite->data)->position = coord1;
+ }
+ }
+ }
+}
+
+
+static void
+gimp_bezier_stroke_anchor_move_absolute (GimpStroke *stroke,
+ GimpAnchor *anchor,
+ const GimpCoords *coord,
+ GimpAnchorFeatureType feature)
+{
+ GimpCoords deltacoord;
+
+ gimp_coords_difference (coord, &anchor->position, &deltacoord);
+ gimp_bezier_stroke_anchor_move_relative (stroke, anchor,
+ &deltacoord, feature);
+}
+
+static void
+gimp_bezier_stroke_anchor_convert (GimpStroke *stroke,
+ GimpAnchor *anchor,
+ GimpAnchorFeatureType feature)
+{
+ GList *anchor_list;
+
+ anchor_list = g_queue_find (stroke->anchors, anchor);
+
+ g_return_if_fail (anchor_list != NULL);
+
+ switch (feature)
+ {
+ case GIMP_ANCHOR_FEATURE_EDGE:
+ if (anchor->type == GIMP_ANCHOR_ANCHOR)
+ {
+ if (g_list_previous (anchor_list))
+ GIMP_ANCHOR (g_list_previous (anchor_list)->data)->position =
+ anchor->position;
+
+ if (g_list_next (anchor_list))
+ GIMP_ANCHOR (g_list_next (anchor_list)->data)->position =
+ anchor->position;
+ }
+ else
+ {
+ if (g_list_previous (anchor_list) &&
+ GIMP_ANCHOR (g_list_previous (anchor_list)->data)->type == GIMP_ANCHOR_ANCHOR)
+ anchor->position = GIMP_ANCHOR (g_list_previous (anchor_list)->data)->position;
+ if (g_list_next (anchor_list) &&
+ GIMP_ANCHOR (g_list_next (anchor_list)->data)->type == GIMP_ANCHOR_ANCHOR)
+ anchor->position = GIMP_ANCHOR (g_list_next (anchor_list)->data)->position;
+ }
+
+ break;
+
+ default:
+ g_warning ("gimp_bezier_stroke_anchor_convert: "
+ "unimplemented anchor conversion %d\n", feature);
+ }
+}
+
+
+static GimpBezierDesc *
+gimp_bezier_stroke_make_bezier (GimpStroke *stroke)
+{
+ GArray *points;
+ GArray *cmd_array;
+ GimpBezierDesc *bezdesc;
+ cairo_path_data_t pathdata;
+ gint num_cmds, i;
+
+ points = gimp_stroke_control_points_get (stroke, NULL);
+
+ g_return_val_if_fail (points && points->len % 3 == 0, NULL);
+ if (points->len < 3)
+ return NULL;
+
+ /* Moveto + (n-1) * curveto + (if closed) curveto + closepath */
+ num_cmds = 2 + (points->len / 3 - 1) * 4;
+ if (stroke->closed)
+ num_cmds += 1 + 4;
+
+ cmd_array = g_array_sized_new (FALSE, FALSE,
+ sizeof (cairo_path_data_t),
+ num_cmds);
+
+ pathdata.header.type = CAIRO_PATH_MOVE_TO;
+ pathdata.header.length = 2;
+ g_array_append_val (cmd_array, pathdata);
+ pathdata.point.x = g_array_index (points, GimpAnchor, 1).position.x;
+ pathdata.point.y = g_array_index (points, GimpAnchor, 1).position.y;
+ g_array_append_val (cmd_array, pathdata);
+
+ for (i = 2; i+2 < points->len; i += 3)
+ {
+ pathdata.header.type = CAIRO_PATH_CURVE_TO;
+ pathdata.header.length = 4;
+ g_array_append_val (cmd_array, pathdata);
+
+ pathdata.point.x = g_array_index (points, GimpAnchor, i).position.x;
+ pathdata.point.y = g_array_index (points, GimpAnchor, i).position.y;
+ g_array_append_val (cmd_array, pathdata);
+
+ pathdata.point.x = g_array_index (points, GimpAnchor, i+1).position.x;
+ pathdata.point.y = g_array_index (points, GimpAnchor, i+1).position.y;
+ g_array_append_val (cmd_array, pathdata);
+
+ pathdata.point.x = g_array_index (points, GimpAnchor, i+2).position.x;
+ pathdata.point.y = g_array_index (points, GimpAnchor, i+2).position.y;
+ g_array_append_val (cmd_array, pathdata);
+ }
+
+ if (stroke->closed)
+ {
+ pathdata.header.type = CAIRO_PATH_CURVE_TO;
+ pathdata.header.length = 4;
+ g_array_append_val (cmd_array, pathdata);
+
+ pathdata.point.x = g_array_index (points, GimpAnchor, i).position.x;
+ pathdata.point.y = g_array_index (points, GimpAnchor, i).position.y;
+ g_array_append_val (cmd_array, pathdata);
+
+ pathdata.point.x = g_array_index (points, GimpAnchor, 0).position.x;
+ pathdata.point.y = g_array_index (points, GimpAnchor, 0).position.y;
+ g_array_append_val (cmd_array, pathdata);
+
+ pathdata.point.x = g_array_index (points, GimpAnchor, 1).position.x;
+ pathdata.point.y = g_array_index (points, GimpAnchor, 1).position.y;
+ g_array_append_val (cmd_array, pathdata);
+
+ pathdata.header.type = CAIRO_PATH_CLOSE_PATH;
+ pathdata.header.length = 1;
+ g_array_append_val (cmd_array, pathdata);
+ }
+
+ if (cmd_array->len != num_cmds)
+ g_printerr ("miscalculated path cmd length! (%d vs. %d)\n",
+ cmd_array->len, num_cmds);
+
+ bezdesc = gimp_bezier_desc_new ((cairo_path_data_t *) cmd_array->data,
+ cmd_array->len);
+ g_array_free (points, TRUE);
+ g_array_free (cmd_array, FALSE);
+
+ return bezdesc;
+}
+
+
+static GArray *
+gimp_bezier_stroke_interpolate (GimpStroke *stroke,
+ gdouble precision,
+ gboolean *ret_closed)
+{
+ GArray *ret_coords;
+ GimpAnchor *anchor;
+ GList *anchorlist;
+ GimpCoords segmentcoords[4];
+ gint count;
+ gboolean need_endpoint = FALSE;
+
+ if (g_queue_is_empty (stroke->anchors))
+ {
+ if (ret_closed)
+ *ret_closed = FALSE;
+ return NULL;
+ }
+
+ ret_coords = g_array_new (FALSE, FALSE, sizeof (GimpCoords));
+
+ count = 0;
+
+ for (anchorlist = stroke->anchors->head;
+ anchorlist && GIMP_ANCHOR (anchorlist->data)->type != GIMP_ANCHOR_ANCHOR;
+ anchorlist = g_list_next (anchorlist));
+
+ for ( ; anchorlist; anchorlist = g_list_next (anchorlist))
+ {
+ anchor = anchorlist->data;
+
+ segmentcoords[count] = anchor->position;
+ count++;
+
+ if (count == 4)
+ {
+ gimp_coords_interpolate_bezier (segmentcoords, precision,
+ ret_coords, NULL);
+ segmentcoords[0] = segmentcoords[3];
+ count = 1;
+ need_endpoint = TRUE;
+ }
+ }
+
+ if (stroke->closed && ! g_queue_is_empty (stroke->anchors))
+ {
+ anchorlist = stroke->anchors->head;
+
+ while (count < 3)
+ {
+ segmentcoords[count] = GIMP_ANCHOR (anchorlist->data)->position;
+ count++;
+ }
+ anchorlist = g_list_next (anchorlist);
+ if (anchorlist)
+ segmentcoords[3] = GIMP_ANCHOR (anchorlist->data)->position;
+
+ gimp_coords_interpolate_bezier (segmentcoords, precision,
+ ret_coords, NULL);
+ need_endpoint = TRUE;
+
+ }
+
+ if (need_endpoint)
+ ret_coords = g_array_append_val (ret_coords, segmentcoords[3]);
+
+ if (ret_closed)
+ *ret_closed = stroke->closed;
+
+ if (ret_coords->len == 0)
+ {
+ g_array_free (ret_coords, TRUE);
+ ret_coords = NULL;
+ }
+
+ return ret_coords;
+}
+
+
+static void
+gimp_bezier_stroke_transform (GimpStroke *stroke,
+ const GimpMatrix3 *matrix,
+ GQueue *ret_strokes)
+{
+ GimpStroke *first_stroke = NULL;
+ GimpStroke *last_stroke = NULL;
+ GList *anchorlist;
+ GimpAnchor *anchor;
+ GimpCoords segmentcoords[4];
+ GQueue *transformed[2];
+ gint n_transformed;
+ gint count;
+ gboolean first;
+ gboolean last;
+
+ /* if there's no need for clipping, use the default implementation */
+ if (! ret_strokes ||
+ gimp_matrix3_is_affine (matrix) ||
+ g_queue_is_empty (stroke->anchors))
+ {
+ GIMP_STROKE_CLASS (parent_class)->transform (stroke, matrix, ret_strokes);
+
+ return;
+ }
+
+ /* transform the individual segments */
+ count = 0;
+ first = TRUE;
+ last = FALSE;
+
+ /* find the first non-control anchor */
+ for (anchorlist = stroke->anchors->head;
+ anchorlist && GIMP_ANCHOR (anchorlist->data)->type != GIMP_ANCHOR_ANCHOR;
+ anchorlist = g_list_next (anchorlist));
+
+ for ( ; anchorlist || stroke->closed; anchorlist = g_list_next (anchorlist))
+ {
+ /* wrap around if 'stroke' is closed, so that we transform the final
+ * segment
+ */
+ if (! anchorlist)
+ {
+ anchorlist = stroke->anchors->head;
+ last = TRUE;
+ }
+
+ anchor = anchorlist->data;
+
+ segmentcoords[count] = anchor->position;
+ count++;
+
+ if (count == 4)
+ {
+ gboolean start_in;
+ gboolean end_in;
+ gint i;
+
+ gimp_transform_bezier_coords (matrix, segmentcoords,
+ transformed, &n_transformed,
+ &start_in, &end_in);
+
+ for (i = 0; i < n_transformed; i++)
+ {
+ GimpStroke *s = NULL;
+ GList *list;
+ gint j;
+
+ if (i == 0 && start_in)
+ {
+ /* current stroke is connected to last stroke */
+ s = last_stroke;
+ }
+ else if (last_stroke)
+ {
+ /* current stroke is not connected to last stroke. finalize
+ * last stroke.
+ */
+ anchor = g_queue_peek_tail (last_stroke->anchors);
+
+ g_queue_push_tail (last_stroke->anchors,
+ gimp_anchor_new (GIMP_ANCHOR_CONTROL,
+ &anchor->position));
+ }
+
+ for (list = transformed[i]->head; list; list = g_list_next (list))
+ {
+ GimpCoords *transformedcoords = list->data;
+
+ if (! s)
+ {
+ /* start a new stroke */
+ s = gimp_bezier_stroke_new ();
+
+ g_queue_push_tail (s->anchors,
+ gimp_anchor_new (GIMP_ANCHOR_CONTROL,
+ &transformedcoords[0]));
+
+ g_queue_push_tail (ret_strokes, s);
+
+ j = 0;
+ }
+ else
+ {
+ /* continue an existing stroke, skipping the first anchor,
+ * which is the same as the last anchor of the last stroke
+ */
+ j = 1;
+ }
+
+ for (; j < 4; j++)
+ {
+ GimpAnchorType type;
+
+ if (j == 0 || j == 3)
+ type = GIMP_ANCHOR_ANCHOR;
+ else
+ type = GIMP_ANCHOR_CONTROL;
+
+ g_queue_push_tail (s->anchors,
+ gimp_anchor_new (type,
+ &transformedcoords[j]));
+ }
+
+ g_free (transformedcoords);
+ }
+
+ g_queue_free (transformed[i]);
+
+ /* if the current stroke is an initial segment of 'stroke',
+ * remember it, so that we can possibly connect it to the last
+ * stroke later.
+ */
+ if (i == 0 && start_in && first)
+ first_stroke = s;
+
+ last_stroke = s;
+ first = FALSE;
+ }
+
+ if (! end_in && last_stroke)
+ {
+ /* the next stroke is not connected to the last stroke. finalize
+ * the last stroke.
+ */
+ anchor = g_queue_peek_tail (last_stroke->anchors);
+
+ g_queue_push_tail (last_stroke->anchors,
+ gimp_anchor_new (GIMP_ANCHOR_CONTROL,
+ &anchor->position));
+
+ last_stroke = NULL;
+ }
+
+ if (last)
+ break;
+
+ segmentcoords[0] = segmentcoords[3];
+ count = 1;
+ }
+ }
+
+ /* if the last stroke is a final segment of 'stroke'... */
+ if (last_stroke)
+ {
+ /* ... and the first stroke is an initial segment of 'stroke', and
+ * 'stroke' is closed ...
+ */
+ if (first_stroke && stroke->closed)
+ {
+ /* connect the first and last strokes */
+
+ /* remove the first anchor, which is a synthetic control point */
+ gimp_anchor_free (g_queue_pop_head (first_stroke->anchors));
+ /* remove the last anchor, which is the same anchor point as the
+ * first anchor
+ */
+ gimp_anchor_free (g_queue_pop_tail (last_stroke->anchors));
+
+ if (first_stroke == last_stroke)
+ {
+ /* the result is a single stroke. move the last anchor, which is
+ * an orphan control point, to the front, to fill in the removed
+ * control point of the first anchor, and close the stroke.
+ */
+ g_queue_push_head (first_stroke->anchors,
+ g_queue_pop_tail (first_stroke->anchors));
+
+ first_stroke->closed = TRUE;
+ }
+ else
+ {
+ /* the result is multiple strokes. prepend the last stroke to
+ * the first stroke, and discard it.
+ */
+ while ((anchor = g_queue_pop_tail (last_stroke->anchors)))
+ g_queue_push_head (first_stroke->anchors, anchor);
+
+ g_object_unref (g_queue_pop_tail (ret_strokes));
+ }
+ }
+ else
+ {
+ /* otherwise, the first and last strokes are not connected. finalize
+ * the last stroke.
+ */
+ anchor = g_queue_peek_tail (last_stroke->anchors);
+
+ g_queue_push_tail (last_stroke->anchors,
+ gimp_anchor_new (GIMP_ANCHOR_CONTROL,
+ &anchor->position));
+ }
+ }
+}
+
+
+GimpStroke *
+gimp_bezier_stroke_new_moveto (const GimpCoords *start)
+{
+ GimpStroke *stroke = gimp_bezier_stroke_new ();
+
+ g_queue_push_tail (stroke->anchors,
+ gimp_anchor_new (GIMP_ANCHOR_CONTROL,
+ start));
+ g_queue_push_tail (stroke->anchors,
+ gimp_anchor_new (GIMP_ANCHOR_ANCHOR,
+ start));
+ g_queue_push_tail (stroke->anchors,
+ gimp_anchor_new (GIMP_ANCHOR_CONTROL,
+ start));
+ return stroke;
+}
+
+void
+gimp_bezier_stroke_lineto (GimpStroke *stroke,
+ const GimpCoords *end)
+{
+ g_return_if_fail (GIMP_IS_BEZIER_STROKE (stroke));
+ g_return_if_fail (stroke->closed == FALSE);
+ g_return_if_fail (g_queue_is_empty (stroke->anchors) == FALSE);
+
+ g_queue_push_tail (stroke->anchors,
+ gimp_anchor_new (GIMP_ANCHOR_CONTROL,
+ end));
+ g_queue_push_tail (stroke->anchors,
+ gimp_anchor_new (GIMP_ANCHOR_ANCHOR,
+ end));
+ g_queue_push_tail (stroke->anchors,
+ gimp_anchor_new (GIMP_ANCHOR_CONTROL,
+ end));
+}
+
+void
+gimp_bezier_stroke_conicto (GimpStroke *stroke,
+ const GimpCoords *control,
+ const GimpCoords *end)
+{
+ GimpCoords start, coords;
+
+ g_return_if_fail (GIMP_IS_BEZIER_STROKE (stroke));
+ g_return_if_fail (stroke->closed == FALSE);
+ g_return_if_fail (g_queue_get_length (stroke->anchors) > 1);
+
+ start = GIMP_ANCHOR (stroke->anchors->tail->prev->data)->position;
+
+ gimp_coords_mix (2.0 / 3.0, control, 1.0 / 3.0, &start, &coords);
+
+ GIMP_ANCHOR (stroke->anchors->tail->data)->position = coords;
+
+ gimp_coords_mix (2.0 / 3.0, control, 1.0 / 3.0, end, &coords);
+
+ g_queue_push_tail (stroke->anchors,
+ gimp_anchor_new (GIMP_ANCHOR_CONTROL,
+ &coords));
+ g_queue_push_tail (stroke->anchors,
+ gimp_anchor_new (GIMP_ANCHOR_ANCHOR,
+ end));
+ g_queue_push_tail (stroke->anchors,
+ gimp_anchor_new (GIMP_ANCHOR_CONTROL,
+ end));
+}
+
+void
+gimp_bezier_stroke_cubicto (GimpStroke *stroke,
+ const GimpCoords *control1,
+ const GimpCoords *control2,
+ const GimpCoords *end)
+{
+ g_return_if_fail (GIMP_IS_BEZIER_STROKE (stroke));
+ g_return_if_fail (stroke->closed == FALSE);
+ g_return_if_fail (g_queue_is_empty (stroke->anchors) == FALSE);
+
+ GIMP_ANCHOR (stroke->anchors->tail->data)->position = *control1;
+
+ g_queue_push_tail (stroke->anchors,
+ gimp_anchor_new (GIMP_ANCHOR_CONTROL,
+ control2));
+ g_queue_push_tail (stroke->anchors,
+ gimp_anchor_new (GIMP_ANCHOR_ANCHOR,
+ end));
+ g_queue_push_tail (stroke->anchors,
+ gimp_anchor_new (GIMP_ANCHOR_CONTROL,
+ end));
+}
+
+static gdouble
+arcto_circleparam (gdouble h,
+ gdouble *y)
+{
+ gdouble t0 = 0.5;
+ gdouble dt = 0.25;
+ gdouble pt0;
+ gdouble y01, y12, y23, y012, y123, y0123; /* subdividing y[] */
+
+ while (dt >= 0.00001)
+ {
+ pt0 = ( y[0] * (1-t0) * (1-t0) * (1-t0) +
+ 3 * y[1] * (1-t0) * (1-t0) * t0 +
+ 3 * y[2] * (1-t0) * t0 * t0 +
+ y[3] * t0 * t0 * t0 );
+
+ if (pt0 > h)
+ t0 = t0 - dt;
+ else if (pt0 < h)
+ t0 = t0 + dt;
+ else
+ break;
+ dt = dt/2;
+ }
+
+ y01 = y[0] * (1-t0) + y[1] * t0;
+ y12 = y[1] * (1-t0) + y[2] * t0;
+ y23 = y[2] * (1-t0) + y[3] * t0;
+ y012 = y01 * (1-t0) + y12 * t0;
+ y123 = y12 * (1-t0) + y23 * t0;
+ y0123 = y012 * (1-t0) + y123 * t0;
+
+ y[0] = y0123; y[1] = y123; y[2] = y23; /* y[3] unchanged */
+
+ return t0;
+}
+
+static void
+arcto_subdivide (gdouble t,
+ gint part,
+ GimpCoords *p)
+{
+ GimpCoords p01, p12, p23, p012, p123, p0123;
+
+ gimp_coords_mix (1-t, &(p[0]), t, &(p[1]), &p01 );
+ gimp_coords_mix (1-t, &(p[1]), t, &(p[2]), &p12 );
+ gimp_coords_mix (1-t, &(p[2]), t, &(p[3]), &p23 );
+ gimp_coords_mix (1-t, &p01 , t, &p12 , &p012 );
+ gimp_coords_mix (1-t, &p12 , t, &p23 , &p123 );
+ gimp_coords_mix (1-t, &p012 , t, &p123 , &p0123);
+
+ if (part == 0)
+ {
+ /* p[0] unchanged */
+ p[1] = p01;
+ p[2] = p012;
+ p[3] = p0123;
+ }
+ else
+ {
+ p[0] = p0123;
+ p[1] = p123;
+ p[2] = p23;
+ /* p[3] unchanged */
+ }
+}
+
+static void
+arcto_ellipsesegment (gdouble radius_x,
+ gdouble radius_y,
+ gdouble phi0,
+ gdouble phi1,
+ GimpCoords *ellips)
+{
+ const GimpCoords template = GIMP_COORDS_DEFAULT_VALUES;
+ const gdouble circlemagic = 4.0 * (G_SQRT2 - 1.0) / 3.0;
+
+ gdouble phi_s, phi_e;
+ gdouble y[4];
+ gdouble h0, h1;
+ gdouble t0, t1;
+
+ g_return_if_fail (ellips != NULL);
+
+ y[0] = 0.0;
+ y[1] = circlemagic;
+ y[2] = 1.0;
+ y[3] = 1.0;
+
+ ellips[0] = template;
+ ellips[1] = template;
+ ellips[2] = template;
+ ellips[3] = template;
+
+ if (phi0 < phi1)
+ {
+ phi_s = floor (phi0 / G_PI_2) * G_PI_2;
+ while (phi_s < 0) phi_s += 2 * G_PI;
+ phi_e = phi_s + G_PI_2;
+ }
+ else
+ {
+ phi_e = floor (phi1 / G_PI_2) * G_PI_2;
+ while (phi_e < 0) phi_e += 2 * G_PI;
+ phi_s = phi_e + G_PI_2;
+ }
+
+ h0 = sin (fabs (phi0-phi_s));
+ h1 = sin (fabs (phi1-phi_s));
+
+ ellips[0].x = cos (phi_s); ellips[0].y = sin (phi_s);
+ ellips[3].x = cos (phi_e); ellips[3].y = sin (phi_e);
+
+ gimp_coords_mix (1, &(ellips[0]), circlemagic, &(ellips[3]), &(ellips[1]));
+ gimp_coords_mix (circlemagic, &(ellips[0]), 1, &(ellips[3]), &(ellips[2]));
+
+ if (h0 > y[0])
+ {
+ t0 = arcto_circleparam (h0, y); /* also subdivides y[] at t0 */
+ arcto_subdivide (t0, 1, ellips);
+ }
+
+ if (h1 < y[3])
+ {
+ t1 = arcto_circleparam (h1, y);
+ arcto_subdivide (t1, 0, ellips);
+ }
+
+ ellips[0].x *= radius_x ; ellips[0].y *= radius_y;
+ ellips[1].x *= radius_x ; ellips[1].y *= radius_y;
+ ellips[2].x *= radius_x ; ellips[2].y *= radius_y;
+ ellips[3].x *= radius_x ; ellips[3].y *= radius_y;
+}
+
+void
+gimp_bezier_stroke_arcto (GimpStroke *bez_stroke,
+ gdouble radius_x,
+ gdouble radius_y,
+ gdouble angle_rad,
+ gboolean large_arc,
+ gboolean sweep,
+ const GimpCoords *end)
+{
+ GimpCoords start;
+ GimpCoords middle; /* between start and end */
+ GimpCoords trans_delta;
+ GimpCoords trans_center;
+ GimpCoords tmp_center;
+ GimpCoords center;
+ GimpCoords ellips[4]; /* control points of untransformed ellipse segment */
+ GimpCoords ctrl[4]; /* control points of next bezier segment */
+
+ GimpMatrix3 anglerot;
+
+ gdouble lambda;
+ gdouble phi0, phi1, phi2;
+ gdouble tmpx, tmpy;
+
+ g_return_if_fail (GIMP_IS_BEZIER_STROKE (bez_stroke));
+ g_return_if_fail (bez_stroke->closed == FALSE);
+ g_return_if_fail (g_queue_get_length (bez_stroke->anchors) > 1);
+
+ if (radius_x == 0 || radius_y == 0)
+ {
+ gimp_bezier_stroke_lineto (bez_stroke, end);
+ return;
+ }
+
+ start = GIMP_ANCHOR (bez_stroke->anchors->tail->prev->data)->position;
+
+ gimp_matrix3_identity (&anglerot);
+ gimp_matrix3_rotate (&anglerot, -angle_rad);
+
+ gimp_coords_mix (0.5, &start, -0.5, end, &trans_delta);
+ gimp_matrix3_transform_point (&anglerot,
+ trans_delta.x, trans_delta.y,
+ &tmpx, &tmpy);
+ trans_delta.x = tmpx;
+ trans_delta.y = tmpy;
+
+ lambda = (SQR (trans_delta.x) / SQR (radius_x) +
+ SQR (trans_delta.y) / SQR (radius_y));
+
+ if (lambda < 0.00001)
+ {
+ /* don't bother with it - endpoint is too close to startpoint */
+ return;
+ }
+
+ trans_center = trans_delta;
+
+ if (lambda > 1.0)
+ {
+ /* The radii are too small for a matching ellipse. We expand them
+ * so that they fit exactly (center of the ellipse between the
+ * start- and endpoint
+ */
+ radius_x *= sqrt (lambda);
+ radius_y *= sqrt (lambda);
+ trans_center.x = 0.0;
+ trans_center.y = 0.0;
+ }
+ else
+ {
+ gdouble factor = sqrt ((1.0 - lambda) / lambda);
+
+ trans_center.x = trans_delta.y * radius_x / radius_y * factor;
+ trans_center.y = - trans_delta.x * radius_y / radius_x * factor;
+ }
+
+ if ((large_arc && sweep) || (!large_arc && !sweep))
+ {
+ trans_center.x *= -1;
+ trans_center.y *= -1;
+ }
+
+ gimp_matrix3_identity (&anglerot);
+ gimp_matrix3_rotate (&anglerot, angle_rad);
+
+ tmp_center = trans_center;
+ gimp_matrix3_transform_point (&anglerot,
+ tmp_center.x, tmp_center.y,
+ &tmpx, &tmpy);
+ tmp_center.x = tmpx;
+ tmp_center.y = tmpy;
+
+ gimp_coords_mix (0.5, &start, 0.5, end, &middle);
+ gimp_coords_add (&tmp_center, &middle, &center);
+
+ phi1 = atan2 ((trans_delta.y - trans_center.y) / radius_y,
+ (trans_delta.x - trans_center.x) / radius_x);
+
+ phi2 = atan2 ((- trans_delta.y - trans_center.y) / radius_y,
+ (- trans_delta.x - trans_center.x) / radius_x);
+
+ if (phi1 < 0)
+ phi1 += 2 * G_PI;
+
+ if (phi2 < 0)
+ phi2 += 2 * G_PI;
+
+ if (sweep)
+ {
+ while (phi2 < phi1)
+ phi2 += 2 * G_PI;
+
+ phi0 = floor (phi1 / G_PI_2) * G_PI_2;
+
+ while (phi0 < phi2)
+ {
+ arcto_ellipsesegment (radius_x, radius_y,
+ MAX (phi0, phi1), MIN (phi0 + G_PI_2, phi2),
+ ellips);
+
+ gimp_matrix3_transform_point (&anglerot, ellips[0].x, ellips[0].y,
+ &tmpx, &tmpy);
+ ellips[0].x = tmpx; ellips[0].y = tmpy;
+ gimp_matrix3_transform_point (&anglerot, ellips[1].x, ellips[1].y,
+ &tmpx, &tmpy);
+ ellips[1].x = tmpx; ellips[1].y = tmpy;
+ gimp_matrix3_transform_point (&anglerot, ellips[2].x, ellips[2].y,
+ &tmpx, &tmpy);
+ ellips[2].x = tmpx; ellips[2].y = tmpy;
+ gimp_matrix3_transform_point (&anglerot, ellips[3].x, ellips[3].y,
+ &tmpx, &tmpy);
+ ellips[3].x = tmpx; ellips[3].y = tmpy;
+
+ gimp_coords_add (&center, &(ellips[1]), &(ctrl[1]));
+ gimp_coords_add (&center, &(ellips[2]), &(ctrl[2]));
+ gimp_coords_add (&center, &(ellips[3]), &(ctrl[3]));
+
+ gimp_bezier_stroke_cubicto (bez_stroke,
+ &(ctrl[1]), &(ctrl[2]), &(ctrl[3]));
+ phi0 += G_PI_2;
+ }
+ }
+ else
+ {
+ while (phi1 < phi2)
+ phi1 += 2 * G_PI;
+
+ phi0 = ceil (phi1 / G_PI_2) * G_PI_2;
+
+ while (phi0 > phi2)
+ {
+ arcto_ellipsesegment (radius_x, radius_y,
+ MIN (phi0, phi1), MAX (phi0 - G_PI_2, phi2),
+ ellips);
+
+ gimp_matrix3_transform_point (&anglerot, ellips[0].x, ellips[0].y,
+ &tmpx, &tmpy);
+ ellips[0].x = tmpx; ellips[0].y = tmpy;
+ gimp_matrix3_transform_point (&anglerot, ellips[1].x, ellips[1].y,
+ &tmpx, &tmpy);
+ ellips[1].x = tmpx; ellips[1].y = tmpy;
+ gimp_matrix3_transform_point (&anglerot, ellips[2].x, ellips[2].y,
+ &tmpx, &tmpy);
+ ellips[2].x = tmpx; ellips[2].y = tmpy;
+ gimp_matrix3_transform_point (&anglerot, ellips[3].x, ellips[3].y,
+ &tmpx, &tmpy);
+ ellips[3].x = tmpx; ellips[3].y = tmpy;
+
+ gimp_coords_add (&center, &(ellips[1]), &(ctrl[1]));
+ gimp_coords_add (&center, &(ellips[2]), &(ctrl[2]));
+ gimp_coords_add (&center, &(ellips[3]), &(ctrl[3]));
+
+ gimp_bezier_stroke_cubicto (bez_stroke,
+ &(ctrl[1]), &(ctrl[2]), &(ctrl[3]));
+ phi0 -= G_PI_2;
+ }
+ }
+}
+
+GimpStroke *
+gimp_bezier_stroke_new_ellipse (const GimpCoords *center,
+ gdouble radius_x,
+ gdouble radius_y,
+ gdouble angle)
+{
+ GimpStroke *stroke;
+ GimpCoords p1 = *center;
+ GimpCoords p2 = *center;
+ GimpCoords p3 = *center;
+ GimpCoords dx = { 0, };
+ GimpCoords dy = { 0, };
+ const gdouble circlemagic = 4.0 * (G_SQRT2 - 1.0) / 3.0;
+ GimpAnchor *handle;
+
+ dx.x = radius_x * cos (angle);
+ dx.y = - radius_x * sin (angle);
+ dy.x = radius_y * sin (angle);
+ dy.y = radius_y * cos (angle);
+
+ gimp_coords_mix (1.0, center, 1.0, &dx, &p1);
+ stroke = gimp_bezier_stroke_new_moveto (&p1);
+
+ handle = g_queue_peek_head (stroke->anchors);
+ gimp_coords_mix (1.0, &p1, -circlemagic, &dy, &handle->position);
+
+ gimp_coords_mix (1.0, &p1, circlemagic, &dy, &p1);
+ gimp_coords_mix (1.0, center, 1.0, &dy, &p3);
+ gimp_coords_mix (1.0, &p3, circlemagic, &dx, &p2);
+ gimp_bezier_stroke_cubicto (stroke, &p1, &p2, &p3);
+
+ gimp_coords_mix (1.0, &p3, -circlemagic, &dx, &p1);
+ gimp_coords_mix (1.0, center, -1.0, &dx, &p3);
+ gimp_coords_mix (1.0, &p3, circlemagic, &dy, &p2);
+ gimp_bezier_stroke_cubicto (stroke, &p1, &p2, &p3);
+
+ gimp_coords_mix (1.0, &p3, -circlemagic, &dy, &p1);
+ gimp_coords_mix (1.0, center, -1.0, &dy, &p3);
+ gimp_coords_mix (1.0, &p3, -circlemagic, &dx, &p2);
+ gimp_bezier_stroke_cubicto (stroke, &p1, &p2, &p3);
+
+ handle = g_queue_peek_tail (stroke->anchors);
+ gimp_coords_mix (1.0, &p3, circlemagic, &dx, &handle->position);
+
+ gimp_stroke_close (stroke);
+
+ return stroke;
+}
+
+
+/* helper function to get the associated anchor of a listitem */
+
+static GList *
+gimp_bezier_stroke_get_anchor_listitem (GList *list)
+{
+ if (!list)
+ return NULL;
+
+ if (GIMP_ANCHOR (list->data)->type == GIMP_ANCHOR_ANCHOR)
+ return list;
+
+ if (list->prev && GIMP_ANCHOR (list->prev->data)->type == GIMP_ANCHOR_ANCHOR)
+ return list->prev;
+
+ if (list->next && GIMP_ANCHOR (list->next->data)->type == GIMP_ANCHOR_ANCHOR)
+ return list->next;
+
+ g_return_val_if_fail (/* bezier stroke inconsistent! */ FALSE, NULL);
+
+ return NULL;
+}
generated by cgit v1.2.3 (git 2.39.1) at 2024-06-09 04:00:46 +0000