Adding upstream version 2.10.22.upstream/2.10.22upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 536 insertions, 0 deletions

diff --git a/plug-ins/selection-to-path/selection-to-path.c b/plug-ins/selection-to-path/selection-to-path.c
new file mode 100644
index 0000000..52fc849
--- /dev/null
+++ b/plug-ins/selection-to-path/selection-to-path.c
@@ -0,0 +1,536 @@
+/*
+ * Copyright (C) 1995 Spencer Kimball and Peter Mattis
+ *
+ * This is a plug-in for GIMP.
+ *
+ * Plugin to convert a selection to a path.
+ *
+ * Copyright (C) 1999 Andy Thomas  alt@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/>.
+ *
+ */
+
+/* Change log:-
+ * 0.1 First version.
+ */
+
+#include "config.h"
+
+#include <string.h>
+
+#include "libgimp/gimp.h"
+#include "libgimp/gimpui.h"
+
+#include "libgimpmath/gimpmath.h"
+
+#include "global.h"
+#include "types.h"
+#include "pxl-outline.h"
+#include "fit.h"
+#include "spline.h"
+#include "selection-to-path.h"
+
+#include "libgimp/stdplugins-intl.h"
+
+
+#define PLUG_IN_BINARY "selection-to-path"
+#define PLUG_IN_ROLE   "gimp-selection-to-path"
+
+#define RESPONSE_RESET 1
+#define MID_POINT      127
+
+/***** Magic numbers *****/
+
+/* Variables set in dialog box */
+
+static void      query  (void);
+static void      run    (const gchar      *name,
+                         gint              nparams,
+                         const GimpParam  *param,
+                         gint             *nreturn_vals,
+                         GimpParam       **return_vals);
+
+static gint      sel2path_dialog         (SELVALS   *sels);
+static void      sel2path_response       (GtkWidget *widget,
+                                          gint       response_id,
+                                          gpointer   data);
+static void      dialog_print_selVals    (SELVALS   *sels);
+static gboolean  sel2path                (gint32     image_ID);
+
+
+const GimpPlugInInfo PLUG_IN_INFO =
+{
+  NULL,    /* init_proc */
+  NULL,    /* quit_proc */
+  query,   /* query_proc */
+  run,     /* run_proc */
+};
+
+static gint         sel_x1, sel_y1, sel_x2, sel_y2;
+static gint         has_sel, sel_width, sel_height;
+static SELVALS      selVals;
+static GeglSampler *sel_sampler;
+static gboolean     retVal = TRUE;  /* Toggle if cancel button clicked */
+
+MAIN ()
+
+static void
+query (void)
+{
+  static const GimpParamDef args[] =
+  {
+    { GIMP_PDB_INT32,    "run-mode", "The run mode { RUN-INTERACTIVE (0), RUN-NONINTERACTIVE (1) }" },
+    { GIMP_PDB_IMAGE,    "image",    "Input image" },
+    { GIMP_PDB_DRAWABLE, "drawable", "Input drawable (unused)" },
+  };
+
+  static const GimpParamDef advanced_args[] =
+  {
+    { GIMP_PDB_INT32,    "run-mode",                    "The run mode { RUN-INTERACTIVE (0), RUN-NONINTERACTIVE (1) }" },
+    { GIMP_PDB_IMAGE,    "image",                       "Input image" },
+    { GIMP_PDB_DRAWABLE, "drawable",                    "Input drawable (unused)" },
+    { GIMP_PDB_FLOAT,    "align-threshold",             "align_threshold"},
+    { GIMP_PDB_FLOAT,    "corner-always-threshold",     "corner_always_threshold"},
+    { GIMP_PDB_INT8,     "corner-surround",             "corner_surround"},
+    { GIMP_PDB_FLOAT,    "corner-threshold",            "corner_threshold"},
+    { GIMP_PDB_FLOAT,    "error-threshold",             "error_threshold"},
+    { GIMP_PDB_INT8,     "filter-alternative-surround", "filter_alternative_surround"},
+    { GIMP_PDB_FLOAT,    "filter-epsilon",              "filter_epsilon"},
+    { GIMP_PDB_INT8,     "filter-iteration-count",      "filter_iteration_count"},
+    { GIMP_PDB_FLOAT,    "filter-percent",              "filter_percent"},
+    { GIMP_PDB_INT8,     "filter-secondary-surround",   "filter_secondary_surround"},
+    { GIMP_PDB_INT8,     "filter-surround",             "filter_surround"},
+    { GIMP_PDB_INT8,     "keep-knees",                  "{1-Yes, 0-No}"},
+    { GIMP_PDB_FLOAT,    "line-reversion-threshold",    "line_reversion_threshold"},
+    { GIMP_PDB_FLOAT,    "line-threshold",              "line_threshold"},
+    { GIMP_PDB_FLOAT,    "reparameterize-improvement",  "reparameterize_improvement"},
+    { GIMP_PDB_FLOAT,    "reparameterize-threshold",    "reparameterize_threshold"},
+    { GIMP_PDB_FLOAT,    "subdivide-search",            "subdivide_search"},
+    { GIMP_PDB_INT8,     "subdivide-surround",          "subdivide_surround"},
+    { GIMP_PDB_FLOAT,    "subdivide-threshold",         "subdivide_threshold"},
+    { GIMP_PDB_INT8,     "tangent-surround",            "tangent_surround"},
+  };
+
+  gimp_install_procedure ("plug-in-sel2path",
+                          "Converts a selection to a path",
+                          "Converts a selection to a path",
+                          "Andy Thomas",
+                          "Andy Thomas",
+                          "1999",
+                          NULL,
+                          "RGB*, INDEXED*, GRAY*",
+                          GIMP_PLUGIN,
+                          G_N_ELEMENTS (args), 0,
+                          args, NULL);
+
+  gimp_install_procedure ("plug-in-sel2path-advanced",
+                          "Converts a selection to a path (with advanced user menu)",
+                          "Converts a selection to a path (with advanced user menu)",
+                          "Andy Thomas",
+                          "Andy Thomas",
+                          "1999",
+                          NULL,
+                          "RGB*, INDEXED*, GRAY*",
+                          GIMP_PLUGIN,
+                          G_N_ELEMENTS (advanced_args), 0,
+                          advanced_args, NULL);
+}
+
+static void
+run (const gchar      *name,
+     gint              nparams,
+     const GimpParam  *param,
+     gint             *nreturn_vals,
+     GimpParam       **return_vals)
+{
+  static GimpParam   values[1];
+  gint32             image_ID;
+  GimpRunMode        run_mode;
+  GimpPDBStatusType  status    = GIMP_PDB_SUCCESS;
+  gboolean           no_dialog;
+
+  INIT_I18N ();
+  gegl_init (NULL, NULL);
+
+  run_mode = param[0].data.d_int32;
+
+  no_dialog = (strcmp (name, "plug-in-sel2path") == 0);
+
+  *nreturn_vals = 1;
+  *return_vals = values;
+
+  values[0].type = GIMP_PDB_STATUS;
+  values[0].data.d_status = status;
+
+  image_ID = param[1].data.d_image;
+  if (image_ID < 0)
+    {
+      g_warning ("plug-in-sel2path needs a valid image ID");
+      return;
+    }
+
+  if (gimp_selection_is_empty (image_ID))
+    {
+      g_message (_("No selection to convert"));
+      return;
+    }
+
+  fit_set_default_params (&selVals);
+
+  if (!no_dialog)
+    {
+      switch (run_mode)
+        {
+        case GIMP_RUN_INTERACTIVE:
+          if (gimp_get_data_size ("plug-in-sel2path-advanced") > 0)
+            {
+              gimp_get_data ("plug-in-sel2path-advanced", &selVals);
+            }
+
+          if (!sel2path_dialog (&selVals))
+            return;
+
+          /* Get the current settings */
+          fit_set_params (&selVals);
+          break;
+
+        case GIMP_RUN_NONINTERACTIVE:
+          if (nparams != 23)
+            status = GIMP_PDB_CALLING_ERROR;
+
+          if (status == GIMP_PDB_SUCCESS)
+            {
+              selVals.align_threshold             =  param[3].data.d_float;
+              selVals.corner_always_threshold     =  param[4].data.d_float;
+              selVals.corner_surround             =  param[5].data.d_int8;
+              selVals.corner_threshold            =  param[6].data.d_float;
+              selVals.error_threshold             =  param[7].data.d_float;
+              selVals.filter_alternative_surround =  param[8].data.d_int8;
+              selVals.filter_epsilon              =  param[9].data.d_float;
+              selVals.filter_iteration_count      = param[10].data.d_int8;
+              selVals.filter_percent              = param[11].data.d_float;
+              selVals.filter_secondary_surround   = param[12].data.d_int8;
+              selVals.filter_surround             = param[13].data.d_int8;
+              selVals.keep_knees                  = param[14].data.d_int8;
+              selVals.line_reversion_threshold    = param[15].data.d_float;
+              selVals.line_threshold              = param[16].data.d_float;
+              selVals.reparameterize_improvement  = param[17].data.d_float;
+              selVals.reparameterize_threshold    = param[18].data.d_float;
+              selVals.subdivide_search            = param[19].data.d_float;
+              selVals.subdivide_surround          = param[20].data.d_int8;
+              selVals.subdivide_threshold         = param[21].data.d_float;
+              selVals.tangent_surround            = param[22].data.d_int8;
+              fit_set_params (&selVals);
+            }
+          break;
+
+        case GIMP_RUN_WITH_LAST_VALS:
+          if(gimp_get_data_size ("plug-in-sel2path-advanced") > 0)
+            {
+              gimp_get_data ("plug-in-sel2path-advanced", &selVals);
+
+              /* Set up the last values */
+              fit_set_params (&selVals);
+            }
+          break;
+
+        default:
+          break;
+        }
+    }
+
+  sel2path (image_ID);
+  values[0].data.d_status = status;
+
+  if (status == GIMP_PDB_SUCCESS)
+    {
+      dialog_print_selVals(&selVals);
+      if (run_mode == GIMP_RUN_INTERACTIVE && !no_dialog)
+        gimp_set_data ("plug-in-sel2path-advanced", &selVals, sizeof(SELVALS));
+    }
+}
+
+static void
+dialog_print_selVals (SELVALS *sels)
+{
+#if 0
+  printf ("selVals.align_threshold %g\n",             selVals.align_threshold);
+  printf ("selVals.corner_always_threshol %g\n",      selVals.corner_always_threshold);
+  printf ("selVals.corner_surround %g\n",             selVals.corner_surround);
+  printf ("selVals.corner_threshold %g\n",            selVals.corner_threshold);
+  printf ("selVals.error_threshold %g\n",             selVals.error_threshold);
+  printf ("selVals.filter_alternative_surround %g\n", selVals.filter_alternative_surround);
+  printf ("selVals.filter_epsilon %g\n",              selVals.filter_epsilon);
+  printf ("selVals.filter_iteration_count %g\n",      selVals.filter_iteration_count);
+  printf ("selVals.filter_percent %g\n",              selVals.filter_percent);
+  printf ("selVals.filter_secondary_surround %g\n",   selVals.filter_secondary_surround);
+  printf ("selVals.filter_surround %g\n",             selVals.filter_surround);
+  printf ("selVals.keep_knees %d\n",                  selVals.keep_knees);
+  printf ("selVals.line_reversion_threshold %g\n",    selVals.line_reversion_threshold);
+  printf ("selVals.line_threshold %g\n",              selVals.line_threshold);
+  printf ("selVals.reparameterize_improvement %g\n",  selVals.reparameterize_improvement);
+  printf ("selVals.reparameterize_threshold %g\n",    selVals.reparameterize_threshold);
+  printf ("selVals.subdivide_search %g\n"             selVals.subdivide_search);
+  printf ("selVals.subdivide_surround %g\n",          selVals.subdivide_surround);
+  printf ("selVals.subdivide_threshold %g\n",         selVals.subdivide_threshold);
+  printf ("selVals.tangent_surround %g\n",            selVals.tangent_surround);
+#endif /* 0 */
+}
+
+/* Build the dialog up. This was the hard part! */
+static gint
+sel2path_dialog (SELVALS *sels)
+{
+  GtkWidget *dlg;
+  GtkWidget *table;
+
+  retVal = FALSE;
+
+  gimp_ui_init (PLUG_IN_BINARY, FALSE);
+
+  dlg = gimp_dialog_new (_("Selection to Path Advanced Settings"),
+                         PLUG_IN_ROLE,
+                         NULL, 0,
+                         gimp_standard_help_func, "plug-in-sel2path-advanced",
+
+                         _("_Reset"), RESPONSE_RESET,
+                         _("_Cancel"), GTK_RESPONSE_CANCEL,
+                         _("_OK"),     GTK_RESPONSE_OK,
+
+                         NULL);
+
+  gtk_dialog_set_alternative_button_order (GTK_DIALOG (dlg),
+                                           RESPONSE_RESET,
+                                           GTK_RESPONSE_OK,
+                                           GTK_RESPONSE_CANCEL,
+                                           -1);
+
+  gimp_window_set_transient (GTK_WINDOW (dlg));
+
+  g_signal_connect (dlg, "response",
+                    G_CALLBACK (sel2path_response),
+                    NULL);
+  g_signal_connect (dlg, "destroy",
+                    G_CALLBACK (gtk_main_quit),
+                    NULL);
+
+  table = dialog_create_selection_area (sels);
+  gtk_container_set_border_width (GTK_CONTAINER (table), 12);
+  gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dlg))),
+                      table, TRUE, TRUE, 0);
+  gtk_widget_show (table);
+
+  gtk_widget_show (dlg);
+
+  gtk_main ();
+
+  return retVal;
+}
+
+static void
+sel2path_response (GtkWidget *widget,
+                   gint       response_id,
+                   gpointer   data)
+{
+  switch (response_id)
+    {
+    case RESPONSE_RESET:
+      reset_adv_dialog ();
+      fit_set_params (&selVals);
+      break;
+
+    case GTK_RESPONSE_OK:
+      retVal = TRUE;
+
+    default:
+      gtk_widget_destroy (widget);
+      break;
+    }
+}
+
+guchar
+sel_pixel_value (gint row,
+                 gint col)
+{
+  guchar ret;
+
+  if (col > sel_width || row > sel_height)
+    {
+      g_warning ("sel_pixel_value [%d,%d] out of bounds", col, row);
+      return 0;
+    }
+
+  gegl_sampler_get (sel_sampler,
+                    col + sel_x1, row + sel_y1, NULL, &ret, GEGL_ABYSS_NONE);
+
+  return ret;
+}
+
+gboolean
+sel_pixel_is_white (gint row,
+                    gint col)
+{
+  if (sel_pixel_value (row, col) < MID_POINT)
+    return TRUE;
+  else
+    return FALSE;
+}
+
+gint
+sel_get_width (void)
+{
+  return sel_width;
+}
+
+gint
+sel_get_height (void)
+{
+  return sel_height;
+}
+
+gboolean
+sel_valid_pixel (gint row,
+                 gint col)
+{
+  return (0 <= (row) && (row) < sel_get_height ()
+          && 0 <= (col) && (col) < sel_get_width ());
+}
+
+
+static void
+do_points (spline_list_array_type in_splines,
+           gint32                 image_ID)
+{
+  gint32   vectors;
+  gint32   stroke;
+  gint     i, j;
+  gboolean have_points = FALSE;
+  spline_list_type spline_list;
+
+  /* check if there really is something to do... */
+  for (i = 0; i < SPLINE_LIST_ARRAY_LENGTH (in_splines); i++)
+    {
+      spline_list = SPLINE_LIST_ARRAY_ELT (in_splines, i);
+      /* Ignore single points that are on their own */
+      if (SPLINE_LIST_LENGTH (spline_list) < 2)
+        continue;
+      have_points = TRUE;
+      break;
+    }
+
+  if (!have_points)
+    return;
+
+  vectors = gimp_vectors_new (image_ID, _("Selection"));
+
+  for (j = 0; j < SPLINE_LIST_ARRAY_LENGTH (in_splines); j++)
+    {
+      spline_type seg;
+
+      spline_list = SPLINE_LIST_ARRAY_ELT (in_splines, j);
+
+      /* Ignore single points that are on their own */
+      if (SPLINE_LIST_LENGTH (spline_list) < 2)
+        continue;
+
+      /*
+       * we're constructing the path backwards
+       * to have the result of least surprise for "Text along Path".
+       */
+      seg = SPLINE_LIST_ELT (spline_list, SPLINE_LIST_LENGTH (spline_list) - 1);
+      stroke = gimp_vectors_bezier_stroke_new_moveto (vectors,
+                                                      END_POINT (seg).x,
+                                                      END_POINT (seg).y);
+
+      for (i = SPLINE_LIST_LENGTH (spline_list); i > 0; i--)
+        {
+          seg = SPLINE_LIST_ELT (spline_list, i-1);
+
+          if (SPLINE_DEGREE (seg) == LINEAR)
+            gimp_vectors_bezier_stroke_lineto (vectors, stroke,
+                                               START_POINT (seg).x,
+                                               START_POINT (seg).y);
+          else if (SPLINE_DEGREE (seg) == CUBIC)
+            gimp_vectors_bezier_stroke_cubicto (vectors, stroke,
+                                                CONTROL2 (seg).x,
+                                                CONTROL2 (seg).y,
+                                                CONTROL1 (seg).x,
+                                                CONTROL1 (seg).y,
+                                                START_POINT (seg).x,
+                                                START_POINT (seg).y);
+          else
+            g_warning ("print_spline: strange degree (%d)",
+                       SPLINE_DEGREE (seg));
+        }
+
+      gimp_vectors_stroke_close (vectors, stroke);
+
+      /* transform to GIMPs coordinate system, taking the selections
+       * bounding box into account  */
+      gimp_vectors_stroke_scale (vectors, stroke, 1.0, -1.0);
+      gimp_vectors_stroke_translate (vectors, stroke,
+                                     sel_x1, sel_y1 + sel_height + 1);
+    }
+
+  gimp_image_insert_vectors (image_ID, vectors, -1, -1);
+}
+
+
+static gboolean
+sel2path (gint32 image_ID)
+{
+  gint32                   selection_ID;
+  GeglBuffer              *sel_buffer;
+  pixel_outline_list_type  olt;
+  spline_list_array_type   splines;
+
+  gimp_selection_bounds (image_ID, &has_sel,
+                         &sel_x1, &sel_y1, &sel_x2, &sel_y2);
+
+  sel_width  = sel_x2 - sel_x1;
+  sel_height = sel_y2 - sel_y1;
+
+  /* Now get the selection channel */
+
+  selection_ID = gimp_image_get_selection (image_ID);
+
+  if (selection_ID < 0)
+    return FALSE;
+
+  sel_buffer  = gimp_drawable_get_buffer (selection_ID);
+  sel_sampler = gegl_buffer_sampler_new (sel_buffer,
+                                         babl_format ("Y u8"),
+                                         GEGL_SAMPLER_NEAREST);
+
+  olt = find_outline_pixels ();
+
+  splines = fitted_splines (olt);
+
+  do_points (splines, image_ID);
+
+  g_object_unref (sel_sampler);
+  g_object_unref (sel_buffer);
+
+  gimp_displays_flush ();
+
+  return TRUE;
+}
+
+void
+safe_free (address *item)
+{
+  g_free (*item);
+  *item = NULL;
+}