I've attached 3 more patches, they are:
box-blur. it's now a good deal faster, and also properly supports fractional blur widths.
fast gaussian blur. this is implemented as 3 box filters in series. it approximates a gaussian fairly closely, visually I can't tell the difference between this and the current gaussian blur, although the units don't match exactly. I've put it in a separate file to allow easy comparisons while we decide whether it's worth keeping.
pixelise. a simple pixelise filter like the one in gimp currently.
While I remember there were a couple of issues I came across whilst working on this. Firstly, if you create a transparent layer, and merge it down, then apply a gegl blur operation to the merged layer (all the blurs have the same issue, and probably other filters too), the edges of the image go transparent. I suspect this is something to do with the RaGaBaA=>RGBA conversion not happening properly for some reason, but I haven't looked in to it.
Secondly, the current gaussian blur doesn't work properly for very wide blurs. A std-dev of 200 makes the tile boundaries quite visible.
If any changes are required, just let me know.
Andy.
From be32a4bc47f86c84c406f24e79ac4db87d39ef12 Mon Sep 17 00:00:00 2001
From: Andy Gill <andyggill@xxxxxxxxx>
Date: Tue, 18 Jan 2011 22:18:12 +0000
Subject: [PATCH 1/3] optimised the box blur filter. also it now supports fractional blur sizes.
---
operations/common/box-blur.c | 307 +++++++++++++++++-------------------------
1 files changed, 123 insertions(+), 184 deletions(-)
diff --git a/operations/common/box-blur.c b/operations/common/box-blur.c
index 6cb3b2e..76a2093 100644
--- a/operations/common/box-blur.c
+++ b/operations/common/box-blur.c
@@ -18,11 +18,14 @@
#include "config.h"
#include <glib/gi18n-lib.h>
+#include <math.h>
#ifdef GEGL_CHANT_PROPERTIES
-gegl_chant_double (radius, _("Radius"), 0.0, 200.0, 4.0,
- _("Radius of square pixel region, (width and height will be radius*2+1)."))
+gegl_chant_double (xblur, _("X-Blur"), 0, 256, 0,
+ _("Radius of horizontal blur in pixels"))
+gegl_chant_double (yblur, _("Y-Blur"), 0, 256, 0,
+ _("Radius of vertical blur in pixels"))
#else
@@ -30,224 +33,160 @@ gegl_chant_double (radius, _("Radius"), 0.0, 200.0, 4.0,
#define GEGL_CHANT_C_FILE "box-blur.c"
#include "gegl-chant.h"
-#include <stdio.h>
-#include <math.h>
-#ifdef USE_DEAD_CODE
-static inline float
-get_mean_component (gfloat *buf,
- gint buf_width,
- gint buf_height,
- gint x0,
- gint y0,
- gint width,
- gint height,
- gint component)
+static void prepare (GeglOperation *operation)
{
- gint x, y;
- gdouble acc=0;
- gint count=0;
+ GeglChantO *o;
+ GeglOperationAreaFilter *op_area;
+
+ op_area = GEGL_OPERATION_AREA_FILTER (operation);
+ o = GEGL_CHANT_PROPERTIES (operation);
- gint offset = (y0 * buf_width + x0) * 4 + component;
+ op_area->left =
+ op_area->right = (gint)floor(o->xblur) + 1; /* ensure we always have an extra pixel for fractional blur sizes */
+ op_area->top =
+ op_area->bottom = (gint)floor(o->yblur) + 1;
- for (y=y0; y<y0+height; y++)
- {
- for (x=x0; x<x0+width; x++)
- {
- if (x>=0 && x<buf_width &&
- y>=0 && y<buf_height)
- {
- acc += buf [offset];
- count++;
- }
- offset+=4;
- }
- offset+= (buf_width * 4) - 4 * width;
- }
- if (count)
- return acc/count;
- return 0.0;
+ gegl_operation_set_format (operation, "output",
+ babl_format ("RaGaBaA float"));
}
-#endif
-static inline void
-get_mean_components (gfloat *buf,
- gint buf_width,
- gint buf_height,
- gint x0,
- gint y0,
- gint width,
- gint height,
- gfloat *components)
+static void
+hor_blur (const gfloat* in,
+ gfloat* out,
+ const GeglRectangle *rect,
+ gfloat xblur,
+ gfloat yblur)
{
- gint y;
- gdouble acc[4]={0,0,0,0};
- gint count[4]={0,0,0,0};
+ gint y;
+ gint x;
+ gint c;
- gint offset = (y0 * buf_width + x0) * 4;
+ gint xblur_pixels = (gint)floor(xblur) + 1; /* ensure we always have an extra pixel for fractional blur sizes */
+ gint yblur_pixels = (gint)floor(yblur) + 1;
- for (y=y0; y<y0+height; y++)
- {
- gint x;
- for (x=x0; x<x0+width; x++)
- {
- if (x>=0 && x<buf_width &&
- y>=0 && y<buf_height)
- {
- gint c;
- for (c=0;c<4;c++)
- {
- acc[c] += buf [offset+c];
- count[c]++;
- }
- }
- offset+=4;
- }
- offset+= (buf_width * 4) - 4 * width;
- }
+ gint width = rect->width;
+ gint height = rect->height;
+ gint total_height = height + 2*yblur_pixels;
+
+
+ gfloat inv_filter_area = 1.0f / (2.0f * xblur + 1.0f);
+ /* initialise weights for fractional blur widths */
+ gfloat outer_weight = xblur - floor(xblur);
+ gfloat inner_weight = 1.0f - outer_weight;
+
+ for(y=0; y<total_height; ++y)
{
- gint c;
- for (c=0;c<4;c++)
+ gfloat sum[4] = {0.0, 0.0, 0.0, 0.0};
+ /* initialise window sum */
+ for (x=-xblur_pixels; x<=xblur_pixels; ++x)
+ {
+ gfloat weight = (ABS(x) == xblur_pixels) ? outer_weight : 1.0f;
+ for (c=0; c<4; ++c)
+ {
+ sum[c] += weight * in[(x+xblur_pixels)*4 + c];
+ }
+ }
+
+ /* compute horizontal blur, updating the window sum as we go */
+ for(x=0; x<width; ++x)
{
- if (count[c])
- components[c] = acc[c]/count[c];
- else
- components[c] = 0.0;
+ for(c=0; c<4; ++c)
+ {
+ *out++ = sum[c] * inv_filter_area;
+ sum[c] -= outer_weight * in[x*4 + c];
+ sum[c] -= inner_weight * in[(x+1)*4 + c];
+ sum[c] += inner_weight * in[(x+2*xblur_pixels)*4 + c];
+ sum[c] += outer_weight * in[(x+2*xblur_pixels+1)*4 + c];
+ }
}
+ in += (width + 2*xblur_pixels) * 4;
}
}
-/* expects src and dst buf to have the same extent */
-static void
-hor_blur (GeglBuffer *src,
- const GeglRectangle *src_rect,
- GeglBuffer *dst,
- const GeglRectangle *dst_rect,
- gint radius)
+static void
+ver_blur (const gfloat* in,
+ gfloat* out,
+ const GeglRectangle *rect,
+ gfloat yblur)
{
- gint u,v;
- gint offset;
- gfloat *src_buf;
- gfloat *dst_buf;
-
- /* src == dst for hor blur */
- src_buf = g_new0 (gfloat, src_rect->width * src_rect->height * 4);
- dst_buf = g_new0 (gfloat, dst_rect->width * dst_rect->height * 4);
-
- gegl_buffer_get (src, 1.0, src_rect, babl_format ("RaGaBaA float"), src_buf, GEGL_AUTO_ROWSTRIDE);
-
- offset = 0;
- for (v=0; v<dst_rect->height; v++)
- for (u=0; u<dst_rect->width; u++)
- {
- gint i;
- gfloat components[4];
-
- get_mean_components (src_buf,
- src_rect->width,
- src_rect->height,
- u - radius,
- v,
- 1 + radius*2,
- 1,
- components);
-
- for (i=0; i<4; i++)
- dst_buf [offset++] = components[i];
- }
-
- gegl_buffer_set (dst, dst_rect, babl_format ("RaGaBaA float"), dst_buf, GEGL_AUTO_ROWSTRIDE);
- g_free (src_buf);
- g_free (dst_buf);
-}
-
+ gint width = rect->width;
+ gint height = rect->height;
-/* expects dst buf to be radius smaller than src buf */
-static void
-ver_blur (GeglBuffer *src,
- const GeglRectangle *src_rect,
- GeglBuffer *dst,
- const GeglRectangle *dst_rect,
- gint radius)
-{
- gint u,v;
- gint offset;
- gfloat *src_buf;
- gfloat *dst_buf;
-
- src_buf = g_new0 (gfloat, src_rect->width * src_rect->height * 4);
- dst_buf = g_new0 (gfloat, dst_rect->width * dst_rect->height * 4);
-
- gegl_buffer_get (src, 1.0, src_rect, babl_format ("RaGaBaA float"), src_buf, GEGL_AUTO_ROWSTRIDE);
-
- offset=0;
- for (v=0; v<dst_rect->height; v++)
- for (u=0; u<dst_rect->width; u++)
- {
- gfloat components[4];
- gint c;
-
- get_mean_components (src_buf,
- src_rect->width,
- src_rect->height,
- u + radius, /* 1x radius is the offset between the bufs */
- v - radius + radius, /* 1x radius is the offset between the bufs */
- 1,
- 1 + radius * 2,
- components);
-
- for (c=0; c<4; c++)
- dst_buf [offset++] = components[c];
- }
-
- gegl_buffer_set (dst, dst_rect, babl_format ("RaGaBaA float"), dst_buf, GEGL_AUTO_ROWSTRIDE);
- g_free (src_buf);
- g_free (dst_buf);
-}
+ gint yblur_pixels = (gint)floor(yblur) + 1; /* ensure we always have an extra pixel for fractional blur sizes */
+
+ gint y;
+ gint x;
+ gint c;
-static void prepare (GeglOperation *operation)
-{
- GeglChantO *o;
- GeglOperationAreaFilter *op_area;
+ gfloat inv_filter_area = 1.0f / (2.0f * yblur + 1.0f);
+ /* initialise weights for fractional blur widths */
+ gfloat outer_weight = yblur - floor(yblur);
+ gfloat inner_weight = 1.0f - outer_weight;
- op_area = GEGL_OPERATION_AREA_FILTER (operation);
- o = GEGL_CHANT_PROPERTIES (operation);
+ for(x=0; x<width; ++x)
+ {
+ gfloat sum[4] = {0.0, 0.0, 0.0, 0.0};
+ /* initialise window sum */
+ for (y=-yblur_pixels; y<=yblur_pixels; ++y)
+ {
+ gfloat weight = (ABS(y) == yblur_pixels) ? outer_weight : 1.0f;
- op_area->left =
- op_area->right =
- op_area->top =
- op_area->bottom = ceil (o->radius);
+ for (c=0; c<4; ++c)
+ {
+ sum[c] += weight * in[((y+yblur_pixels)*width + x)*4 + c];
+ }
+ }
- gegl_operation_set_format (operation, "output",
- babl_format ("RaGaBaA float"));
+ /* compute vertical blur */
+ for(y=0; y<height; ++y)
+ {
+ for(c=0; c<4; ++c)
+ {
+ out[(y*width + x)*4 + c] = sum[c] * inv_filter_area;
+ sum[c] -= outer_weight * in[(y*width + x)*4 + c];
+ sum[c] -= inner_weight * in[((y+1)*width + x)*4 + c];
+ sum[c] += inner_weight * in[((y+2*yblur_pixels)*width + x)*4 + c];
+ sum[c] += outer_weight * in[((y+2*yblur_pixels+1)*width + x)*4 + c];
+ }
+ }
+ }
}
+
static gboolean
process (GeglOperation *operation,
GeglBuffer *input,
GeglBuffer *output,
- const GeglRectangle *result)
+ const GeglRectangle *roi)
{
- GeglRectangle rect;
+ GeglRectangle src_rect;
GeglChantO *o = GEGL_CHANT_PROPERTIES (operation);
- GeglBuffer *temp;
GeglOperationAreaFilter *op_area;
+ gfloat* buf0;
+ gfloat* buf1;
+
op_area = GEGL_OPERATION_AREA_FILTER (operation);
- rect = *result;
+ src_rect = *roi;
+ src_rect.x -= op_area->left;
+ src_rect.y -= op_area->top;
+ src_rect.width += op_area->left + op_area->right;
+ src_rect.height += op_area->top + op_area->bottom;
+
+ buf0 = g_new0 (gfloat, src_rect.width * src_rect.height * 4);
+ buf1 = g_new0 (gfloat, roi->width * src_rect.height * 4);
- rect.x-=op_area->left;
- rect.y-=op_area->top;
- rect.width+=op_area->left + op_area->right;
- rect.height+=op_area->top + op_area->bottom;
+ gegl_buffer_get (input, 1.0, &src_rect, babl_format ("RaGaBaA float"), buf0, GEGL_AUTO_ROWSTRIDE);
- temp = gegl_buffer_new (&rect,
- babl_format ("RaGaBaA float"));
+ hor_blur (buf0, buf1, roi, o->xblur, o->yblur);
+ ver_blur (buf1, buf0, roi, o->yblur);
- hor_blur (input, &rect, temp, &rect, o->radius);
- ver_blur (temp, &rect, output, result, o->radius);
+ gegl_buffer_set (output, roi, babl_format ("RaGaBaA float"), buf0, GEGL_AUTO_ROWSTRIDE);
+
+ g_free (buf0);
+ g_free (buf1);
- g_object_unref (temp);
return TRUE;
}
--
1.7.1
From ce2e5bc69693d3cbeddd5e517b45233f2aaaeb59 Mon Sep 17 00:00:00 2001
From: Andy Gill <andyggill@xxxxxxxxx>
Date: Tue, 18 Jan 2011 22:21:02 +0000
Subject: [PATCH 2/3] added fast gaussian blur operation by repeated box blur.
---
operations/common/fast-gaussian-blur.c | 75 ++++++++++++++++++++++++++++++++
1 files changed, 75 insertions(+), 0 deletions(-)
create mode 100644 operations/common/fast-gaussian-blur.c
diff --git a/operations/common/fast-gaussian-blur.c b/operations/common/fast-gaussian-blur.c
new file mode 100644
index 0000000..cd11c6d
--- /dev/null
+++ b/operations/common/fast-gaussian-blur.c
@@ -0,0 +1,75 @@
+/* This file is an image processing operation for GEGL
+ *
+ * GEGL is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * GEGL is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with GEGL; if not, see <http://www.gnu.org/licenses/>.
+ *
+ * Copyright 2006, 2010 Ãyvind KolÃs <pippin@xxxxxxxx>
+ */
+
+#include "config.h"
+#include <glib/gi18n-lib.h>
+
+#ifdef GEGL_CHANT_PROPERTIES
+
+gegl_chant_double (xblur, _("X-Blur"), 0, 256, 0,
+ _("Horizontal blur size"))
+gegl_chant_double (yblur, _("Y-Blur"), 0, 256, 0,
+ _("Vertical blur size"))
+
+#else
+
+#define GEGL_CHANT_TYPE_META
+#define GEGL_CHANT_C_FILE "fast-gaussian-blur.c"
+
+#include "gegl-chant.h"
+
+static void attach (GeglOperation *operation)
+{
+ GeglNode *gegl, *input, *output, *blur1, *blur2, *blur3;
+
+ gegl = operation->node;
+
+ input = gegl_node_get_input_proxy (gegl, "input");
+ output = gegl_node_get_output_proxy (gegl, "output");
+ blur1 = gegl_node_new_child (gegl, "operation", "gegl:box-blur", NULL);
+ blur2 = gegl_node_new_child (gegl, "operation", "gegl:box-blur", NULL);
+ blur3 = gegl_node_new_child (gegl, "operation", "gegl:box-blur", NULL);
+
+ /* approximate a gaussian filter with 3 box filters in series */
+ gegl_node_link_many (input, blur1, blur2, blur3, output, NULL);
+
+ gegl_operation_meta_redirect (operation, "xblur", blur1, "xblur");
+ gegl_operation_meta_redirect (operation, "yblur", blur1, "yblur");
+ gegl_operation_meta_redirect (operation, "xblur", blur2, "xblur");
+ gegl_operation_meta_redirect (operation, "yblur", blur2, "yblur");
+ gegl_operation_meta_redirect (operation, "xblur", blur3, "xblur");
+ gegl_operation_meta_redirect (operation, "yblur", blur3, "yblur");
+}
+
+static void
+gegl_chant_class_init (GeglChantClass *klass)
+{
+ GObjectClass *object_class;
+ GeglOperationClass *operation_class;
+
+ object_class = G_OBJECT_CLASS (klass);
+ operation_class = GEGL_OPERATION_CLASS (klass);
+ operation_class->attach = attach;
+
+ operation_class->name = "gegl:fast-gaussian-blur";
+ operation_class->categories = "blur";
+ operation_class->description =
+ _("Fast gaussian blur by repeated box filter");
+}
+
+#endif
--
1.7.1
From 720d0b44c8bc01ca61b46f59c1254885c513c612 Mon Sep 17 00:00:00 2001
From: Andy Gill <andyggill@xxxxxxxxx>
Date: Tue, 18 Jan 2011 22:22:55 +0000
Subject: [PATCH 3/3] added pixelise filter
---
operations/common/pixelise.c | 183 ++++++++++++++++++++++++++++++++++++++++++
1 files changed, 183 insertions(+), 0 deletions(-)
create mode 100644 operations/common/pixelise.c
diff --git a/operations/common/pixelise.c b/operations/common/pixelise.c
new file mode 100644
index 0000000..a87fbcb
--- /dev/null
+++ b/operations/common/pixelise.c
@@ -0,0 +1,183 @@
+/* This file is an image processing operation for GEGL
+ *
+ * GEGL is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * GEGL is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with GEGL; if not, see <http://www.gnu.org/licenses/>.
+ *
+ * Copyright 2006 Ãyvind KolÃs <pippin@xxxxxxxx>
+ */
+
+#include "config.h"
+#include <glib/gi18n-lib.h>
+#include <math.h>
+
+#ifdef GEGL_CHANT_PROPERTIES
+
+gegl_chant_int (xsize, _("Block Width"), 1, 256, 8,
+ _("Width of blocks in pixels"))
+gegl_chant_int (ysize, _("Block Height"), 1, 256, 8,
+ _("Height of blocks in pixels"))
+
+#else
+
+#define GEGL_CHANT_TYPE_AREA_FILTER
+#define GEGL_CHANT_C_FILE "pixelise.c"
+
+#include "gegl-chant.h"
+
+#define CELL_X(px, cell_width) ((px) / (cell_width))
+#define CELL_Y(py, cell_height) ((py) / (cell_height))
+
+
+static void prepare (GeglOperation *operation)
+{
+ GeglChantO *o;
+ GeglOperationAreaFilter *op_area;
+
+ op_area = GEGL_OPERATION_AREA_FILTER (operation);
+ o = GEGL_CHANT_PROPERTIES (operation);
+
+ op_area->left =
+ op_area->right = o->xsize;
+ op_area->top =
+ op_area->bottom = o->ysize;
+
+ gegl_operation_set_format (operation, "output",
+ babl_format ("RaGaBaA float"));
+}
+
+static void
+calc_block_colors (gfloat* block_colors,
+ const gfloat* input,
+ const GeglRectangle* roi,
+ gint xsize,
+ gint ysize)
+{
+ gint cx0 = CELL_X(roi->x, xsize);
+ gint cy0 = CELL_Y(roi->y, ysize);
+ gint cx1 = CELL_X(roi->x + roi->width - 1, xsize);
+ gint cy1 = CELL_Y(roi->y + roi->height - 1, ysize);
+
+ gint cx;
+ gint cy;
+ gfloat weight = 1.0f / (xsize * ysize);
+ gint line_width = roi->width + 2*xsize;
+ /* loop over the blocks within the region of interest */
+ for (cy=cy0; cy<=cy1; ++cy)
+ {
+ for (cx=cx0; cx<=cx1; ++cx)
+ {
+ gint px = (cx * xsize) - roi->x + xsize;
+ gint py = (cy * ysize) - roi->y + ysize;
+
+ /* calculate the average color for this block */
+ gint j,i,c;
+ gfloat col[4] = {0.0f, 0.0f, 0.0f, 0.0f};
+ for (j=py; j<py+ysize; ++j)
+ {
+ for (i=px; i<px+xsize; ++i)
+ {
+ for (c=0; c<4; ++c)
+ col[c] += input[(py*line_width + px)*4 + c];
+ }
+ }
+ for (c=0; c<4; ++c)
+ block_colors[c] = weight * col[c];
+ block_colors += 4;
+ }
+ }
+}
+
+static void
+pixelise (gfloat* buf,
+ const GeglRectangle* roi,
+ gint xsize,
+ gint ysize)
+{
+ gint cx0 = CELL_X(roi->x, xsize);
+ gint cy0 = CELL_Y(roi->y, ysize);
+ gint block_count_x = CELL_X(roi->x + roi->width - 1, xsize) - cx0 + 1;
+ gint block_count_y = CELL_Y(roi->y + roi->height - 1, ysize) - cy0 + 1;
+ gfloat* block_colors = g_new0 (gfloat, block_count_x * block_count_y * 4);
+ gint x;
+ gint y;
+ gint c;
+
+ /* calculate the average color of all the blocks */
+ calc_block_colors(block_colors, buf, roi, xsize, ysize);
+
+ /* set each pixel to the average color of the block it belongs to */
+ for (y=0; y<roi->height; ++y)
+ {
+ gint cy = CELL_Y(y + roi->y, ysize) - cy0;
+ for (x=0; x<roi->width; ++x)
+ {
+ gint cx = CELL_X(x + roi->x, xsize) - cx0;
+ for (c=0; c<4; ++c)
+ *buf++ = block_colors[(cy*block_count_x + cx)*4 + c];
+ }
+ }
+
+ g_free (block_colors);
+}
+
+static gboolean
+process (GeglOperation *operation,
+ GeglBuffer *input,
+ GeglBuffer *output,
+ const GeglRectangle *roi)
+{
+ GeglRectangle src_rect;
+ GeglChantO *o = GEGL_CHANT_PROPERTIES (operation);
+ GeglOperationAreaFilter *op_area;
+ gfloat* buf;
+
+ op_area = GEGL_OPERATION_AREA_FILTER (operation);
+ src_rect = *roi;
+ src_rect.x -= op_area->left;
+ src_rect.y -= op_area->top;
+ src_rect.width += op_area->left + op_area->right;
+ src_rect.height += op_area->top + op_area->bottom;
+
+ buf = g_new0 (gfloat, src_rect.width * src_rect.height * 4);
+
+ gegl_buffer_get (input, 1.0, &src_rect, babl_format ("RaGaBaA float"), buf, GEGL_AUTO_ROWSTRIDE);
+
+ pixelise(buf, roi, o->xsize, o->ysize);
+
+ gegl_buffer_set (output, roi, babl_format ("RaGaBaA float"), buf, GEGL_AUTO_ROWSTRIDE);
+
+ g_free (buf);
+
+ return TRUE;
+}
+
+
+static void
+gegl_chant_class_init (GeglChantClass *klass)
+{
+ GeglOperationClass *operation_class;
+ GeglOperationFilterClass *filter_class;
+
+ operation_class = GEGL_OPERATION_CLASS (klass);
+ filter_class = GEGL_OPERATION_FILTER_CLASS (klass);
+
+ filter_class->process = process;
+ operation_class->prepare = prepare;
+
+ operation_class->categories = "blur";
+ operation_class->name = "gegl:pixelise";
+ operation_class->description =
+ _("Pixelise filter");
+}
+
+#endif
--
1.7.1
_______________________________________________
Gegl-developer mailing list
Gegl-developer@xxxxxxxxxxxxxxxxxxxxxx
https://lists.XCF.Berkeley.EDU/mailman/listinfo/gegl-developer
[Video For Linux]
[Photo]
[Yosemite News]
[Yosemite Photos]
[gtk]
[GIMP Users]
[KDE]
[Scanner]
[Gimp's Home]
[Gimp on Windows]
[Steve's Art]
[Webcams]