static gboolean
gui_get_background_func (GimpRGB *color)
{
g_return_val_if_fail (color != NULL, FALSE);
g_return_val_if_fail (GIMP_IS_GIMP (the_gui_gimp), FALSE);
gimp_context_get_background (gimp_get_user_context (the_gui_gimp), color);
return TRUE;
}
void
palette_editor_actions_update (GimpActionGroup *group,
gpointer user_data)
{
GimpPaletteEditor *editor = GIMP_PALETTE_EDITOR (user_data);
GimpDataEditor *data_editor = GIMP_DATA_EDITOR (user_data);
GimpData *data;
gboolean editable = FALSE;
GimpRGB fg;
GimpRGB bg;
gboolean edit_active = FALSE;
data = data_editor->data;
if (data)
{
if (data_editor->data_editable)
editable = TRUE;
}
if (data_editor->context)
{
gimp_context_get_foreground (data_editor->context, &fg);
gimp_context_get_background (data_editor->context, &bg);
}
edit_active = gimp_data_editor_get_edit_active (data_editor);
#define SET_SENSITIVE(action,condition) \
gimp_action_group_set_action_sensitive (group, action, (condition) != 0)
#define SET_ACTIVE(action,condition) \
gimp_action_group_set_action_active (group, action, (condition) != 0)
#define SET_COLOR(action,color) \
gimp_action_group_set_action_color (group, action, color, FALSE);
SET_SENSITIVE ("palette-editor-edit-color", editable && editor->color);
SET_SENSITIVE ("palette-editor-delete-color", editable && editor->color);
SET_SENSITIVE ("palette-editor-new-color-fg", editable);
SET_SENSITIVE ("palette-editor-new-color-bg", editable);
SET_COLOR ("palette-editor-new-color-fg", data_editor->context ? &fg : NULL);
SET_COLOR ("palette-editor-new-color-bg", data_editor->context ? &bg : NULL);
SET_SENSITIVE ("palette-editor-zoom-out", data);
SET_SENSITIVE ("palette-editor-zoom-in", data);
SET_SENSITIVE ("palette-editor-zoom-all", data);
SET_ACTIVE ("palette-editor-edit-active", edit_active);
#undef SET_SENSITIVE
#undef SET_ACTIVE
#undef SET_COLOR
}
static gboolean
gimp_color_panel_button_press (GtkWidget *widget,
GdkEventButton *bevent)
{
if (gdk_event_triggers_context_menu ((GdkEvent *) bevent))
{
GimpColorButton *color_button;
GimpColorPanel *color_panel;
GtkUIManager *ui_manager;
GtkActionGroup *group;
GtkAction *action;
GimpRGB color;
color_button = GIMP_COLOR_BUTTON (widget);
color_panel = GIMP_COLOR_PANEL (widget);
ui_manager = GTK_UI_MANAGER (color_button->popup_menu);
group = gtk_ui_manager_get_action_groups (ui_manager)->data;
action = gtk_action_group_get_action (group,
"color-button-use-foreground");
gtk_action_set_visible (action, color_panel->context != NULL);
action = gtk_action_group_get_action (group,
"color-button-use-background");
gtk_action_set_visible (action, color_panel->context != NULL);
if (color_panel->context)
{
action = gtk_action_group_get_action (group,
"color-button-use-foreground");
gimp_context_get_foreground (color_panel->context, &color);
g_object_set (action, "color", &color, NULL);
action = gtk_action_group_get_action (group,
"color-button-use-background");
gimp_context_get_background (color_panel->context, &color);
g_object_set (action, "color", &color, NULL);
}
action = gtk_action_group_get_action (group, "color-button-use-black");
gimp_rgba_set (&color, 0.0, 0.0, 0.0, GIMP_OPACITY_OPAQUE);
g_object_set (action, "color", &color, NULL);
action = gtk_action_group_get_action (group, "color-button-use-white");
gimp_rgba_set (&color, 1.0, 1.0, 1.0, GIMP_OPACITY_OPAQUE);
g_object_set (action, "color", &color, NULL);
}
if (GTK_WIDGET_CLASS (parent_class)->button_press_event)
return GTK_WIDGET_CLASS (parent_class)->button_press_event (widget, bevent);
return FALSE;
}
/* --------------------------
* p_create_corpus_layer
* --------------------------
* create the corpus layer that builds the reference pattern
* for the resynthesizer call. The reference pattern is built
* as duplicate of the original image reduced to the area around the current selection.
* (grown by corpus_border_radius)
* Note that the duplicate image has a selection, that includes the gorwn area
* around the orignal selection, but EXCLUDES the original selection
* (that is the area holding the object that has to be replaced
* by pattern of the surrounding area)
* returns the layer_id of the reference pattern.
*/
static gint32
p_create_corpus_layer(gint32 image_id, gint32 drawable_id, TransValues *val_ptr)
{
gint32 dup_image_id;
gint32 channel_id;
gint32 channel_2_id;
GimpRGB bck_color;
GimpRGB white_opaque_color;
/* gboolean has_selection; */
gboolean non_empty;
gint x1, y1, x2, y2;
gint32 active_layer_stackposition;
gint32 active_dup_layer_id;
active_layer_stackposition = gap_layer_get_stackposition(image_id, drawable_id);
dup_image_id = gimp_image_duplicate(image_id);
channel_id = gimp_selection_save(dup_image_id);
gimp_selection_grow(dup_image_id, val_ptr->corpus_border_radius);
gimp_selection_invert(dup_image_id);
gimp_context_get_background(&bck_color);
channel_2_id = gimp_selection_save(dup_image_id);
gimp_image_select_item(dup_image_id, GIMP_CHANNEL_OP_REPLACE, channel_id);
gimp_rgba_set_uchar (&white_opaque_color, 255, 255, 255, 255);
gimp_context_set_background(&white_opaque_color);
gimp_edit_clear(channel_2_id);
gimp_context_set_background(&bck_color); /* restore original background color */
gimp_selection_load(channel_2_id);
gimp_selection_invert(dup_image_id);
/* has_selection = */ gimp_selection_bounds(dup_image_id, &non_empty, &x1, &y1, &x2, &y2);
gimp_image_crop(dup_image_id, (x2 - x1), (y2 - y1), x1, y1);
gimp_selection_invert(dup_image_id);
active_dup_layer_id = gap_layer_get_id_by_stackposition(dup_image_id, active_layer_stackposition);
if (1==0)
{
/* debug code shows the duplicate image by adding a display */
gimp_display_new(dup_image_id);
}
return (active_dup_layer_id);
} /* end p_create_corpus_layer */
void
edit_actions_setup (GimpActionGroup *group)
{
GimpContext *context = gimp_get_user_context (group->gimp);
GimpRGB color;
GimpPattern *pattern;
GtkAction *action;
gimp_action_group_add_actions (group, "edit-action",
edit_actions,
G_N_ELEMENTS (edit_actions));
gimp_action_group_add_enum_actions (group, "edit-action",
edit_fill_actions,
G_N_ELEMENTS (edit_fill_actions),
G_CALLBACK (edit_fill_cmd_callback));
action = gtk_action_group_get_action (GTK_ACTION_GROUP (group),
"edit-paste-as-new-short");
gtk_action_set_accel_path (action, "<Actions>/edit/edit-paste-as-new");
action = gtk_action_group_get_action (GTK_ACTION_GROUP (group),
"edit-fill-pattern");
g_object_set (action, "context", context, NULL);
g_signal_connect_object (context, "foreground-changed",
G_CALLBACK (edit_actions_foreground_changed),
group, 0);
g_signal_connect_object (context, "background-changed",
G_CALLBACK (edit_actions_background_changed),
group, 0);
g_signal_connect_object (context, "pattern-changed",
G_CALLBACK (edit_actions_pattern_changed),
group, 0);
gimp_context_get_foreground (context, &color);
edit_actions_foreground_changed (context, &color, group);
gimp_context_get_background (context, &color);
edit_actions_background_changed (context, &color, group);
pattern = gimp_context_get_pattern (context);
edit_actions_pattern_changed (context, pattern, group);
#define SET_ALWAYS_SHOW_IMAGE(action,show) \
gimp_action_group_set_action_always_show_image (group, action, show)
SET_ALWAYS_SHOW_IMAGE ("edit-fill-fg", TRUE);
SET_ALWAYS_SHOW_IMAGE ("edit-fill-bg", TRUE);
SET_ALWAYS_SHOW_IMAGE ("edit-fill-pattern", TRUE);
#undef SET_ALWAYS_SHOW_IMAGE
}
gboolean
gimp_get_fill_params (GimpContext *context,
GimpFillType fill_type,
GimpRGB *color,
GimpPattern **pattern,
GError **error)
{
g_return_val_if_fail (GIMP_IS_CONTEXT (context), FALSE);
g_return_val_if_fail (color != NULL, FALSE);
g_return_val_if_fail (pattern != NULL, FALSE);
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
*pattern = NULL;
switch (fill_type)
{
case GIMP_FILL_FOREGROUND:
gimp_context_get_foreground (context, color);
break;
case GIMP_FILL_BACKGROUND:
gimp_context_get_background (context, color);
break;
case GIMP_FILL_WHITE:
gimp_rgba_set (color, 1.0, 1.0, 1.0, GIMP_OPACITY_OPAQUE);
break;
case GIMP_FILL_TRANSPARENT:
gimp_rgba_set (color, 0.0, 0.0, 0.0, GIMP_OPACITY_TRANSPARENT);
break;
case GIMP_FILL_PATTERN:
*pattern = gimp_context_get_pattern (context);
if (! *pattern)
{
g_set_error_literal (error, GIMP_ERROR, GIMP_FAILED,
_("No patterns available for this operation."));
return FALSE;
}
break;
default:
g_warning ("%s: invalid fill_type %d", G_STRFUNC, fill_type);
return FALSE;
}
return TRUE;
}
gint
image_setup (GimpDrawable *drawable,
gint interactive)
{
/* Set the tile cache size */
/* ======================= */
gimp_tile_cache_ntiles ((drawable->width + gimp_tile_width() - 1) /
gimp_tile_width ());
/* Get some useful info on the input drawable */
/* ========================================== */
input_drawable = drawable;
output_drawable = drawable;
gimp_drawable_mask_bounds (drawable->drawable_id,
&border_x1, &border_y1, &border_x2, &border_y2);
width = input_drawable->width;
height = input_drawable->height;
gimp_pixel_rgn_init (&source_region, input_drawable,
0, 0, width, height, FALSE, FALSE);
maxcounter = (glong) width * (glong) height;
if (mapvals.transparent_background == TRUE)
{
gimp_rgba_set (&background, 0.0, 0.0, 0.0, 0.0);
}
else
{
gimp_context_get_background (&background);
gimp_rgb_set_alpha (&background, 1.0);
}
/* Assume at least RGB */
/* =================== */
in_channels = 3;
if (gimp_drawable_has_alpha (input_drawable->drawable_id) == TRUE)
in_channels++;
if (interactive == TRUE)
{
preview_rgb_data = g_new0 (guchar, PREVIEW_HEIGHT * PREVIEW_WIDTH * 3);
}
return TRUE;
}
void
context_background_blue_cmd_callback (GtkAction *action,
gint value,
gpointer data)
{
GimpContext *context;
GimpRGB color;
return_if_no_context (context, data);
gimp_context_get_background (context, &color);
color.b = action_select_value ((GimpActionSelectType) value,
color.b,
0.0, 1.0, 1.0,
1.0 / 255.0, 0.01, 0.1, 0.0, FALSE);
gimp_context_set_background (context, &color);
}
static void
initialize_background (GimpImageType image_type,
gint channels,
guchar *here,
guchar *best,
void **tmp)
{
GimpRGB background;
guchar *ch;
if (*tmp == NULL)
{
*tmp = (void *) g_new (guchar, 3);
ch = (guchar *)*tmp;
gimp_context_get_background (&background);
gimp_rgb_get_uchar (&background, &ch[0], &ch[1], &ch[2]);
}
}
void
context_background_value_cmd_callback (GtkAction *action,
gint value,
gpointer data)
{
GimpContext *context;
GimpRGB color;
GimpHSV hsv;
return_if_no_context (context, data);
gimp_context_get_background (context, &color);
gimp_rgb_to_hsv (&color, &hsv);
hsv.v = action_select_value ((GimpActionSelectType) value,
hsv.v,
0.0, 1.0, 1.0,
0.01, 0.01, 0.1, 0.0, FALSE);
gimp_hsv_to_rgb (&hsv, &color);
gimp_context_set_background (context, &color);
}
static void
lens_distort_preview (GimpDrawable *drawable,
GimpPreview *preview)
{
guchar *dest;
guchar *pixel;
gint width, height, bpp;
gint x, y;
GimpPixelFetcher *pft;
GimpRGB background;
pft = gimp_pixel_fetcher_new (drawable, FALSE);
gimp_context_get_background (&background);
gimp_rgb_set_alpha (&background, 0.0);
gimp_pixel_fetcher_set_bg_color (pft, &background);
gimp_pixel_fetcher_set_edge_mode (pft, GIMP_PIXEL_FETCHER_EDGE_BACKGROUND);
lens_setup_calc (drawable->width, drawable->height);
dest = gimp_zoom_preview_get_source (GIMP_ZOOM_PREVIEW (preview),
&width, &height, &bpp);
pixel = dest;
for (y = 0; y < height; y++)
{
for (x = 0; x < width; x++)
{
gint sx, sy;
gimp_preview_untransform (preview, x, y, &sx, &sy);
lens_distort_func (sx, sy, pixel, bpp, pft);
pixel += bpp;
}
}
gimp_pixel_fetcher_destroy (pft);
gimp_preview_draw_buffer (preview, dest, width * bpp);
g_free (dest);
}
void
colormap_actions_update (GimpActionGroup *group,
gpointer data)
{
GimpImage *image = action_data_get_image (data);
GimpContext *context = action_data_get_context (data);
gboolean indexed = FALSE;
gint num_colors = 0;
GimpRGB fg;
GimpRGB bg;
if (image)
{
indexed = (gimp_image_get_base_type (image) == GIMP_INDEXED);
num_colors = gimp_image_get_colormap_size (image);
}
if (context)
{
gimp_context_get_foreground (context, &fg);
gimp_context_get_background (context, &bg);
}
#define SET_SENSITIVE(action,condition) \
gimp_action_group_set_action_sensitive (group, action, (condition) != 0)
#define SET_COLOR(action,color) \
gimp_action_group_set_action_color (group, action, color, FALSE);
SET_SENSITIVE ("colormap-edit-color",
image && indexed && num_colors > 0);
SET_SENSITIVE ("colormap-add-color-from-fg",
image && indexed && num_colors < 256);
SET_SENSITIVE ("colormap-add-color-from-bg",
image && indexed && num_colors < 256);
SET_COLOR ("colormap-add-color-from-fg", context ? &fg : NULL);
SET_COLOR ("colormap-add-color-from-bg", context ? &bg : NULL);
#undef SET_SENSITIVE
#undef SET_COLOR
}
void
palette_editor_new_color_cmd_callback (GtkAction *action,
gint value,
gpointer data)
{
GimpPaletteEditor *editor = GIMP_PALETTE_EDITOR (data);
GimpDataEditor *data_editor = GIMP_DATA_EDITOR (data);
if (data_editor->data_editable)
{
GimpPalette *palette = GIMP_PALETTE (data_editor->data);
GimpRGB color;
if (value)
gimp_context_get_background (data_editor->context, &color);
else
gimp_context_get_foreground (data_editor->context, &color);
editor->color = gimp_palette_add_entry (palette, -1, NULL, &color);
}
}
static void
polarize (GimpDrawable *drawable)
{
GimpRgnIterator *iter;
GimpPixelFetcher *pft;
GimpRGB background;
pft = gimp_pixel_fetcher_new (drawable, FALSE);
gimp_context_get_background (&background);
gimp_rgb_set_alpha (&background, 0.0);
gimp_pixel_fetcher_set_bg_color (pft, &background);
gimp_pixel_fetcher_set_edge_mode (pft, GIMP_PIXEL_FETCHER_EDGE_SMEAR);
gimp_progress_init (_("Polar coordinates"));
iter = gimp_rgn_iterator_new (drawable, 0);
gimp_rgn_iterator_dest (iter, polarize_func, pft);
gimp_rgn_iterator_free (iter);
gimp_pixel_fetcher_destroy (pft);
}
void
get_colors (GimpDrawable *drawable,
guint8 *fg,
guint8 *bg)
{
GimpRGB foreground;
GimpRGB background;
gimp_context_get_foreground (&foreground);
gimp_context_get_background (&background);
fg[0] = fg[1] = fg[2] = fg[3] = 255;
bg[0] = bg[1] = bg[2] = bg[3] = 255;
switch (gimp_drawable_type (drawable->drawable_id))
{
case GIMP_RGB_IMAGE:
case GIMP_RGBA_IMAGE:
gimp_rgb_get_uchar (&foreground, &fg[0], &fg[1], &fg[2]);
gimp_rgb_get_uchar (&background, &bg[0], &bg[1], &bg[2]);
break;
case GIMP_GRAYA_IMAGE:
case GIMP_GRAY_IMAGE:
fg[0] = gimp_rgb_luminance_uchar (&foreground);
bg[0] = gimp_rgb_luminance_uchar (&background);
break;
case GIMP_INDEXEDA_IMAGE:
case GIMP_INDEXED_IMAGE: /* FIXME: Should use current fg/bg colors. */
g_warning("maze: get_colors: Indexed image. Using colors 15 and 0.\n");
fg[0] = 15; /* As a plugin, I protest. *I* shouldn't be the */
bg[0] = 0; /* one who has to deal with this colormapcrap. */
break;
default:
break;
}
}
void
colormap_add_color_cmd_callback (GtkAction *action,
gint value,
gpointer data)
{
GimpContext *context;
GimpImage *image;
return_if_no_context (context, data);
return_if_no_image (image, data);
if (gimp_image_get_colormap_size (image) < 256)
{
GimpRGB color;
if (value)
gimp_context_get_background (context, &color);
else
gimp_context_get_foreground (context, &color);
gimp_image_add_colormap_entry (image, &color);
gimp_image_flush (image);
}
}
static void
lens_distort (GimpDrawable *drawable)
{
GimpRgnIterator *iter;
GimpPixelFetcher *pft;
GimpRGB background;
lens_setup_calc (drawable->width, drawable->height);
pft = gimp_pixel_fetcher_new (drawable, FALSE);
gimp_context_get_background (&background);
gimp_rgb_set_alpha (&background, 0.0);
gimp_pixel_fetcher_set_bg_color (pft, &background);
gimp_pixel_fetcher_set_edge_mode (pft, GIMP_PIXEL_FETCHER_EDGE_BACKGROUND);
gimp_progress_init (_("Lens distortion"));
iter = gimp_rgn_iterator_new (drawable, 0);
gimp_rgn_iterator_dest (iter, (GimpRgnFuncDest) lens_distort_func, pft);
gimp_rgn_iterator_free (iter);
gimp_pixel_fetcher_destroy (pft);
}
static void
mblur_radial (GimpDrawable *drawable,
GimpPreview *preview,
gint x1,
gint y1,
gint width,
gint height)
{
GimpPixelRgn dest_rgn;
GimpPixelFetcher *pft;
gpointer pr;
GimpRGB background;
gdouble center_x;
gdouble center_y;
guchar *dest;
guchar *d;
guchar pixel[4];
guchar p1[4], p2[4], p3[4], p4[4];
gint32 sum[4];
gint progress, max_progress, c;
gint x, y, i, p, n, count;
gdouble angle, theta, r, xx, yy, xr, yr;
gdouble phi, phi_start, s_val, c_val;
gdouble dx, dy;
/* initialize */
xx = 0.0;
yy = 0.0;
center_x = mbvals.center_x;
center_y = mbvals.center_y;
gimp_pixel_rgn_init (&dest_rgn, drawable,
x1, y1, width, height, (preview == NULL), TRUE);
pft = gimp_pixel_fetcher_new (drawable, FALSE);
gimp_context_get_background (&background);
gimp_pixel_fetcher_set_bg_color (pft, &background);
progress = 0;
max_progress = width * height;
angle = gimp_deg_to_rad (mbvals.angle);
for (pr = gimp_pixel_rgns_register (1, &dest_rgn), p = 0;
pr != NULL;
pr = gimp_pixel_rgns_process (pr), p++)
{
dest = dest_rgn.data;
for (y = dest_rgn.y; y < dest_rgn.y + dest_rgn.h; y++)
{
d = dest;
for (x = dest_rgn.x; x < dest_rgn.x + dest_rgn.w; x++)
{
xr = (gdouble) x - center_x;
yr = (gdouble) y - center_y;
r = sqrt (SQR (xr) + SQR (yr));
n = r * angle;
if (angle == 0.0)
{
gimp_pixel_fetcher_get_pixel (pft, x, y, d);
d += dest_rgn.bpp;
continue;
}
/* ensure quality with small angles */
if (n < 3)
n = 3; /* always use at least 3 (interpolation) steps */
/* limit loop count due to performanc reasons */
if (n > 100)
n = 100 + sqrt (n-100);
if (xr != 0.0)
{
phi = atan(yr/xr);
if (xr < 0.0)
phi = G_PI + phi;
}
else
{
if (yr >= 0.0)
phi = G_PI_2;
else
phi = -G_PI_2;
}
for (c = 0; c < img_bpp; c++)
sum[c] = 0;
if (n == 1)
phi_start = phi;
else
phi_start = phi + angle/2.0;
theta = angle / (gdouble)n;
count = 0;
for (i = 0; i < n; i++)
{
s_val = sin (phi_start - (gdouble) i * theta);
c_val = cos (phi_start - (gdouble) i * theta);
xx = center_x + r * c_val;
yy = center_y + r * s_val;
if ((yy < y1) || (yy >= y1 + height) ||
(xx < x1) || (xx >= x1 + width))
continue;
++count;
if ((xx + 1 < x1 + width) && (yy + 1 < y1 + height))
{
dx = xx - floor (xx);
dy = yy - floor (yy);
gimp_pixel_fetcher_get_pixel (pft, xx, yy, p1);
gimp_pixel_fetcher_get_pixel (pft, xx+1, yy, p2);
gimp_pixel_fetcher_get_pixel (pft, xx, yy+1, p3);
gimp_pixel_fetcher_get_pixel (pft, xx+1, yy+1, p4);
for (c = 0; c < img_bpp; c++)
{
pixel[c] = (((gdouble) p1[c] * (1.0-dx) +
(gdouble) p2[c] * dx) * (1.0-dy) +
((gdouble) p3[c] * (1.0-dx) +
(gdouble) p4[c] * dx) * dy);
}
}
else
{
gimp_pixel_fetcher_get_pixel (pft, xx+.5, yy+.5, pixel);
}
if (has_alpha)
{
gint32 alpha = pixel[img_bpp-1];
sum[img_bpp-1] += alpha;
for (c = 0; c < img_bpp-1; c++)
sum[c] += pixel[c] * alpha;
}
else
{
for (c = 0; c < img_bpp; c++)
sum[c] += pixel[c];
}
}
if (count == 0)
{
gimp_pixel_fetcher_get_pixel (pft, xx, yy, d);
}
else
{
if (has_alpha)
{
gint32 alpha = sum[img_bpp-1];
if ((d[img_bpp-1] = alpha/count) != 0)
{
for (c = 0; c < img_bpp-1; c++)
d[c] = sum[c] / alpha;
}
}
else
{
for (c = 0; c < img_bpp; c++)
d[c] = sum[c] / count;
}
}
d += dest_rgn.bpp;
}
dest += dest_rgn.rowstride;
}
if (preview)
{
gimp_drawable_preview_draw_region (GIMP_DRAWABLE_PREVIEW (preview),
&dest_rgn);
}
else
{
progress += dest_rgn.w * dest_rgn.h;
if ((p % 8) == 0)
gimp_progress_update ((gdouble) progress / max_progress);
}
}
gimp_pixel_fetcher_destroy (pft);
}
static void
mblur_linear (GimpDrawable *drawable,
GimpPreview *preview,
gint x1,
gint y1,
gint width,
gint height)
{
GimpPixelRgn dest_rgn;
GimpPixelFetcher *pft;
gpointer pr;
GimpRGB background;
guchar *dest;
guchar *d;
guchar pixel[4];
gint32 sum[4];
gint progress, max_progress;
gint c, p;
gint x, y, i, xx, yy, n;
gint dx, dy, px, py, swapdir, err, e, s1, s2;
gimp_pixel_rgn_init (&dest_rgn, drawable,
x1, y1, width, height, (preview == NULL), TRUE);
pft = gimp_pixel_fetcher_new (drawable, FALSE);
gimp_context_get_background (&background);
gimp_pixel_fetcher_set_bg_color (pft, &background);
progress = 0;
max_progress = width * height;
n = mbvals.length;
px = (gdouble) n * cos (mbvals.angle / 180.0 * G_PI);
py = (gdouble) n * sin (mbvals.angle / 180.0 * G_PI);
/*
* Initialization for Bresenham algorithm:
* dx = abs(x2-x1), s1 = sign(x2-x1)
* dy = abs(y2-y1), s2 = sign(y2-y1)
*/
if ((dx = px) != 0)
{
if (dx < 0)
{
dx = -dx;
s1 = -1;
}
else
s1 = 1;
}
else
s1 = 0;
if ((dy = py) != 0)
{
if (dy < 0)
{
dy = -dy;
s2 = -1;
}
else
s2 = 1;
}
else
s2 = 0;
if (dy > dx)
{
swapdir = dx;
dx = dy;
dy = swapdir;
swapdir = 1;
}
else
swapdir = 0;
dy *= 2;
err = dy - dx; /* Initial error term */
dx *= 2;
for (pr = gimp_pixel_rgns_register (1, &dest_rgn), p = 0;
pr != NULL;
pr = gimp_pixel_rgns_process (pr), p++)
{
dest = dest_rgn.data;
for (y = dest_rgn.y; y < dest_rgn.y + dest_rgn.h; y++)
{
d = dest;
for (x = dest_rgn.x; x < dest_rgn.x + dest_rgn.w; x++)
{
xx = x; yy = y; e = err;
for (c = 0; c < img_bpp; c++)
sum[c]= 0;
for (i = 0; i < n; )
{
gimp_pixel_fetcher_get_pixel (pft, xx, yy, pixel);
if (has_alpha)
{
gint32 alpha = pixel[img_bpp-1];
sum[img_bpp-1] += alpha;
for (c = 0; c < img_bpp-1; c++)
sum[c] += pixel[c] * alpha;
}
else
{
for (c = 0; c < img_bpp; c++)
sum[c] += pixel[c];
}
i++;
while (e >= 0 && dx)
{
if (swapdir)
xx += s1;
else
yy += s2;
e -= dx;
}
if (swapdir)
yy += s2;
else
xx += s1;
e += dy;
if ((xx < x1) || (xx >= x1 + width) ||
(yy < y1) || (yy >= y1 + height))
break;
}
if (i == 0)
{
gimp_pixel_fetcher_get_pixel (pft, xx, yy, d);
}
else
{
if (has_alpha)
{
gint32 alpha = sum[img_bpp-1];
if ((d[img_bpp-1] = alpha/i) != 0)
{
for (c = 0; c < img_bpp-1; c++)
d[c] = sum[c] / alpha;
}
}
else
{
for (c = 0; c < img_bpp; c++)
d[c] = sum[c] / i;
}
}
d += dest_rgn.bpp;
}
dest += dest_rgn.rowstride;
}
if (preview)
{
gimp_drawable_preview_draw_region (GIMP_DRAWABLE_PREVIEW (preview),
&dest_rgn);
}
else
{
progress += dest_rgn.w * dest_rgn.h;
if ((p % 8) == 0)
gimp_progress_update ((gdouble) progress / max_progress);
}
}
gimp_pixel_fetcher_destroy (pft);
}
static void
prepare_coef (params *p)
{
GimpRGB color1;
GimpRGB color2;
gdouble scalex = svals.scalex;
gdouble scaley = svals.scaley;
GRand *gr;
gr = g_rand_new ();
g_rand_set_seed (gr, svals.seed);
switch (svals.colorization)
{
case BILINEAR:
p->blend = bilinear;
break;
case SINUS:
p->blend = cosinus;
break;
case LINEAR:
default:
p->blend = linear;
}
if (svals.perturbation==IDEAL)
{
/* Presumably the 0 * g_rand_int ()s are to pop random
* values off the prng, I don't see why though. */
p->c11= 0 * g_rand_int (gr);
p->c12= g_rand_double_range (gr, -1, 1) * scaley;
p->c13= g_rand_double_range (gr, 0, 2 * G_PI);
p->c21= 0 * g_rand_int (gr);
p->c22= g_rand_double_range (gr, -1, 1) * scaley;
p->c23= g_rand_double_range (gr, 0, 2 * G_PI);
p->c31= g_rand_double_range (gr, -1, 1) * scalex;
p->c32= 0 * g_rand_int (gr);
p->c33= g_rand_double_range (gr, 0, 2 * G_PI);
}
else
{
p->c11= g_rand_double_range (gr, -1, 1) * scalex;
p->c12= g_rand_double_range (gr, -1, 1) * scaley;
p->c13= g_rand_double_range (gr, 0, 2 * G_PI);
p->c21= g_rand_double_range (gr, -1, 1) * scalex;
p->c22= g_rand_double_range (gr, -1, 1) * scaley;
p->c23= g_rand_double_range (gr, 0, 2 * G_PI);
p->c31= g_rand_double_range (gr, -1, 1) * scalex;
p->c32= g_rand_double_range (gr, -1, 1) * scaley;
p->c33= g_rand_double_range (gr, 0, 2 * G_PI);
}
if (svals.tiling)
{
p->c11= ROUND (p->c11/(2*G_PI))*2*G_PI;
p->c12= ROUND (p->c12/(2*G_PI))*2*G_PI;
p->c21= ROUND (p->c21/(2*G_PI))*2*G_PI;
p->c22= ROUND (p->c22/(2*G_PI))*2*G_PI;
p->c31= ROUND (p->c31/(2*G_PI))*2*G_PI;
p->c32= ROUND (p->c32/(2*G_PI))*2*G_PI;
}
color1 = svals.col1;
color2 = svals.col2;
if (drawable_is_grayscale)
{
gimp_rgb_set (&color1, 1.0, 1.0, 1.0);
gimp_rgb_set (&color2, 0.0, 0.0, 0.0);
}
else
{
switch (svals.colors)
{
case USE_COLORS:
break;
case B_W:
gimp_rgb_set (&color1, 1.0, 1.0, 1.0);
gimp_rgb_set (&color2, 0.0, 0.0, 0.0);
break;
case USE_FG_BG:
gimp_context_get_background (&color1);
gimp_context_get_foreground (&color2);
break;
}
}
gimp_rgba_get_uchar (&color1, &p->r, &p->g, &p->b, &p->a);
gimp_rgba_subtract (&color2, &color1);
p->dr = color2.r * 255.0;
p->dg = color2.g * 255.0;
p->db = color2.b * 255.0;
p->da = color2.a * 255.0;
g_rand_free (gr);
}
static gboolean apply_resize(resize_settings settings, image_output out)
{
gboolean success = FALSE;
gint orig_w, orig_h, final_w, final_h, view_w, view_h;
gdouble orig_res_x, orig_res_y;
if (settings->change_res) {
success = gimp_image_get_resolution(
out->image_id,
&orig_res_x,
&orig_res_y
);
if ((settings->new_res_x != orig_res_x) || (settings->new_res_y != orig_res_y)) {
// change resolution
success = gimp_image_set_resolution(
out->image_id,
settings->new_res_x,
settings->new_res_y
);
}
}
orig_w = gimp_image_width(out->image_id);
orig_h = gimp_image_height(out->image_id);
if (settings->resize_mode == RESIZE_PERCENT) {
if (settings->stretch_mode == STRETCH_ASPECT) {
gdouble newpct = min(settings->new_w_pc, settings->new_h_pc);
final_w = view_w = round((orig_w * newpct) / 100.0);
final_h = view_h = round((orig_h * newpct) / 100.0);
}
else if (settings->stretch_mode == STRETCH_PADDED) {
gdouble newpct = min(settings->new_w_pc, settings->new_h_pc);
final_w = round((orig_w * newpct) / 100.0);
final_h = round((orig_h * newpct) / 100.0);
view_w = round((orig_w * settings->new_w_pc) / 100.0);
view_h = round((orig_h * settings->new_h_pc) / 100.0);
}
else {
final_w = view_w = round((orig_w * settings->new_w_pc) / 100.0);
final_h = view_h = round((orig_h * settings->new_h_pc) / 100.0);
}
}
else {
// user typed exact pixel size
if (settings->resize_mode == RESIZE_PIXEL_WIDTH) {
view_w = settings->new_w_px; // width is fixed
if (settings->stretch_mode == STRETCH_ASPECT) {
final_w = view_w;
final_h = view_h = round(((float)final_w * orig_h) / orig_w);
}
else if (settings->stretch_mode == STRETCH_PADDED) {
final_w = min(view_w, orig_w);
final_h = round(((float)final_w * orig_h) / orig_w);
view_h = max(orig_h, final_h);
}
else {
final_w = view_w;
final_h = view_h = orig_h;
}
}
else if (settings->resize_mode == RESIZE_PIXEL_HEIGHT) {
view_h = settings->new_h_px; // height is fixed
if (settings->stretch_mode == STRETCH_ASPECT) {
final_h = view_h;
final_w = view_w = round(((float)final_h * orig_w) / orig_h);
}
else if (settings->stretch_mode == STRETCH_PADDED) {
final_h = min(view_h, orig_h);
final_w = round(((float)final_h * orig_w) / orig_h);
view_w = max(orig_w, final_w);
}
else {
final_h = view_h;
final_w = view_w = orig_w;
}
}
else {
// both dimensions are defined
if (settings->stretch_mode == STRETCH_ASPECT) {
// Find which new dimension is the smallest percentage of the existing image dimension
gdouble newwpct = (float)settings->new_w_px / (float)orig_w;
gdouble newhpct = (float)settings->new_h_px / (float)orig_h;
gdouble newpct = min(newwpct, newhpct);
final_w = view_w = round(orig_w * newpct);
final_h = view_h = round(orig_h * newpct);
}
else if (settings->stretch_mode == STRETCH_PADDED) {
// Find which new dimension is the smallest percentage of the existing image dimension
gdouble newwpct = (float)settings->new_w_px / (float)orig_w;
gdouble newhpct = (float)settings->new_h_px / (float)orig_h;
gdouble newpct = min(newwpct, newhpct);
final_w = round(orig_w * newpct);
final_h = round(orig_h * newpct);
view_w = round(orig_w * newwpct);
view_h = round(orig_h * newhpct);
}
else {
final_w = view_w = settings->new_w_px;
final_h = view_h = settings->new_h_px;
}
}
}
// do resize
#if USE_API26
success = gimp_image_scale_full (
out->image_id,
final_w,
final_h,
settings->interpolation
);
#else
// starting from 2.8, gimp_image_scale_full is deprecated.
// use gimp_image_scale instead
GimpInterpolationType old_interpolation;
old_interpolation = gimp_context_get_interpolation();
success = gimp_context_set_interpolation (settings->interpolation);
success = gimp_image_scale (
out->image_id,
final_w,
final_h
);
success = gimp_context_set_interpolation (old_interpolation);
#endif
// add a padding if requested
if (settings->stretch_mode == STRETCH_PADDED) {
// the padding will be drawn using a coloured layer at the bottom of the image
gint32 layerId = gimp_layer_new(
out->image_id,
"padding_layer",
view_w, view_h,
GIMP_RGBA_IMAGE,
(settings->padding_color_alpha / (float)G_MAXUINT16) * 100,
GIMP_NORMAL_MODE
);
#if USE_API26
gimp_image_add_layer (
out->image_id,
layerId,
0
);
gimp_image_lower_layer_to_bottom(out->image_id, layerId);
#else
gimp_image_insert_layer(
out->image_id,
layerId,
0,
0
);
gimp_image_lower_item_to_bottom(out->image_id, layerId);
#endif
// fill it with the selected color
GimpRGB old_background, new_background;
gimp_context_get_background(&old_background);
gimp_rgb_parse_hex (&new_background, gdk_color_to_string(&(settings->padding_color)), strlen(gdk_color_to_string(&(settings->padding_color))));
gimp_context_set_background(&new_background);
gimp_drawable_fill(layerId, GIMP_BACKGROUND_FILL);
gimp_context_set_background(&old_background);
// move it to the center
gimp_layer_translate(layerId, -abs(view_w - final_w) / 2, -abs(view_h - final_h) / 2);
// finish changing the canvas size accordingly
success = gimp_image_resize_to_layers(out->image_id);
}
return success;
}
static void
gimp_operation_tool_sync_op (GimpOperationTool *op_tool,
GimpDrawable *drawable)
{
GimpImageMapTool *im_tool = GIMP_IMAGE_MAP_TOOL (op_tool);
GimpToolOptions *options = GIMP_TOOL_GET_OPTIONS (op_tool);
GParamSpec **pspecs;
guint n_pspecs;
gint bounds_x;
gint bounds_y;
gint bounds_width;
gint bounds_height;
gint i;
gimp_item_mask_intersect (GIMP_ITEM (drawable),
&bounds_x, &bounds_y,
&bounds_width, &bounds_height);
pspecs = g_object_class_list_properties (G_OBJECT_GET_CLASS (im_tool->config),
&n_pspecs);
for (i = 0; i < n_pspecs; i++)
{
GParamSpec *pspec = pspecs[i];
#define HAS_KEY(p,k,v) gimp_gegl_param_spec_has_key (p, k, v)
if (HAS_KEY (pspec, "role", "output-extent"))
{
if (HAS_KEY (pspec, "unit", "pixel-coordinate") &&
HAS_KEY (pspec, "axis", "x"))
{
g_object_set (im_tool->config, pspec->name, 0, NULL);
}
else if (HAS_KEY (pspec, "unit", "pixel-coordinate") &&
HAS_KEY (pspec, "axis", "y"))
{
g_object_set (im_tool->config, pspec->name, 0, NULL);
}
else if (HAS_KEY (pspec, "unit", "pixel-distance") &&
HAS_KEY (pspec, "axis", "x"))
{
g_object_set (im_tool->config, pspec->name, bounds_width, NULL);
}
else if (HAS_KEY (pspec, "unit", "pixel-distance") &&
HAS_KEY (pspec, "axis", "y"))
{
g_object_set (im_tool->config, pspec->name, bounds_height, NULL);
}
}
else if (HAS_KEY (pspec, "role", "color-primary"))
{
GimpRGB color;
gimp_context_get_foreground (GIMP_CONTEXT (options), &color);
g_object_set (im_tool->config, pspec->name, &color, NULL);
}
else if (HAS_KEY (pspec, "role", "color-secondary"))
{
GimpRGB color;
gimp_context_get_background (GIMP_CONTEXT (options), &color);
g_object_set (im_tool->config, pspec->name, &color, NULL);
}
}
g_free (pspecs);
}
GeglBuffer *
gimp_drawable_transform_buffer_rotate (GimpDrawable *drawable,
GimpContext *context,
GeglBuffer *orig_buffer,
gint orig_offset_x,
gint orig_offset_y,
GimpRotationType rotate_type,
gdouble center_x,
gdouble center_y,
gboolean clip_result,
gint *new_offset_x,
gint *new_offset_y)
{
GeglBuffer *new_buffer;
GeglRectangle src_rect;
GeglRectangle dest_rect;
gint orig_x, orig_y;
gint orig_width, orig_height;
gint orig_bpp;
gint new_x, new_y;
gint new_width, new_height;
g_return_val_if_fail (GIMP_IS_DRAWABLE (drawable), NULL);
g_return_val_if_fail (gimp_item_is_attached (GIMP_ITEM (drawable)), NULL);
g_return_val_if_fail (GIMP_IS_CONTEXT (context), NULL);
g_return_val_if_fail (GEGL_IS_BUFFER (orig_buffer), NULL);
orig_x = orig_offset_x;
orig_y = orig_offset_y;
orig_width = gegl_buffer_get_width (orig_buffer);
orig_height = gegl_buffer_get_height (orig_buffer);
orig_bpp = babl_format_get_bytes_per_pixel (gegl_buffer_get_format (orig_buffer));
switch (rotate_type)
{
case GIMP_ROTATE_90:
gimp_drawable_transform_rotate_point (orig_x,
orig_y + orig_height,
rotate_type, center_x, center_y,
&new_x, &new_y);
new_width = orig_height;
new_height = orig_width;
break;
case GIMP_ROTATE_180:
gimp_drawable_transform_rotate_point (orig_x + orig_width,
orig_y + orig_height,
rotate_type, center_x, center_y,
&new_x, &new_y);
new_width = orig_width;
new_height = orig_height;
break;
case GIMP_ROTATE_270:
gimp_drawable_transform_rotate_point (orig_x + orig_width,
orig_y,
rotate_type, center_x, center_y,
&new_x, &new_y);
new_width = orig_height;
new_height = orig_width;
break;
default:
g_return_val_if_reached (NULL);
break;
}
if (clip_result && (new_x != orig_x || new_y != orig_y ||
new_width != orig_width || new_height != orig_height))
{
GimpRGB bg;
GeglColor *color;
gint clip_x, clip_y;
gint clip_width, clip_height;
new_buffer = gimp_gegl_buffer_new (GEGL_RECTANGLE (0, 0,
orig_width, orig_height),
gegl_buffer_get_format (orig_buffer));
*new_offset_x = orig_x;
*new_offset_y = orig_y;
/* "Outside" a channel is transparency, not the bg color */
if (GIMP_IS_CHANNEL (drawable))
gimp_rgba_set (&bg, 0.0, 0.0, 0.0, 0.0);
else
gimp_context_get_background (context, &bg);
color = gimp_gegl_color_new (&bg);
gegl_buffer_set_color (new_buffer, NULL, color);
g_object_unref (color);
if (gimp_rectangle_intersect (orig_x, orig_y, orig_width, orig_height,
new_x, new_y, new_width, new_height,
&clip_x, &clip_y,
&clip_width, &clip_height))
{
gint saved_orig_x = orig_x;
gint saved_orig_y = orig_y;
new_x = clip_x - orig_x;
new_y = clip_y - orig_y;
switch (rotate_type)
{
case GIMP_ROTATE_90:
gimp_drawable_transform_rotate_point (clip_x + clip_width,
clip_y,
GIMP_ROTATE_270,
center_x,
center_y,
&orig_x,
&orig_y);
orig_x -= saved_orig_x;
orig_y -= saved_orig_y;
orig_width = clip_height;
orig_height = clip_width;
break;
case GIMP_ROTATE_180:
orig_x = clip_x - orig_x;
orig_y = clip_y - orig_y;
orig_width = clip_width;
orig_height = clip_height;
break;
case GIMP_ROTATE_270:
gimp_drawable_transform_rotate_point (clip_x,
clip_y + clip_height,
GIMP_ROTATE_90,
center_x,
center_y,
&orig_x,
&orig_y);
orig_x -= saved_orig_x;
orig_y -= saved_orig_y;
orig_width = clip_height;
orig_height = clip_width;
break;
}
new_width = clip_width;
new_height = clip_height;
}
else
{
new_width = 0;
new_height = 0;
}
}
else
{
new_buffer = gimp_gegl_buffer_new (GEGL_RECTANGLE (0, 0,
new_width, new_height),
gegl_buffer_get_format (orig_buffer));
*new_offset_x = new_x;
*new_offset_y = new_y;
orig_x = 0;
orig_y = 0;
new_x = 0;
new_y = 0;
}
if (new_width < 1 || new_height < 1)
return new_buffer;
src_rect.x = orig_x;
src_rect.y = orig_y;
src_rect.width = orig_width;
src_rect.height = orig_height;
dest_rect.x = new_x;
dest_rect.y = new_y;
dest_rect.width = new_width;
dest_rect.height = new_height;
switch (rotate_type)
{
case GIMP_ROTATE_90:
{
guchar *buf = g_new (guchar, new_height * orig_bpp);
gint i;
g_assert (new_height == orig_width);
src_rect.y = orig_y + orig_height - 1;
src_rect.height = 1;
dest_rect.x = new_x;
dest_rect.width = 1;
for (i = 0; i < orig_height; i++)
{
src_rect.y = orig_y + orig_height - 1 - i;
dest_rect.x = new_x + i;
gegl_buffer_get (orig_buffer, &src_rect, 1.0, NULL, buf,
GEGL_AUTO_ROWSTRIDE, GEGL_ABYSS_NONE);
gegl_buffer_set (new_buffer, &dest_rect, 0, NULL, buf,
GEGL_AUTO_ROWSTRIDE);
}
g_free (buf);
}
break;
case GIMP_ROTATE_180:
{
guchar *buf = g_new (guchar, new_width * orig_bpp);
gint i, j, k;
g_assert (new_width == orig_width);
src_rect.y = orig_y + orig_height - 1;
src_rect.height = 1;
dest_rect.y = new_y;
dest_rect.height = 1;
for (i = 0; i < orig_height; i++)
{
src_rect.y = orig_y + orig_height - 1 - i;
dest_rect.y = new_y + i;
gegl_buffer_get (orig_buffer, &src_rect, 1.0, NULL, buf,
GEGL_AUTO_ROWSTRIDE, GEGL_ABYSS_NONE);
for (j = 0; j < orig_width / 2; j++)
{
guchar *left = buf + j * orig_bpp;
guchar *right = buf + (orig_width - 1 - j) * orig_bpp;
for (k = 0; k < orig_bpp; k++)
{
guchar tmp = left[k];
left[k] = right[k];
right[k] = tmp;
}
}
gegl_buffer_set (new_buffer, &dest_rect, 0, NULL, buf,
GEGL_AUTO_ROWSTRIDE);
}
g_free (buf);
}
break;
case GIMP_ROTATE_270:
{
guchar *buf = g_new (guchar, new_width * orig_bpp);
gint i;
g_assert (new_width == orig_height);
src_rect.x = orig_x + orig_width - 1;
src_rect.width = 1;
dest_rect.y = new_y;
dest_rect.height = 1;
for (i = 0; i < orig_width; i++)
{
src_rect.x = orig_x + orig_width - 1 - i;
dest_rect.y = new_y + i;
gegl_buffer_get (orig_buffer, &src_rect, 1.0, NULL, buf,
GEGL_AUTO_ROWSTRIDE, GEGL_ABYSS_NONE);
gegl_buffer_set (new_buffer, &dest_rect, 0, NULL, buf,
GEGL_AUTO_ROWSTRIDE);
}
g_free (buf);
}
break;
}
return new_buffer;
}
GeglBuffer *
gimp_drawable_transform_buffer_flip (GimpDrawable *drawable,
GimpContext *context,
GeglBuffer *orig_buffer,
gint orig_offset_x,
gint orig_offset_y,
GimpOrientationType flip_type,
gdouble axis,
gboolean clip_result,
gint *new_offset_x,
gint *new_offset_y)
{
GeglBuffer *new_buffer;
GeglRectangle src_rect;
GeglRectangle dest_rect;
gint orig_x, orig_y;
gint orig_width, orig_height;
gint new_x, new_y;
gint new_width, new_height;
gint i;
g_return_val_if_fail (GIMP_IS_DRAWABLE (drawable), NULL);
g_return_val_if_fail (gimp_item_is_attached (GIMP_ITEM (drawable)), NULL);
g_return_val_if_fail (GIMP_IS_CONTEXT (context), NULL);
g_return_val_if_fail (GEGL_IS_BUFFER (orig_buffer), NULL);
orig_x = orig_offset_x;
orig_y = orig_offset_y;
orig_width = gegl_buffer_get_width (orig_buffer);
orig_height = gegl_buffer_get_height (orig_buffer);
new_x = orig_x;
new_y = orig_y;
new_width = orig_width;
new_height = orig_height;
switch (flip_type)
{
case GIMP_ORIENTATION_HORIZONTAL:
new_x = RINT (-((gdouble) orig_x +
(gdouble) orig_width - axis) + axis);
break;
case GIMP_ORIENTATION_VERTICAL:
new_y = RINT (-((gdouble) orig_y +
(gdouble) orig_height - axis) + axis);
break;
case GIMP_ORIENTATION_UNKNOWN:
g_return_val_if_reached (NULL);
break;
}
new_buffer = gimp_gegl_buffer_new (GEGL_RECTANGLE (0, 0,
new_width, new_height),
gegl_buffer_get_format (orig_buffer));
if (clip_result && (new_x != orig_x || new_y != orig_y))
{
GimpRGB bg;
GeglColor *color;
gint clip_x, clip_y;
gint clip_width, clip_height;
*new_offset_x = orig_x;
*new_offset_y = orig_y;
/* "Outside" a channel is transparency, not the bg color */
if (GIMP_IS_CHANNEL (drawable))
gimp_rgba_set (&bg, 0.0, 0.0, 0.0, 0.0);
else
gimp_context_get_background (context, &bg);
color = gimp_gegl_color_new (&bg);
gegl_buffer_set_color (new_buffer, NULL, color);
g_object_unref (color);
if (gimp_rectangle_intersect (orig_x, orig_y, orig_width, orig_height,
new_x, new_y, new_width, new_height,
&clip_x, &clip_y,
&clip_width, &clip_height))
{
orig_x = new_x = clip_x - orig_x;
orig_y = new_y = clip_y - orig_y;
}
orig_width = new_width = clip_width;
orig_height = new_height = clip_height;
}
else
{
*new_offset_x = new_x;
*new_offset_y = new_y;
orig_x = 0;
orig_y = 0;
new_x = 0;
new_y = 0;
}
if (new_width == 0 && new_height == 0)
return new_buffer;
switch (flip_type)
{
case GIMP_ORIENTATION_HORIZONTAL:
src_rect.x = orig_x;
src_rect.y = orig_y;
src_rect.width = 1;
src_rect.height = orig_height;
dest_rect.x = new_x + new_width - 1;
dest_rect.y = new_y;
dest_rect.width = 1;
dest_rect.height = new_height;
for (i = 0; i < orig_width; i++)
{
src_rect.x = i + orig_x;
dest_rect.x = new_x + new_width - i - 1;
gegl_buffer_copy (orig_buffer, &src_rect,
new_buffer, &dest_rect);
}
break;
case GIMP_ORIENTATION_VERTICAL:
src_rect.x = orig_x;
src_rect.y = orig_y;
src_rect.width = orig_width;
src_rect.height = 1;
dest_rect.x = new_x;
dest_rect.y = new_y + new_height - 1;
dest_rect.width = new_width;
dest_rect.height = 1;
for (i = 0; i < orig_height; i++)
{
src_rect.y = i + orig_y;
dest_rect.y = new_y + new_height - i - 1;
gegl_buffer_copy (orig_buffer, &src_rect,
new_buffer, &dest_rect);
}
break;
case GIMP_ORIENTATION_UNKNOWN:
break;
}
return new_buffer;
}
static void
dialog_update_preview (GimpDrawable *drawable,
GimpPreview *preview)
{
gdouble cx, cy;
gint x, y;
gint sx, sy;
gint width, height;
guchar *pixel;
guchar outside[4];
GimpRGB background;
guchar *dest;
gint j;
gint bpp;
GimpPixelFetcher *pft;
guchar in_pixels[4][4];
guchar *in_values[4];
for (j = 0; j < 4; j++)
in_values[j] = in_pixels[j];
pft = gimp_pixel_fetcher_new (drawable, FALSE);
gimp_context_get_background (&background);
gimp_rgb_set_alpha (&background, 0.0);
gimp_drawable_get_color_uchar (drawable->drawable_id, &background, outside);
gimp_pixel_fetcher_set_bg_color (pft, &background);
gimp_pixel_fetcher_set_edge_mode (pft, GIMP_PIXEL_FETCHER_EDGE_SMEAR);
dest = gimp_zoom_preview_get_source (GIMP_ZOOM_PREVIEW (preview),
&width, &height, &bpp);
pixel = dest;
for (y = 0; y < height; y++)
{
for (x = 0; x < width; x++)
{
gimp_preview_untransform (preview, x, y, &sx, &sy);
if (calc_undistorted_coords ((gdouble)sx, (gdouble)sy,
&cx, &cy))
{
gimp_pixel_fetcher_get_pixel (pft, cx, cy, in_pixels[0]);
gimp_pixel_fetcher_get_pixel (pft, cx + 1, cy, in_pixels[1]);
gimp_pixel_fetcher_get_pixel (pft, cx, cy + 1, in_pixels[2]);
gimp_pixel_fetcher_get_pixel (pft, cx + 1, cy + 1, in_pixels[3]);
gimp_bilinear_pixels_8 (pixel, cx, cy, bpp,
img_has_alpha, in_values);
}
else
{
for (j = 0; j < bpp; j++)
pixel[j] = outside[j];
}
pixel += bpp;
}
}
gimp_pixel_fetcher_destroy (pft);
gimp_preview_draw_buffer (preview, dest, width * bpp);
g_free (dest);
}
static void
mblur_zoom (GimpDrawable *drawable,
GimpPreview *preview,
gint x1,
gint y1,
gint width,
gint height)
{
GimpPixelRgn dest_rgn;
GimpPixelFetcher *pft;
gpointer pr;
GimpRGB background;
gdouble center_x;
gdouble center_y;
guchar *dest, *d;
guchar pixel[4];
guchar p1[4], p2[4], p3[4], p4[4];
gint32 sum[4];
gint progress, max_progress;
gint x, y, i, n, p, c;
gdouble xx_start, xx_end, yy_start, yy_end;
gdouble xx, yy;
gdouble dxx, dyy;
gdouble dx, dy;
gint xy_len;
gdouble f, r;
gint drawable_x1, drawable_y1;
gint drawable_x2, drawable_y2;
/* initialize */
xx = 0.0;
yy = 0.0;
center_x = mbvals.center_x;
center_y = mbvals.center_y;
gimp_drawable_mask_bounds (drawable->drawable_id,
&drawable_x1, &drawable_y1,
&drawable_x2, &drawable_y2);
gimp_pixel_rgn_init (&dest_rgn, drawable,
x1, y1, width, height, (preview == NULL), TRUE);
pft = gimp_pixel_fetcher_new (drawable, FALSE);
gimp_context_get_background (&background);
gimp_pixel_fetcher_set_bg_color (pft, &background);
progress = 0;
max_progress = width * height;
n = mbvals.length;
if (n == 0)
n = 1;
r = sqrt (SQR (drawable->width / 2) + SQR (drawable->height / 2));
n = ((gdouble) n * r / MBLUR_LENGTH_MAX);
f = (r-n)/r;
for (pr = gimp_pixel_rgns_register (1, &dest_rgn), p = 0;
pr != NULL;
pr = gimp_pixel_rgns_process (pr), p++)
{
dest = dest_rgn.data;
for (y = dest_rgn.y; y < dest_rgn.y + dest_rgn.h; y++)
{
d = dest;
for (x = dest_rgn.x; x < dest_rgn.x + dest_rgn.w; x++)
{
for (c = 0; c < img_bpp; c++)
sum[c] = 0;
xx_start = x;
yy_start = y;
if (mbvals.blur_outward)
{
xx_end = center_x + ((gdouble) x - center_x) * f;
yy_end = center_y + ((gdouble) y - center_y) * f;
}
else
{
xx_end = center_x + ((gdouble) x - center_x) * (1.0/f);
yy_end = center_y + ((gdouble) y - center_y) * (1.0/f);
}
xy_len = sqrt (SQR (xx_end-xx_start) + SQR (yy_end-yy_start)) + 1;
if (xy_len < 3)
xy_len = 3;
dxx = (xx_end - xx_start) / (gdouble) xy_len;
dyy = (yy_end - yy_start) / (gdouble) xy_len;
xx = xx_start;
yy = yy_start;
for (i = 0; i < xy_len; i++)
{
if ((yy < drawable_y1) || (yy >= drawable_y2) ||
(xx < drawable_x1) || (xx >= drawable_x2))
break;
if ((xx+1 < drawable_x2) && (yy+1 < drawable_y2))
{
dx = xx - floor (xx);
dy = yy - floor (yy);
gimp_pixel_fetcher_get_pixel (pft, xx, yy, p1);
gimp_pixel_fetcher_get_pixel (pft, xx+1, yy, p2);
gimp_pixel_fetcher_get_pixel (pft, xx, yy+1, p3);
gimp_pixel_fetcher_get_pixel (pft, xx+1, yy+1, p4);
for (c = 0; c < img_bpp; c++)
{
pixel[c] = (((gdouble)p1[c] * (1.0-dx) +
(gdouble)p2[c] * dx) * (1.0-dy) +
((gdouble)p3[c] * (1.0-dx) +
(gdouble)p4[c] * dx) * dy);
}
}
else
{
gimp_pixel_fetcher_get_pixel (pft, xx+.5, yy+.5, pixel);
}
if (has_alpha)
{
gint32 alpha = pixel[img_bpp-1];
sum[img_bpp-1] += alpha;
for (c = 0; c < img_bpp-1; c++)
sum[c] += pixel[c] * alpha;
}
else
{
for (c = 0; c < img_bpp; c++)
sum[c] += pixel[c];
}
xx += dxx;
yy += dyy;
}
if (i == 0)
{
gimp_pixel_fetcher_get_pixel (pft, xx, yy, d);
}
else
{
if (has_alpha)
{
gint32 alpha = sum[img_bpp-1];
if ((d[img_bpp-1] = alpha/i) != 0)
{
for (c = 0; c < img_bpp-1; c++)
d[c] = sum[c] / alpha;
}
}
else
{
for (c = 0; c < img_bpp; c++)
d[c] = sum[c] / i;
}
}
d += dest_rgn.bpp;
}
dest += dest_rgn.rowstride;
}
if (preview)
{
gimp_drawable_preview_draw_region (GIMP_DRAWABLE_PREVIEW (preview),
&dest_rgn);
}
else
{
progress += dest_rgn.w * dest_rgn.h;
if ((p % 8) == 0)
gimp_progress_update ((gdouble) progress / max_progress);
}
}
gimp_pixel_fetcher_destroy (pft);
}
GeglBuffer *
gimp_drawable_transform_buffer_rotate (GimpDrawable *drawable,
GimpContext *context,
GeglBuffer *orig_buffer,
gint orig_offset_x,
gint orig_offset_y,
GimpRotationType rotate_type,
gdouble center_x,
gdouble center_y,
gboolean clip_result,
GimpColorProfile **buffer_profile,
gint *new_offset_x,
gint *new_offset_y)
{
const Babl *format;
GeglBuffer *new_buffer;
GeglRectangle src_rect;
GeglRectangle dest_rect;
gint orig_x, orig_y;
gint orig_width, orig_height;
gint orig_bpp;
gint new_x, new_y;
gint new_width, new_height;
g_return_val_if_fail (GIMP_IS_DRAWABLE (drawable), NULL);
g_return_val_if_fail (gimp_item_is_attached (GIMP_ITEM (drawable)), NULL);
g_return_val_if_fail (GIMP_IS_CONTEXT (context), NULL);
g_return_val_if_fail (GEGL_IS_BUFFER (orig_buffer), NULL);
g_return_val_if_fail (buffer_profile != NULL, NULL);
g_return_val_if_fail (new_offset_x != NULL, NULL);
g_return_val_if_fail (new_offset_y != NULL, NULL);
*buffer_profile =
gimp_color_managed_get_color_profile (GIMP_COLOR_MANAGED (drawable));
orig_x = orig_offset_x;
orig_y = orig_offset_y;
orig_width = gegl_buffer_get_width (orig_buffer);
orig_height = gegl_buffer_get_height (orig_buffer);
orig_bpp = babl_format_get_bytes_per_pixel (gegl_buffer_get_format (orig_buffer));
switch (rotate_type)
{
case GIMP_ROTATE_90:
gimp_drawable_transform_rotate_point (orig_x,
orig_y + orig_height,
rotate_type, center_x, center_y,
&new_x, &new_y);
new_width = orig_height;
new_height = orig_width;
break;
case GIMP_ROTATE_180:
gimp_drawable_transform_rotate_point (orig_x + orig_width,
orig_y + orig_height,
rotate_type, center_x, center_y,
&new_x, &new_y);
new_width = orig_width;
new_height = orig_height;
break;
case GIMP_ROTATE_270:
gimp_drawable_transform_rotate_point (orig_x + orig_width,
orig_y,
rotate_type, center_x, center_y,
&new_x, &new_y);
new_width = orig_height;
new_height = orig_width;
break;
default:
g_return_val_if_reached (NULL);
break;
}
format = gegl_buffer_get_format (orig_buffer);
if (clip_result && (new_x != orig_x || new_y != orig_y ||
new_width != orig_width || new_height != orig_height))
{
GimpRGB bg;
GeglColor *color;
gint clip_x, clip_y;
gint clip_width, clip_height;
new_buffer = gegl_buffer_new (GEGL_RECTANGLE (0, 0,
orig_width, orig_height),
format);
*new_offset_x = orig_x;
*new_offset_y = orig_y;
/* Use transparency, rather than the bg color, as the "outside" color of
* channels, and drawables with an alpha channel.
*/
if (GIMP_IS_CHANNEL (drawable) || babl_format_has_alpha (format))
{
gimp_rgba_set (&bg, 0.0, 0.0, 0.0, 0.0);
}
else
{
gimp_context_get_background (context, &bg);
gimp_pickable_srgb_to_image_color (GIMP_PICKABLE (drawable),
&bg, &bg);
}
color = gimp_gegl_color_new (&bg, gimp_drawable_get_space (drawable));
gegl_buffer_set_color (new_buffer, NULL, color);
g_object_unref (color);
if (gimp_rectangle_intersect (orig_x, orig_y, orig_width, orig_height,
new_x, new_y, new_width, new_height,
&clip_x, &clip_y,
&clip_width, &clip_height))
{
gint saved_orig_x = orig_x;
gint saved_orig_y = orig_y;
new_x = clip_x - orig_x;
new_y = clip_y - orig_y;
switch (rotate_type)
{
case GIMP_ROTATE_90:
gimp_drawable_transform_rotate_point (clip_x + clip_width,
clip_y,
GIMP_ROTATE_270,
center_x,
center_y,
&orig_x,
&orig_y);
orig_x -= saved_orig_x;
orig_y -= saved_orig_y;
orig_width = clip_height;
orig_height = clip_width;
break;
case GIMP_ROTATE_180:
orig_x = clip_x - orig_x;
orig_y = clip_y - orig_y;
orig_width = clip_width;
orig_height = clip_height;
break;
case GIMP_ROTATE_270:
gimp_drawable_transform_rotate_point (clip_x,
clip_y + clip_height,
GIMP_ROTATE_90,
center_x,
center_y,
&orig_x,
&orig_y);
orig_x -= saved_orig_x;
orig_y -= saved_orig_y;
orig_width = clip_height;
orig_height = clip_width;
break;
}
new_width = clip_width;
new_height = clip_height;
}
else
{
new_width = 0;
new_height = 0;
}
}
else
{
new_buffer = gegl_buffer_new (GEGL_RECTANGLE (0, 0,
new_width, new_height),
format);
*new_offset_x = new_x;
*new_offset_y = new_y;
orig_x = 0;
orig_y = 0;
new_x = 0;
new_y = 0;
}
if (new_width < 1 || new_height < 1)
return new_buffer;
src_rect.x = orig_x;
src_rect.y = orig_y;
src_rect.width = orig_width;
src_rect.height = orig_height;
dest_rect.x = new_x;
dest_rect.y = new_y;
dest_rect.width = new_width;
dest_rect.height = new_height;
switch (rotate_type)
{
case GIMP_ROTATE_90:
{
guchar *buf = g_new (guchar, new_height * orig_bpp);
gint i;
/* Not cool, we leak memory if we return, but anyway that is
* never supposed to happen. If we see this warning, a bug has
* to be fixed!
*/
g_return_val_if_fail (new_height == orig_width, NULL);
src_rect.y = orig_y + orig_height - 1;
src_rect.height = 1;
dest_rect.x = new_x;
dest_rect.width = 1;
for (i = 0; i < orig_height; i++)
{
src_rect.y = orig_y + orig_height - 1 - i;
dest_rect.x = new_x + i;
gegl_buffer_get (orig_buffer, &src_rect, 1.0, NULL, buf,
GEGL_AUTO_ROWSTRIDE, GEGL_ABYSS_NONE);
gegl_buffer_set (new_buffer, &dest_rect, 0, NULL, buf,
GEGL_AUTO_ROWSTRIDE);
}
g_free (buf);
}
break;
case GIMP_ROTATE_180:
{
guchar *buf = g_new (guchar, new_width * orig_bpp);
gint i, j, k;
/* Not cool, we leak memory if we return, but anyway that is
* never supposed to happen. If we see this warning, a bug has
* to be fixed!
*/
g_return_val_if_fail (new_width == orig_width, NULL);
src_rect.y = orig_y + orig_height - 1;
src_rect.height = 1;
dest_rect.y = new_y;
dest_rect.height = 1;
for (i = 0; i < orig_height; i++)
{
src_rect.y = orig_y + orig_height - 1 - i;
dest_rect.y = new_y + i;
gegl_buffer_get (orig_buffer, &src_rect, 1.0, NULL, buf,
GEGL_AUTO_ROWSTRIDE, GEGL_ABYSS_NONE);
for (j = 0; j < orig_width / 2; j++)
{
guchar *left = buf + j * orig_bpp;
guchar *right = buf + (orig_width - 1 - j) * orig_bpp;
for (k = 0; k < orig_bpp; k++)
{
guchar tmp = left[k];
left[k] = right[k];
right[k] = tmp;
}
}
gegl_buffer_set (new_buffer, &dest_rect, 0, NULL, buf,
GEGL_AUTO_ROWSTRIDE);
}
g_free (buf);
}
break;
case GIMP_ROTATE_270:
{
guchar *buf = g_new (guchar, new_width * orig_bpp);
gint i;
/* Not cool, we leak memory if we return, but anyway that is
* never supposed to happen. If we see this warning, a bug has
* to be fixed!
*/
g_return_val_if_fail (new_width == orig_height, NULL);
src_rect.x = orig_x + orig_width - 1;
src_rect.width = 1;
dest_rect.y = new_y;
dest_rect.height = 1;
for (i = 0; i < orig_width; i++)
{
src_rect.x = orig_x + orig_width - 1 - i;
dest_rect.y = new_y + i;
gegl_buffer_get (orig_buffer, &src_rect, 1.0, NULL, buf,
GEGL_AUTO_ROWSTRIDE, GEGL_ABYSS_NONE);
gegl_buffer_set (new_buffer, &dest_rect, 0, NULL, buf,
GEGL_AUTO_ROWSTRIDE);
}
g_free (buf);
}
break;
}
return new_buffer;
}
GeglBuffer *
gimp_drawable_transform_buffer_flip (GimpDrawable *drawable,
GimpContext *context,
GeglBuffer *orig_buffer,
gint orig_offset_x,
gint orig_offset_y,
GimpOrientationType flip_type,
gdouble axis,
gboolean clip_result,
GimpColorProfile **buffer_profile,
gint *new_offset_x,
gint *new_offset_y)
{
const Babl *format;
GeglBuffer *new_buffer;
GeglBufferIterator *iter;
GeglRectangle src_rect;
GeglRectangle dest_rect;
gint bpp;
gint orig_x, orig_y;
gint orig_width, orig_height;
gint new_x, new_y;
gint new_width, new_height;
gint x, y;
g_return_val_if_fail (GIMP_IS_DRAWABLE (drawable), NULL);
g_return_val_if_fail (gimp_item_is_attached (GIMP_ITEM (drawable)), NULL);
g_return_val_if_fail (GIMP_IS_CONTEXT (context), NULL);
g_return_val_if_fail (GEGL_IS_BUFFER (orig_buffer), NULL);
g_return_val_if_fail (buffer_profile != NULL, NULL);
g_return_val_if_fail (new_offset_x != NULL, NULL);
g_return_val_if_fail (new_offset_y != NULL, NULL);
*buffer_profile =
gimp_color_managed_get_color_profile (GIMP_COLOR_MANAGED (drawable));
orig_x = orig_offset_x;
orig_y = orig_offset_y;
orig_width = gegl_buffer_get_width (orig_buffer);
orig_height = gegl_buffer_get_height (orig_buffer);
new_x = orig_x;
new_y = orig_y;
new_width = orig_width;
new_height = orig_height;
switch (flip_type)
{
case GIMP_ORIENTATION_HORIZONTAL:
new_x = RINT (-((gdouble) orig_x +
(gdouble) orig_width - axis) + axis);
break;
case GIMP_ORIENTATION_VERTICAL:
new_y = RINT (-((gdouble) orig_y +
(gdouble) orig_height - axis) + axis);
break;
case GIMP_ORIENTATION_UNKNOWN:
g_return_val_if_reached (NULL);
break;
}
format = gegl_buffer_get_format (orig_buffer);
bpp = babl_format_get_bytes_per_pixel (format);
new_buffer = gegl_buffer_new (GEGL_RECTANGLE (0, 0,
new_width, new_height),
format);
if (clip_result && (new_x != orig_x || new_y != orig_y))
{
GimpRGB bg;
GeglColor *color;
gint clip_x, clip_y;
gint clip_width, clip_height;
*new_offset_x = orig_x;
*new_offset_y = orig_y;
/* Use transparency, rather than the bg color, as the "outside" color of
* channels, and drawables with an alpha channel.
*/
if (GIMP_IS_CHANNEL (drawable) || babl_format_has_alpha (format))
{
gimp_rgba_set (&bg, 0.0, 0.0, 0.0, 0.0);
}
else
{
gimp_context_get_background (context, &bg);
gimp_pickable_srgb_to_image_color (GIMP_PICKABLE (drawable),
&bg, &bg);
}
color = gimp_gegl_color_new (&bg, gimp_drawable_get_space (drawable));
gegl_buffer_set_color (new_buffer, NULL, color);
g_object_unref (color);
if (gimp_rectangle_intersect (orig_x, orig_y, orig_width, orig_height,
new_x, new_y, new_width, new_height,
&clip_x, &clip_y,
&clip_width, &clip_height))
{
orig_x = new_x = clip_x - orig_x;
orig_y = new_y = clip_y - orig_y;
}
orig_width = new_width = clip_width;
orig_height = new_height = clip_height;
}
else
{
*new_offset_x = new_x;
*new_offset_y = new_y;
orig_x = 0;
orig_y = 0;
new_x = 0;
new_y = 0;
}
if (new_width == 0 && new_height == 0)
return new_buffer;
dest_rect.x = new_x;
dest_rect.y = new_y;
dest_rect.width = new_width;
dest_rect.height = new_height;
iter = gegl_buffer_iterator_new (new_buffer, &dest_rect, 0, NULL,
GEGL_BUFFER_WRITE, GEGL_ABYSS_NONE, 1);
switch (flip_type)
{
case GIMP_ORIENTATION_HORIZONTAL:
while (gegl_buffer_iterator_next (iter))
{
gint stride = iter->items[0].roi.width * bpp;
src_rect = iter->items[0].roi;
src_rect.x = (orig_x + orig_width) -
(iter->items[0].roi.x - dest_rect.x) -
iter->items[0].roi.width;
gegl_buffer_get (orig_buffer, &src_rect, 1.0, NULL, iter->items[0].data,
stride, GEGL_ABYSS_NONE);
for (y = 0; y < iter->items[0].roi.height; y++)
{
guint8 *left = iter->items[0].data;
guint8 *right = iter->items[0].data;
left += y * stride;
right += y * stride + (iter->items[0].roi.width - 1) * bpp;
for (x = 0; x < iter->items[0].roi.width / 2; x++)
{
guint8 temp[bpp];
memcpy (temp, left, bpp);
memcpy (left, right, bpp);
memcpy (right, temp, bpp);
left += bpp;
right -= bpp;
}
}
}
break;
case GIMP_ORIENTATION_VERTICAL:
while (gegl_buffer_iterator_next (iter))
{
gint stride = iter->items[0].roi.width * bpp;
src_rect = iter->items[0].roi;
src_rect.y = (orig_y + orig_height) -
(iter->items[0].roi.y - dest_rect.y) -
iter->items[0].roi.height;
gegl_buffer_get (orig_buffer, &src_rect, 1.0, NULL, iter->items[0].data,
stride, GEGL_ABYSS_NONE);
for (x = 0; x < iter->items[0].roi.width; x++)
{
guint8 *top = iter->items[0].data;
guint8 *bottom = iter->items[0].data;
top += x * bpp;
bottom += x * bpp + (iter->items[0].roi.height - 1) * stride;
for (y = 0; y < iter->items[0].roi.height / 2; y++)
{
guint8 temp[bpp];
memcpy (temp, top, bpp);
memcpy (top, bottom, bpp);
memcpy (bottom, temp, bpp);
top += stride;
bottom -= stride;
}
}
}
break;
case GIMP_ORIENTATION_UNKNOWN:
gegl_buffer_iterator_stop (iter);
break;
}
return new_buffer;
}
static inline void
filter (void)
{
static void (* overlap)(guchar *, const guchar *);
GimpPixelRgn src;
GimpPixelRgn dst;
GimpRGB color;
guchar pixel[4];
gint division_x;
gint division_y;
gint offset_x;
gint offset_y;
Tile *tiles;
gint numof_tiles;
Tile *t;
gint i;
gint x;
gint y;
gint move_max_pixels;
gint clear_x0;
gint clear_y0;
gint clear_x1;
gint clear_y1;
gint clear_width;
gint clear_height;
guchar *pixels;
guchar *buffer;
gint dindex;
gint sindex;
gint px, py;
GRand *gr;
gr = g_rand_new ();
/* INITIALIZE */
gimp_pixel_rgn_init (&src, p.drawable, 0, 0,
p.drawable->width, p.drawable->height, FALSE, FALSE);
gimp_pixel_rgn_init (&dst, p.drawable, 0, 0,
p.drawable->width, p.drawable->height, TRUE, TRUE);
pixels = g_new (guchar,
p.drawable->bpp * p.drawable->width * p.drawable->height);
buffer = g_new (guchar,
p.drawable->bpp * p.params.tile_width * p.params.tile_height);
overlap = p.drawable_has_alpha ? overlap_RGBA : overlap_RGB;
gimp_progress_init (_("Paper Tile"));
gimp_drawable_mask_bounds (p.drawable->drawable_id,
&p.selection.x0, &p.selection.y0,
&p.selection.x1, &p.selection.y1);
p.selection.width = p.selection.x1 - p.selection.x0;
p.selection.height = p.selection.y1 - p.selection.y0;
gimp_tile_cache_ntiles (2 * (p.selection.width / gimp_tile_width () + 1));
/* TILES */
division_x = p.params.division_x;
division_y = p.params.division_y;
if (p.params.fractional_type == FRACTIONAL_TYPE_FORCE)
{
if (0 < p.drawable->width % p.params.tile_width) division_x++;
if (0 < p.drawable->height % p.params.tile_height) division_y++;
if (p.params.centering)
{
if (1 < p.drawable->width % p.params.tile_width)
{
division_x++;
offset_x =
(p.drawable->width % p.params.tile_width) / 2 -
p.params.tile_width;
}
else
{
offset_x = 0;
}
if (1 < p.drawable->height % p.params.tile_height)
{
division_y++;
offset_y =
(p.drawable->height % p.params.tile_height) / 2 -
p.params.tile_height;
}
else
{
offset_y = 0;
}
}
else
{
offset_x = 0;
offset_y = 0;
}
}
else
{
if (p.params.centering)
{
offset_x = (p.drawable->width % p.params.tile_width) / 2;
offset_y = (p.drawable->height % p.params.tile_height) / 2;
}
else
{
offset_x = 0;
offset_y = 0;
}
}
move_max_pixels = p.params.move_max_rate * p.params.tile_width / 100.0;
numof_tiles = division_x * division_y;
t = tiles = g_new(Tile, numof_tiles);
for (y = 0; y < division_y; y++)
{
gint srcy = offset_y + p.params.tile_height * y;
for (x = 0; x < division_x; x++, t++)
{
gint srcx = offset_x + p.params.tile_width * x;
if (srcx < 0)
{
t->x = 0;
t->width = srcx + p.params.tile_width;
}
else if (srcx + p.params.tile_width < p.drawable->width)
{
t->x = srcx;
t->width = p.params.tile_width;
}
else
{
t->x = srcx;
t->width = p.drawable->width - srcx;
}
if (srcy < 0)
{
t->y = 0;
t->height = srcy + p.params.tile_height;
}
else if (srcy + p.params.tile_height < p.drawable->height)
{
t->y = srcy;
t->height = p.params.tile_height;
}
else
{
t->y = srcy;
t->height = p.drawable->height - srcy;
}
t->z = g_rand_int (gr);
random_move (&t->move_x, &t->move_y, move_max_pixels);
}
}
qsort (tiles, numof_tiles, sizeof *tiles, tile_compare);
gimp_pixel_rgn_get_rect (&src, pixels, 0, 0, p.drawable->width,
p.drawable->height);
if (p.params.fractional_type == FRACTIONAL_TYPE_IGNORE)
{
clear_x0 = offset_x;
clear_y0 = offset_y;
clear_width = p.params.tile_width * division_x;
clear_height = p.params.tile_height * division_y;
}
else
{
clear_x0 = 0;
clear_y0 = 0;
clear_width = p.drawable->width;
clear_height = p.drawable->height;
}
clear_x1 = clear_x0 + clear_width;
clear_y1 = clear_y0 + clear_height;
switch (p.params.background_type)
{
case BACKGROUND_TYPE_TRANSPARENT:
for (y = clear_y0; y < clear_y1; y++)
{
for (x = clear_x0; x < clear_x1; x++)
{
dindex = p.drawable->bpp * (p.drawable->width * y + x);
for (i = 0; i < p.drawable->bpp; i++)
{
pixels[dindex+i] = 0;
}
}
}
break;
case BACKGROUND_TYPE_INVERTED:
for (y = clear_y0; y < clear_y1; y++)
{
for (x = clear_x0; x < clear_x1; x++)
{
dindex = p.drawable->bpp * (p.drawable->width * y + x);
pixels[dindex+0] = 255 - pixels[dindex+0];
pixels[dindex+1] = 255 - pixels[dindex+1];
pixels[dindex+2] = 255 - pixels[dindex+2];
}
}
break;
case BACKGROUND_TYPE_IMAGE:
break;
case BACKGROUND_TYPE_FOREGROUND:
gimp_context_get_foreground (&color);
gimp_rgb_get_uchar (&color, &pixel[0], &pixel[1], &pixel[2]);
pixel[3] = 255;
for (y = clear_y0; y < clear_y1; y++)
{
for (x = clear_x0; x < clear_x1; x++)
{
dindex = p.drawable->bpp * (p.drawable->width * y + x);
for (i = 0; i < p.drawable->bpp; i++)
{
pixels[dindex+i] = pixel[i];
}
}
}
break;
case BACKGROUND_TYPE_BACKGROUND:
gimp_context_get_background (&color);
gimp_rgb_get_uchar (&color, &pixel[0], &pixel[1], &pixel[2]);
pixel[3] = 255;
for (y = clear_y0; y < clear_y1; y++)
{
for (x = clear_x0; x < clear_x1; x++)
{
dindex = p.drawable->bpp * (p.drawable->width * y + x);
for(i = 0; i < p.drawable->bpp; i++)
{
pixels[dindex+i] = pixel[i];
}
}
}
break;
case BACKGROUND_TYPE_COLOR:
gimp_rgba_get_uchar (&p.params.background_color,
pixel, pixel + 1, pixel + 2, pixel + 3);
for (y = clear_y0; y < clear_y1; y++)
{
for (x = clear_x0; x < clear_x1; x++)
{
dindex = p.drawable->bpp * (p.drawable->width * y + x);
for(i = 0; i < p.drawable->bpp; i++)
{
pixels[dindex+i] = pixel[i];
}
}
}
break;
}
/* DRAW */
for (t = tiles, i = 0; i < numof_tiles; i++, t++)
{
gint x0 = t->x + t->move_x;
gint y0 = t->y + t->move_y;
gimp_pixel_rgn_get_rect (&src, buffer, t->x, t->y, t->width, t->height);
for (y = 0; y < t->height; y++)
{
py = y0 + y;
for (x = 0; x < t->width; x++)
{
px = x0 + x;
sindex = p.drawable->bpp * (t->width * y + x);
if (0 <= px && px < p.drawable->width &&
0 <= py && py < p.drawable->height)
{
dindex = p.drawable->bpp * (p.drawable->width * py + px);
overlap(&pixels[dindex], &buffer[sindex]);
}
else if (p.params.wrap_around)
{
px = (px + p.drawable->width) % p.drawable->width;
py = (py + p.drawable->height) % p.drawable->height;
dindex = p.drawable->bpp * (p.drawable->width * py + px);
overlap(&pixels[dindex], &buffer[sindex]);
}
}
}
gimp_progress_update ((gdouble) i / (gdouble) numof_tiles);
}
gimp_pixel_rgn_set_rect (&dst, pixels, 0, 0, p.drawable->width,
p.drawable->height);
gimp_progress_update (1.0);
gimp_drawable_flush (p.drawable);
gimp_drawable_merge_shadow (p.drawable->drawable_id, TRUE);
gimp_drawable_update (p.drawable->drawable_id,
p.selection.x0, p.selection.y0,
p.selection.width, p.selection.height);
g_rand_free (gr);
g_free (buffer);
g_free (pixels);
g_free (tiles);
}
static void
run (const gchar *name,
gint nparams,
const GimpParam *param,
gint *nreturn_vals,
GimpParam **return_vals)
{
static GimpParam values[1];
GimpDrawable *drawable;
GimpPDBStatusType status;
GimpRunMode run_mode;
gdouble xhsiz, yhsiz;
GimpRGB background;
status = GIMP_PDB_SUCCESS;
run_mode = param[0].data.d_int32;
values[0].type = GIMP_PDB_STATUS;
values[0].data.d_status = status;
*nreturn_vals = 1;
*return_vals = values;
INIT_I18N ();
/* Get the active drawable info */
drawable = gimp_drawable_get (param[2].data.d_drawable);
img_width = gimp_drawable_width (drawable->drawable_id);
img_height = gimp_drawable_height (drawable->drawable_id);
img_has_alpha = gimp_drawable_has_alpha (drawable->drawable_id);
gimp_drawable_mask_bounds (drawable->drawable_id,
&sel_x1, &sel_y1, &sel_x2, &sel_y2);
/* Calculate scaling parameters */
sel_width = sel_x2 - sel_x1;
sel_height = sel_y2 - sel_y1;
cen_x = (double) (sel_x1 + sel_x2 - 1) / 2.0;
cen_y = (double) (sel_y1 + sel_y2 - 1) / 2.0;
xhsiz = (double) (sel_width - 1) / 2.0;
yhsiz = (double) (sel_height - 1) / 2.0;
if (xhsiz < yhsiz)
{
scale_x = yhsiz / xhsiz;
scale_y = 1.0;
}
else if (xhsiz > yhsiz)
{
scale_x = 1.0;
scale_y = xhsiz / yhsiz;
}
else
{
scale_x = 1.0;
scale_y = 1.0;
}
/* Get background color */
gimp_context_get_background (&background);
gimp_rgb_set_alpha (&background, 0.0);
gimp_drawable_get_color_uchar (drawable->drawable_id, &background,
back_color);
/* See how we will run */
switch (run_mode)
{
case GIMP_RUN_INTERACTIVE:
/* Possibly retrieve data */
gimp_get_data (PLUG_IN_PROC, &pcvals);
/* Get information from the dialog */
if (! polarize_dialog (drawable))
return;
break;
case GIMP_RUN_NONINTERACTIVE:
/* Make sure all the arguments are present */
if (nparams != 8)
{
status = GIMP_PDB_CALLING_ERROR;
}
else
{
pcvals.circle = param[3].data.d_float;
pcvals.angle = param[4].data.d_float;
pcvals.backwards = param[5].data.d_int32;
pcvals.inverse = param[6].data.d_int32;
pcvals.polrec = param[7].data.d_int32;
}
break;
case GIMP_RUN_WITH_LAST_VALS:
/* Possibly retrieve data */
gimp_get_data (PLUG_IN_PROC, &pcvals);
break;
default:
break;
}
/* Distort the image */
if ((status == GIMP_PDB_SUCCESS) &&
(gimp_drawable_is_rgb (drawable->drawable_id) ||
gimp_drawable_is_gray (drawable->drawable_id)))
{
/* Set the tile cache size */
gimp_tile_cache_ntiles (2 * (drawable->width + gimp_tile_width() - 1) /
gimp_tile_width ());
/* Run! */
polarize (drawable);
/* If run mode is interactive, flush displays */
if (run_mode != GIMP_RUN_NONINTERACTIVE)
gimp_displays_flush ();
/* Store data */
if (run_mode == GIMP_RUN_INTERACTIVE)
gimp_set_data (PLUG_IN_PROC, &pcvals, sizeof (polarize_vals_t));
}
else if (status == GIMP_PDB_SUCCESS)
status = GIMP_PDB_EXECUTION_ERROR;
values[0].data.d_status = status;
gimp_drawable_detach (drawable);
}