[gimp/goat-invasion: 165/241] app: port GimpBoundary to GEGL, including its API



commit 25b752379f765073e57228a19009779a3f6b431e
Author: Michael Natterer <mitch gimp org>
Date:   Tue Mar 20 19:55:23 2012 +0100

    app: port GimpBoundary to GEGL, including its API

 app/core/gimpboundary.c           |  279 +++++++++++++++++++------------------
 app/core/gimpboundary.h           |   37 +++---
 app/core/gimpbrush-boundary.c     |   24 ++--
 app/core/gimpchannel.c            |   24 ++--
 app/core/gimplayer-floating-sel.c |   14 +-
 app/tools/gimpregionselecttool.c  |   16 +--
 6 files changed, 201 insertions(+), 193 deletions(-)
---
diff --git a/app/core/gimpboundary.c b/app/core/gimpboundary.c
index d6d04b5..154a748 100644
--- a/app/core/gimpboundary.c
+++ b/app/core/gimpboundary.c
@@ -20,16 +20,12 @@
 #include <stdlib.h>
 #include <string.h>
 
-#include <glib-object.h>
+#include <gegl.h>
 
 #include "libgimpmath/gimpmath.h"
 
 #include "core-types.h"
 
-#include "base/pixel-region.h"
-#include "base/tile.h"
-#include "base/tile-manager.h"
-
 #include "gimpboundary.h"
 
 
@@ -59,48 +55,51 @@ struct _GimpBoundary
 
 /*  local function prototypes  */
 
-static GimpBoundary * gimp_boundary_new        (PixelRegion     *PR);
+static GimpBoundary * gimp_boundary_new        (const GeglRectangle *region);
 static GimpBoundSeg * gimp_boundary_free       (GimpBoundary    *boundary,
                                                 gboolean         free_segs);
 
-static void       gimp_boundary_add_seg    (GimpBoundary        *bounrady,
-                                            gint             x1,
-                                            gint             y1,
-                                            gint             x2,
-                                            gint             y2,
-                                            gboolean         open);
-
-static void       find_empty_segs     (PixelRegion      *maskPR,
-                                       gint              scanline,
-                                       gint              empty_segs[],
-                                       gint              max_empty,
-                                       gint             *num_empty,
-                                       GimpBoundaryType  type,
-                                       gint              x1,
-                                       gint              y1,
-                                       gint              x2,
-                                       gint              y2,
-                                       guchar            threshold);
-static void       process_horiz_seg   (GimpBoundary     *boundary,
-                                       gint              x1,
-                                       gint              y1,
-                                       gint              x2,
-                                       gint              y2,
-                                       gboolean          open);
-static void       make_horiz_segs     (GimpBoundary     *boundary,
-                                       gint              start,
-                                       gint              end,
-                                       gint              scanline,
-                                       gint              empty[],
-                                       gint              num_empty,
-                                       gint              top);
-static GimpBoundary * generate_boundary   (PixelRegion     *PR,
+static void           gimp_boundary_add_seg    (GimpBoundary        *bounrady,
+                                                gint             x1,
+                                                gint             y1,
+                                                gint             x2,
+                                                gint             y2,
+                                                gboolean         open);
+
+static void           find_empty_segs     (const GeglRectangle *region,
+                                           const guchar        *line_data,
+                                           gint                 bpp,
+                                           gint                 scanline,
+                                           gint                 empty_segs[],
+                                           gint                 max_empty,
+                                           gint                *num_empty,
+                                           GimpBoundaryType     type,
+                                           gint                 x1,
+                                           gint                 y1,
+                                           gint                 x2,
+                                           gint                 y2,
+                                           guchar               threshold);
+static void           process_horiz_seg   (GimpBoundary        *boundary,
+                                           gint                 x1,
+                                           gint                 y1,
+                                           gint                 x2,
+                                           gint                 y2,
+                                           gboolean             open);
+static void           make_horiz_segs     (GimpBoundary        *boundary,
+                                           gint                 start,
+                                           gint                 end,
+                                           gint                 scanline,
+                                           gint                 empty[],
+                                           gint                 num_empty,
+                                           gint                 top);
+static GimpBoundary * generate_boundary   (GeglBuffer          *buffer,
+                                           const GeglRectangle *region,
                                            GimpBoundaryType     type,
-                                           gint             x1,
-                                           gint             y1,
-                                           gint             x2,
-                                           gint             y2,
-                                           guchar           threshold);
+                                           gint                 x1,
+                                           gint                 y1,
+                                           gint                 x2,
+                                           gint                 y2,
+                                           guchar               threshold);
 
 static gint       cmp_segptr_xy1_addr (const GimpBoundSeg **seg_ptr_a,
                                        const GimpBoundSeg **seg_ptr_b);
@@ -153,21 +152,33 @@ static void       simplify_subdivide  (const GimpBoundSeg  *segs,
  * Return value: the boundary array.
  **/
 GimpBoundSeg *
-gimp_boundary_find (PixelRegion      *maskPR,
-                    GimpBoundaryType  type,
-                    int               x1,
-                    int               y1,
-                    int               x2,
-                    int               y2,
-                    guchar            threshold,
-                    int              *num_segs)
+gimp_boundary_find (GeglBuffer          *buffer,
+                    const GeglRectangle *region,
+                    GimpBoundaryType     type,
+                    int                  x1,
+                    int                  y1,
+                    int                  x2,
+                    int                  y2,
+                    guchar               threshold,
+                    int                 *num_segs)
 {
-  GimpBoundary *boundary;
+  GimpBoundary  *boundary;
+  GeglRectangle  rect = { 0, };
 
-  g_return_val_if_fail (maskPR != NULL, NULL);
+  g_return_val_if_fail (GEGL_IS_BUFFER (buffer), NULL);
   g_return_val_if_fail (num_segs != NULL, NULL);
 
-  boundary = generate_boundary (maskPR, type, x1, y1, x2, y2, threshold);
+  if (region)
+    {
+      rect = *region;
+    }
+  else
+    {
+      rect.width  = gegl_buffer_get_width  (buffer);
+      rect.height = gegl_buffer_get_height (buffer);
+    }
+
+  boundary = generate_boundary (buffer, &rect, type, x1, y1, x2, y2, threshold);
 
   *num_segs = boundary->num_segs;
 
@@ -390,26 +401,26 @@ gimp_boundary_offset (GimpBoundSeg *segs,
 /*  private functions  */
 
 static GimpBoundary *
-gimp_boundary_new (PixelRegion *PR)
+gimp_boundary_new (const GeglRectangle *region)
 {
   GimpBoundary *boundary = g_slice_new0 (GimpBoundary);
 
-  if (PR)
+  if (region)
     {
       gint i;
 
       /*  array for determining the vertical line segments
        *  which must be drawn
        */
-      boundary->vert_segs = g_new (gint, PR->w + PR->x + 1);
+      boundary->vert_segs = g_new (gint, region->width + region->x + 1);
 
-      for (i = 0; i <= (PR->w + PR->x); i++)
+      for (i = 0; i <= (region->width + region->x); i++)
         boundary->vert_segs[i] = -1;
 
       /*  find the maximum possible number of empty segments
        *  given the current mask
        */
-      boundary->max_empty_segs = PR->w + 3;
+      boundary->max_empty_segs = region->width + 3;
 
       boundary->empty_segs_n = g_new (gint, boundary->max_empty_segs);
       boundary->empty_segs_c = g_new (gint, boundary->max_empty_segs);
@@ -465,32 +476,30 @@ gimp_boundary_add_seg (GimpBoundary *boundary,
 }
 
 static void
-find_empty_segs (PixelRegion      *maskPR,
-                 gint              scanline,
-                 gint              empty_segs[],
-                 gint              max_empty,
-                 gint             *num_empty,
-                 GimpBoundaryType  type,
-                 gint              x1,
-                 gint              y1,
-                 gint              x2,
-                 gint              y2,
-                 guchar            threshold)
+find_empty_segs (const GeglRectangle *region,
+                 const guchar        *line_data,
+                 gint                 bpp,
+                 gint                 scanline,
+                 gint                 empty_segs[],
+                 gint                 max_empty,
+                 gint                *num_empty,
+                 GimpBoundaryType     type,
+                 gint                 x1,
+                 gint                 y1,
+                 gint                 x2,
+                 gint                 y2,
+                 guchar               threshold)
 {
-  const guchar *data  = NULL;
-  Tile         *tile  = NULL;
-  gint          start = 0;
-  gint          end   = 0;
-  gint          endx  = 0;
-  gint          bpp   = 0;
-  gint          tilex = -1;
-  gint          last  = -1;
-  gint          l_num_empty;
-  gint          x;
+  gint start = 0;
+  gint end   = 0;
+  gint endx  = 0;
+  gint last  = -1;
+  gint l_num_empty;
+  gint x;
 
   *num_empty = 0;
 
-  if (scanline < maskPR->y || scanline >= (maskPR->y + maskPR->h))
+  if (scanline < region->y || scanline >= (region->y + region->height))
     {
       empty_segs[(*num_empty)++] = 0;
       empty_segs[(*num_empty)++] = G_MAXINT;
@@ -511,8 +520,8 @@ find_empty_segs (PixelRegion      *maskPR,
     }
   else if (type == GIMP_BOUNDARY_IGNORE_BOUNDS)
     {
-      start = maskPR->x;
-      end   = maskPR->x + maskPR->w;
+      start = region->x;
+      end   = region->x + region->width;
       if (scanline < y1 || scanline >= y2)
         x2 = -1;
     }
@@ -521,43 +530,20 @@ find_empty_segs (PixelRegion      *maskPR,
 
   l_num_empty = *num_empty;
 
-  bpp = maskPR->bytes;
+  endx = end;
 
-  if (! maskPR->tiles)
-    {
-      data  = maskPR->data + scanline * maskPR->rowstride;
-      endx = end;
-    }
+  line_data += bpp * start;
+  line_data += bpp - 1;
 
   for (x = start; x < end;)
     {
-      /*  Check to see if we must advance to next tile  */
-      if (maskPR->tiles)
-        {
-          if ((x / TILE_WIDTH) != tilex)
-            {
-              if (tile)
-                tile_release (tile, FALSE);
-
-              tile = tile_manager_get_tile (maskPR->tiles,
-                                            x, scanline, TRUE, FALSE);
-              data = ((const guchar *) tile_data_pointer (tile, x, scanline) +
-                      bpp - 1);
-
-              tilex = x / TILE_WIDTH;
-            }
-
-          endx = x + (TILE_WIDTH - (x % TILE_WIDTH));
-          endx = MIN (end, endx);
-        }
-
       if (type == GIMP_BOUNDARY_IGNORE_BOUNDS && (endx > x1 || x < x2))
         {
           for (; x < endx; x++)
             {
               gint val;
 
-              if (*data > threshold)
+              if (*line_data > threshold)
                 {
                   if (x >= x1 && x < x2)
                     val = -1;
@@ -569,7 +555,7 @@ find_empty_segs (PixelRegion      *maskPR,
                   val = -1;
                 }
 
-              data += bpp;
+              line_data += bpp;
 
               if (last != val)
                 empty_segs[l_num_empty++] = x;
@@ -583,12 +569,12 @@ find_empty_segs (PixelRegion      *maskPR,
             {
               gint val;
 
-              if (*data > threshold)
+              if (*line_data > threshold)
                 val = 1;
               else
                 val = -1;
 
-              data += bpp;
+              line_data += bpp;
 
               if (last != val)
                 empty_segs[l_num_empty++] = x;
@@ -604,9 +590,6 @@ find_empty_segs (PixelRegion      *maskPR,
     empty_segs[(*num_empty)++] = x;
 
   empty_segs[(*num_empty)++] = G_MAXINT;
-
-  if (tile)
-    tile_release (tile, FALSE);
 }
 
 static void
@@ -672,25 +655,38 @@ make_horiz_segs (GimpBoundary *boundary,
 }
 
 static GimpBoundary *
-generate_boundary (PixelRegion      *PR,
-                   GimpBoundaryType  type,
-                   gint              x1,
-                   gint              y1,
-                   gint              x2,
-                   gint              y2,
-                   guchar            threshold)
+generate_boundary (GeglBuffer          *buffer,
+                   const GeglRectangle *region,
+                   GimpBoundaryType     type,
+                   gint                 x1,
+                   gint                 y1,
+                   gint                 x2,
+                   gint                 y2,
+                   guchar               threshold)
 {
-  GimpBoundary *boundary;
-  gint          scanline;
-  gint          i;
-  gint          start, end;
-  gint         *tmp_segs;
+  GimpBoundary  *boundary;
+  const Babl    *format;
+  GeglRectangle  line_rect = { 0, };
+  guchar        *line_data;
+  gint           bpp;
+  gint           scanline;
+  gint           i;
+  gint           start, end;
+  gint          *tmp_segs;
 
   gint          num_empty_n = 0;
   gint          num_empty_c = 0;
   gint          num_empty_l = 0;
 
-  boundary = gimp_boundary_new (PR);
+  boundary = gimp_boundary_new (region);
+
+  format = gegl_buffer_get_format (buffer);
+  bpp = babl_format_get_bytes_per_pixel (format);
+
+  line_rect.width  = gegl_buffer_get_width (buffer);
+  line_rect.height = 1;
+
+  line_data = g_alloca (bpp * line_rect.width);
 
   start = 0;
   end   = 0;
@@ -702,16 +698,23 @@ generate_boundary (PixelRegion      *PR,
     }
   else if (type == GIMP_BOUNDARY_IGNORE_BOUNDS)
     {
-      start = PR->y;
-      end   = PR->y + PR->h;
+      start = region->y;
+      end   = region->y + region->height;
     }
 
   /*  Find the empty segments for the previous and current scanlines  */
-  find_empty_segs (PR, start - 1, boundary->empty_segs_l,
+  find_empty_segs (region, NULL, bpp,
+                   start - 1, boundary->empty_segs_l,
                    boundary->max_empty_segs, &num_empty_l,
                    type, x1, y1, x2, y2,
                    threshold);
-  find_empty_segs (PR, start, boundary->empty_segs_c,
+
+  line_rect.y = start;
+  gegl_buffer_get (buffer, 1.0, &line_rect, format,
+                   line_data, GEGL_AUTO_ROWSTRIDE);
+
+  find_empty_segs (region, line_data, bpp,
+                   start, boundary->empty_segs_c,
                    boundary->max_empty_segs, &num_empty_c,
                    type, x1, y1, x2, y2,
                    threshold);
@@ -719,7 +722,15 @@ generate_boundary (PixelRegion      *PR,
   for (scanline = start; scanline < end; scanline++)
     {
       /*  find the empty segment list for the next scanline  */
-      find_empty_segs (PR, scanline + 1, boundary->empty_segs_n,
+      line_rect.y = scanline + 1;
+      if (scanline + 1 == end)
+        line_data = NULL;
+      else
+        gegl_buffer_get (buffer, 1.0, &line_rect, format,
+                         line_data, GEGL_AUTO_ROWSTRIDE);
+
+      find_empty_segs (region, line_data, bpp,
+                       scanline + 1, boundary->empty_segs_n,
                        boundary->max_empty_segs, &num_empty_n,
                        type, x1, y1, x2, y2,
                        threshold);
diff --git a/app/core/gimpboundary.h b/app/core/gimpboundary.h
index 64d423a..fabda66 100644
--- a/app/core/gimpboundary.h
+++ b/app/core/gimpboundary.h
@@ -41,26 +41,27 @@ struct _GimpBoundSeg
 };
 
 
-GimpBoundSeg * gimp_boundary_find      (PixelRegion        *maskPR,
-                                        GimpBoundaryType    type,
-                                        gint                x1,
-                                        gint                y1,
-                                        gint                x2,
-                                        gint                y2,
-                                        guchar              threshold,
-                                        gint               *num_segs);
-GimpBoundSeg * gimp_boundary_sort      (const GimpBoundSeg *segs,
-                                        gint                num_segs,
-                                        gint               *num_groups);
-GimpBoundSeg * gimp_boundary_simplify  (GimpBoundSeg       *sorted_segs,
-                                        gint                num_groups,
-                                        gint               *num_segs);
+GimpBoundSeg * gimp_boundary_find      (GeglBuffer          *buffer,
+                                        const GeglRectangle *region,
+                                        GimpBoundaryType     type,
+                                        gint                 x1,
+                                        gint                 y1,
+                                        gint                 x2,
+                                        gint                 y2,
+                                        guchar               threshold,
+                                        gint                *num_segs);
+GimpBoundSeg * gimp_boundary_sort      (const GimpBoundSeg  *segs,
+                                        gint                 num_segs,
+                                        gint                *num_groups);
+GimpBoundSeg * gimp_boundary_simplify  (GimpBoundSeg        *sorted_segs,
+                                        gint                 num_groups,
+                                        gint                *num_segs);
 
 /* offsets in-place */
-void       gimp_boundary_offset        (GimpBoundSeg       *segs,
-                                        gint                num_segs,
-                                        gint                off_x,
-                                        gint                off_y);
+void       gimp_boundary_offset        (GimpBoundSeg        *segs,
+                                        gint                 num_segs,
+                                        gint                 off_x,
+                                        gint                 off_y);
 
 
 #endif  /*  __GIMP_BOUNDARY_H__  */
diff --git a/app/core/gimpbrush-boundary.c b/app/core/gimpbrush-boundary.c
index cc12225..4906950 100644
--- a/app/core/gimpbrush-boundary.c
+++ b/app/core/gimpbrush-boundary.c
@@ -17,12 +17,11 @@
 
 #include "config.h"
 
-#include <glib-object.h>
 #include <cairo.h>
+#include <gegl.h>
 
 #include "core-types.h"
 
-#include "base/pixel-region.h"
 #include "base/temp-buf.h"
 
 #include "gimpbezierdesc.h"
@@ -45,18 +44,25 @@ gimp_brush_transform_boundary_exact (GimpBrush *brush,
 
   if (mask)
     {
-      PixelRegion   maskPR;
-      GimpBoundSeg *bound_segs;
-      gint          n_bound_segs;
-
-      pixel_region_init_temp_buf (&maskPR, (TempBuf *) mask,
-                                  0, 0, mask->width, mask->height);
-
-      bound_segs = gimp_boundary_find (&maskPR, GIMP_BOUNDARY_WITHIN_BOUNDS,
-                                       0, 0, maskPR.w, maskPR.h,
+      GeglBuffer    *buffer;
+      GeglRectangle  rect = { 0, 0, mask->width, mask->height };
+      GimpBoundSeg  *bound_segs;
+      gint           n_bound_segs;
+
+      buffer = gegl_buffer_linear_new_from_data (mask->data,
+                                                 babl_format ("Y u8"),
+                                                 &rect,
+                                                 GEGL_AUTO_ROWSTRIDE,
+                                                 NULL, NULL);
+
+      bound_segs = gimp_boundary_find (buffer, NULL,
+                                       GIMP_BOUNDARY_WITHIN_BOUNDS,
+                                       0, 0, mask->width, mask->height,
                                        0,
                                        &n_bound_segs);
 
+      g_object_unref (buffer);
+
       if (bound_segs)
         {
           GimpBoundSeg *stroke_segs;
diff --git a/app/core/gimpchannel.c b/app/core/gimpchannel.c
index 4dafa63..0aca136 100644
--- a/app/core/gimpchannel.c
+++ b/app/core/gimpchannel.c
@@ -1010,22 +1010,23 @@ gimp_channel_real_boundary (GimpChannel         *channel,
                             gint                 x2,
                             gint                 y2)
 {
-  gint         x3, y3, x4, y4;
-  PixelRegion  bPR;
-
   if (! channel->boundary_known)
     {
+      gint x3, y3, x4, y4;
+
       /* free the out of date boundary segments */
       g_free (channel->segs_in);
       g_free (channel->segs_out);
 
       if (gimp_channel_bounds (channel, &x3, &y3, &x4, &y4))
         {
-          pixel_region_init (&bPR,
-                             gimp_drawable_get_tiles (GIMP_DRAWABLE (channel)),
-                             x3, y3, x4 - x3, y4 - y3, FALSE);
+          GeglBuffer *buffer;
+          GeglRectangle  rect = { x3, y3, x4 - x3, y4 - y3 };
 
-          channel->segs_out = gimp_boundary_find (&bPR, GIMP_BOUNDARY_IGNORE_BOUNDS,
+          buffer = gimp_drawable_get_read_buffer (GIMP_DRAWABLE (channel));
+
+          channel->segs_out = gimp_boundary_find (buffer, &rect,
+                                                  GIMP_BOUNDARY_IGNORE_BOUNDS,
                                                   x1, y1, x2, y2,
                                                   GIMP_BOUNDARY_HALF_WAY,
                                                   &channel->num_segs_out);
@@ -1036,13 +1037,8 @@ gimp_channel_real_boundary (GimpChannel         *channel,
 
           if (x2 > x1 && y2 > y1)
             {
-              pixel_region_init (&bPR,
-                                 gimp_drawable_get_tiles (GIMP_DRAWABLE (channel)),
-                                 0, 0,
-                                 gimp_item_get_width  (GIMP_ITEM (channel)),
-                                 gimp_item_get_height (GIMP_ITEM (channel)), FALSE);
-
-              channel->segs_in = gimp_boundary_find (&bPR, GIMP_BOUNDARY_WITHIN_BOUNDS,
+              channel->segs_in = gimp_boundary_find (buffer, NULL,
+                                                     GIMP_BOUNDARY_WITHIN_BOUNDS,
                                                      x1, y1, x2, y2,
                                                      GIMP_BOUNDARY_HALF_WAY,
                                                      &channel->num_segs_in);
diff --git a/app/core/gimplayer-floating-sel.c b/app/core/gimplayer-floating-sel.c
index 2f7c795..f6865d9 100644
--- a/app/core/gimplayer-floating-sel.c
+++ b/app/core/gimplayer-floating-sel.c
@@ -190,9 +190,6 @@ const GimpBoundSeg *
 floating_sel_boundary (GimpLayer *layer,
                        gint      *n_segs)
 {
-  PixelRegion bPR;
-  gint        i;
-
   g_return_val_if_fail (GIMP_IS_LAYER (layer), NULL);
   g_return_val_if_fail (gimp_layer_is_floating_sel (layer), NULL);
   g_return_val_if_fail (n_segs != NULL, NULL);
@@ -211,11 +208,14 @@ floating_sel_boundary (GimpLayer *layer,
 
       if (gimp_drawable_has_alpha (GIMP_DRAWABLE (layer)))
         {
+          GeglBuffer *buffer;
+          gint        i;
+
           /*  find the segments  */
-          pixel_region_init (&bPR,
-                             gimp_drawable_get_tiles (GIMP_DRAWABLE (layer)),
-                             0, 0, width, height, FALSE);
-          layer->fs.segs = gimp_boundary_find (&bPR, GIMP_BOUNDARY_WITHIN_BOUNDS,
+          buffer = gimp_drawable_get_read_buffer (GIMP_DRAWABLE (layer));
+
+          layer->fs.segs = gimp_boundary_find (buffer, NULL,
+                                               GIMP_BOUNDARY_WITHIN_BOUNDS,
                                                0, 0, width, height,
                                                GIMP_BOUNDARY_HALF_WAY,
                                                &layer->fs.num_segs);
diff --git a/app/tools/gimpregionselecttool.c b/app/tools/gimpregionselecttool.c
index 495f18a..f6f58d1 100644
--- a/app/tools/gimpregionselecttool.c
+++ b/app/tools/gimpregionselecttool.c
@@ -26,8 +26,6 @@
 
 #include "tools-types.h"
 
-#include "base/pixel-region.h"
-
 #include "core/gimpboundary.h"
 #include "core/gimpchannel.h"
 #include "core/gimpchannel-select.h"
@@ -345,8 +343,8 @@ gimp_region_select_tool_calculate (GimpRegionSelectTool *region_sel,
                                    gint                 *n_segs)
 {
   GimpDisplayShell *shell = gimp_display_get_shell (display);
+  GeglBuffer       *buffer;
   GimpBoundSeg     *segs;
-  PixelRegion       maskPR;
 
   gimp_display_shell_set_override_cursor (shell, GDK_WATCH);
 
@@ -368,14 +366,10 @@ gimp_region_select_tool_calculate (GimpRegionSelectTool *region_sel,
   /*  calculate and allocate a new segment array which represents the
    *  boundary of the contiguous region
    */
-  pixel_region_init (&maskPR,
-                     gimp_drawable_get_tiles (GIMP_DRAWABLE (region_sel->region_mask)),
-                     0, 0,
-                     gimp_item_get_width  (GIMP_ITEM (region_sel->region_mask)),
-                     gimp_item_get_height (GIMP_ITEM (region_sel->region_mask)),
-                     FALSE);
-
-  segs = gimp_boundary_find (&maskPR, GIMP_BOUNDARY_WITHIN_BOUNDS,
+  buffer = gimp_drawable_get_read_buffer (GIMP_DRAWABLE (region_sel->region_mask));
+
+  segs = gimp_boundary_find (buffer, NULL,
+                             GIMP_BOUNDARY_WITHIN_BOUNDS,
                              0, 0,
                              gimp_item_get_width  (GIMP_ITEM (region_sel->region_mask)),
                              gimp_item_get_height (GIMP_ITEM (region_sel->region_mask)),



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