[gimp] app: reorganize the line art code inside a GimpLineArt object.



commit db18c679f382f5e0647e8204760f95659ea96126
Author: Jehan <jehan girinstud io>
Date:   Sat Dec 1 18:33:51 2018 +0100

    app: reorganize the line art code inside a GimpLineArt object.
    
    The code was too much spread out, in core and tool code, and also it was
    made too specific to fill. I'll want to reuse this code at least in the
    fuzzy select tool. This will avoid code duplication, and also make this
    new process more self-contained and simpler to review later (the
    algorithm also has a lot of settings and it is much cleaner to have them
    as properties rather than passing these as parameters through many
    functions).
    
    The refactoring may not be finished; that's at least a first step.

 app/core/core-types.h                     |   1 +
 app/core/gimpchannel-select.c             |   3 +-
 app/core/gimpdrawable-bucket-fill.c       |  27 +-
 app/core/gimpdrawable-bucket-fill.h       |  14 +-
 app/core/gimplineart.c                    | 749 +++++++++++++++++++++++++++---
 app/core/gimplineart.h                    |  52 ++-
 app/core/gimppickable-contiguous-region.c | 272 +----------
 app/core/gimppickable-contiguous-region.h |  25 +-
 app/pdb/drawable-edit-cmds.c              |   3 +-
 app/tools/gimpbucketfilltool.c            | 295 ++++--------
 app/tools/gimpfuzzyselecttool.c           |   3 +-
 pdb/groups/drawable_edit.pdb              |   3 +-
 12 files changed, 826 insertions(+), 621 deletions(-)
---
diff --git a/app/core/core-types.h b/app/core/core-types.h
index b427704f14..ad1565fbac 100644
--- a/app/core/core-types.h
+++ b/app/core/core-types.h
@@ -196,6 +196,7 @@ typedef struct _GimpHistogram                   GimpHistogram;
 typedef struct _GimpIdTable                     GimpIdTable;
 typedef struct _GimpImagefile                   GimpImagefile;
 typedef struct _GimpInterpreterDB               GimpInterpreterDB;
+typedef struct _GimpLineArt                     GimpLineArt;
 typedef struct _GimpObjectQueue                 GimpObjectQueue;
 typedef struct _GimpParasiteList                GimpParasiteList;
 typedef struct _GimpPdbProgress                 GimpPdbProgress;
diff --git a/app/core/gimpchannel-select.c b/app/core/gimpchannel-select.c
index d23cadcb05..dd6c433aee 100644
--- a/app/core/gimpchannel-select.c
+++ b/app/core/gimpchannel-select.c
@@ -516,13 +516,12 @@ gimp_channel_select_fuzzy (GimpChannel         *channel,
     pickable = GIMP_PICKABLE (drawable);
 
   add_on = gimp_pickable_contiguous_region_by_seed (pickable,
-                                                    NULL, NULL,
+                                                    NULL,
                                                     antialias,
                                                     threshold,
                                                     select_transparent,
                                                     select_criterion,
                                                     diagonal_neighbors,
-                                                    0.92, 3, 20, 60, /* TODO */
                                                     x, y);
 
   if (! sample_merged)
diff --git a/app/core/gimpdrawable-bucket-fill.c b/app/core/gimpdrawable-bucket-fill.c
index 9ff6f0a3da..030c6edcde 100644
--- a/app/core/gimpdrawable-bucket-fill.c
+++ b/app/core/gimpdrawable-bucket-fill.c
@@ -49,18 +49,13 @@
 
 void
 gimp_drawable_bucket_fill (GimpDrawable         *drawable,
-                           GeglBuffer           *line_art,
-                           gfloat               *distmap,
+                           GimpLineArt          *line_art,
                            GimpFillOptions      *options,
                            gboolean              fill_transparent,
                            GimpSelectCriterion   fill_criterion,
                            gdouble               threshold,
                            gboolean              sample_merged,
                            gboolean              diagonal_neighbors,
-                           gfloat                line_art_stroke_threshold,
-                           gint                  line_art_max_grow,
-                           gint                  line_art_segment_max_length,
-                           gint                  line_art_spline_max_length,
                            gdouble               seed_x,
                            gdouble               seed_y)
 {
@@ -76,15 +71,10 @@ gimp_drawable_bucket_fill (GimpDrawable         *drawable,
 
   image = gimp_item_get_image (GIMP_ITEM (drawable));
   gimp_set_busy (image->gimp);
-  buffer = gimp_drawable_get_bucket_fill_buffer (drawable, line_art,
-                                                 distmap, options,
+  buffer = gimp_drawable_get_bucket_fill_buffer (drawable, line_art, options,
                                                  fill_transparent, fill_criterion,
                                                  threshold, sample_merged,
                                                  diagonal_neighbors,
-                                                 line_art_stroke_threshold,
-                                                 line_art_max_grow,
-                                                 line_art_segment_max_length,
-                                                 line_art_spline_max_length,
                                                  seed_x, seed_y, NULL,
                                                  &mask_x, &mask_y, &width, &height);
 
@@ -141,18 +131,13 @@ gimp_drawable_bucket_fill (GimpDrawable         *drawable,
  */
 GeglBuffer *
 gimp_drawable_get_bucket_fill_buffer (GimpDrawable         *drawable,
-                                      GeglBuffer           *line_art,
-                                      gfloat               *distmap,
+                                      GimpLineArt          *line_art,
                                       GimpFillOptions      *options,
                                       gboolean              fill_transparent,
                                       GimpSelectCriterion   fill_criterion,
                                       gdouble               threshold,
                                       gboolean              sample_merged,
                                       gboolean              diagonal_neighbors,
-                                      gfloat                stroke_threshold,
-                                      gint                  max_grow,
-                                      gint                  segment_max_length,
-                                      gint                  spline_max_length,
                                       gdouble               seed_x,
                                       gdouble               seed_y,
                                       GeglBuffer          **mask_buffer,
@@ -208,16 +193,12 @@ gimp_drawable_get_bucket_fill_buffer (GimpDrawable         *drawable,
    *  contiguous region.
    */
   new_mask = gimp_pickable_contiguous_region_by_seed (pickable,
-                                                      line_art, distmap,
+                                                      line_art,
                                                       antialias,
                                                       threshold,
                                                       fill_transparent,
                                                       fill_criterion,
                                                       diagonal_neighbors,
-                                                      stroke_threshold,
-                                                      max_grow,
-                                                      segment_max_length,
-                                                      spline_max_length,
                                                       (gint) seed_x,
                                                       (gint) seed_y);
   if (mask_buffer && *mask_buffer)
diff --git a/app/core/gimpdrawable-bucket-fill.h b/app/core/gimpdrawable-bucket-fill.h
index 4019d82780..e2b2525d45 100644
--- a/app/core/gimpdrawable-bucket-fill.h
+++ b/app/core/gimpdrawable-bucket-fill.h
@@ -20,33 +20,23 @@
 
 
 void         gimp_drawable_bucket_fill            (GimpDrawable         *drawable,
-                                                   GeglBuffer           *line_art,
-                                                   gfloat               *distmap,
+                                                   GimpLineArt          *line_art,
                                                    GimpFillOptions      *options,
                                                    gboolean              fill_transparent,
                                                    GimpSelectCriterion   fill_criterion,
                                                    gdouble               threshold,
                                                    gboolean              sample_merged,
                                                    gboolean              diagonal_neighbors,
-                                                   gfloat                line_art_stroke_threshold,
-                                                   gint                  line_art_max_grow,
-                                                   gint                  line_art_segment_max_length,
-                                                   gint                  line_art_spline_max_length,
                                                    gdouble               x,
                                                    gdouble               y);
 GeglBuffer * gimp_drawable_get_bucket_fill_buffer (GimpDrawable         *drawable,
-                                                   GeglBuffer           *line_art,
-                                                   gfloat               *distmap,
+                                                   GimpLineArt          *line_art,
                                                    GimpFillOptions      *options,
                                                    gboolean              fill_transparent,
                                                    GimpSelectCriterion   fill_criterion,
                                                    gdouble               threshold,
                                                    gboolean              sample_merged,
                                                    gboolean              diagonal_neighbors,
-                                                   gfloat                line_art_stroke_threshold,
-                                                   gint                  line_art_max_grow,
-                                                   gint                  line_art_segment_max_length,
-                                                   gint                  line_art_spline_max_length,
                                                    gdouble               seed_x,
                                                    gdouble               seed_y,
                                                    GeglBuffer          **mask_buffer,
diff --git a/app/core/gimplineart.c b/app/core/gimplineart.c
index fcc4d67f7f..ae0027ee6e 100644
--- a/app/core/gimplineart.c
+++ b/app/core/gimplineart.c
@@ -20,13 +20,74 @@
 
 #include "config.h"
 
+#include <gdk-pixbuf/gdk-pixbuf.h>
 #include <gegl.h>
 
 #include "libgimpmath/gimpmath.h"
 
 #include "core-types.h"
 
+#include "gimp-parallel.h"
+#include "gimp-utils.h" /* GIMP_TIMER */
+#include "gimpasync.h"
+#include "gimpcancelable.h"
+#include "gimpdrawable.h"
+#include "gimpimage.h"
 #include "gimplineart.h"
+#include "gimppickable.h"
+#include "gimpprojection.h"
+#include "gimpwaitable.h"
+
+#include "gimp-intl.h"
+
+enum
+{
+  PROP_0,
+  PROP_SELECT_TRANSPARENT,
+  PROP_MAX_GROW,
+  PROP_THRESHOLD,
+  PROP_SPLINE_MAX_LEN,
+  PROP_SEGMENT_MAX_LEN,
+};
+
+typedef struct _GimpLineArtPrivate GimpLineArtPrivate;
+
+struct _GimpLineArtPrivate
+{
+  gboolean      frozen;
+  gboolean      compute_after_thaw;
+
+  GimpAsync    *async;
+
+  GimpPickable *input;
+  GeglBuffer   *closed;
+  gfloat       *distmap;
+
+  /* Used in the closing step. */
+  gboolean      select_transparent;
+  gdouble       threshold;
+  gint          spline_max_len;
+  gint          segment_max_len;
+
+  /* Used in the grow step. */
+  gint          max_grow;
+};
+
+typedef struct
+{
+  GeglBuffer  *buffer;
+
+  gboolean     select_transparent;
+  gdouble      threshold;
+  gint         spline_max_len;
+  gint         segment_max_len;
+} LineArtData;
+
+typedef struct
+{
+  GeglBuffer *closed;
+  gfloat     *distmap;
+} LineArtResult;
 
 static int DeltaX[4] = {+1, -1, 0, 0};
 static int DeltaY[4] = {0, 0, +1, -1};
@@ -67,56 +128,109 @@ typedef struct _Edgel
   guint     next, previous;
 } Edgel;
 
-static void         gimp_lineart_denoise                    (GeglBuffer             *buffer,
-                                                             int                     size);
-static void         gimp_lineart_compute_normals_curvatures (GeglBuffer             *mask,
-                                                             gfloat                 *normals,
-                                                             gfloat                 *curvatures,
-                                                             gfloat                 *smoothed_curvatures,
-                                                             int                     
normal_estimate_mask_size);
-static gfloat *     gimp_lineart_get_smooth_curvatures      (GArray                 *edgelset);
-static GArray     * gimp_lineart_curvature_extremums        (gfloat                 *curvatures,
-                                                             gfloat                 *smoothed_curvatures,
-                                                             gint                    curvatures_width,
-                                                             gint                    curvatures_height);
-static gint         gimp_spline_candidate_cmp               (const SplineCandidate  *a,
-                                                             const SplineCandidate  *b,
-                                                             gpointer                user_data);
-static GList      * gimp_lineart_find_spline_candidates     (GArray                 *max_positions,
-                                                             gfloat                 *normals,
-                                                             gint                    width,
-                                                             gint                    distance_threshold,
-                                                             gfloat                  max_angle_deg);
-
-static GArray     * gimp_lineart_discrete_spline            (Pixel                   p0,
-                                                             GimpVector2             n0,
-                                                             Pixel                   p1,
-                                                             GimpVector2             n1);
-
-static gint         gimp_number_of_transitions               (GArray                 *pixels,
-                                                              GeglBuffer             *buffer);
-static gboolean     gimp_lineart_curve_creates_region        (GeglBuffer             *mask,
-                                                              GArray                 *pixels,
-                                                              int                     lower_size_limit,
-                                                              int                     upper_size_limit);
-static GArray     * gimp_lineart_line_segment_until_hit      (const GeglBuffer       *buffer,
-                                                              Pixel                   start,
-                                                              GimpVector2             direction,
-                                                              int                     size);
-static gfloat     * gimp_lineart_estimate_strokes_radii      (GeglBuffer             *mask);
+
+static void            gimp_line_art_finalize                  (GObject               *object);
+static void            gimp_line_art_set_property              (GObject                *object,
+                                                                guint                   property_id,
+                                                                const GValue           *value,
+                                                                GParamSpec             *pspec);
+static void            gimp_line_art_get_property              (GObject                *object,
+                                                                guint                   property_id,
+                                                                GValue                 *value,
+                                                                GParamSpec             *pspec);
+
+/* Functions for asynchronous computation. */
+
+static void            gimp_line_art_compute                   (GimpLineArt            *line_art);
+static void            gimp_line_art_compute_cb                (GimpAsync              *async,
+                                                                GimpLineArt            *line_art);
+
+static GimpAsync     * gimp_line_art_prepare_async             (GimpLineArt            *line_art,
+                                                                gint                    priority);
+static void            gimp_line_art_prepare_async_func        (GimpAsync              *async,
+                                                                LineArtData            *data);
+static LineArtData   * line_art_data_new                       (GeglBuffer             *buffer,
+                                                                GimpLineArt            *line_art);
+static void            line_art_data_free                      (LineArtData            *data);
+static LineArtResult * line_art_result_new                     (GeglBuffer             *line_art,
+                                                                gfloat                 *distmap);
+static void            line_art_result_free                    (LineArtResult          *result);
+
+static void            gimp_line_art_projection_rendered       (GimpProjection         *proj,
+                                                                GimpLineArt            *line_art);
+static void            gimp_line_art_drawable_painted          (GimpDrawable           *drawable,
+                                                                GimpLineArt            *line_art);
+
+
+/* All actual computation functions. */
+
+static GeglBuffer    * gimp_line_art_close                     (GeglBuffer             *buffer,
+                                                                gboolean                select_transparent,
+                                                                gdouble                 stroke_threshold,
+                                                                gint                    spline_max_length,
+                                                                gint                    segment_max_length,
+                                                                gint                    minimal_lineart_area,
+                                                                gint                    
normal_estimate_mask_size,
+                                                                gfloat                  end_point_rate,
+                                                                gfloat                  spline_max_angle,
+                                                                gint                    
end_point_connectivity,
+                                                                gfloat                  spline_roundness,
+                                                                gboolean                
allow_self_intersections,
+                                                                gint                    
created_regions_significant_area,
+                                                                gint                    
created_regions_minimum_area,
+                                                                gboolean                
small_segments_from_spline_sources,
+                                                                gfloat                **lineart_distmap);
+
+static void            gimp_lineart_denoise                    (GeglBuffer             *buffer,
+                                                                int                     size);
+static void            gimp_lineart_compute_normals_curvatures (GeglBuffer             *mask,
+                                                                gfloat                 *normals,
+                                                                gfloat                 *curvatures,
+                                                                gfloat                 *smoothed_curvatures,
+                                                                int                     
normal_estimate_mask_size);
+static gfloat        * gimp_lineart_get_smooth_curvatures      (GArray                 *edgelset);
+static GArray        * gimp_lineart_curvature_extremums        (gfloat                 *curvatures,
+                                                                gfloat                 *smoothed_curvatures,
+                                                                gint                    curvatures_width,
+                                                                gint                    curvatures_height);
+static gint            gimp_spline_candidate_cmp               (const SplineCandidate  *a,
+                                                                const SplineCandidate  *b,
+                                                                gpointer                user_data);
+static GList         * gimp_lineart_find_spline_candidates     (GArray                 *max_positions,
+                                                                gfloat                 *normals,
+                                                                gint                    width,
+                                                                gint                    distance_threshold,
+                                                                gfloat                  max_angle_deg);
+
+static GArray        * gimp_lineart_discrete_spline            (Pixel                   p0,
+                                                                GimpVector2             n0,
+                                                                Pixel                   p1,
+                                                                GimpVector2             n1);
+
+static gint            gimp_number_of_transitions               (GArray                 *pixels,
+                                                                 GeglBuffer             *buffer);
+static gboolean        gimp_lineart_curve_creates_region        (GeglBuffer             *mask,
+                                                                 GArray                 *pixels,
+                                                                 int                     lower_size_limit,
+                                                                 int                     upper_size_limit);
+static GArray        * gimp_lineart_line_segment_until_hit      (const GeglBuffer       *buffer,
+                                                                 Pixel                   start,
+                                                                 GimpVector2             direction,
+                                                                 int                     size);
+static gfloat        * gimp_lineart_estimate_strokes_radii      (GeglBuffer             *mask);
 
 /* Some callback-type functions. */
 
-static guint        visited_hash_fun                         (Pixel                  *key);
-static gboolean     visited_equal_fun                        (Pixel                  *e1,
-                                                              Pixel                  *e2);
+static guint           visited_hash_fun                         (Pixel                  *key);
+static gboolean        visited_equal_fun                        (Pixel                  *e1,
+                                                                 Pixel                  *e2);
 
-static inline gboolean    border_in_direction (GeglBuffer *mask,
-                                               Pixel       p,
-                                               int         direction);
-static inline GimpVector2 pair2normal         (Pixel       p,
-                                               gfloat     *normals,
-                                               gint        width);
+static inline gboolean border_in_direction                      (GeglBuffer             *mask,
+                                                                 Pixel                   p,
+                                                                 int                     direction);
+static inline GimpVector2 pair2normal                           (Pixel                   p,
+                                                                 gfloat                 *normals,
+                                                                 gint                    width);
 
 /* Edgel */
 
@@ -157,22 +271,518 @@ static void       gimp_edgelset_next8             (const GeglBuffer  *buffer,
                                                    Edgel             *it,
                                                    Edgel             *n);
 
+G_DEFINE_TYPE_WITH_CODE (GimpLineArt, gimp_line_art, GIMP_TYPE_OBJECT,
+                         G_ADD_PRIVATE (GimpLineArt))
+
+static void
+gimp_line_art_class_init (GimpLineArtClass *klass)
+{
+  GObjectClass *object_class = G_OBJECT_CLASS (klass);
+
+  object_class->finalize     = gimp_line_art_finalize;
+  object_class->set_property = gimp_line_art_set_property;
+  object_class->get_property = gimp_line_art_get_property;
+
+  g_object_class_install_property (object_class, PROP_SELECT_TRANSPARENT,
+                                   g_param_spec_boolean ("select-transparent",
+                                                         _("Select transparent pixels instead of gray ones"),
+                                                         _("Select transparent pixels instead of gray ones"),
+                                                         TRUE,
+                                                         G_PARAM_CONSTRUCT | GIMP_PARAM_READWRITE));
+
+  g_object_class_install_property (object_class, PROP_THRESHOLD,
+                                   g_param_spec_double ("threshold",
+                                                        _("Line art detection threshold"),
+                                                        _("Threshold to detect contour (higher values will 
include more pixels)"),
+                                                        0.0, 1.0, 0.92,
+                                                        G_PARAM_CONSTRUCT | GIMP_PARAM_READWRITE));
+
+  g_object_class_install_property (object_class, PROP_MAX_GROW,
+                                   g_param_spec_int ("max-grow",
+                                                     _("Maximum growing size"),
+                                                     _("Maximum number of pixels grown under the line art"),
+                                                     1, 100, 3,
+                                                     G_PARAM_CONSTRUCT | GIMP_PARAM_READWRITE));
+
+  g_object_class_install_property (object_class, PROP_SPLINE_MAX_LEN,
+                                   g_param_spec_int ("spline-max-length",
+                                                     _("Maximum curved closing length"),
+                                                     _("Maximum curved length (in pixels) to close the line 
art"),
+                                                     1, 1000, 60,
+                                                     G_PARAM_CONSTRUCT | GIMP_PARAM_READWRITE));
+
+  g_object_class_install_property (object_class, PROP_SEGMENT_MAX_LEN,
+                                   g_param_spec_int ("segment-max-length",
+                                                     _("Maximum straight closing length"),
+                                                     _("Maximum straight length (in pixels) to close the 
line art"),
+                                                     1, 1000, 20,
+                                                     G_PARAM_CONSTRUCT | GIMP_PARAM_READWRITE));
+}
+
+static void
+gimp_line_art_init (GimpLineArt *line_art)
+{
+  line_art->priv = gimp_line_art_get_instance_private (line_art);
+}
+
+static void
+gimp_line_art_finalize (GObject *object)
+{
+  GimpLineArt *line_art = GIMP_LINE_ART (object);
+
+  if (line_art->priv->input)
+    {
+      if (GIMP_IS_IMAGE (line_art->priv->input))
+        g_signal_handlers_disconnect_by_data (gimp_image_get_projection (GIMP_IMAGE (line_art->priv->input)),
+                                              line_art);
+      else
+        g_signal_handlers_disconnect_by_data (line_art->priv->input,
+                                              line_art);
+    }
+  if (line_art->priv->async)
+    {
+      /* we cancel the async, but don't wait for it to finish, since
+       * it can't actually be interrupted.  instead
+       * gimp_bucket_fill_compute_line_art_cb() bails if the async has
+       * been canceled, to avoid accessing the dead tool.
+       */
+      gimp_cancelable_cancel (GIMP_CANCELABLE (line_art->priv->async));
+      g_clear_object (&line_art->priv->async);
+    }
+
+  g_clear_object (&line_art->priv->closed);
+  g_clear_pointer (&line_art->priv->distmap, g_free);
+}
+
+static void
+gimp_line_art_set_property (GObject      *object,
+                            guint         property_id,
+                            const GValue *value,
+                            GParamSpec   *pspec)
+{
+  GimpLineArt *line_art = GIMP_LINE_ART (object);
+
+  switch (property_id)
+    {
+    case PROP_SELECT_TRANSPARENT:
+      line_art->priv->select_transparent = g_value_get_boolean (value);
+      gimp_line_art_compute (line_art);
+      break;
+    case PROP_MAX_GROW:
+      line_art->priv->max_grow = g_value_get_int (value);
+      break;
+    case PROP_THRESHOLD:
+      line_art->priv->threshold = g_value_get_double (value);
+      gimp_line_art_compute (line_art);
+      break;
+    case PROP_SPLINE_MAX_LEN:
+      line_art->priv->spline_max_len = g_value_get_int (value);
+      gimp_line_art_compute (line_art);
+      break;
+    case PROP_SEGMENT_MAX_LEN:
+      line_art->priv->segment_max_len = g_value_get_int (value);
+      gimp_line_art_compute (line_art);
+      break;
+
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+      break;
+    }
+}
+
+static void
+gimp_line_art_get_property (GObject    *object,
+                            guint       property_id,
+                            GValue     *value,
+                            GParamSpec *pspec)
+{
+  GimpLineArt *line_art = GIMP_LINE_ART (object);
+
+  switch (property_id)
+    {
+    case PROP_SELECT_TRANSPARENT:
+      g_value_set_boolean (value, line_art->priv->select_transparent);
+      break;
+    case PROP_MAX_GROW:
+      g_value_set_int (value, line_art->priv->max_grow);
+      break;
+    case PROP_THRESHOLD:
+      g_value_set_double (value, line_art->priv->threshold);
+      break;
+    case PROP_SPLINE_MAX_LEN:
+      g_value_set_int (value, line_art->priv->spline_max_len);
+      break;
+    case PROP_SEGMENT_MAX_LEN:
+      g_value_set_int (value, line_art->priv->segment_max_len);
+      break;
+
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+      break;
+    }
+}
+
 /* Public functions */
 
+GimpLineArt *
+gimp_line_art_new (void)
+{
+  return g_object_new (GIMP_TYPE_LINE_ART,
+                       NULL);
+}
+
+void
+gimp_line_art_set_input (GimpLineArt  *line_art,
+                         GimpPickable *pickable)
+{
+  if (line_art->priv->input)
+    {
+      if (GIMP_IS_IMAGE (line_art->priv->input))
+        g_signal_handlers_disconnect_by_data (gimp_image_get_projection (GIMP_IMAGE (line_art->priv->input)),
+                                              line_art);
+      else
+        g_signal_handlers_disconnect_by_data (line_art->priv->input,
+                                              line_art);
+    }
+
+  line_art->priv->input = pickable;
+
+  gimp_line_art_compute (line_art);
+  if (pickable)
+    {
+      if (GIMP_IS_IMAGE (pickable))
+        g_signal_connect (gimp_image_get_projection (GIMP_IMAGE (pickable)), "rendered",
+                          G_CALLBACK (gimp_line_art_projection_rendered),
+                          line_art);
+      else if (GIMP_IS_DRAWABLE (pickable))
+        g_signal_connect (pickable, "painted",
+                          G_CALLBACK (gimp_line_art_drawable_painted),
+                          line_art);
+      else
+        g_return_if_reached ();
+    }
+}
+
+void
+gimp_line_art_freeze (GimpLineArt *line_art)
+{
+  g_return_if_fail (! line_art->priv->frozen);
+
+  line_art->priv->frozen             = TRUE;
+  line_art->priv->compute_after_thaw = FALSE;
+}
+
+void
+gimp_line_art_thaw (GimpLineArt *line_art)
+{
+  g_return_if_fail (line_art->priv->frozen);
+
+  line_art->priv->frozen = FALSE;
+  if (line_art->priv->compute_after_thaw)
+    {
+      gimp_line_art_compute (line_art);
+      line_art->priv->compute_after_thaw = FALSE;
+    }
+}
+
+GeglBuffer *
+gimp_line_art_get (GimpLineArt  *line_art,
+                   gfloat      **distmap)
+{
+  g_return_val_if_fail (line_art->priv->input, NULL);
+
+  if (line_art->priv->async)
+    {
+      gimp_waitable_wait (GIMP_WAITABLE (line_art->priv->async));
+    }
+  else if (! line_art->priv->closed)
+    {
+      gimp_line_art_compute (line_art);
+      if (line_art->priv->async)
+        gimp_waitable_wait (GIMP_WAITABLE (line_art->priv->async));
+    }
+
+  g_return_val_if_fail (line_art->priv->closed, NULL);
+
+  if (distmap)
+    *distmap = line_art->priv->distmap;
+
+  return line_art->priv->closed;
+}
+
+/* Functions for asynchronous computation. */
+
+static void
+gimp_line_art_compute (GimpLineArt *line_art)
+{
+  if (line_art->priv->frozen)
+    {
+      line_art->priv->compute_after_thaw = TRUE;
+      return;
+    }
+
+  if (line_art->priv->async)
+    {
+      gimp_cancelable_cancel (GIMP_CANCELABLE (line_art->priv->async));
+      g_clear_object (&line_art->priv->async);
+    }
+
+  g_clear_object (&line_art->priv->closed);
+  g_clear_pointer (&line_art->priv->distmap, g_free);
+
+  if (line_art->priv->input)
+    {
+      /* gimp_line_art_prepare_async() will flush the pickable, which
+       * may trigger this signal handler, and will leak a line art (as
+       * line_art->priv->async has not been set yet).
+       */
+      if (GIMP_IS_IMAGE (line_art->priv->input))
+        g_signal_handlers_block_by_func (gimp_image_get_projection (GIMP_IMAGE (line_art->priv->input)),
+                                         G_CALLBACK (gimp_line_art_projection_rendered),
+                                         line_art);
+      else
+        g_signal_handlers_block_by_func (line_art->priv->input,
+                                         G_CALLBACK (gimp_line_art_drawable_painted),
+                                         line_art);
+      line_art->priv->async = gimp_line_art_prepare_async (line_art, +1);
+      if (GIMP_IS_IMAGE (line_art->priv->input))
+        g_signal_handlers_unblock_by_func (gimp_image_get_projection (GIMP_IMAGE (line_art->priv->input)),
+                                           G_CALLBACK (gimp_line_art_projection_rendered),
+                                           line_art);
+      else
+        g_signal_handlers_unblock_by_func (line_art->priv->input,
+                                           G_CALLBACK (gimp_line_art_drawable_painted),
+                                           line_art);
+
+      gimp_async_add_callback_for_object (line_art->priv->async,
+                                          (GimpAsyncCallback) gimp_line_art_compute_cb,
+                                          line_art, line_art);
+    }
+}
+
+static void
+gimp_line_art_compute_cb (GimpAsync   *async,
+                          GimpLineArt *line_art)
+{
+  if (gimp_async_is_canceled (async))
+    return;
+
+  if (gimp_async_is_finished (async))
+    {
+      LineArtResult *result;
+
+      result = gimp_async_get_result (async);
+
+      line_art->priv->closed  = g_object_ref (result->closed);
+      line_art->priv->distmap = result->distmap;
+      result->distmap  = NULL;
+    }
+
+  g_clear_object (&line_art->priv->async);
+}
+
+static GimpAsync *
+gimp_line_art_prepare_async (GimpLineArt *line_art,
+                             gint         priority)
+{
+  GeglBuffer  *buffer;
+  GimpAsync   *async;
+  LineArtData *data;
+
+  g_return_val_if_fail (GIMP_IS_PICKABLE (line_art->priv->input), NULL);
+
+  gimp_pickable_flush (line_art->priv->input);
+
+  buffer = gegl_buffer_dup (gimp_pickable_get_buffer (line_art->priv->input));
+
+  data  = line_art_data_new (buffer, line_art);
+
+  g_object_unref (buffer);
+
+  async = gimp_parallel_run_async_full (
+    priority,
+    (GimpParallelRunAsyncFunc) gimp_line_art_prepare_async_func,
+    data, (GDestroyNotify) line_art_data_free);
+
+  return async;
+}
+
+static void
+gimp_line_art_prepare_async_func (GimpAsync   *async,
+                                  LineArtData *data)
+{
+  GeglBuffer *closed;
+  gfloat     *distmap;
+  gboolean    has_alpha;
+  gboolean    select_transparent = FALSE;
+
+  has_alpha = babl_format_has_alpha (gegl_buffer_get_format (data->buffer));
+
+  if (has_alpha)
+    {
+      if (data->select_transparent)
+        {
+          /*  don't select transparent regions if there are no fully
+           *  transparent pixels.
+           */
+          GeglBufferIterator *gi;
+
+          gi = gegl_buffer_iterator_new (data->buffer, NULL, 0,
+                                         babl_format ("A u8"),
+                                         GEGL_ACCESS_READ, GEGL_ABYSS_NONE, 3);
+          while (gegl_buffer_iterator_next (gi))
+            {
+              guint8 *p = (guint8*) gi->items[0].data;
+              gint    k;
+
+              if (gimp_async_is_canceled (async))
+                {
+                  gegl_buffer_iterator_stop (gi);
+
+                  gimp_async_abort (async);
+
+                  line_art_data_free (data);
+
+                  return;
+                }
+
+              for (k = 0; k < gi->length; k++)
+                {
+                  if (! *p)
+                    {
+                      select_transparent = TRUE;
+                      break;
+                    }
+                  p++;
+                }
+              if (select_transparent)
+                break;
+            }
+          if (select_transparent)
+            gegl_buffer_iterator_stop (gi);
+        }
+    }
+
+  /* For smart selection, we generate a binarized image with close
+   * regions, then run a composite selection with no threshold on
+   * this intermediate buffer.
+   */
+  GIMP_TIMER_START();
+
+  closed = gimp_line_art_close (data->buffer,
+                                select_transparent,
+                                data->threshold,
+                                data->spline_max_len,
+                                data->segment_max_len,
+                                /*minimal_lineart_area,*/
+                                5,
+                                /*normal_estimate_mask_size,*/
+                                5,
+                                /*end_point_rate,*/
+                                0.85,
+                                /*spline_max_angle,*/
+                                90.0,
+                                /*end_point_connectivity,*/
+                                2,
+                                /*spline_roundness,*/
+                                1.0,
+                                /*allow_self_intersections,*/
+                                TRUE,
+                                /*created_regions_significant_area,*/
+                                4,
+                                /*created_regions_minimum_area,*/
+                                100,
+                                /*small_segments_from_spline_sources,*/
+                                TRUE,
+                                &distmap);
+
+  GIMP_TIMER_END("close line-art");
+
+  gimp_async_finish_full (async,
+                          line_art_result_new (closed, distmap),
+                          (GDestroyNotify) line_art_result_free);
+
+  line_art_data_free (data);
+}
+
+static LineArtData *
+line_art_data_new (GeglBuffer  *buffer,
+                   GimpLineArt *line_art)
+{
+  LineArtData *data = g_slice_new (LineArtData);
+
+  data->buffer             = g_object_ref (buffer);
+  data->select_transparent = line_art->priv->select_transparent;
+  data->threshold          = line_art->priv->threshold;
+  data->spline_max_len     = line_art->priv->spline_max_len;
+  data->segment_max_len    = line_art->priv->segment_max_len;
+
+  return data;
+}
+
+static void
+line_art_data_free (LineArtData *data)
+{
+  g_object_unref (data->buffer);
+
+  g_slice_free (LineArtData, data);
+}
+
+static LineArtResult *
+line_art_result_new (GeglBuffer *closed,
+                     gfloat     *distmap)
+{
+  LineArtResult *data;
+
+  data = g_slice_new (LineArtResult);
+  data->closed  = closed;
+  data->distmap = distmap;
+
+  return data;
+}
+
+static void
+line_art_result_free (LineArtResult *data)
+{
+  g_object_unref (data->closed);
+  g_clear_pointer (&data->distmap, g_free);
+
+  g_slice_free (LineArtResult, data);
+}
+
+static void
+gimp_line_art_projection_rendered (GimpProjection *proj,
+                                   GimpLineArt    *line_art)
+{
+  gimp_line_art_compute (line_art);
+}
+
+static void
+gimp_line_art_drawable_painted (GimpDrawable *drawable,
+                                GimpLineArt  *line_art)
+{
+  gimp_line_art_compute (line_art);
+}
+
+/* All actual computation functions. */
+
 /**
- * gimp_lineart_close:
+ * gimp_line_art_close:
  * @buffer: the input #GeglBuffer.
  * @select_transparent: whether we binarize the alpha channel or the
  *                      luminosity.
  * @stroke_threshold: [0-1] threshold value for detecting stroke pixels
  *                    (higher values will detect more stroke pixels).
+ * @spline_max_length: the maximum length for creating splines between
+ *                     end points.
+ * @segment_max_length: the maximum length for creating segments
+ *                      between end points. Unlike splines, segments
+ *                      are straight lines.
  * @minimal_lineart_area: the minimum size in number pixels for area to
  *                        be considered as line art.
  * @normal_estimate_mask_size:
  * @end_point_rate: threshold to estimate if a curvature is an end-point
  *                  in [0-1] range value.
- * @spline_max_length: the maximum length for creating splines between
- *                     end points.
  * @spline_max_angle: the maximum angle between end point normals for
  *                    creating splines between them.
  * @end_point_connectivity:
@@ -182,9 +792,6 @@ static void       gimp_edgelset_next8             (const GeglBuffer  *buffer,
  * @created_regions_significant_area:
  * @created_regions_minimum_area:
  * @small_segments_from_spline_sources:
- * @segments_max_length: the maximum length for creating segments
- *                       between end points. Unlike splines, segments
- *                       are straight lines.
  * @closed_distmap: a distance map of the closed line art pixels.
  *
  * Creates a binarized version of the strokes of @buffer, detected either
@@ -204,23 +811,23 @@ static void       gimp_edgelset_next8             (const GeglBuffer  *buffer,
  *          newly allocated float buffer is returned, which can be used
  *          for overflowing created masks later.
  */
-GeglBuffer *
-gimp_lineart_close (GeglBuffer  *buffer,
-                    gboolean     select_transparent,
-                    gfloat       stroke_threshold,
-                    gint         minimal_lineart_area,
-                    gint         normal_estimate_mask_size,
-                    gfloat       end_point_rate,
-                    gint         spline_max_length,
-                    gfloat       spline_max_angle,
-                    gint         end_point_connectivity,
-                    gfloat       spline_roundness,
-                    gboolean     allow_self_intersections,
-                    gint         created_regions_significant_area,
-                    gint         created_regions_minimum_area,
-                    gboolean     small_segments_from_spline_sources,
-                    gint         segments_max_length,
-                    gfloat     **closed_distmap)
+static GeglBuffer *
+gimp_line_art_close (GeglBuffer  *buffer,
+                     gboolean     select_transparent,
+                     gdouble      stroke_threshold,
+                     gint         spline_max_length,
+                     gint         segment_max_length,
+                     gint         minimal_lineart_area,
+                     gint         normal_estimate_mask_size,
+                     gfloat       end_point_rate,
+                     gfloat       spline_max_angle,
+                     gint         end_point_connectivity,
+                     gfloat       spline_roundness,
+                     gboolean     allow_self_intersections,
+                     gint         created_regions_significant_area,
+                     gint         created_regions_minimum_area,
+                     gboolean     small_segments_from_spline_sources,
+                     gfloat     **closed_distmap)
 {
   const Babl         *gray_format;
   gfloat             *normals;
@@ -421,7 +1028,7 @@ gimp_lineart_close (GeglBuffer  *buffer,
         {
           GArray *segment = gimp_lineart_line_segment_until_hit (closed, *point,
                                                                  pair2normal (*point, normals, width),
-                                                                 segments_max_length);
+                                                                 segment_max_length);
 
           if (segment->len &&
               ! gimp_lineart_curve_creates_region (closed, segment,
@@ -487,8 +1094,6 @@ gimp_lineart_close (GeglBuffer  *buffer,
   return closed;
 }
 
-/* Private functions */
-
 static void
 gimp_lineart_denoise (GeglBuffer *buffer,
                       int         minimum_area)
diff --git a/app/core/gimplineart.h b/app/core/gimplineart.h
index 5ab579800b..1a867b598a 100644
--- a/app/core/gimplineart.h
+++ b/app/core/gimplineart.h
@@ -22,22 +22,42 @@
 #define __GIMP_LINEART__
 
 
-GeglBuffer * gimp_lineart_close (GeglBuffer  *buffer,
-                                 gboolean     select_transparent,
-                                 gfloat       stroke_threshold,
-                                 gint         minimal_lineart_area,
-                                 gint         normal_estimate_mask_size,
-                                 gfloat       end_point_rate,
-                                 gint         spline_max_length,
-                                 gfloat       spline_max_angle,
-                                 gint         end_point_connectivity,
-                                 gfloat       spline_roundness,
-                                 gboolean     allow_self_intersections,
-                                 gint         created_regions_significant_area,
-                                 gint         created_regions_minimum_area,
-                                 gboolean     small_segments_from_spline_sources,
-                                 gint         segments_max_length,
-                                 gfloat     **lineart_distmap);
+#include "gimpobject.h"
 
+#define GIMP_TYPE_LINE_ART            (gimp_line_art_get_type ())
+#define GIMP_LINE_ART(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_LINE_ART, GimpLineArt))
+#define GIMP_LINE_ART_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_LINE_ART, 
GimpLineArtClass))
+#define GIMP_IS_LINE_ART(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_LINE_ART))
+#define GIMP_IS_LINE_ART_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_LINE_ART))
+#define GIMP_LINE_ART_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_LINE_ART, 
GimpLineArtClass))
+
+
+typedef struct _GimpLineArtClass   GimpLineArtClass;
+typedef struct _GimpLineArtPrivate GimpLineArtPrivate;
+
+struct _GimpLineArt
+{
+  GimpObject          parent_instance;
+
+  GimpLineArtPrivate *priv;
+};
+
+struct _GimpLineArtClass
+{
+  GimpObjectClass     parent_class;
+};
+
+
+GType                gimp_line_art_get_type         (void) G_GNUC_CONST;
+
+GimpLineArt *        gimp_line_art_new              (void);
+
+void                 gimp_line_art_set_input        (GimpLineArt  *line_art,
+                                                     GimpPickable *pickable);
+void                 gimp_line_art_freeze           (GimpLineArt  *line_art);
+void                 gimp_line_art_thaw             (GimpLineArt  *line_art);
+
+GeglBuffer *         gimp_line_art_get              (GimpLineArt  *line_art,
+                                                     gfloat      **distmap);
 
 #endif /* __GIMP_LINEART__ */
diff --git a/app/core/gimppickable-contiguous-region.c b/app/core/gimppickable-contiguous-region.c
index 2ea4fc35d8..ebd7b2b530 100644
--- a/app/core/gimppickable-contiguous-region.c
+++ b/app/core/gimppickable-contiguous-region.c
@@ -38,15 +38,6 @@
 #include "gimppickable-contiguous-region.h"
 
 
-typedef struct
-{
-  GeglBuffer *buffer;
-  gboolean    select_transparent;
-  gfloat      stroke_threshold;
-  gint        segment_max_length;
-  gint        spline_max_length;
-} LineArtData;
-
 typedef struct
 {
   gint   x;
@@ -114,17 +105,6 @@ static void     find_contiguous_region    (GeglBuffer          *src_buffer,
                                            gint                 y,
                                            const gfloat        *col);
 
-static LineArtData   * line_art_data_new    (GeglBuffer          *buffer,
-                                             gboolean             select_transparent,
-                                             gfloat               stroke_threshold,
-                                             gint                 segment_max_length,
-                                             gint                 spline_max_length);
-static void            line_art_data_free   (LineArtData         *data);
-static GimpPickableLineArtAsyncResult *
-                       line_art_result_new  (GeglBuffer          *line_art,
-                                             gfloat              *distmap);
-static void            line_art_result_free (GimpPickableLineArtAsyncResult
-                                                                 *data);
 static void            line_art_queue_pixel (GQueue              *queue,
                                              gint                 x,
                                              gint                 y,
@@ -133,220 +113,46 @@ static void            line_art_queue_pixel (GQueue              *queue,
 
 /*  public functions  */
 
-static void
-gimp_pickable_contiguous_region_prepare_line_art_async_func (GimpAsync   *async,
-                                                             LineArtData *data)
-{
-  GeglBuffer *lineart;
-  gfloat     *distmap;
-  gboolean    has_alpha;
-  gboolean    select_transparent = FALSE;
-
-  has_alpha = babl_format_has_alpha (gegl_buffer_get_format (data->buffer));
-
-  if (has_alpha)
-    {
-      if (data->select_transparent)
-        {
-          /*  don't select transparent regions if there are no fully
-           *  transparent pixels.
-           */
-          GeglBufferIterator *gi;
-
-          gi = gegl_buffer_iterator_new (data->buffer, NULL, 0,
-                                         babl_format ("A u8"),
-                                         GEGL_ACCESS_READ, GEGL_ABYSS_NONE, 3);
-          while (gegl_buffer_iterator_next (gi))
-            {
-              guint8 *p = (guint8*) gi->items[0].data;
-              gint    k;
-
-              if (gimp_async_is_canceled (async))
-                {
-                  gegl_buffer_iterator_stop (gi);
-
-                  gimp_async_abort (async);
-
-                  line_art_data_free (data);
-
-                  return;
-                }
-
-              for (k = 0; k < gi->length; k++)
-                {
-                  if (! *p)
-                    {
-                      select_transparent = TRUE;
-                      break;
-                    }
-                  p++;
-                }
-              if (select_transparent)
-                break;
-            }
-          if (select_transparent)
-            gegl_buffer_iterator_stop (gi);
-        }
-    }
-
-  /* For smart selection, we generate a binarized image with close
-   * regions, then run a composite selection with no threshold on
-   * this intermediate buffer.
-   */
-  GIMP_TIMER_START();
-
-  lineart = gimp_lineart_close (data->buffer,
-                                select_transparent,
-                                data->stroke_threshold,
-                                /*minimal_lineart_area,*/
-                                5,
-                                /*normal_estimate_mask_size,*/
-                                5,
-                                /*end_point_rate,*/
-                                0.85,
-                                data->spline_max_length,
-                                /*spline_max_angle,*/
-                                90.0,
-                                /*end_point_connectivity,*/
-                                2,
-                                /*spline_roundness,*/
-                                1.0,
-                                /*allow_self_intersections,*/
-                                TRUE,
-                                /*created_regions_significant_area,*/
-                                4,
-                                /*created_regions_minimum_area,*/
-                                100,
-                                /*small_segments_from_spline_sources,*/
-                                TRUE,
-                                data->segment_max_length,
-                                &distmap);
-
-  GIMP_TIMER_END("close line-art");
-
-  gimp_async_finish_full (async,
-                          line_art_result_new (lineart, distmap),
-                          (GDestroyNotify) line_art_result_free);
-
-  line_art_data_free (data);
-}
-
-GeglBuffer *
-gimp_pickable_contiguous_region_prepare_line_art (GimpPickable  *pickable,
-                                                  gboolean       select_transparent,
-                                                  gfloat         stroke_threshold,
-                                                  gint           segment_max_length,
-                                                  gint           spline_max_length,
-                                                  gfloat       **distmap)
-{
-  GimpAsync                      *async;
-  LineArtData                    *data;
-  GimpPickableLineArtAsyncResult *result;
-  GeglBuffer                     *lineart;
-
-  g_return_val_if_fail (GIMP_IS_PICKABLE (pickable), NULL);
-
-  gimp_pickable_flush (pickable);
-
-  async = gimp_async_new ();
-  data  = line_art_data_new (gimp_pickable_get_buffer (pickable),
-                             select_transparent, stroke_threshold,
-                             segment_max_length, spline_max_length);
-
-  gimp_pickable_contiguous_region_prepare_line_art_async_func (async, data);
-
-  result = gimp_async_get_result (async);
-
-  lineart   = g_object_ref (result->line_art);
-  *distmap  = result->distmap;
-  result->distmap  = NULL;
-
-  g_object_unref (async);
-
-  return lineart;
-}
-
-GimpAsync *
-gimp_pickable_contiguous_region_prepare_line_art_async (GimpPickable *pickable,
-                                                        gboolean      select_transparent,
-                                                        gfloat        stroke_threshold,
-                                                        gint          segment_max_length,
-                                                        gint          spline_max_length,
-                                                        gint          priority)
-{
-  GeglBuffer  *buffer;
-  GimpAsync   *async;
-  LineArtData *data;
-
-  g_return_val_if_fail (GIMP_IS_PICKABLE (pickable), NULL);
-
-  gimp_pickable_flush (pickable);
-
-  buffer = gegl_buffer_dup (gimp_pickable_get_buffer (pickable));
-
-  data  = line_art_data_new (buffer, select_transparent, stroke_threshold,
-                             segment_max_length, spline_max_length);
-
-  g_object_unref (buffer);
-
-  async = gimp_parallel_run_async_full (
-    priority,
-    (GimpParallelRunAsyncFunc)
-      gimp_pickable_contiguous_region_prepare_line_art_async_func,
-    data,
-    (GDestroyNotify) line_art_data_free);
-
-  return async;
-}
-
 GeglBuffer *
 gimp_pickable_contiguous_region_by_seed (GimpPickable        *pickable,
-                                         GeglBuffer          *line_art,
-                                         gfloat              *distmap,
+                                         GimpLineArt         *line_art,
                                          gboolean             antialias,
                                          gfloat               threshold,
                                          gboolean             select_transparent,
                                          GimpSelectCriterion  select_criterion,
                                          gboolean             diagonal_neighbors,
-                                         gfloat               stroke_threshold,
-                                         gint                 flooding_max,
-                                         gint                 segment_max_length,
-                                         gint                 spline_max_length,
                                          gint                 x,
                                          gint                 y)
 {
   GeglBuffer    *src_buffer;
   GeglBuffer    *mask_buffer;
   const Babl    *format;
+  gfloat        *distmap = NULL;
   GeglRectangle  extent;
   gint           n_components;
   gboolean       has_alpha;
   gfloat         start_col[MAX_CHANNELS];
   gboolean       smart_line_art = FALSE;
   gboolean       free_line_art  = FALSE;
+  gint           line_art_max_grow;
 
   g_return_val_if_fail (GIMP_IS_PICKABLE (pickable), NULL);
 
   if (select_criterion == GIMP_SELECT_CRITERION_LINE_ART)
     {
-      g_return_val_if_fail ((line_art && distmap) ||
-                            (! line_art && ! distmap),
-                            NULL);
-      if (line_art == NULL)
+      if (! line_art)
         {
           /* It is much better experience to pre-compute the line art,
            * but it may not be always possible (for instance when
            * selecting/filling through a PDB call).
            */
-          line_art      = gimp_pickable_contiguous_region_prepare_line_art (pickable, select_transparent,
-                                                                            stroke_threshold,
-                                                                            segment_max_length,
-                                                                            spline_max_length,
-                                                                            &distmap);
+          line_art = gimp_line_art_new ();
+          gimp_line_art_set_input (line_art, pickable);
           free_line_art = TRUE;
         }
 
-      src_buffer = line_art;
+      src_buffer = gimp_line_art_get (line_art, &distmap);
+      g_return_val_if_fail (src_buffer && distmap, NULL);
 
       smart_line_art     = TRUE;
       antialias          = FALSE;
@@ -427,8 +233,8 @@ gimp_pickable_contiguous_region_by_seed (GimpPickable        *pickable,
        */
       gfloat *mask;
       GQueue *queue  = g_queue_new ();
-      gint    width  = gegl_buffer_get_width (line_art);
-      gint    height = gegl_buffer_get_height (line_art);
+      gint    width  = gegl_buffer_get_width (src_buffer);
+      gint    height = gegl_buffer_get_height (src_buffer);
       gint    nx, ny;
 
       GIMP_TIMER_START();
@@ -520,6 +326,9 @@ gimp_pickable_contiguous_region_by_seed (GimpPickable        *pickable,
               }
           }
 
+      g_object_get (line_art,
+                    "max-grow", &line_art_max_grow,
+                    NULL);
       while (! g_queue_is_empty (queue))
         {
           BorderPixel *c = g_queue_pop_head (queue);
@@ -527,7 +336,7 @@ gimp_pickable_contiguous_region_by_seed (GimpPickable        *pickable,
           if (mask[c->x + c->y * width] != 1.0)
             {
               mask[c->x + c->y * width] = 1.0;
-              if (c->level >= flooding_max)
+              if (c->level >= line_art_max_grow)
                 /* Do not overflood under line arts. */
                 continue;
               if (c->x > 0)
@@ -600,10 +409,7 @@ gimp_pickable_contiguous_region_by_seed (GimpPickable        *pickable,
       GIMP_TIMER_END("watershed line art");
 
       if (free_line_art)
-        {
-          g_object_unref (src_buffer);
-          g_free (distmap);
-        }
+        g_clear_object (&line_art);
     }
 
   return mask_buffer;
@@ -1150,54 +956,6 @@ find_contiguous_region (GeglBuffer          *src_buffer,
 #endif
 }
 
-static LineArtData *
-line_art_data_new (GeglBuffer *buffer,
-                   gboolean    select_transparent,
-                   gfloat      stroke_threshold,
-                   gint        segment_max_length,
-                   gint        spline_max_length)
-{
-  LineArtData *data = g_slice_new (LineArtData);
-
-  data->buffer             = g_object_ref (buffer);
-  data->select_transparent = select_transparent;
-  data->stroke_threshold   = stroke_threshold;
-  data->segment_max_length = segment_max_length;
-  data->spline_max_length  = spline_max_length;
-
-  return data;
-}
-
-static void
-line_art_data_free (LineArtData *data)
-{
-  g_object_unref (data->buffer);
-
-  g_slice_free (LineArtData, data);
-}
-
-static GimpPickableLineArtAsyncResult *
-line_art_result_new (GeglBuffer *line_art,
-                     gfloat     *distmap)
-{
-  GimpPickableLineArtAsyncResult *data;
-
-  data = g_slice_new (GimpPickableLineArtAsyncResult);
-  data->line_art = line_art;
-  data->distmap  = distmap;
-
-  return data;
-}
-
-static void
-line_art_result_free (GimpPickableLineArtAsyncResult *data)
-{
-  g_object_unref (data->line_art);
-  g_clear_pointer (&data->distmap, g_free);
-
-  g_slice_free (GimpPickableLineArtAsyncResult, data);
-}
-
 static void
 line_art_queue_pixel (GQueue *queue,
                       gint    x,
diff --git a/app/core/gimppickable-contiguous-region.h b/app/core/gimppickable-contiguous-region.h
index 772f9d3cdc..9b4ffa544f 100644
--- a/app/core/gimppickable-contiguous-region.h
+++ b/app/core/gimppickable-contiguous-region.h
@@ -18,37 +18,14 @@
 #ifndef __GIMP_PICKABLE_CONTIGUOUS_REGION_H__
 #define __GIMP_PICKABLE_CONTIGUOUS_REGION_H__
 
-typedef struct
-{
-  GeglBuffer *line_art;
-  gfloat     *distmap;
-} GimpPickableLineArtAsyncResult;
-
-GeglBuffer * gimp_pickable_contiguous_region_prepare_line_art       (GimpPickable        *pickable,
-                                                                     gboolean             select_transparent,
-                                                                     gfloat               stroke_threshold,
-                                                                     gint                 segment_max_length,
-                                                                     gint                 spline_max_length,
-                                                                     gfloat             **distmap);
-GimpAsync  * gimp_pickable_contiguous_region_prepare_line_art_async (GimpPickable        *pickable,
-                                                                     gboolean             select_transparent,
-                                                                     gfloat               stroke_threshold,
-                                                                     gint                 segment_max_length,
-                                                                     gint                 spline_max_length,
-                                                                     gint                 priority);
 
 GeglBuffer * gimp_pickable_contiguous_region_by_seed                (GimpPickable        *pickable,
-                                                                     GeglBuffer          *line_art,
-                                                                     gfloat              *line_art_distmap,
+                                                                     GimpLineArt         *line_art,
                                                                      gboolean             antialias,
                                                                      gfloat               threshold,
                                                                      gboolean             select_transparent,
                                                                      GimpSelectCriterion  select_criterion,
                                                                      gboolean             diagonal_neighbors,
-                                                                     gfloat               
line_art_stroke_threshold,
-                                                                     gint                 line_art_max_grow,
-                                                                     gint                 
line_art_segment_max_length,
-                                                                     gint                 
line_art_spline_max_length,
                                                                      gint                 x,
                                                                      gint                 y);
 
diff --git a/app/pdb/drawable-edit-cmds.c b/app/pdb/drawable-edit-cmds.c
index 4d7c8a9cfc..a5212bb1cd 100644
--- a/app/pdb/drawable-edit-cmds.c
+++ b/app/pdb/drawable-edit-cmds.c
@@ -165,13 +165,12 @@ drawable_edit_bucket_fill_invoker (GimpProcedure         *procedure,
           if (gimp_fill_options_set_by_fill_type (options, context,
                                                   fill_type, error))
             {
-              gimp_drawable_bucket_fill (drawable, NULL, NULL, options,
+              gimp_drawable_bucket_fill (drawable, NULL, options,
                                          GIMP_PDB_CONTEXT (context)->sample_transparent,
                                          GIMP_PDB_CONTEXT (context)->sample_criterion,
                                          GIMP_PDB_CONTEXT (context)->sample_threshold,
                                          GIMP_PDB_CONTEXT (context)->sample_merged,
                                          GIMP_PDB_CONTEXT (context)->diagonal_neighbors,
-                                         0.92, 3, 20, 60, /* TODO */
                                          x, y);
             }
           else
diff --git a/app/tools/gimpbucketfilltool.c b/app/tools/gimpbucketfilltool.c
index 6347134f2e..31955f417f 100644
--- a/app/tools/gimpbucketfilltool.c
+++ b/app/tools/gimpbucketfilltool.c
@@ -61,15 +61,10 @@
 
 struct _GimpBucketFillToolPrivate
 {
-  GimpAsync          *async;
-  GeglBuffer         *line_art;
-  gfloat             *distmap;
+  GimpLineArt        *line_art;
   GWeakRef            cached_image;
   GWeakRef            cached_drawable;
 
-  gboolean            fill_in_progress;
-  gboolean            compute_line_art_after_fill;
-  GeglBuffer         *fill_buffer;
   GeglBuffer         *fill_mask;
 
   /* For preview */
@@ -129,20 +124,17 @@ static void     gimp_bucket_fill_tool_cursor_update    (GimpTool              *t
                                                         GdkModifierType        state,
                                                         GimpDisplay           *display);
 
-static void     gimp_bucket_fill_compute_line_art      (GimpBucketFillTool    *tool);
 static gboolean gimp_bucket_fill_tool_connect_handlers (gpointer               data);
 static void     gimp_bucket_fill_tool_options_notified (GimpBucketFillOptions *options,
                                                         GParamSpec            *pspec,
                                                         GimpBucketFillTool    *tool);
+static void     gimp_bucket_fill_reset_line_art        (GimpBucketFillTool    *tool,
+                                                        GimpBucketFillOptions *options);
 static void     gimp_bucket_fill_tool_image_changed    (GimpContext           *context,
                                                         GimpImage             *image,
                                                         GimpBucketFillTool    *tool);
 static void     gimp_bucket_fill_tool_drawable_changed (GimpImage            *image,
                                                         GimpBucketFillTool   *tool);
-static void  gimp_bucket_fill_tool_projection_rendered (GimpProjection     *proj,
-                                                        GimpBucketFillTool *tool);
-static void     gimp_bucket_fill_tool_drawable_painted (GimpDrawable         *drawable,
-                                                        GimpBucketFillTool   *tool);
 
 
 G_DEFINE_TYPE_WITH_PRIVATE (GimpBucketFillTool, gimp_bucket_fill_tool, GIMP_TYPE_COLOR_TOOL)
@@ -211,9 +203,28 @@ gimp_bucket_fill_tool_constructed (GObject *object)
   GimpTool              *tool    = GIMP_TOOL (object);
   GimpBucketFillOptions *options = GIMP_BUCKET_FILL_TOOL_GET_OPTIONS (object);
   Gimp                  *gimp    = GIMP_CONTEXT (options)->gimp;
+  GimpLineArt           *line_art;
 
   G_OBJECT_CLASS (parent_class)->constructed (object);
 
+  line_art = gimp_line_art_new ();
+  g_object_bind_property (options,  "fill-transparent",
+                          line_art, "select-transparent",
+                          G_BINDING_SYNC_CREATE | G_BINDING_BIDIRECTIONAL);
+  g_object_bind_property (options,  "line-art-threshold",
+                          line_art, "threshold",
+                          G_BINDING_SYNC_CREATE | G_BINDING_BIDIRECTIONAL);
+  g_object_bind_property (options,  "line-art-max-grow",
+                          line_art, "max-grow",
+                          G_BINDING_SYNC_CREATE | G_BINDING_BIDIRECTIONAL);
+  g_object_bind_property (options,  "line-art-spline-max-len",
+                          line_art, "spline-max-length",
+                          G_BINDING_SYNC_CREATE | G_BINDING_BIDIRECTIONAL);
+  g_object_bind_property (options,  "line-art-segment-max-len",
+                          line_art, "segment-max-length",
+                          G_BINDING_SYNC_CREATE | G_BINDING_BIDIRECTIONAL);
+  GIMP_BUCKET_FILL_TOOL (tool)->priv->line_art = line_art;
+
   /* Avoid computing initial line art several times (for every option
    * property as it gets deserialized) if tool is selected when starting
    * GIMP with an image.
@@ -235,38 +246,16 @@ gimp_bucket_fill_tool_finalize (GObject *object)
   Gimp                  *gimp     = GIMP_CONTEXT (options)->gimp;
   GimpContext           *context  = gimp_get_user_context (gimp);
   GimpImage             *image    = g_weak_ref_get (&tool->priv->cached_image);
-  GimpDrawable          *drawable = g_weak_ref_get (&tool->priv->cached_drawable);
-
-  if (tool->priv->async)
-    {
-      /* we cancel the async, but don't wait for it to finish, since
-       * it can't actually be interrupted.  instead
-       * gimp_bucket_fill_compute_line_art_cb() bails if the async has
-       * been canceled, to avoid accessing the dead tool.
-       */
-      gimp_cancelable_cancel (GIMP_CANCELABLE (tool->priv->async));
-      g_clear_object (&tool->priv->async);
-    }
 
   g_clear_object (&tool->priv->line_art);
-  g_clear_pointer (&tool->priv->distmap, g_free);
 
   if (image)
     {
       g_signal_handlers_disconnect_by_data (image, tool);
-      g_signal_handlers_disconnect_by_data (gimp_image_get_projection (image),
-                                            tool);
       g_object_unref (image);
     }
-  if (drawable)
-    {
-      g_signal_handlers_disconnect_by_data (drawable, tool);
-      g_object_unref (drawable);
-    }
 
-  g_signal_handlers_disconnect_by_func (options,
-                                        G_CALLBACK (gimp_bucket_fill_tool_options_notified),
-                                        tool);
+  g_signal_handlers_disconnect_by_data (options, tool);
   g_signal_handlers_disconnect_by_data (context, tool);
 
   G_OBJECT_CLASS (parent_class)->finalize (object);
@@ -321,7 +310,7 @@ gimp_bucket_fill_tool_start (GimpBucketFillTool *tool,
 
   g_return_if_fail (! tool->priv->filter);
 
-  tool->priv->fill_in_progress = TRUE;
+  gimp_line_art_freeze (tool->priv->line_art);
 
   GIMP_TOOL (tool)->display  = display;
   GIMP_TOOL (tool)->drawable = drawable;
@@ -348,12 +337,6 @@ gimp_bucket_fill_tool_start (GimpBucketFillTool *tool,
   g_signal_connect (tool->priv->filter, "flush",
                     G_CALLBACK (gimp_bucket_fill_tool_filter_flush),
                     tool);
-
-  if (options->fill_criterion == GIMP_SELECT_CRITERION_LINE_ART &&
-      tool->priv->async)
-    {
-      gimp_waitable_wait (GIMP_WAITABLE (tool->priv->async));
-    }
 }
 
 static void
@@ -369,8 +352,6 @@ gimp_bucket_fill_tool_preview (GimpBucketFillTool *tool,
   if (tool->priv->filter)
     {
       GeglBuffer *fill     = NULL;
-      GeglBuffer *line_art = NULL;
-      gfloat     *distmap  = NULL;
       gdouble     x        = coords->x;
       gdouble     y        = coords->y;
 
@@ -384,29 +365,16 @@ gimp_bucket_fill_tool_preview (GimpBucketFillTool *tool,
           y -= (gdouble) off_y;
         }
 
-      if (options->fill_criterion == GIMP_SELECT_CRITERION_LINE_ART)
-        {
-          line_art = g_object_ref (tool->priv->line_art);
-          distmap  = tool->priv->distmap;
-        }
-
       fill = gimp_drawable_get_bucket_fill_buffer (drawable,
-                                                   line_art, distmap,
+                                                   tool->priv->line_art,
                                                    fill_options,
                                                    options->fill_transparent,
                                                    options->fill_criterion,
                                                    options->threshold / 255.0,
                                                    options->sample_merged,
                                                    options->diagonal_neighbors,
-                                                   options->line_art_threshold,
-                                                   options->line_art_max_grow,
-                                                   options->line_art_segment_max_len,
-                                                   options->line_art_spline_max_len,
                                                    x, y, &tool->priv->fill_mask,
                                                    &x, &y, NULL, NULL);
-      if (line_art)
-        g_object_unref (line_art);
-
       if (fill)
         {
           gegl_node_set (tool->priv->fill_node,
@@ -427,12 +395,6 @@ gimp_bucket_fill_tool_commit (GimpBucketFillTool *tool)
 {
   if (tool->priv->filter)
     {
-      GimpBucketFillOptions *options = GIMP_BUCKET_FILL_TOOL_GET_OPTIONS (tool);
-
-      /* Make sure the drawable will signal being painted. */
-      if (! options->sample_merged)
-        tool->priv->fill_in_progress = FALSE;
-
       gimp_drawable_filter_commit (tool->priv->filter,
                                    GIMP_PROGRESS (tool), FALSE);
       gimp_image_flush (gimp_display_get_image (GIMP_TOOL (tool)->display));
@@ -455,8 +417,7 @@ gimp_bucket_fill_tool_halt (GimpBucketFillTool *tool)
     }
   g_clear_object (&tool->priv->fill_mask);
 
-  tool->priv->fill_in_progress            = FALSE;
-  tool->priv->compute_line_art_after_fill = FALSE;
+  gimp_line_art_thaw (tool->priv->line_art);
 
   GIMP_TOOL (tool)->display  = NULL;
   GIMP_TOOL (tool)->drawable = NULL;
@@ -590,8 +551,6 @@ gimp_bucket_fill_tool_motion (GimpTool         *tool,
       GimpFillOptions *fill_options;
       GError          *error = NULL;
 
-      g_return_if_fail (bucket_tool->priv->fill_in_progress);
-
       fill_options = gimp_fill_options_new (image->gimp, NULL, FALSE);
 
       if (gimp_fill_options_set_by_fill_mode (fill_options, context,
@@ -752,92 +711,6 @@ gimp_bucket_fill_tool_cursor_update (GimpTool         *tool,
   GIMP_TOOL_CLASS (parent_class)->cursor_update (tool, coords, state, display);
 }
 
-static void
-gimp_bucket_fill_compute_line_art_cb (GimpAsync          *async,
-                                      GimpBucketFillTool *tool)
-{
-  if (gimp_async_is_canceled (async))
-    return;
-
-  if (gimp_async_is_finished (async))
-    {
-      GimpPickableLineArtAsyncResult *result;
-
-      result = gimp_async_get_result (async);
-
-      tool->priv->line_art = g_object_ref (result->line_art);
-      tool->priv->distmap  = result->distmap;
-      result->distmap  = NULL;
-    }
-
-  g_clear_object (&tool->priv->async);
-}
-
-static void
-gimp_bucket_fill_compute_line_art (GimpBucketFillTool *tool)
-{
-  GimpBucketFillOptions *options = GIMP_BUCKET_FILL_TOOL_GET_OPTIONS (tool);
-
-  if (tool->priv->fill_in_progress)
-    {
-      tool->priv->compute_line_art_after_fill = TRUE;
-      return;
-    }
-
-  if (tool->priv->async)
-    {
-      gimp_cancelable_cancel (GIMP_CANCELABLE (tool->priv->async));
-      g_clear_object (&tool->priv->async);
-    }
-
-  g_clear_object (&tool->priv->line_art);
-  g_clear_pointer (&tool->priv->distmap, g_free);
-
-  if (options->fill_criterion == GIMP_SELECT_CRITERION_LINE_ART)
-    {
-      GimpPickable *pickable = NULL;
-      GimpDrawable *image    = g_weak_ref_get (&tool->priv->cached_image);
-      GimpDrawable *drawable = g_weak_ref_get (&tool->priv->cached_drawable);
-
-      if (image && options->sample_merged)
-        pickable = GIMP_PICKABLE (image);
-      else if (drawable && ! options->sample_merged)
-        pickable = GIMP_PICKABLE (drawable);
-
-      if (pickable)
-        {
-          /* gimp_pickable_contiguous_region_prepare_line_art_async()
-           * will flush the pickable, which may trigger this signal
-           * handler, and will leak a line art (as tool->priv->async has
-           * not been set yet.
-           */
-          g_signal_handlers_block_by_func (gimp_image_get_projection (GIMP_IMAGE (image)),
-                                           G_CALLBACK (gimp_bucket_fill_tool_projection_rendered),
-                                           tool);
-          tool->priv->async =
-            gimp_pickable_contiguous_region_prepare_line_art_async (
-              pickable,
-              options->fill_transparent,
-              options->line_art_threshold,
-              options->line_art_segment_max_len,
-              options->line_art_spline_max_len,
-              +1);
-          g_signal_handlers_unblock_by_func (gimp_image_get_projection (GIMP_IMAGE (image)),
-                                           G_CALLBACK (gimp_bucket_fill_tool_projection_rendered),
-                                           tool);
-
-          gimp_async_add_callback_for_object (
-            tool->priv->async,
-            (GimpAsyncCallback) gimp_bucket_fill_compute_line_art_cb,
-            tool,
-            tool);
-        }
-
-      g_clear_object (&image);
-      g_clear_object (&drawable);
-    }
-}
-
 static gboolean
 gimp_bucket_fill_tool_connect_handlers (gpointer data)
 {
@@ -856,13 +729,6 @@ gimp_bucket_fill_tool_connect_handlers (gpointer data)
       g_signal_connect (options, "notify::sample-merged",
                         G_CALLBACK (gimp_bucket_fill_tool_options_notified),
                         tool);
-      g_signal_connect (options, "notify::fill-transparent",
-                        G_CALLBACK (gimp_bucket_fill_tool_options_notified),
-                        tool);
-      g_signal_connect (options, "notify::line-art-threshold",
-                        G_CALLBACK (gimp_bucket_fill_tool_options_notified),
-                        tool);
-
       g_signal_connect (options, "notify::fill-mode",
                         G_CALLBACK (gimp_bucket_fill_tool_options_notified),
                         tool);
@@ -882,13 +748,10 @@ gimp_bucket_fill_tool_options_notified (GimpBucketFillOptions *options,
                                         GParamSpec            *pspec,
                                         GimpBucketFillTool    *tool)
 {
-  if ((! strcmp (pspec->name, "fill-criterion")     ||
-       ! strcmp (pspec->name, "fill-transparent")   ||
-       ! strcmp (pspec->name, "line-art-threshold") ||
-       ! strcmp (pspec->name, "sample-merged")) &&
-      options->fill_criterion == GIMP_SELECT_CRITERION_LINE_ART)
+  if (! strcmp (pspec->name, "fill-criterion") ||
+      ! strcmp (pspec->name, "sample-merged"))
     {
-      gimp_bucket_fill_compute_line_art (tool);
+      gimp_bucket_fill_reset_line_art (tool, options);
     }
   else if (! strcmp (pspec->name, "fill-mode"))
     {
@@ -917,6 +780,49 @@ gimp_bucket_fill_tool_options_notified (GimpBucketFillOptions *options,
     }
 }
 
+static void
+gimp_bucket_fill_reset_line_art (GimpBucketFillTool    *tool,
+                                 GimpBucketFillOptions *options)
+{
+  GimpImage   *prev_image = g_weak_ref_get (&tool->priv->cached_image);
+  GimpContext *context    = gimp_get_user_context (GIMP_CONTEXT (options)->gimp);
+  GimpImage   *image      = gimp_context_get_image (context);
+
+  if (prev_image)
+    {
+      g_signal_handlers_disconnect_by_data (prev_image, tool);
+      g_object_unref (prev_image);
+    }
+  g_weak_ref_set (&tool->priv->cached_image, image ? image : NULL);
+  g_weak_ref_set (&tool->priv->cached_drawable, NULL);
+
+  if (image && options->fill_criterion == GIMP_SELECT_CRITERION_LINE_ART)
+    {
+      GimpBucketFillOptions *options  = GIMP_BUCKET_FILL_TOOL_GET_OPTIONS (tool);
+      GimpDrawable          *drawable = gimp_image_get_active_drawable (image);
+
+      g_signal_connect (image, "active-layer-changed",
+                        G_CALLBACK (gimp_bucket_fill_tool_drawable_changed),
+                        tool);
+      g_signal_connect (image, "active-channel-changed",
+                        G_CALLBACK (gimp_bucket_fill_tool_drawable_changed),
+                        tool);
+
+      g_weak_ref_set (&tool->priv->cached_drawable, drawable ? drawable : NULL);
+
+      if (options->sample_merged)
+        gimp_line_art_set_input (tool->priv->line_art, GIMP_PICKABLE (image));
+      else if (drawable)
+        gimp_line_art_set_input (tool->priv->line_art, GIMP_PICKABLE (drawable));
+      else
+        gimp_line_art_set_input (tool->priv->line_art, NULL);
+    }
+  else
+    {
+      gimp_line_art_set_input (tool->priv->line_art, NULL);
+    }
+}
+
 static void
 gimp_bucket_fill_tool_image_changed (GimpContext        *context,
                                      GimpImage          *image,
@@ -926,37 +832,32 @@ gimp_bucket_fill_tool_image_changed (GimpContext        *context,
 
   if (image != prev_image)
     {
-      GimpImage *prev_drawable = g_weak_ref_get (&tool->priv->cached_drawable);
-
-      g_clear_object (&tool->priv->line_art);
-      g_clear_pointer (&tool->priv->distmap, g_free);
-
       if (prev_image)
         {
           g_signal_handlers_disconnect_by_data (prev_image, tool);
-          g_signal_handlers_disconnect_by_data (gimp_image_get_projection (prev_image),
-                                                tool);
-        }
-      if (prev_drawable)
-        {
-          g_signal_handlers_disconnect_by_data (prev_drawable, tool);
-          g_object_unref (prev_drawable);
         }
 
       g_weak_ref_set (&tool->priv->cached_image, image ? image : NULL);
       g_weak_ref_set (&tool->priv->cached_drawable, NULL);
       if (image)
         {
+          GimpBucketFillOptions *options = GIMP_BUCKET_FILL_TOOL_GET_OPTIONS (tool);
+
           g_signal_connect (image, "active-layer-changed",
                             G_CALLBACK (gimp_bucket_fill_tool_drawable_changed),
                             tool);
           g_signal_connect (image, "active-channel-changed",
                             G_CALLBACK (gimp_bucket_fill_tool_drawable_changed),
                             tool);
-          g_signal_connect (gimp_image_get_projection (image), "rendered",
-                            G_CALLBACK (gimp_bucket_fill_tool_projection_rendered),
-                            tool);
           gimp_bucket_fill_tool_drawable_changed (image, tool);
+
+          if (options->sample_merged)
+            gimp_line_art_set_input (tool->priv->line_art,
+                                     GIMP_PICKABLE (image));
+        }
+      else
+        {
+          gimp_line_art_set_input (tool->priv->line_art, NULL);
         }
     }
   if (prev_image)
@@ -972,37 +873,13 @@ gimp_bucket_fill_tool_drawable_changed (GimpImage          *image,
 
   if (drawable != prev_drawable)
     {
-      if (prev_drawable)
-        g_signal_handlers_disconnect_by_data (prev_drawable, tool);
+      GimpBucketFillOptions *options = GIMP_BUCKET_FILL_TOOL_GET_OPTIONS (tool);
 
       g_weak_ref_set (&tool->priv->cached_drawable, drawable ? drawable : NULL);
-      if (drawable)
-        g_signal_connect (drawable, "painted",
-                          G_CALLBACK (gimp_bucket_fill_tool_drawable_painted),
-                          tool);
-
-      gimp_bucket_fill_compute_line_art (tool);
+      if (! options->sample_merged)
+        gimp_line_art_set_input (tool->priv->line_art,
+                                 drawable ? GIMP_PICKABLE (drawable) : NULL);
     }
   if (prev_drawable)
     g_object_unref (prev_drawable);
 }
-
-static void
-gimp_bucket_fill_tool_projection_rendered (GimpProjection     *proj,
-                                           GimpBucketFillTool *tool)
-{
-  GimpBucketFillOptions *options = GIMP_BUCKET_FILL_TOOL_GET_OPTIONS (tool);
-
-  if (options->sample_merged)
-    gimp_bucket_fill_compute_line_art (tool);
-}
-
-static void
-gimp_bucket_fill_tool_drawable_painted (GimpDrawable       *drawable,
-                                        GimpBucketFillTool *tool)
-{
-  GimpBucketFillOptions *options = GIMP_BUCKET_FILL_TOOL_GET_OPTIONS (tool);
-
-  if (! options->sample_merged)
-    gimp_bucket_fill_compute_line_art (tool);
-}
diff --git a/app/tools/gimpfuzzyselecttool.c b/app/tools/gimpfuzzyselecttool.c
index de86b3c171..b3eee7d196 100644
--- a/app/tools/gimpfuzzyselecttool.c
+++ b/app/tools/gimpfuzzyselecttool.c
@@ -122,12 +122,11 @@ gimp_fuzzy_select_tool_get_mask (GimpRegionSelectTool *region_select,
       pickable = GIMP_PICKABLE (image);
     }
 
-  return gimp_pickable_contiguous_region_by_seed (pickable, NULL, NULL,
+  return gimp_pickable_contiguous_region_by_seed (pickable, NULL,
                                                   sel_options->antialias,
                                                   options->threshold / 255.0,
                                                   options->select_transparent,
                                                   options->select_criterion,
                                                   options->diagonal_neighbors,
-                                                  0.92, 3, 20, 60, /* TODO */
                                                   x, y);
 }
diff --git a/pdb/groups/drawable_edit.pdb b/pdb/groups/drawable_edit.pdb
index 2be98f4456..79b8c395c5 100644
--- a/pdb/groups/drawable_edit.pdb
+++ b/pdb/groups/drawable_edit.pdb
@@ -169,13 +169,12 @@ HELP
       if (gimp_fill_options_set_by_fill_type (options, context,
                                               fill_type, error))
         {
-          gimp_drawable_bucket_fill (drawable, NULL, NULL, options,
+          gimp_drawable_bucket_fill (drawable, NULL, options,
                                      GIMP_PDB_CONTEXT (context)->sample_transparent,
                                      GIMP_PDB_CONTEXT (context)->sample_criterion,
                                      GIMP_PDB_CONTEXT (context)->sample_threshold,
                                      GIMP_PDB_CONTEXT (context)->sample_merged,
                                      GIMP_PDB_CONTEXT (context)->diagonal_neighbors,
-                                     0.92, 3, 20, 60, /* TODO */
                                      x, y);
         }
       else



[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]