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/wind.c

1244 lines
30 KiB
C
Raw Blame History

/*
* wind 1.1.0 - a plug-in for the GIMP
*
* Copyright (C) Nigel Wetten
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*
* Contact info: nigel@cs.nwu.edu
* Version: 1.0.0
*
* Version: 1.1.0
* May 2000 tim copperfield [timecop@japan.co.jp]
*
* Added dynamic preview.
*
*/
#include "config.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <gtk/gtk.h>
#include <libgimp/gimp.h>
#include <libgimp/gimpui.h>
#include "libgimp/stdplugins-intl.h"
#define PLUG_IN_NAME "wind"
#define COMPARE_WIDTH 3
#define SCALE_WIDTH 200
#define MIN_THRESHOLD 0
#define MAX_THRESHOLD 50
#define MIN_STRENGTH 1
#define MAX_STRENGTH 50
#define PREVIEW_SIZE 128
typedef enum
{
LEFT,
RIGHT
} direction_t;
typedef enum
{
RENDER_WIND,
RENDER_BLAST
} algorithm_t;
typedef enum
{
BOTH,
LEADING,
TRAILING
} edge_t;
static void query (void);
static void run (gchar *name,
gint nparams,
GimpParam *param,
gint *nreturn_vals,
GimpParam **return_vals);
static void dialog_box (GimpDrawable *drawable);
static void ok_callback (GtkWidget *widget,
gpointer data);
static void radio_callback (GtkWidget *widget,
gpointer data);
static gint render_effect (GimpDrawable *drawable,
gboolean preview_mode);
static void render_wind (GimpDrawable *drawable,
gint threshold,
gint strength,
direction_t direction,
edge_t edge,
gboolean preview_mode);
static void render_blast (GimpDrawable *drawable,
gint threshold,
gint strength,
direction_t direction,
edge_t edge,
gboolean preview_mode);
static gint render_blast_row (guchar *buffer,
gint bytes,
gint lpi,
gint threshold,
gint strength,
edge_t edge);
static void render_wind_row (guchar *sb,
gint bytes,
gint lpi,
gint threshold,
gint strength,
edge_t edge);
static void get_derivative (guchar *pixel_R1,
guchar *pixel_R2,
edge_t edge,
gboolean has_alpha,
gint *derivative_R,
gint *derivative_G,
gint *derivative_B,
gint *derivative_A);
static gint threshold_exceeded (guchar *pixel_R1,
guchar *pixel_R2,
edge_t edge,
gint threshold,
gboolean has_alpha);
static void reverse_buffer (guchar *buffer,
gint length,
gint bytes);
static void fill_preview (GtkWidget *preview_widget,
GimpDrawable *drawable);
static GtkWidget *preview_widget (GimpDrawable *drawable);
GimpPlugInInfo PLUG_IN_INFO =
{
NULL, /* init_proc */
NULL, /* quit_proc */
query, /* query_proc */
run /* run_proc */
};
/*********************
Globals
*******************/
/* This is needed to communicate the result from the dialog
box button's callback function*/
static gint dialog_result = -1;
struct config_tag
{
gint threshold; /* derivative comparison for edge detection */
direction_t direction; /* of wind, LEFT or RIGHT */
gint strength; /* how many pixels to bleed */
algorithm_t alg; /* which algorithm */
edge_t edge; /* controls abs, ne+ static guchar *preview_bits;
+ static GtkWidget *preview;
gation of derivative */
};
typedef struct config_tag config_t;
config_t config =
{
10, /* threshold for derivative edge detection */
LEFT, /* bleed to the right */
10, /* how many pixels to bleed */
RENDER_WIND, /* default algorithm */
LEADING /* abs(derivative); */
};
static guchar *preview_cache;
static GtkWidget *preview;
static gint preview_cache_rowstride;
static gint preview_cache_bpp;
MAIN ()
static void
query (void)
{
static GimpParamDef args[] =
{
{ GIMP_PDB_INT32, "run_mode", "Interactive, non-interactive" },
{ GIMP_PDB_IMAGE, "image", "Input image (unused)" },
{ GIMP_PDB_DRAWABLE, "drawable", "Input drawable" },
{ GIMP_PDB_INT32, "threshold", "Controls where blending will be done >= 0" },
{ GIMP_PDB_INT32, "direction", "Left or Right: 0 or 1" },
{ GIMP_PDB_INT32, "strength", "Controls the extent of the blending > 1" },
{ GIMP_PDB_INT32, "alg", "WIND, BLAST" },
{ GIMP_PDB_INT32, "edge", "LEADING, TRAILING, or BOTH" }
};
static gint nargs = sizeof (args) / sizeof (args[0]);
gimp_install_procedure ("plug_in_wind",
"Renders a wind effect.",
"Renders a wind effect.",
"Nigel Wetten",
"Nigel Wetten",
"May 2000",
N_("<Image>/Filters/Distorts/Wind..."),
"RGB*",
GIMP_PLUGIN,
nargs, 0,
args, NULL);
}
static void
run (gchar *name,
gint nparams,
GimpParam *param,
gint *nreturn_vals,
GimpParam **return_vals)
{
static GimpParam values[1];
GimpDrawable *drawable;
GimpRunModeType run_mode;
GimpPDBStatusType status = GIMP_PDB_SUCCESS;
run_mode = param[0].data.d_int32;
drawable = gimp_drawable_get(param[2].data.d_drawable);
gimp_tile_cache_ntiles(2 * (drawable->width / gimp_tile_width() + 1));
switch (run_mode)
{
case GIMP_RUN_NONINTERACTIVE:
INIT_I18N();
if (nparams != 8)
{
status = GIMP_PDB_CALLING_ERROR;
}
else
{
config.threshold = param[3].data.d_int32;
config.direction = param[4].data.d_int32;
config.strength = param[5].data.d_int32;
config.alg = param[6].data.d_int32;
config.edge = param[7].data.d_int32;
if (render_effect(drawable, 0) == -1)
status = GIMP_PDB_EXECUTION_ERROR;
}
break;
case GIMP_RUN_INTERACTIVE:
INIT_I18N_UI();
gimp_get_data("plug_in_wind", &config);
dialog_box(drawable);
if (dialog_result == -1)
{
status = GIMP_PDB_EXECUTION_ERROR;
break;
}
if (render_effect(drawable, 0) == -1)
{
status = GIMP_PDB_CALLING_ERROR;
break;
}
g_free(preview_cache);
gimp_set_data("plug_in_wind", &config, sizeof(config_t));
gimp_displays_flush();
break;
case GIMP_RUN_WITH_LAST_VALS:
INIT_I18N();
gimp_get_data("plug_in_wind", &config);
if (render_effect (drawable, FALSE) == -1)
{
status = GIMP_PDB_EXECUTION_ERROR;
gimp_message("An execution error occured.");
}
else
{
gimp_displays_flush ();
}
}
gimp_drawable_detach(drawable);
*nreturn_vals = 1;
*return_vals = values;
values[0].type = GIMP_PDB_STATUS;
values[0].data.d_status = status;
return;
}
static gint
render_effect (GimpDrawable *drawable,
gboolean preview_mode)
{
if (config.alg == RENDER_WIND)
{
render_wind (drawable, config.threshold, config.strength,
config.direction, config.edge, preview_mode);
}
else if (config.alg == RENDER_BLAST)
{
render_blast (drawable, config.threshold, config.strength,
config.direction, config.edge, preview_mode);
}
return 0;
}
static void
preview_do_row(gint row,
gint width,
guchar *even,
guchar *odd,
guchar *src)
{
gint x;
guchar *p0 = even;
guchar *p1 = odd;
gdouble r, g, b, a;
gdouble c0, c1;
for (x = 0; x < width; x++)
{
if (preview_cache_bpp == 4)
{
r = ((gdouble)src[x*4+0]) / 255.0;
g = ((gdouble)src[x*4+1]) / 255.0;
b = ((gdouble)src[x*4+2]) / 255.0;
a = ((gdouble)src[x*4+3]) / 255.0;
}
else if (preview_cache_bpp == 3)
{
r = ((gdouble)src[x*3+0]) / 255.0;
g = ((gdouble)src[x*3+1]) / 255.0;
b = ((gdouble)src[x*3+2]) / 255.0;
a = 1.0;
}
else
{
r = ((gdouble)src[x*preview_cache_bpp+0]) / 255.0;
g = b = r;
if (preview_cache_bpp == 2)
a = ((gdouble)src[x*preview_cache_bpp+1]) / 255.0;
else
a = 1.0;
}
if ((x / GIMP_CHECK_SIZE) & 1)
{
c0 = GIMP_CHECK_LIGHT;
c1 = GIMP_CHECK_DARK;
}
else
{
c0 = GIMP_CHECK_DARK;
c1 = GIMP_CHECK_LIGHT;
}
*p0++ = (c0 + (r - c0) * a) * 255.0;
*p0++ = (c0 + (g - c0) * a) * 255.0;
*p0++ = (c0 + (b - c0) * a) * 255.0;
*p1++ = (c1 + (r - c1) * a) * 255.0;
*p1++ = (c1 + (g - c1) * a) * 255.0;
*p1++ = (c1 + (b - c1) * a) * 255.0;
} /* for */
if ((row / GIMP_CHECK_SIZE) & 1)
{
gtk_preview_draw_row (GTK_PREVIEW (preview), (guchar *)odd, 0, row, width);
}
else
{
gtk_preview_draw_row (GTK_PREVIEW (preview), (guchar *)even, 0, row, width);
}
}
static void
render_blast (GimpDrawable *drawable,
gint threshold,
gint strength,
direction_t direction,
edge_t edge,
gboolean preview_mode)
{
gint x1, x2, y1, y2;
gint width;
gint height;
gint bytes = drawable->bpp;
guchar *buffer;
GimpPixelRgn src_region, dest_region;
gint row;
gint row_stride;
gint marker = 0;
gint lpi;
guchar *odd = NULL;
guchar *even = NULL;
if (preview_mode)
{
width = GTK_PREVIEW (preview)->buffer_width;
height = GTK_PREVIEW (preview)->buffer_height;
bytes = preview_cache_bpp;
x1 = y1 = 0;
x2 = width;
y2 = height;
row_stride = preview_cache_rowstride;
even = g_malloc (width * 3);
odd = g_malloc (width * 3);
}
else
{
gimp_progress_init( _("Rendering Blast..."));
gimp_drawable_mask_bounds (drawable->id, &x1, &y1, &x2, &y2);
width = x2 - x1;
height = y2 - y1;
gimp_pixel_rgn_init (&src_region, drawable, x1, y1, width, height, FALSE, FALSE);
gimp_pixel_rgn_init (&dest_region, drawable, x1, y1, width, height, TRUE, TRUE);
row_stride = width * bytes;
}
lpi = row_stride - bytes;
buffer = (guchar *) g_malloc (row_stride);
for (row = y1; row < y2; row++)
{
if (preview_mode)
memcpy (buffer, preview_cache + (row * row_stride), row_stride);
else
gimp_pixel_rgn_get_row (&src_region, buffer, x1, row, width);
if (direction == RIGHT)
{
reverse_buffer (buffer, row_stride, bytes);
}
marker = render_blast_row (buffer, bytes, lpi, threshold, strength, edge);
if (direction == RIGHT)
{
reverse_buffer (buffer, row_stride, bytes);
}
if (preview_mode)
{
preview_do_row(row,width,even,odd,buffer);
}
else
{
gimp_pixel_rgn_set_row (&dest_region, buffer, x1, row, width);
gimp_progress_update ((double) (row - y1)/ (double) (height));
}
if (marker)
{
gint j, limit;
limit = 1 + rand () % 2;
for (j = 0; (j < limit) && (row < y2); j++)
{
row++;
if (row < y2)
{
if (preview_mode)
{
memcpy (buffer, preview_cache + (row * row_stride), row_stride);
preview_do_row(row,width,even,odd,buffer);
}
else
{
gimp_pixel_rgn_get_row (&src_region, buffer, x1, row, width);
gimp_pixel_rgn_set_row (&dest_region, buffer, x1, row, width);
}
}
}
marker = 0;
}
}
if(even)
g_free(even);
if(odd)
g_free(odd);
g_free(buffer);
/* update the region */
if (preview_mode)
{
gtk_widget_queue_draw (preview);
}
else
{
gimp_drawable_flush (drawable);
gimp_drawable_merge_shadow (drawable->id, TRUE);
gimp_drawable_update (drawable->id, x1, y1, x2 - x1, y2 - y1);
}
return;
}
static void
render_wind (GimpDrawable *drawable,
gint threshold,
gint strength,
direction_t direction,
edge_t edge,
gboolean preview_mode)
{
GimpPixelRgn src_region, dest_region;
gint width;
gint height;
gint bytes;
gint row_stride;
gint comp_stride;
gint row;
guchar *sb;
gint lpi;
gint x1, y1, x2, y2;
guchar *odd = NULL;
guchar *even = NULL;
if (preview_mode)
{
width = GTK_PREVIEW (preview)->buffer_width;
height = GTK_PREVIEW (preview)->buffer_height;
bytes = preview_cache_bpp;
x1 = y1 = 0;
x2 = width;
y2 = height;
row_stride = preview_cache_rowstride;
even = g_malloc (width * 3);
odd = g_malloc (width * 3);
}
else
{
gimp_progress_init( _("Rendering Wind..."));
gimp_drawable_mask_bounds (drawable->id, &x1, &y1, &x2, &y2);
bytes = drawable->bpp;
width = x2 - x1;
height = y2 - y1;
gimp_pixel_rgn_init (&src_region, drawable, x1, y1, width, height, FALSE, FALSE);
gimp_pixel_rgn_init (&dest_region, drawable, x1, y1, width, height, TRUE, TRUE);
row_stride = width * bytes;
}
comp_stride = bytes * COMPARE_WIDTH;
lpi = row_stride - comp_stride;
sb = g_malloc (row_stride);
for (row = y1; row < y2; row++)
{
if (preview_mode)
memcpy (sb, preview_cache + (row * row_stride), row_stride);
else
gimp_pixel_rgn_get_row (&src_region, sb, x1, row, width);
if (direction == RIGHT)
reverse_buffer (sb, row_stride, bytes);
render_wind_row (sb, bytes, lpi, threshold, strength, edge);
if (direction == RIGHT)
reverse_buffer(sb, row_stride, bytes);
if (preview_mode)
{
preview_do_row(row,width,even,odd,sb);
}
else
{
gimp_pixel_rgn_set_row (&dest_region, sb, x1, row, width);
gimp_progress_update ((double) (row - y1)/ (double) (height));
}
}
if(even)
g_free(even);
if(odd)
g_free(odd);
g_free(sb);
/* update the region */
if (preview_mode)
{
gtk_widget_queue_draw (preview);
}
else
{
gimp_drawable_flush (drawable);
gimp_drawable_merge_shadow (drawable->id, TRUE);
gimp_drawable_update (drawable->id, x1, y1, x2 - x1, y2 - y1);
}
return;
}
static gint
render_blast_row (guchar *buffer,
gint bytes,
gint lpi,
gint threshold,
gint strength,
edge_t edge)
{
gint Ri, Gi, Bi, Ai= 0;
gint sbi, lbi;
gint bleed_length;
gint i, j;
gint weight, random_factor;
gint skip = 0;
for (j = 0; j < lpi; j += bytes)
{
Ri = j; Gi = j + 1; Bi = j + 2;
if(bytes > 3)
Ai = j + 3;
if (threshold_exceeded(buffer+Ri, buffer+Ri+bytes, edge, threshold, (bytes > 3)))
{
/* we have found an edge, do bleeding */
sbi = Ri;
weight = rand() % 10;
if (weight > 5)
{
random_factor = 2;
}
else if (weight > 3)
{
random_factor = 3;
}
else
{
random_factor = 4;
}
bleed_length = 0;
switch (rand() % random_factor)
{
case 3:
bleed_length += strength;
/* fall through to add up multiples of strength */
case 2:
bleed_length += strength;
/* fall through */
case 1:
bleed_length += strength;
/* fall through */
case 0:
bleed_length += strength;
/* fall through */
}
lbi = sbi + bytes * bleed_length;
if (lbi > lpi)
{
lbi = lpi;
}
for (i = sbi; i < lbi; i += bytes)
{
buffer[i] = buffer[Ri];
buffer[i+1] = buffer[Gi];
buffer[i+2] = buffer[Bi];
if(bytes > 3)
buffer[i+3] = buffer[Ai];
}
j = lbi - bytes;
if ((rand() % 10) > 7)
{
skip = 1;
}
}
}
return skip;
}
static void
render_wind_row (guchar *sb,
gint bytes,
gint lpi,
gint threshold,
gint strength,
edge_t edge)
{
gint i, j;
gint bleed_length;
gint blend_amt_R, blend_amt_G, blend_amt_B, blend_amt_A = 0 ;
gint blend_colour_R, blend_colour_G, blend_colour_B, blend_colour_A = 0 ;
gint target_colour_R, target_colour_G, target_colour_B, target_colour_A = 0;
gdouble bleed_length_max;
gint bleed_variation;
gint n;
gint sbi; /* starting bleed index */
gint lbi; /* last bleed index */
gdouble denominator;
gint comp_stride = bytes * COMPARE_WIDTH;
for (j = 0; j < lpi; j += bytes)
{
gint Ri = j;
gint Gi = j + 1;
gint Bi = j + 2;
gint Ai = 0;
if(bytes > 3)
Ai = j + 3;
if (threshold_exceeded(sb+Ri, sb+Ri+comp_stride, edge, threshold,(bytes > 3)))
{
/* we have found an edge, do bleeding */
sbi = Ri + comp_stride;
blend_colour_R = sb[Ri];
blend_colour_G = sb[Gi];
blend_colour_B = sb[Bi];
target_colour_R = sb[sbi];
target_colour_G = sb[sbi+1];
target_colour_B = sb[sbi+2];
bleed_length_max = strength;
if(bytes > 3)
{
blend_colour_A = sb[Ai];
target_colour_A = sb[sbi+3];
}
if (rand() % 3) /* introduce weighted randomness */
{
bleed_length_max = strength;
}
else
{
bleed_length_max = 4 * strength;
}
bleed_variation = 1
+ (gint) (bleed_length_max * rand() / (G_MAXRAND + 1.0));
lbi = sbi + bleed_variation * bytes;
if (lbi > lpi)
{
lbi = lpi; /* stop overunning the buffer */
}
bleed_length = bleed_variation;
blend_amt_R = target_colour_R - blend_colour_R;
blend_amt_G = target_colour_G - blend_colour_G;
blend_amt_B = target_colour_B - blend_colour_B;
if(bytes > 3)
{
blend_amt_A = target_colour_A - blend_colour_A;
}
denominator = bleed_length * bleed_length + bleed_length;
denominator = 2.0 / denominator;
n = bleed_length;
for (i = sbi; i < lbi; i += bytes)
{
/* check against original colour */
if (!threshold_exceeded(sb+Ri, sb+i, edge, threshold,(bytes>3))
&& (rand() % 2))
{
break;
}
blend_colour_R += blend_amt_R * n * denominator;
blend_colour_G += blend_amt_G * n * denominator;
blend_colour_B += blend_amt_B * n * denominator;
if(bytes > 3)
{
blend_colour_A += blend_amt_A * n * denominator;
if (blend_colour_A > 255) blend_colour_A = 255;
else if (blend_colour_A < 0) blend_colour_A = 0;
}
if (blend_colour_R > 255) blend_colour_R = 255;
else if (blend_colour_R < 0) blend_colour_R = 0;
if (blend_colour_G > 255) blend_colour_G = 255;
else if (blend_colour_G < 0) blend_colour_G = 0;
if (blend_colour_B > 255) blend_colour_B = 255;
else if (blend_colour_B < 0) blend_colour_B = 0;
sb[i] = (blend_colour_R * 2 + sb[i]) / 3;
sb[i+1] = (blend_colour_G * 2 + sb[i+1]) / 3;
sb[i+2] = (blend_colour_B * 2 + sb[i+2]) / 3;
if(bytes > 3)
sb[i+3] = (blend_colour_A * 2 + sb[i+3]) / 3;
if (threshold_exceeded(sb+i, sb+i+comp_stride, BOTH,
threshold,(bytes>3)))
{
target_colour_R = sb[i+comp_stride];
target_colour_G = sb[i+comp_stride+1];
target_colour_B = sb[i+comp_stride+2];
if(bytes > 3)
target_colour_A = sb[i+comp_stride+3];
blend_amt_R = target_colour_R - blend_colour_R;
blend_amt_G = target_colour_G - blend_colour_G;
blend_amt_B = target_colour_B - blend_colour_B;
if(bytes > 3)
blend_amt_A = target_colour_A - blend_colour_A;
denominator = n * n + n;
denominator = 2.0 / denominator;
}
n--;
}
}
}
return;
}
static gint
threshold_exceeded (guchar *pixel_R1,
guchar *pixel_R2,
edge_t edge,
gint threshold,
gboolean has_alpha)
{
gint derivative_R, derivative_G, derivative_B, derivative_A;
gint return_value;
get_derivative(pixel_R1, pixel_R2, edge, has_alpha,
&derivative_R, &derivative_G, &derivative_B, &derivative_A);
if(((derivative_R +
derivative_G +
derivative_B +
derivative_A) / 4) > threshold)
{
return_value = 1;
}
else
{
return_value = 0;
}
return return_value;
}
static void
get_derivative (guchar *pixel_R1,
guchar *pixel_R2,
edge_t edge,
gboolean has_alpha,
gint *derivative_R,
gint *derivative_G,
gint *derivative_B,
gint *derivative_A)
{
guchar *pixel_G1 = pixel_R1 + 1;
guchar *pixel_B1 = pixel_R1 + 2;
guchar *pixel_G2 = pixel_R2 + 1;
guchar *pixel_B2 = pixel_R2 + 2;
guchar *pixel_A1;
guchar *pixel_A2;
if(has_alpha)
{
pixel_A1 = pixel_R1 + 3;
pixel_A2 = pixel_R2 + 3;
*derivative_A = *pixel_A2 - *pixel_A1;
}
else
{
*derivative_A = 0;
}
*derivative_R = *pixel_R2 - *pixel_R1;
*derivative_G = *pixel_G2 - *pixel_G1;
*derivative_B = *pixel_B2 - *pixel_B1;
if (edge == BOTH)
{
*derivative_R = abs(*derivative_R);
*derivative_G = abs(*derivative_G);
*derivative_B = abs(*derivative_B);
*derivative_A = abs(*derivative_A);
}
else if (edge == LEADING)
{
*derivative_R = -(*derivative_R);
*derivative_G = -(*derivative_G);
*derivative_B = -(*derivative_B);
*derivative_A = -(*derivative_A);
}
else if (edge == TRAILING)
{
/* no change needed */
}
return;
}
static void
reverse_buffer (guchar *buffer,
gint length,
gint bytes)
{
gint i, si;
gint temp;
gint midpoint;
midpoint = length / 2;
for (i = 0; i < midpoint; i += bytes)
{
si = length - bytes - i;
temp = buffer[i];
buffer[i] = buffer[si];
buffer[si] = (guchar) temp;
temp = buffer[i+1];
buffer[i+1] = buffer[si+1];
buffer[si+1] = (guchar) temp;
temp = buffer[i+2];
buffer[i+2] = buffer[si+2];
buffer[si+2] = (guchar) temp;
if(bytes > 3)
{
temp = buffer[i+3];
buffer[i+3] = buffer[si+3];
buffer[si+3] = (guchar) temp;
}
}
return;
}
/***************************************************
GUI
***************************************************/
static void
ok_callback (GtkWidget *widget,
gpointer data)
{
/* we have to stop the dialog from being closed with strength < 1 */
/* since we use spinbuttons this should never happen ... */
if (config.strength < 1)
{
g_message (_("Wind Strength must be greater than 0."));
}
else
{
dialog_result = 1;
gtk_widget_destroy (GTK_WIDGET (data));
}
}
static void
radio_callback (GtkWidget *widget,
gpointer data)
{
GimpDrawable *drawable;
gimp_radio_button_update (widget, data);
if (GTK_TOGGLE_BUTTON (widget)->active)
{
drawable = gtk_object_get_data (GTK_OBJECT (widget), "drawable");
if (drawable != NULL)
render_effect (drawable, TRUE);
}
}
static void
dialog_box (GimpDrawable *drawable)
{
GtkWidget *main_vbox;
GtkWidget *vbox;
GtkWidget *abox;
GtkWidget *table;
GtkObject *adj;
GtkWidget *frame;
GtkWidget *dlg;
GtkWidget *style1;
GtkWidget *style2;
GtkWidget *dir1;
GtkWidget *dir2;
GtkWidget *edge1;
GtkWidget *edge2;
GtkWidget *edge3;
gimp_ui_init ("wind", TRUE);
dlg = gimp_dialog_new ( _("Wind"), "wind",
gimp_standard_help_func, "filters/wind.html",
GTK_WIN_POS_MOUSE,
FALSE, TRUE, FALSE,
_("OK"), ok_callback,
NULL, NULL, NULL, TRUE, FALSE,
_("Cancel"), gtk_widget_destroy,
NULL, 1, NULL, FALSE, TRUE,
NULL);
gtk_signal_connect (GTK_OBJECT (dlg), "destroy",
GTK_SIGNAL_FUNC (gtk_main_quit),
NULL);
/* init tooltips */
gimp_help_init ();
vbox = gtk_vbox_new (FALSE, 2);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 0);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dlg)->vbox), vbox, TRUE, TRUE, 0);
gtk_widget_show (vbox);
frame = gtk_frame_new (_("Preview"));
gtk_container_set_border_width (GTK_CONTAINER (frame), 6);
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
gtk_widget_show (frame);
abox = gtk_alignment_new (0.5, 0.5, 0.0, 0.0);
gtk_container_set_border_width (GTK_CONTAINER (abox), 4);
gtk_container_add (GTK_CONTAINER (frame), abox);
gtk_widget_show (abox);
frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
gtk_container_add (GTK_CONTAINER (abox), frame);
gtk_widget_show (frame);
preview = preview_widget (drawable); /* we are here */
gtk_container_add (GTK_CONTAINER (frame), preview);
render_effect (drawable, TRUE); /* render preview image */
gtk_widget_show (preview);
frame = gtk_frame_new (_("Parameter Settings"));
gtk_container_set_border_width (GTK_CONTAINER (frame), 6);
gtk_box_pack_start (GTK_BOX (vbox), frame, TRUE, TRUE, 0);
gtk_widget_show (frame);
main_vbox = gtk_vbox_new (FALSE, 4);
gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 6);
gtk_container_add (GTK_CONTAINER (frame), main_vbox);
gtk_widget_show (main_vbox);
/*****************************************************
outer frame and table
***************************************************/
table = gtk_table_new (1, 3, FALSE);
gtk_table_set_col_spacings (GTK_TABLE (table), 4);
gtk_table_set_row_spacings (GTK_TABLE (table), 2);
gtk_box_pack_start (GTK_BOX (main_vbox), table, FALSE, FALSE, 0);
/*********************************************************
radio buttons for choosing wind rendering algorithm
******************************************************/
frame = gimp_radio_group_new2 (TRUE, _("Style"),
radio_callback,
&config.alg, (gpointer) config.alg,
_("Wind"), (gpointer) RENDER_WIND, &style1,
_("Blast"), (gpointer) RENDER_BLAST, &style2,
NULL);
gtk_object_set_data (GTK_OBJECT (style1), "drawable", drawable);
gtk_object_set_data (GTK_OBJECT (style2), "drawable", drawable);
gtk_table_attach (GTK_TABLE (table), frame, 0, 1, 0, 1,
GTK_FILL | GTK_EXPAND, GTK_FILL | GTK_EXPAND, 0, 0);
gtk_widget_show (frame);
/******************************************************
radio buttons for choosing LEFT or RIGHT
**************************************************/
frame = gimp_radio_group_new2 (TRUE, _("Direction"),
radio_callback,
&config.direction, (gpointer) config.direction,
_("Left"), (gpointer) LEFT, &dir1,
_("Right"), (gpointer) RIGHT, &dir2,
NULL);
gtk_object_set_data (GTK_OBJECT (dir1), "drawable", drawable);
gtk_object_set_data (GTK_OBJECT (dir2), "drawable", drawable);
gtk_table_attach (GTK_TABLE (table), frame, 1, 2, 0, 1,
GTK_FILL | GTK_EXPAND, GTK_FILL | GTK_EXPAND, 0, 0);
gtk_widget_show (frame);
/*****************************************************
radio buttons for choosing BOTH, LEADING, TRAILING
***************************************************/
frame = gimp_radio_group_new2 (TRUE, _("Edge Affected"),
radio_callback,
&config.edge, (gpointer) config.edge,
_("Leading"), (gpointer) LEADING, &edge1,
_("Trailing"), (gpointer) TRAILING, &edge2,
_("Both"), (gpointer) BOTH, &edge3,
NULL);
gtk_object_set_data (GTK_OBJECT (edge1), "drawable", drawable);
gtk_object_set_data (GTK_OBJECT (edge2), "drawable", drawable);
gtk_object_set_data (GTK_OBJECT (edge3), "drawable", drawable);
gtk_table_attach (GTK_TABLE (table), frame, 2, 3, 0, 1,
GTK_FILL | GTK_EXPAND, GTK_FILL | GTK_EXPAND, 0, 0);
gtk_widget_show (frame);
gtk_widget_show (table);
/****************************************************
table for sliders
****************************************************/
table = gtk_table_new (2, 3, FALSE);
gtk_table_set_col_spacings (GTK_TABLE (table), 4);
gtk_table_set_row_spacings (GTK_TABLE (table), 2);
gtk_box_pack_start (GTK_BOX (main_vbox), table, FALSE, FALSE, 0);
/*****************************************************
slider and entry for threshold
***************************************************/
adj = gimp_scale_entry_new (GTK_TABLE (table), 0, 0,
_("Threshold:"), SCALE_WIDTH, 0,
config.threshold,
MIN_THRESHOLD, MAX_THRESHOLD, 1.0, 10, 0,
TRUE, 0, 0,
_("Higher values restrict the effect to fewer areas of the image"), NULL);
gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
GTK_SIGNAL_FUNC (gimp_int_adjustment_update),
&config.threshold);
gtk_signal_connect_object (GTK_OBJECT (adj), "value_changed",
GTK_SIGNAL_FUNC (render_effect),
(gpointer)drawable);
/*****************************************************
slider and entry for strength of wind
****************************************************/
adj = gimp_scale_entry_new (GTK_TABLE (table), 0, 1,
_("Strength:"), SCALE_WIDTH, 0,
config.strength,
MIN_STRENGTH, MAX_STRENGTH, 1.0, 10.0, 0,
TRUE, 0, 0,
_("Higher values increase the magnitude of the effect"), NULL);
gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
GTK_SIGNAL_FUNC (gimp_int_adjustment_update),
&config.strength);
gtk_signal_connect_object (GTK_OBJECT (adj), "value_changed",
GTK_SIGNAL_FUNC (render_effect),
(gpointer)drawable);
gtk_widget_show (table);
gtk_widget_show (dlg);
gtk_main ();
gdk_flush ();
}
static GtkWidget *
preview_widget (GimpDrawable *drawable)
{
gint size;
preview = gtk_preview_new (GTK_PREVIEW_COLOR);
fill_preview (preview, drawable);
size = GTK_PREVIEW (preview)->rowstride * GTK_PREVIEW (preview)->buffer_height;
return preview;
}
static void
fill_preview (GtkWidget *widget,
GimpDrawable *drawable)
{
GimpPixelRgn srcPR;
gint width;
gint height;
gint x1, x2, y1, y2;
gint bpp;
gint y;
guchar *src;
guchar *even, *odd;
gimp_drawable_mask_bounds (drawable->id, &x1, &y1, &x2, &y2);
if (x2 - x1 > PREVIEW_SIZE)
x2 = x1 + PREVIEW_SIZE;
if (y2 - y1 > PREVIEW_SIZE)
y2 = y1 + PREVIEW_SIZE;
width = x2 - x1;
height = y2 - y1;
bpp = gimp_drawable_bpp (drawable->id);
if (width < 1 || height < 1)
return;
gtk_preview_size (GTK_PREVIEW (widget), width, height);
gimp_pixel_rgn_init (&srcPR, drawable, x1, y1, x2, y2, FALSE, FALSE);
even = g_malloc (width * 3);
odd = g_malloc (width * 3);
src = g_malloc (width * bpp);
preview_cache = g_malloc(width * bpp * height);
preview_cache_rowstride = width * bpp;
preview_cache_bpp = bpp;
for (y = 0; y < height; y++)
{
gimp_pixel_rgn_get_row (&srcPR, src, x1, y + y1, width);
memcpy(preview_cache + (y*width*bpp),src,width*bpp);
}
for (y = 0; y < height; y++)
{
preview_do_row(y,width,even,odd,preview_cache + (y*width*bpp));
}
g_free (even);
g_free (odd);
g_free (src);
}
Reference in New Issue View Git Blame Copy Permalink