dnrops
/
gimp
mirror of https://github.com/GNOME/gimp.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
gimp/plug-ins/common/waves.c

843 lines
20 KiB
C
Raw Blame History

/**************************************************
* file: waves/waves.c
*
* Copyright (c) 1997 Eric L. Hernes (erich@rrnet.com)
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. The name of the author may not be used to endorse or promote products
* derived from this software withough specific prior written permission
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* $Id$
*/
#include "config.h"
#include <string.h>
#include <stdlib.h>
#include <gtk/gtk.h>
#include <libgimp/gimp.h>
#include <libgimp/gimpui.h>
#include "libgimp/stdplugins-intl.h"
enum
{
MODE_SMEAR,
MODE_BLACKEN
};
struct Grgb
{
guint8 red;
guint8 green;
guint8 blue;
};
struct GRegion
{
gint32 x;
gint32 y;
gint32 width;
gint32 height;
};
struct piArgs
{
gdouble amplitude;
gdouble phase;
gdouble wavelength;
gint32 type;
gint32 reflective;
};
/* preview stuff -- to be removed as soon as we have a real libgimp preview */
struct mwPreview
{
gint width;
gint height;
gint bpp;
gdouble scale;
guchar *bits;
};
#define PREVIEW_SIZE 100
static gint do_preview = TRUE;
static GtkWidget * mw_preview_new (GtkWidget *parent,
struct mwPreview *mwp);
static struct mwPreview * mw_preview_build (GimpDrawable *drawable);
static struct mwPreview *mwp;
static void query (void);
static void run (gchar *name,
gint nparam,
GimpParam *param,
gint *nretvals,
GimpParam **retvals);
static gint pluginCore (struct piArgs *argp,
gint32 drawable);
static gint pluginCoreIA (struct piArgs *argp,
gint32 drawable);
static void waves_do_preview (GtkWidget *preview);
static void wave (guchar *src,
guchar *dest,
gint width,
gint height,
gint bypp,
gdouble amplitude,
gdouble wavelength,
gdouble phase,
gint smear,
gint reflective,
gint verbose);
static guchar bilinear (gdouble x,
gdouble y,
guchar *v);
#define WITHIN(a, b, c) ((((a) <= (b)) && ((b) <= (c))) ? TRUE : FALSE)
GimpPlugInInfo PLUG_IN_INFO =
{
NULL, /* init_proc */
NULL, /* quit_proc */
query, /* query_proc */
run, /* run_proc */
};
MAIN ()
static void
query (void)
{
static GimpParamDef args[] =
{
{ GIMP_PDB_INT32, "run_mode", "Interactive, non-interactive" },
{ GIMP_PDB_IMAGE, "image", "The Image" },
{ GIMP_PDB_DRAWABLE, "drawable", "The Drawable" },
{ GIMP_PDB_FLOAT, "amplitude", "The Amplitude of the Waves" },
{ GIMP_PDB_FLOAT, "phase", "The Phase of the Waves" },
{ GIMP_PDB_FLOAT, "wavelength", "The Wavelength of the Waves" },
{ GIMP_PDB_INT32, "type", "Type of waves, black/smeared" },
{ GIMP_PDB_INT32, "reflective", "Use Reflection" }
};
static gint nargs = sizeof (args) / sizeof (args[0]);
gimp_install_procedure ("plug_in_waves",
"Distort the image with waves",
"none yet",
"Eric L. Hernes, Stephen Norris",
"Stephen Norris",
"1997",
N_("<Image>/Filters/Distorts/Waves..."),
"RGB*, GRAY*",
GIMP_PLUGIN,
nargs, 0,
args, NULL);
}
static void
run (gchar *name,
gint nparam,
GimpParam *param,
gint *nretvals,
GimpParam **retvals)
{
static GimpParam rvals[1];
struct piArgs args;
*nretvals = 1;
*retvals = rvals;
memset (&args, (int) 0, sizeof (struct piArgs));
args.type = -1;
gimp_get_data ("plug_in_waves", &args);
rvals[0].type = GIMP_PDB_STATUS;
rvals[0].data.d_status = GIMP_PDB_SUCCESS;
switch (param[0].data.d_int32)
{
GimpDrawable *drawable;
case GIMP_RUN_INTERACTIVE:
INIT_I18N_UI();
/* XXX: add code here for interactive running */
if (args.type == -1)
{
args.amplitude = 10.0;
args.wavelength = 10;
args.phase = 0.0;
args.type = MODE_SMEAR;
args.reflective = 0;
}
drawable = gimp_drawable_get (param[2].data.d_drawable);
mwp = mw_preview_build (drawable);
if (pluginCoreIA(&args, param[2].data.d_drawable) == -1)
{
rvals[0].data.d_status = GIMP_PDB_EXECUTION_ERROR;
}
else
{
gimp_set_data ("plug_in_waves", &args, sizeof (struct piArgs));
}
break;
case GIMP_RUN_NONINTERACTIVE:
INIT_I18N();
/* XXX: add code here for non-interactive running */
if (nparam != 8)
{
rvals[0].data.d_status = GIMP_PDB_CALLING_ERROR;
break;
}
args.amplitude = param[3].data.d_float;
args.phase = param[4].data.d_float;
args.wavelength = param[5].data.d_float;
args.type = param[6].data.d_int32;
args.reflective = param[7].data.d_int32;
if (pluginCore (&args, param[2].data.d_drawable) == -1)
{
rvals[0].data.d_status = GIMP_PDB_EXECUTION_ERROR;
break;
}
break;
case GIMP_RUN_WITH_LAST_VALS:
INIT_I18N();
/* XXX: add code here for last-values running */
if (pluginCore (&args, param[2].data.d_drawable) == -1)
{
rvals[0].data.d_status = GIMP_PDB_EXECUTION_ERROR;
}
break;
}
}
static gint
pluginCore (struct piArgs *argp,
gint32 drawable)
{
gint retval=0;
GimpDrawable *drw;
GimpPixelRgn srcPr, dstPr;
guchar *src, *dst;
guint width, height, Bpp;
drw = gimp_drawable_get (drawable);
width = drw->width;
height = drw->height;
Bpp = drw->bpp;
src = g_new (guchar, width * height * Bpp);
dst = g_new (guchar, width * height * Bpp);
gimp_pixel_rgn_init (&srcPr, drw, 0, 0, width, height, FALSE, FALSE);
gimp_pixel_rgn_init (&dstPr, drw, 0, 0, width, height, TRUE, TRUE);
gimp_pixel_rgn_get_rect (&srcPr, src, 0, 0, width, height);
wave (src, dst, width, height, Bpp, argp->amplitude, argp->wavelength,
argp->phase, argp->type==0, argp->reflective, 1);
gimp_pixel_rgn_set_rect (&dstPr, dst, 0, 0, width, height);
g_free (src);
g_free (dst);
gimp_drawable_flush (drw);
gimp_drawable_merge_shadow (drw->drawable_id, TRUE);
gimp_drawable_update (drw->drawable_id, 0, 0, width, height);
gimp_displays_flush ();
return retval;
}
static gboolean run_flag = FALSE;
static void
waves_ok_callback (GtkWidget *widget,
gpointer data)
{
run_flag = TRUE;
gtk_widget_destroy (GTK_WIDGET (data));
}
static void
waves_toggle_button_update (GtkWidget *widget,
gpointer data)
{
gimp_toggle_button_update (widget, data);
if (do_preview)
waves_do_preview (NULL);
}
static void
waves_radio_button_update (GtkWidget *widget,
gpointer data)
{
gimp_radio_button_update (widget, data);
if (do_preview && GTK_TOGGLE_BUTTON (widget)->active)
waves_do_preview (NULL);
}
static void
waves_double_adjustment_update (GtkAdjustment *adjustment,
gpointer data)
{
gimp_double_adjustment_update (adjustment, data);
if (do_preview)
waves_do_preview (NULL);
}
static gint
pluginCoreIA (struct piArgs *argp,
gint32 drawable)
{
gint r=-1; /* default to error return */
GtkWidget *dlg;
GtkWidget *main_vbox;
GtkWidget *frame;
GtkWidget *hbox;
GtkWidget *vbox;
GtkWidget *sep;
GtkWidget *table;
GtkWidget *preview;
GtkWidget *toggle;
GtkObject *adj;
gimp_ui_init ("waves", TRUE);
dlg = gimp_dialog_new ( _("Waves"), "waves",
gimp_standard_help_func, "filters/waves.html",
GTK_WIN_POS_MOUSE,
FALSE, TRUE, FALSE,
GTK_STOCK_OK, waves_ok_callback,
NULL, NULL, NULL, TRUE, FALSE,
GTK_STOCK_CANCEL, gtk_widget_destroy,
NULL, 1, NULL, FALSE, TRUE,
NULL);
gtk_signal_connect (GTK_OBJECT (dlg), "destroy",
GTK_SIGNAL_FUNC (gtk_main_quit),
NULL);
main_vbox = gtk_vbox_new (FALSE, 4);
gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 6);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dlg)->vbox), main_vbox,
TRUE, TRUE, 0);
gtk_widget_show (main_vbox);
hbox = gtk_hbox_new (FALSE, 4);
gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, FALSE, 0);
gtk_widget_show (hbox);
preview = mw_preview_new (hbox, mwp);
gtk_object_set_data (GTK_OBJECT (preview), "piArgs", argp);
waves_do_preview (preview);
frame = gimp_radio_group_new2 (TRUE, _("Mode"),
G_CALLBACK (waves_radio_button_update),
&argp->type, (gpointer) argp->type,
_("Smear"), (gpointer) MODE_SMEAR, NULL,
_("Blacken"), (gpointer) MODE_BLACKEN, NULL,
NULL);
gtk_box_pack_start (GTK_BOX (hbox), frame, TRUE, TRUE, 0);
gtk_widget_show (frame);
vbox = GTK_BIN (frame)->child;
sep = gtk_hseparator_new ();
gtk_box_pack_start (GTK_BOX (vbox), sep, FALSE, FALSE, 2);
gtk_widget_show (sep);
toggle = gtk_check_button_new_with_label ( _("Reflective"));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), argp->reflective);
gtk_box_pack_start (GTK_BOX (vbox), toggle, FALSE, FALSE, 0);
gtk_signal_connect (GTK_OBJECT (toggle), "toggled",
GTK_SIGNAL_FUNC (waves_toggle_button_update),
&argp->reflective);
gtk_widget_show (toggle);
frame = gtk_frame_new ( _("Parameter Settings"));
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_ETCHED_IN);
gtk_box_pack_start (GTK_BOX (main_vbox), frame, FALSE, FALSE, 0);
gtk_widget_show (frame);
table = gtk_table_new (3, 3, FALSE);
gtk_table_set_col_spacings (GTK_TABLE (table), 4);
gtk_table_set_row_spacings (GTK_TABLE (table), 2);
gtk_container_set_border_width (GTK_CONTAINER (table), 4);
gtk_container_add (GTK_CONTAINER (frame), table);
adj = gimp_scale_entry_new (GTK_TABLE (table), 0, 0,
_("Amplitude:"), 140, 0,
argp->amplitude, 0.0, 101.0, 1.0, 5.0, 2,
TRUE, 0, 0,
NULL, NULL);
gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
GTK_SIGNAL_FUNC (waves_double_adjustment_update),
&argp->amplitude);
adj = gimp_scale_entry_new (GTK_TABLE (table), 0, 1,
_("Phase:"), 140, 0,
argp->phase, 0.0, 360.0, 2.0, 5.0, 2,
TRUE, 0, 0,
NULL, NULL);
gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
GTK_SIGNAL_FUNC (waves_double_adjustment_update),
&argp->phase);
adj = gimp_scale_entry_new (GTK_TABLE (table), 0, 2,
_("Wavelength:"), 140, 0,
argp->wavelength, 0.1, 50.0, 1.0, 5.0, 2,
TRUE, 0, 0,
NULL, NULL);
gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
GTK_SIGNAL_FUNC (waves_double_adjustment_update),
&argp->wavelength);
gtk_widget_show (table);
gtk_widget_show (dlg);
gtk_main ();
gdk_flush ();
if (run_flag)
{
#if 0
fprintf (stderr, "running:\n");
/*fprintf (stderr, "\t(image %d)\n", argp->image);*/
fprintf (stderr, "\t(drawable %d)\n", argp->drawable);
fprintf (stderr, "\t(amplitude %f)\n", argp->amplitude);
fprintf (stderr, "\t(phase %f)\n", argp->phase);
fprintf (stderr, "\t(wavelength %f)\n", argp->wavelength);
fprintf (stderr, "\t(type %d)\n", argp->type);
fprintf (stderr, "\t(reflective %d)\n", argp->reflective);
#endif
return pluginCore (argp, drawable);
}
else
{
return r;
}
}
static void
waves_do_preview (GtkWidget *widget)
{
static GtkWidget *theWidget = NULL;
struct piArgs *argp;
guchar *dst;
gint y;
if (theWidget == NULL)
{
theWidget = widget;
}
argp = gtk_object_get_data (GTK_OBJECT (theWidget), "piArgs");
dst = g_new (guchar, mwp->width * mwp->height * mwp->bpp);
wave (mwp->bits, dst, mwp->width, mwp->height, mwp->bpp,
(argp->amplitude / mwp->scale), (argp->wavelength / mwp->scale),
argp->phase, argp->type == 0, argp->reflective, 0);
for (y = 0; y < mwp->height; y++)
{
gtk_preview_draw_row (GTK_PREVIEW (theWidget),
dst + (y * mwp->width * mwp->bpp), 0, y,
mwp->width);
}
gtk_widget_draw (theWidget, NULL);
gdk_flush ();
g_free (dst);
}
static void
mw_preview_toggle_callback (GtkWidget *widget,
gpointer data)
{
gimp_toggle_button_update (widget, data);
if (do_preview)
waves_do_preview (NULL);
}
static struct mwPreview *
mw_preview_build_virgin (GimpDrawable *drawable)
{
struct mwPreview *mwp;
mwp = g_new (struct mwPreview, 1);
if (drawable->width > drawable->height)
{
mwp->scale = (gdouble) drawable->width / (gdouble) PREVIEW_SIZE;
mwp->width = PREVIEW_SIZE;
mwp->height = drawable->height / mwp->scale;
}
else
{
mwp->scale = (gdouble) drawable->height / (gdouble) PREVIEW_SIZE;
mwp->height = PREVIEW_SIZE;
mwp->width = drawable->width / mwp->scale;
}
mwp->bpp = 3;
mwp->bits = NULL;
return mwp;
}
static struct mwPreview *
mw_preview_build (GimpDrawable *drawable)
{
struct mwPreview *mwp;
gint x, y, b;
guchar *bc;
guchar *drawableBits;
GimpPixelRgn pr;
mwp = mw_preview_build_virgin (drawable);
gimp_pixel_rgn_init (&pr, drawable,
0, 0, drawable->width, drawable->height, FALSE, FALSE);
drawableBits = g_new (guchar, drawable->width * drawable->bpp);
bc = mwp->bits = g_new (guchar, mwp->width * mwp->height * mwp->bpp);
for (y = 0; y < mwp->height; y++)
{
gimp_pixel_rgn_get_row (&pr, drawableBits,
0, (gint) (y * mwp->scale), drawable->width);
for (x = 0; x < mwp->width; x++)
{
for (b = 0; b < mwp->bpp; b++)
*bc++ = *(drawableBits +
((gint) (x * mwp->scale) * drawable->bpp) +
b % drawable->bpp);
}
}
g_free (drawableBits);
return mwp;
}
static GtkWidget *
mw_preview_new (GtkWidget *parent,
struct mwPreview *mwp)
{
GtkWidget *preview;
GtkWidget *frame;
GtkWidget *pframe;
GtkWidget *vbox;
GtkWidget *button;
frame = gtk_frame_new (_("Preview"));
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_ETCHED_IN);
gtk_box_pack_start (GTK_BOX (parent), frame, FALSE, FALSE, 0);
gtk_widget_show (frame);
vbox = gtk_vbox_new (FALSE, 2);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 4);
gtk_container_add (GTK_CONTAINER (frame), vbox);
gtk_widget_show (vbox);
pframe = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME(pframe), GTK_SHADOW_IN);
gtk_box_pack_start (GTK_BOX (vbox), pframe, FALSE, FALSE, 0);
gtk_widget_show (pframe);
preview = gtk_preview_new (GTK_PREVIEW_COLOR);
gtk_preview_size (GTK_PREVIEW (preview), mwp->width, mwp->height);
gtk_container_add (GTK_CONTAINER (pframe), preview);
gtk_widget_show (preview);
button = gtk_check_button_new_with_label (_("Do Preview"));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), do_preview);
gtk_signal_connect (GTK_OBJECT (button), "toggled",
GTK_SIGNAL_FUNC (mw_preview_toggle_callback),
&do_preview);
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
gtk_widget_show (button);
return preview;
}
static void
wave (guchar *src,
guchar *dst,
gint width,
gint height,
gint bypp,
gdouble amplitude,
gdouble wavelength,
gdouble phase,
gint smear,
gint reflective,
gint verbose)
{
glong rowsiz;
guchar *p;
guchar *dest;
gint x1, y1, x2, y2;
gint x, y;
gint prog_interval=0;
gint x1_in, y1_in, x2_in, y2_in;
gdouble cen_x, cen_y; /* Center of wave */
gdouble xhsiz, yhsiz; /* Half size of selection */
gdouble radius, radius2; /* Radius and radius^2 */
gdouble amnt, d;
gdouble needx, needy;
gdouble dx, dy;
gdouble xscale, yscale;
gint xi, yi;
guchar values[4];
guchar val;
gint k;
phase = phase * G_PI / 180;
rowsiz = width * bypp;
if (verbose)
{
gimp_progress_init (_("Waving..."));
prog_interval=height/10;
}
x1 = y1 = 0;
x2 = width;
y2 = height;
/* Wave the image. For each pixel in the destination image
* which is inside the selection, we compute the corresponding
* waved location in the source image. We use bilinear
* interpolation to avoid ugly jaggies.
*
* Let's assume that we are operating on a circular area.
* Every point within <radius> distance of the wave center is
* waveed to its destination position.
*
* Basically, introduce a wave into the image. I made up the
* forumla initially, but it looks good. Quartic added the
* wavelength etc. to it while I was asleep :) Just goes to show
* we should work with people in different time zones more.
*
*/
/* Center of selection */
cen_x = (double) (x2 - 1 + x1) / 2.0;
cen_y = (double) (y2 - 1 + y1) / 2.0;
/* Compute wave radii (semiaxes) */
xhsiz = (double) (x2 - x1) / 2.0;
yhsiz = (double) (y2 - y1) / 2.0;
/* These are the necessary scaling factors to turn the wave
ellipse into a large circle */
if (xhsiz < yhsiz)
{
xscale = yhsiz / xhsiz;
yscale = 1.0;
}
else if (xhsiz > yhsiz)
{
xscale = 1.0;
yscale = xhsiz / yhsiz;
}
else
{
xscale = 1.0;
yscale = 1.0;
}
radius = MAX (xhsiz, yhsiz);
radius2 = radius * radius;
/* Wave the image! */
dst += y1 * rowsiz + x1 * bypp;
wavelength *= 2;
for (y = y1; y < y2; y++)
{
dest = dst;
if (verbose && (y % prog_interval == 0))
gimp_progress_update ((double) y / (double) height);
for (x = x1; x < x2; x++)
{
/* Distance from current point to wave center, scaled */
dx = (x - cen_x) * xscale;
dy = (y - cen_y) * yscale;
/* Distance^2 to center of *circle* (our scaled ellipse) */
d = sqrt (dx * dx + dy * dy);
/* Use the formula described above. */
/* Calculate waved point and scale again to ellipsify */
/*
* Reflective waves are strange - the effect is much
* more like a mirror which is in the shape of
* the wave than anything else.
*/
if (reflective)
{
amnt = amplitude * fabs (sin (((d / wavelength) * (2.0 * G_PI) +
phase)));
needx = (amnt * dx) / xscale + cen_x;
needy = (amnt * dy) / yscale + cen_y;
}
else
{
amnt = amplitude * sin (((d / wavelength) * (2.0 * G_PI) +
phase));
needx = (amnt + dx) / xscale + cen_x;
needy = (amnt + dy) / yscale + cen_y;
}
/* Calculations complete; now copy the proper pixel */
xi = needx;
yi = needy;
if (smear)
{
if (xi > width - 2)
{
xi = width - 2;
}
else if (xi < 0)
{
xi = 0;
}
if (yi > height - 2)
{
yi = height - 2;
}
else if (yi < 0)
{
yi = 0;
}
}
p = src + rowsiz * yi + xi * bypp;
x1_in = WITHIN (0, xi, width - 1);
y1_in = WITHIN (0, yi, height - 1);
x2_in = WITHIN (0, xi + 1, width - 1);
y2_in = WITHIN (0, yi + 1, height - 1);
for (k = 0; k < bypp; k++)
{
if (x1_in && y1_in)
values[0] = *(p + k);
else
values[0] = 0;
if (x2_in && y1_in)
values[1] = *(p + bypp + k);
else
values[1] = 0;
if (x1_in && y2_in)
values[2] = *(p + rowsiz + k);
else
values[2] = 0;
if (x2_in)
{
if (y2_in)
values[3] = *(p + bypp + k + rowsiz);
else
values[3] = 0;
}
else
values[3] = 0;
val = bilinear (needx, needy, values);
*dest++ = val;
}
}
dst += rowsiz;
}
if (verbose)
gimp_progress_update (1.0);
}
static guchar
bilinear (gdouble x,
gdouble y,
guchar *v)
{
gdouble m0, m1;
x = fmod (x, 1.0);
y = fmod (y, 1.0);
if (x < 0)
x += 1.0;
if (y < 0)
y += 1.0;
m0 = (1.0 - x) * v[0] + x * v[1];
m1 = (1.0 - x) * v[2] + x * v[3];
return (guchar) ((1.0 - y) * m0 + y * m1);
}
Reference in New Issue View Git Blame Copy Permalink