[gegl/soc-2011-ops] Addded the ripple op
- From: Robert Sasu <sasurobert src gnome org>
- To: commits-list gnome org
- Cc:
- Subject: [gegl/soc-2011-ops] Addded the ripple op
- Date: Tue, 19 Jul 2011 19:09:24 +0000 (UTC)
commit 0b1d88f868334c05ac51eee824c4eaebdaea6b11
Author: Robert Sasu <sasu robert gmail com>
Date: Tue Jul 19 22:08:53 2011 +0300
Addded the ripple op
operations/workshop/ripple.c | 427 ++++++++++++++++++++++++++++++++++++++++++
1 files changed, 427 insertions(+), 0 deletions(-)
---
diff --git a/operations/workshop/ripple.c b/operations/workshop/ripple.c
new file mode 100644
index 0000000..4380a6c
--- /dev/null
+++ b/operations/workshop/ripple.c
@@ -0,0 +1,427 @@
+/* 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 (C) 1997 Brian Degenhardt <bdegenha ucsd edu>
+ * Copyright (C) 2011 Robert Sasu <sasu robert gmail com>
+ */
+
+#include "config.h"
+#include <glib/gi18n-lib.h>
+
+#ifdef GEGL_CHANT_PROPERTIES
+
+gegl_chant_boolean (antialias, _("Antialiasing"), FALSE,
+ _("Antialiasing"))
+gegl_chant_boolean (tile, _("Retain tilebility"), FALSE,
+ _("Retain tilability"))
+gegl_chant_string (orientation, _("Orientation"), "horizontal",
+ _("Type of orientation to choose."
+ "Choices are horizontal, vertical."
+ "Default is horizontal"))
+gegl_chant_string (wave, _("Wave type"), "sine",
+ _("Type of wave to choose."
+ "Choices are sine, sawtooth."
+ "Default is sine"))
+gegl_chant_string (background, _("Edges"), "wrap",
+ _("Type of edges to choose."
+ "Choices are wrap, smear, blank."
+ "Default is wrap"))
+gegl_chant_int (amplitude, _("Amplitude"), 0, 200, 50,
+ _("Amplitude of ripple"))
+gegl_chant_int (period, _("Period"), 0, 200, 50,
+ _("Period of ripple"))
+gegl_chant_int (phi, _("Phase Shift"), 0, 360, 0,
+ _("As proportion of pi"))
+
+#else
+
+#define GEGL_CHANT_TYPE_AREA_FILTER
+#define GEGL_CHANT_C_FILE "ripple.c"
+
+#include "gegl-chant.h"
+#include <stdio.h>
+#include <math.h>
+
+#define SCALE_WIDTH 200
+#define TILE_CACHE_SIZE 16
+
+typedef enum
+{
+ BACKGROUND_TYPE_WRAP,
+ BACKGROUND_TYPE_SMEAR,
+ BACKGROUND_TYPE_BLANK
+} BackgroundType;
+
+typedef enum
+{
+ WAVE_TYPE_SINE,
+ WAVE_TYPE_SAWTOOTH,
+} WaveType;
+
+typedef enum
+{
+ ORIENTATION_TYPE_VERTICAL,
+ ORIENTATION_TYPE_HORIZONTAL
+} OrientationType;
+
+typedef struct
+{
+ OrientationType orie_t;
+ WaveType wave_t;
+ BackgroundType back_t;
+ gint per;
+} RippleContext;
+
+
+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->bottom =
+ op_area->right = op_area->top = o->amplitude;
+
+ gegl_operation_set_format (operation, "input",
+ babl_format ("RGBA float"));
+ gegl_operation_set_format (operation, "output",
+ babl_format ("RGBA float"));
+}
+
+static void
+average_two_pixels (gfloat *dest,
+ gfloat *temp1,
+ gfloat *temp2,
+ gdouble rem)
+{
+ gfloat x0, x1;
+ gfloat alpha;
+ gint i;
+
+ x0 = temp1[3] * (1.0 - rem);
+ x1 = temp2[3] * rem;
+
+ alpha = x0 + x1;
+
+ for (i=0;i<3;i++)
+ dest[i] = (x0 * temp1[i] + x1 * temp2[i]) / alpha;
+
+ dest[3] = alpha;
+}
+
+
+static gdouble
+displace_amount (gint location,
+ GeglChantO *o,
+ WaveType wave_t)
+{
+ const gdouble phi = o->phi / 360.0;
+ gdouble lambda;
+
+ switch (wave_t)
+ {
+ case WAVE_TYPE_SINE:
+ return (o->amplitude *
+ sin (2 * G_PI * (location / (gdouble) o->period - phi)));
+
+ case WAVE_TYPE_SAWTOOTH:
+ lambda = location % o->period - phi * o->period;
+ if (lambda < 0)
+ lambda += o->period;
+ return (o->amplitude * (fabs (((lambda / o->period) * 4) - 2) - 1));
+ }
+
+ return 0.0;
+}
+
+static void
+ripple_horizontal (gfloat *src_buf,
+ gfloat *dst_buf,
+ const GeglRectangle *result,
+ const GeglRectangle *extended,
+ const GeglRectangle *image,
+ gint y,
+ RippleContext rip,
+ GeglChantO *o)
+{
+ gint x;
+ gint src_offset, dst_offset;
+
+ dst_offset = (y - result->y) * result->width * 4;
+
+ for (x = result->x; x < result->x + result->width; x++)
+ {
+ gdouble shift = x + displace_amount(y, o, rip.wave_t);
+ gint xi = floor (shift);
+ gint xi_a = xi + 1;
+ gdouble rem = shift - xi;
+ gint i;
+ gfloat dest[4];
+
+ if (rip.back_t == BACKGROUND_TYPE_WRAP)
+ {
+ shift = fmod (shift, image->width);
+ while (shift < 0.0)
+ shift += image->width;
+
+ xi = (xi % image->width);
+ while (xi < 0)
+ xi += image->width;
+
+ xi_a = (xi+1) % image->width;
+ }
+ else if (rip.back_t == BACKGROUND_TYPE_SMEAR)
+ {
+ shift = CLAMP (shift, 0, image->width - 1);
+ xi = CLAMP (xi, 0 ,image->width - 1);
+ xi_a = CLAMP (xi_a, 0, image->width - 1);
+ }
+
+ if (o->antialias)
+ {
+ gfloat temp1[4], temp2[4];
+ if (xi >= 0 && xi < image->width)
+ {
+ src_offset = (y - extended->y) * extended->width * 4 +
+ (xi - extended->x) * 4;
+ for (i=0;i<4;i++)
+ temp1[i] = src_buf[src_offset++];
+ }
+ else temp1[0] = temp1[1] = temp2[2] = temp1[3] = 0.0;
+
+ if (xi_a >= 0 && xi_a < image->width)
+ {
+ src_offset = (y - extended->y) * extended->width * 4 +
+ (xi_a - extended->x) * 4;
+ for (i=0;i<4;i++)
+ temp1[i] = src_buf[src_offset++];
+ }
+ else temp2[0] = temp2[1] = temp2[2] = temp2[3] = 0.0;
+
+ average_two_pixels (dest, temp1, temp2, rem);
+ }
+ else
+ {
+ if (xi >= 0 && xi < image->width)
+ {
+ src_offset = (y - extended->y) * extended->width * 4 +
+ (xi - extended->x) * 4;
+ for (i=0;i<4;i++)
+ dest[i] = src_buf[src_offset++];
+ }
+ else dest[0] = dest[1] = dest[2] = dest[3] = 0.0;
+ }
+
+ for (i=0;i<4;i++)
+ dst_buf[dst_offset++] = dest[i];
+
+ }
+}
+
+static void
+ripple_vertical (gfloat *src_buf,
+ gfloat *dst_buf,
+ const GeglRectangle *result,
+ const GeglRectangle *extended,
+ const GeglRectangle *image,
+ gint y,
+ RippleContext rip,
+ GeglChantO *o)
+{
+ gint x;
+ gint src_offset, dst_offset;
+
+ dst_offset = (y - result->y) * result->width * 4;
+
+ for (x = result->x; x < result->x + result->width; x++)
+ {
+ gdouble shift = y + displace_amount(x, o, rip.wave_t);
+ gint xi = floor (shift);
+ gint xi_a = xi + 1;
+ gdouble rem = shift - xi;
+ gint i;
+ gfloat dest[4];
+
+ if (rip.back_t == BACKGROUND_TYPE_WRAP)
+ {
+ shift = fmod (shift, image->height);
+ while (shift < 0.0)
+ shift += image->height;
+
+ xi = (xi % image->height);
+ while (xi < 0)
+ xi += image->height;
+
+ xi_a = (xi+1) % image->height;
+ }
+ else if (rip.back_t == BACKGROUND_TYPE_SMEAR)
+ {
+ shift = CLAMP (shift, 0, image->height - 1);
+ xi = CLAMP (xi, 0 ,image->height - 1);
+ xi_a = CLAMP (xi_a, 0, image->height - 1);
+ }
+
+ if (o->antialias)
+ {
+ gfloat temp1[4], temp2[4];
+ if (xi >= 0 && xi < image->height)
+ {
+ src_offset = (xi - extended->y) * extended->width * 4 +
+ (x - extended->x) * 4;
+ for (i=0;i<4;i++)
+ temp1[i] = src_buf[src_offset++];
+ }
+ else temp1[0] = temp1[1] = temp2[2] = temp1[3] = 0.0;
+
+ if (xi_a >= 0 && xi_a < image->height)
+ {
+ src_offset = (xi_a - extended->y) * extended->width * 4 +
+ (x - extended->x) * 4;
+ for (i=0;i<4;i++)
+ temp1[i] = src_buf[src_offset++];
+ }
+ else temp2[0] = temp2[1] = temp2[2] = temp2[3] = 0.0;
+
+ average_two_pixels (dest, temp1, temp2, rem);
+ }
+ else
+ {
+ if (xi >= 0 && xi < image->height)
+ {
+ src_offset = (xi - extended->y) * extended->width * 4 +
+ (x - extended->x) * 4;
+ for (i=0;i<4;i++)
+ dest[i] = src_buf[src_offset++];
+ }
+ else dest[0] = dest[1] = dest[2] = dest[3] = 0.0;
+ }
+
+ for (i=0;i<4;i++)
+ dst_buf[dst_offset++] = dest[i];
+
+ }
+}
+
+static GeglRectangle
+get_effective_area (GeglOperation *operation)
+{
+ GeglRectangle result = {0,0,0,0};
+ GeglRectangle *in_rect = gegl_operation_source_get_bounding_box (operation, "input");
+
+ gegl_rectangle_copy(&result, in_rect);
+
+ return result;
+}
+
+static gboolean
+process (GeglOperation *operation,
+ GeglBuffer *input,
+ GeglBuffer *output,
+ const GeglRectangle *result)
+{
+ GeglChantO *o = GEGL_CHANT_PROPERTIES (operation);
+ GeglOperationAreaFilter *op_area = GEGL_OPERATION_AREA_FILTER (operation);
+ GeglRectangle boundary = get_effective_area (operation);
+ GeglRectangle extended;
+ Babl *format = babl_format ("RGBA float");
+ RippleContext rip;
+
+ gfloat *dst_buf, *src_buf;
+ gint y;
+
+ extended.x = CLAMP (result->x - op_area->left, boundary.x, boundary.x +
+ boundary.width);
+ extended.width = CLAMP (result->width + op_area->left + op_area->right, 0,
+ boundary.width);
+ extended.y = CLAMP (result->y - op_area->top, boundary.y, boundary.y +
+ boundary.width);
+ extended.height = CLAMP (result->height + op_area->top + op_area->bottom, 0,
+ boundary.height);
+
+ dst_buf = g_new0 (gfloat, result->width * result->height * 4);
+ src_buf = g_new0 (gfloat, extended.width * extended.height * 4);
+
+ rip.per = o->period;
+
+ rip.wave_t = WAVE_TYPE_SINE;
+ if (!strcmp (o->wave, "sine"))
+ rip.wave_t = WAVE_TYPE_SINE;
+ else if (!strcmp(o->wave, "sawtooth"))
+ rip.wave_t = WAVE_TYPE_SAWTOOTH;
+
+ rip.back_t = BACKGROUND_TYPE_WRAP;
+ if (!strcmp (o->background, "wrap"))
+ rip.back_t = BACKGROUND_TYPE_WRAP;
+ else if (!strcmp (o->background, "smear"))
+ rip.back_t = BACKGROUND_TYPE_SMEAR;
+ else if (!strcmp (o->background, "blank"))
+ rip.back_t = BACKGROUND_TYPE_BLANK;
+
+ rip.orie_t = ORIENTATION_TYPE_HORIZONTAL;
+ if (!strcmp (o->orientation, "horizontal"))
+ rip.orie_t = ORIENTATION_TYPE_HORIZONTAL;
+ else if (!strcmp(o->orientation, "vertical"))
+ rip.orie_t = ORIENTATION_TYPE_VERTICAL;
+
+ if (o->tile)
+ {
+ rip.back_t = BACKGROUND_TYPE_WRAP;
+ rip.per = (boundary.width / (boundary.width / rip.per) *
+ (rip.orie_t == ORIENTATION_TYPE_HORIZONTAL) +
+ boundary.height / (boundary.height / rip.per) *
+ (rip.orie_t == ORIENTATION_TYPE_VERTICAL));
+ }
+
+
+ gegl_buffer_get (input, 1.0, &extended, format,
+ src_buf, GEGL_AUTO_ROWSTRIDE);
+
+ for (y = result->y; y < result->y + result->height; y++)
+ if (rip.orie_t == ORIENTATION_TYPE_HORIZONTAL)
+ ripple_horizontal (src_buf, dst_buf, result, &extended, &boundary, y,
+ rip, o);
+ else if (rip.orie_t == ORIENTATION_TYPE_VERTICAL)
+ ripple_vertical (src_buf, dst_buf, result, &extended, &boundary, y,
+ rip, o);
+
+ gegl_buffer_set (output, result, format, dst_buf, GEGL_AUTO_ROWSTRIDE);
+
+ g_free (dst_buf);
+ g_free (src_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 = "distorts";
+ operation_class->name = "gegl:ripple";
+ operation_class->description = _("Performs ripple on the image.");
+}
+
+#endif
[
Date Prev][
Date Next] [
Thread Prev][
Thread Next]
[
Thread Index]
[
Date Index]
[
Author Index]
