static gint32
create_image (GdkPixbuf *pixbuf,
GdkRegion *shape,
const gchar *name)
{
gint32 image;
gint32 layer;
gdouble xres, yres;
gchar *comment;
gint width, height;
gboolean status;
status = gimp_progress_init (_("Importing screenshot"));
width = gdk_pixbuf_get_width (pixbuf);
height = gdk_pixbuf_get_height (pixbuf);
image = gimp_image_new (width, height, GIMP_RGB);
gimp_image_undo_disable (image);
gimp_get_monitor_resolution (&xres, &yres);
gimp_image_set_resolution (image, xres, yres);
comment = gimp_get_default_comment ();
if (comment)
{
GimpParasite *parasite;
parasite = gimp_parasite_new ("gimp-comment", GIMP_PARASITE_PERSISTENT,
strlen (comment) + 1, comment);
gimp_image_parasite_attach (image, parasite);
gimp_parasite_free (parasite);
g_free (comment);
}
layer = gimp_layer_new_from_pixbuf (image,
name ? name : _("Screenshot"),
pixbuf,
100, GIMP_NORMAL_MODE, 0.0, 1.0);
gimp_image_add_layer (image, layer, 0);
if (shape && ! gdk_region_empty (shape))
{
image_select_shape (image, shape);
if (! gimp_selection_is_empty (image))
{
gimp_layer_add_alpha (layer);
gimp_edit_clear (layer);
gimp_selection_none (image);
}
}
gimp_image_undo_enable (image);
return image;
}
static void
image_select_shape (gint32 image,
GdkRegion *shape)
{
GdkRectangle *rects;
gint num_rects;
gint i;
gimp_selection_none (image);
gdk_region_get_rectangles (shape, &rects, &num_rects);
for (i = 0; i < num_rects; i++)
{
gimp_rect_select (image,
rects[i].x, rects[i].y, rects[i].width, rects[i].height,
GIMP_CHANNEL_OP_ADD, FALSE, 0);
}
g_free (rects);
gimp_selection_invert (image);
}
static void
run (const gchar *name,
gint nparams,
const GimpParam *param,
gint *nreturn_vals,
GimpParam **return_vals)
{
static GimpParam values[1];
gint32 drawable_id;
GimpRunMode run_mode;
GimpPDBStatusType status = GIMP_PDB_SUCCESS;
gint pwidth, pheight;
INIT_I18N ();
gfig_context = g_new0 (GFigContext, 1);
gfig_context->show_background = TRUE;
gfig_context->selected_obj = NULL;
drawable_id = param[2].data.d_drawable;
run_mode = param[0].data.d_int32;
gfig_context->image_id = param[1].data.d_image;
gfig_context->drawable_id = drawable_id;
*nreturn_vals = 1;
*return_vals = values;
values[0].type = GIMP_PDB_STATUS;
values[0].data.d_status = status;
gimp_image_undo_group_start (gfig_context->image_id);
gimp_context_push ();
/* TMP Hack - clear any selections */
if (! gimp_selection_is_empty (gfig_context->image_id))
gimp_selection_none (gfig_context->image_id);
gimp_drawable_mask_bounds (drawable_id,
&sel_x1, &sel_y1, &sel_x2, &sel_y2);
sel_width = sel_x2 - sel_x1;
sel_height = sel_y2 - sel_y1;
/* Calculate preview size */
if (sel_width > sel_height)
{
pwidth = MIN (sel_width, PREVIEW_SIZE);
pheight = sel_height * pwidth / sel_width;
}
else
{
pheight = MIN (sel_height, PREVIEW_SIZE);
pwidth = sel_width * pheight / sel_height;
}
preview_width = MAX (pwidth, 2); /* Min size is 2 */
preview_height = MAX (pheight, 2);
org_scale_x_factor = scale_x_factor =
(gdouble) sel_width / (gdouble) preview_width;
org_scale_y_factor = scale_y_factor =
(gdouble) sel_height / (gdouble) preview_height;
/* initialize */
gfig_init_object_classes ();
switch (run_mode)
{
case GIMP_RUN_INTERACTIVE:
case GIMP_RUN_WITH_LAST_VALS:
/*gimp_get_data (PLUG_IN_PROC, &selvals);*/
if (! gfig_dialog ())
{
gimp_image_undo_group_end (gfig_context->image_id);
return;
}
break;
case GIMP_RUN_NONINTERACTIVE:
status = GIMP_PDB_CALLING_ERROR;
break;
default:
break;
}
gimp_context_pop ();
gimp_image_undo_group_end (gfig_context->image_id);
if (run_mode != GIMP_RUN_NONINTERACTIVE)
gimp_displays_flush ();
else
#if 0
if (run_mode == GIMP_RUN_INTERACTIVE)
gimp_set_data (PLUG_IN_PROC, &selvals, sizeof (SelectItVals));
else
#endif /* 0 */
{
status = GIMP_PDB_EXECUTION_ERROR;
}
values[0].data.d_status = status;
}
static gboolean
lcms_image_apply_profile (gint32 image,
cmsHPROFILE src_profile,
cmsHPROFILE dest_profile,
const gchar *filename,
GimpColorRenderingIntent intent,
gboolean bpc)
{
gint32 saved_selection = -1;
gimp_image_undo_group_start (image);
if (! lcms_image_set_profile (image, dest_profile, filename, FALSE))
{
gimp_image_undo_group_end (image);
return FALSE;
}
{
gchar *src = lcms_icc_profile_get_desc (src_profile);
gchar *dest = lcms_icc_profile_get_desc (dest_profile);
/* ICC color profile conversion */
gimp_progress_init_printf (_("Converting from '%s' to '%s'"), src, dest);
g_printerr ("lcms: converting from '%s' to '%s'\n", src, dest);
g_free (dest);
g_free (src);
}
if (! gimp_selection_is_empty (image))
{
saved_selection = gimp_selection_save (image);
gimp_selection_none (image);
}
switch (gimp_image_base_type (image))
{
case GIMP_RGB:
lcms_image_transform_rgb (image,
src_profile, dest_profile, intent, bpc);
break;
case GIMP_GRAY:
g_warning ("colorspace conversion not implemented for "
"grayscale images");
break;
case GIMP_INDEXED:
lcms_image_transform_indexed (image,
src_profile, dest_profile, intent, bpc);
break;
}
if (saved_selection != -1)
{
gimp_image_select_item (image, GIMP_CHANNEL_OP_REPLACE, saved_selection);
gimp_image_remove_channel (image, saved_selection);
}
gimp_progress_update (1.0);
gimp_image_undo_group_end (image);
return TRUE;
}
static void
do_zcrop (gint32 drawable_id,
gint32 image_id)
{
GeglBuffer *drawable_buffer;
GeglBuffer *shadow_buffer;
gfloat *linear_buf;
const Babl *format;
gint x, y, width, height;
gint components;
gint8 *killrows;
gint8 *killcols;
gint32 livingrows, livingcols, destrow, destcol;
gint32 selection_copy_id;
gboolean has_alpha;
drawable_buffer = gimp_drawable_get_buffer (drawable_id);
shadow_buffer = gimp_drawable_get_shadow_buffer (drawable_id);
width = gegl_buffer_get_width (drawable_buffer);
height = gegl_buffer_get_height (drawable_buffer);
has_alpha = gimp_drawable_has_alpha (drawable_id);
if (has_alpha)
format = babl_format ("R'G'B'A float");
else
format = babl_format ("R'G'B' float");
components = babl_format_get_n_components (format);
killrows = g_new (gint8, height);
killcols = g_new (gint8, width);
linear_buf = g_new (gfloat, (width > height ? width : height) * components);
/* search which rows to remove */
livingrows = 0;
for (y = 0; y < height; y++)
{
gegl_buffer_get (drawable_buffer, GEGL_RECTANGLE (0, y, width, 1),
1.0, format, linear_buf,
GEGL_AUTO_ROWSTRIDE, GEGL_ABYSS_NONE);
killrows[y] = TRUE;
for (x = components; x < width * components; x += components)
{
if (! colors_equal (linear_buf, &linear_buf[x], components, has_alpha))
{
livingrows++;
killrows[y] = FALSE;
break;
}
}
}
gimp_progress_update (0.25);
/* search which columns to remove */
livingcols = 0;
for (x = 0; x < width; x++)
{
gegl_buffer_get (drawable_buffer, GEGL_RECTANGLE (x, 0, 1, height),
1.0, format, linear_buf,
GEGL_AUTO_ROWSTRIDE, GEGL_ABYSS_NONE);
killcols[x] = TRUE;
for (y = components; y < height * components; y += components)
{
if (! colors_equal (linear_buf, &linear_buf[y], components, has_alpha))
{
livingcols++;
killcols[x] = FALSE;
break;
}
}
}
gimp_progress_update (0.5);
if ((livingcols == 0 || livingrows == 0) ||
(livingcols == width && livingrows == height))
{
g_message (_("Nothing to crop."));
g_free (linear_buf);
g_free (killrows);
g_free (killcols);
return;
}
/* restitute living rows */
destrow = 0;
for (y = 0; y < height; y++)
{
if (!killrows[y])
{
gegl_buffer_copy (drawable_buffer,
GEGL_RECTANGLE (0, y, width, 1),
GEGL_ABYSS_NONE,
shadow_buffer,
GEGL_RECTANGLE (0, destrow, width, 1));
destrow++;
}
}
gimp_progress_update (0.75);
/* restitute living columns */
destcol = 0;
for (x = 0; x < width; x++)
{
if (!killcols[x])
{
gegl_buffer_copy (shadow_buffer,
GEGL_RECTANGLE (x, 0, 1, height),
GEGL_ABYSS_NONE,
shadow_buffer,
GEGL_RECTANGLE (destcol, 0, 1, height));
destcol++;
}
}
gimp_progress_update (1.00);
gimp_image_undo_group_start (image_id);
selection_copy_id = gimp_selection_save (image_id);
gimp_selection_none (image_id);
gegl_buffer_flush (shadow_buffer);
gimp_drawable_merge_shadow (drawable_id, TRUE);
gegl_buffer_flush (drawable_buffer);
gimp_image_select_item (image_id, GIMP_CHANNEL_OP_REPLACE, selection_copy_id);
gimp_image_remove_channel (image_id, selection_copy_id);
gimp_image_crop (image_id, livingcols, livingrows, 0, 0);
gimp_image_undo_group_end (image_id);
g_object_unref (shadow_buffer);
g_object_unref (drawable_buffer);
g_free (linear_buf);
g_free (killrows);
g_free (killcols);
}
static void
border (gint32 image_ID)
{
GdkPixbuf *pixbuf = NULL;
int texture_width;
int texture_height;
gdouble margin_x;
gdouble margin_y;
pixbuf = gdk_pixbuf_new_from_inline (-1, bvals.border->texture, FALSE, NULL);
if (pixbuf)
{
texture_width = gdk_pixbuf_get_width (pixbuf);
texture_height = gdk_pixbuf_get_height (pixbuf);
gint32 texture_image = gimp_image_new (texture_width, texture_height, GIMP_RGB);
gint32 texture_layer = gimp_layer_new_from_pixbuf (texture_image, "texture", pixbuf, 100, GIMP_NORMAL_MODE, 0, 0);
gimp_image_add_layer (texture_image, texture_layer, -1);
gint width = gimp_image_width (image_ID);
gint height = gimp_image_height (image_ID);
if (bvals.border->top || bvals.border->bottom || bvals.border->left || bvals.border->right)
{
width += bvals.border->left + bvals.border->right;
height += bvals.border->top + bvals.border->bottom;
gimp_image_resize (image_ID,
width,
height,
bvals.border->left,
bvals.border->top);
}
gint32 layer = gimp_layer_new (image_ID, "border",
width, height,
GIMP_RGBA_IMAGE,
100,
GIMP_NORMAL_MODE);
gimp_image_add_layer (image_ID, layer, -1);
if (width > texture_width - bvals.border->length)
margin_x = (texture_width - bvals.border->length) / 2;
else
margin_x = (gdouble) width / 2;
if (height > texture_height - bvals.border->length)
margin_y = (texture_height - bvals.border->length) / 2;
else
margin_y = (gdouble) height / 2;
/* fix gimp_context_set_pattern ("Clipboard") only works on English versions of Gimp */
//gimp_context_set_pattern ("Clipboard");
INIT_I18N ();
gimp_context_set_pattern (_("Clipboard"));
if (width > margin_x * 2) {
/* top */
gimp_rect_select (texture_image,
margin_x,
0,
texture_width - margin_x * 2,
margin_y,
GIMP_CHANNEL_OP_REPLACE, FALSE, 0);
gimp_edit_copy (texture_layer);
gimp_rect_select (image_ID,
margin_x,
0,
width - margin_x * 2,
margin_y,
GIMP_CHANNEL_OP_REPLACE, FALSE, 0);
gimp_edit_fill (layer, GIMP_PATTERN_FILL);
/* bottom */
gimp_rect_select (texture_image,
margin_x,
texture_height - margin_y,
texture_width - margin_x * 2,
texture_height,
GIMP_CHANNEL_OP_REPLACE, FALSE, 0);
gimp_edit_copy (texture_layer);
gimp_rect_select (image_ID,
margin_x,
height - margin_y,
width - margin_x * 2,
height,
GIMP_CHANNEL_OP_REPLACE, FALSE, 0);
gimp_edit_fill (layer, GIMP_PATTERN_FILL);
}
if (height > margin_y * 2) {
/* left */
gimp_rect_select (texture_image,
0,
margin_y,
margin_x,
texture_height - margin_y * 2,
GIMP_CHANNEL_OP_REPLACE, FALSE, 0);
gimp_edit_copy (texture_layer);
gimp_rect_select (image_ID,
0,
margin_y,
margin_x,
height - margin_y * 2,
GIMP_CHANNEL_OP_REPLACE, FALSE, 0);
gimp_edit_fill (layer, GIMP_PATTERN_FILL);
/* right */
gimp_rect_select (texture_image,
texture_width - margin_x,
margin_y,
margin_x,
texture_height - margin_y * 2,
GIMP_CHANNEL_OP_REPLACE, FALSE, 0);
gimp_edit_copy (texture_layer);
gimp_rect_select (image_ID,
width - margin_x,
margin_y,
margin_x,
height - margin_y * 2,
GIMP_CHANNEL_OP_REPLACE, FALSE, 0);
gimp_edit_fill (layer, GIMP_PATTERN_FILL);
}
/* top left */
gimp_rect_select (texture_image,
0,
0,
margin_x,
margin_y,
GIMP_CHANNEL_OP_REPLACE, FALSE, 0);
gimp_edit_copy (texture_layer);
gimp_rect_select (image_ID,
0,
0,
margin_x,
margin_y,
GIMP_CHANNEL_OP_REPLACE, FALSE, 0);
gimp_edit_fill (layer, GIMP_PATTERN_FILL);
/* top right */
gimp_rect_select (texture_image,
texture_width - margin_x,
0,
margin_x,
margin_y,
GIMP_CHANNEL_OP_REPLACE, FALSE, 0);
gimp_edit_copy (texture_layer);
gimp_rect_select (image_ID,
width - margin_x,
0,
margin_x,
margin_y,
GIMP_CHANNEL_OP_REPLACE, FALSE, 0);
gimp_edit_fill (layer, GIMP_PATTERN_FILL);
/* bottom left */
gimp_rect_select (texture_image,
0,
texture_height - margin_y,
margin_x,
margin_y,
GIMP_CHANNEL_OP_REPLACE, FALSE, 0);
gimp_edit_copy (texture_layer);
gimp_rect_select (image_ID,
0,
height - margin_y,
margin_x,
margin_y,
GIMP_CHANNEL_OP_REPLACE, FALSE, 0);
gimp_edit_fill (layer, GIMP_PATTERN_FILL);
/* bottom right */
gimp_rect_select (texture_image,
texture_width - margin_x,
texture_height - margin_y,
margin_x,
margin_y,
GIMP_CHANNEL_OP_REPLACE, FALSE, 0);
gimp_edit_copy (texture_layer);
gimp_rect_select (image_ID,
width - margin_x,
height - margin_y,
margin_x,
margin_y,
GIMP_CHANNEL_OP_REPLACE, FALSE, 0);
gimp_edit_fill (layer, GIMP_PATTERN_FILL);
gimp_image_merge_down(image_ID, layer, GIMP_CLIP_TO_IMAGE);
gimp_selection_none (image_ID);
}
}
static void
export_merge (gint32 image_ID,
gint32 *drawable_ID)
{
gint32 nlayers;
gint32 nvisible = 0;
gint32 i;
gint32 *layers;
gint32 merged;
gint32 transp;
layers = gimp_image_get_layers (image_ID, &nlayers);
for (i = 0; i < nlayers; i++)
{
if (gimp_item_get_visible (layers[i]))
nvisible++;
}
if (nvisible <= 1)
{
/* if there is only one (or zero) visible layer, add a new transparent
layer that has the same size as the canvas. The merge that follows
will ensure that the offset, opacity and size are correct */
transp = gimp_layer_new (image_ID, "-",
gimp_image_width (image_ID),
gimp_image_height (image_ID),
gimp_drawable_type (*drawable_ID) | 1,
100.0, GIMP_NORMAL_MODE);
gimp_image_insert_layer (image_ID, transp, -1, 1);
gimp_selection_none (image_ID);
gimp_edit_clear (transp);
nvisible++;
}
if (nvisible > 1)
{
g_free (layers);
merged = gimp_image_merge_visible_layers (image_ID, GIMP_CLIP_TO_IMAGE);
if (merged != -1)
*drawable_ID = merged;
else
return; /* shouldn't happen */
layers = gimp_image_get_layers (image_ID, &nlayers);
/* make sure that the merged drawable matches the image size */
if (gimp_drawable_width (merged) != gimp_image_width (image_ID) ||
gimp_drawable_height (merged) != gimp_image_height (image_ID))
{
gint off_x, off_y;
gimp_drawable_offsets (merged, &off_x, &off_y);
gimp_layer_resize (merged,
gimp_image_width (image_ID),
gimp_image_height (image_ID),
off_x, off_y);
}
}
/* remove any remaining (invisible) layers */
for (i = 0; i < nlayers; i++)
{
if (layers[i] != *drawable_ID)
gimp_image_remove_layer (image_ID, layers[i]);
}
g_free (layers);
}
/* --------------------------------------------
* gap_fg_from_selection_exec_apply_run
* --------------------------------------------
* generate a tri map from the current selection by filling the shrinked
* shape with white, the expanded shape with black and the borderline
* between shrinked and expanded selection with medium gray.
* the trimap is attached as layermask to the input drawable,
* and used as input for the foreground selection via alpha matting algorithm,
* that creates a resulting layer with trimmed selection.
*
*/
gint
gap_fg_from_selection_exec_apply_run (gint32 image_id, gint32 drawable_id
, gboolean doProgress, gboolean doFlush
, GapFgSelectValues *fsValPtr)
{
GimpRGB color;
gint32 activeSelection;
gint32 shrinkedSelection;
gint32 trimap;
gboolean hadSelection;
gint rc;
rc = 0;
trimap = -1;
activeSelection = -1;
shrinkedSelection = -1;
hadSelection = FALSE;
gimp_context_push();
gimp_image_undo_group_start(image_id);
if (gimp_selection_is_empty(image_id) == TRUE)
{
if (gimp_drawable_has_alpha(drawable_id) == FALSE)
{
/* if the layer has no alpha select all */
gimp_selection_all(image_id);
}
else
{
gimp_selection_layer_alpha(drawable_id);
}
activeSelection = gimp_selection_save(image_id);
}
else
{
activeSelection = gimp_selection_save(image_id);
hadSelection = TRUE;
}
trimap = gimp_layer_get_mask(drawable_id);
if (trimap < 0)
{
/* create trimap as new layermask */
trimap = gimp_layer_create_mask(drawable_id, GIMP_ADD_BLACK_MASK);
gimp_layer_add_mask(drawable_id, trimap);
}
else
{
/* use BLACK color to fill the already existing layermask
* (note that gimp_drawable_fill is used to fill the entire mask
* regardless to the current selection)
*/
color.r = 0.0;
color.g = 0.0;
color.b = 0.0;
color.a = 1.0;
gimp_context_set_background (&color);
gimp_drawable_fill(trimap, GIMP_BACKGROUND_FILL);
}
gimp_selection_sharpen(image_id);
if (fsValPtr->innerRadius > 0)
{
gimp_selection_shrink(image_id, fsValPtr->innerRadius);
}
shrinkedSelection = gimp_selection_save(image_id);
/* use WHITE color to mark foreground regions
*/
color.r = 1.0;
color.g = 1.0;
color.b = 1.0;
color.a = 1.0;
gimp_context_set_background (&color);
gimp_edit_fill(trimap, GIMP_BACKGROUND_FILL);
gimp_selection_load(activeSelection);
gimp_selection_sharpen(image_id);
if (fsValPtr->outerRadius > 0)
{
gimp_selection_grow(image_id, fsValPtr->outerRadius);
}
gimp_selection_combine(shrinkedSelection, GIMP_CHANNEL_OP_SUBTRACT);
/* use medium GRAY to mark undefined regions
*/
color.r = 0.5;
color.g = 0.5;
color.b = 0.5;
color.a = 1.0;
gimp_context_set_background (&color);
gimp_edit_fill(trimap, GIMP_BACKGROUND_FILL);
gimp_selection_none(image_id);
/* perform the foreground selection (that creates the resulting layer) */
{
GapFgExtractValues fgExtractValues;
GapFgExtractValues *fgValPtr;
fgValPtr = &fgExtractValues;
fgValPtr->input_drawable_id = drawable_id;
fgValPtr->tri_map_drawable_id = trimap;
fgValPtr->create_result = TRUE;
fgValPtr->create_layermask = fsValPtr->create_layermask;
fgValPtr->lock_color = fsValPtr->lock_color;
fgValPtr->colordiff_threshold = fsValPtr->colordiff_threshold;
rc = gap_fg_matting_exec_apply_run (image_id, drawable_id
, doProgress, doFlush
, fgValPtr
);
}
/* restore original selection */
if (hadSelection == TRUE)
{
gimp_selection_load(activeSelection);
}
gimp_image_undo_group_end(image_id);
gimp_context_pop();
return (rc);
} /* end gap_fg_from_selection_exec_apply_run */
static void
d_paint_star (GfigObject *obj)
{
/* first point center */
/* Next point is radius */
gdouble *line_pnts;
gint seg_count = 0;
gint i = 0;
DobjPoints *center_pnt;
DobjPoints *outer_radius_pnt;
DobjPoints *inner_radius_pnt;
gint16 shift_x;
gint16 shift_y;
gdouble ang_grid;
gdouble ang_loop;
gdouble outer_radius;
gdouble inner_radius;
gdouble offset_angle;
gint loop;
GdkPoint first_pnt = { 0, 0 };
GdkPoint last_pnt = { 0, 0 };
gboolean first = TRUE;
gdouble *min_max;
g_assert (obj != NULL);
/* count - add one to close polygon */
seg_count = 2 * obj->type_data + 1;
center_pnt = obj->points;
if (!center_pnt || !seg_count)
return; /* no-line */
line_pnts = g_new0 (gdouble, 2 * seg_count + 1);
min_max = g_new (gdouble, 4);
/* Go around all the points drawing a line from one to the next */
/* Next point defines the radius */
outer_radius_pnt = center_pnt->next; /* this defines the vetices */
if (!outer_radius_pnt)
{
#ifdef DEBUG
g_warning ("Internal error in star - no outer vertice point \n");
#endif /* DEBUG */
g_free (line_pnts);
g_free (min_max);
return;
}
inner_radius_pnt = outer_radius_pnt->next; /* this defines the vetices */
if (!inner_radius_pnt)
{
#ifdef DEBUG
g_warning ("Internal error in star - no inner vertice point \n");
#endif /* DEBUG */
g_free (line_pnts);
g_free (min_max);
return;
}
shift_x = outer_radius_pnt->pnt.x - center_pnt->pnt.x;
shift_y = outer_radius_pnt->pnt.y - center_pnt->pnt.y;
outer_radius = sqrt ((shift_x*shift_x) + (shift_y*shift_y));
/* Lines */
ang_grid = 2.0 * G_PI / (2.0 * (gdouble) obj->type_data);
offset_angle = atan2 (shift_y, shift_x);
shift_x = inner_radius_pnt->pnt.x - center_pnt->pnt.x;
shift_y = inner_radius_pnt->pnt.y - center_pnt->pnt.y;
inner_radius = sqrt ((shift_x*shift_x) + (shift_y*shift_y));
for (loop = 0 ; loop < 2 * obj->type_data ; loop++)
{
gdouble lx, ly;
GdkPoint calc_pnt;
ang_loop = (gdouble)loop * ang_grid + offset_angle;
if (loop % 2)
{
lx = inner_radius * cos (ang_loop);
ly = inner_radius * sin (ang_loop);
}
else
{
lx = outer_radius * cos (ang_loop);
ly = outer_radius * sin (ang_loop);
}
calc_pnt.x = RINT (lx + center_pnt->pnt.x);
calc_pnt.y = RINT (ly + center_pnt->pnt.y);
/* Miss out duped pnts */
if (!first)
{
if (calc_pnt.x == last_pnt.x && calc_pnt.y == last_pnt.y)
{
continue;
}
}
line_pnts[i++] = calc_pnt.x;
line_pnts[i++] = calc_pnt.y;
last_pnt = calc_pnt;
if (first)
{
first_pnt = calc_pnt;
first = FALSE;
min_max[0] = min_max[2] = calc_pnt.x;
min_max[1] = min_max[3] = calc_pnt.y;
}
else
{
min_max[0] = MIN (min_max[0], calc_pnt.x);
min_max[1] = MIN (min_max[1], calc_pnt.y);
min_max[2] = MAX (min_max[2], calc_pnt.x);
min_max[3] = MAX (min_max[3], calc_pnt.y);
}
}
line_pnts[i++] = first_pnt.x;
line_pnts[i++] = first_pnt.y;
/* Scale before drawing */
if (selvals.scaletoimage)
{
scale_to_original_xy (&line_pnts[0], i / 2);
scale_to_original_xy (min_max, 2);
}
else
{
scale_to_xy (&line_pnts[0], i / 2);
scale_to_xy (min_max, 2);
}
if (gfig_context_get_current_style ()->fill_type != FILL_NONE)
{
gimp_context_push ();
gimp_context_set_antialias (selopt.antia);
gimp_context_set_feather (selopt.feather);
gimp_context_set_feather_radius (selopt.feather_radius, selopt.feather_radius);
gimp_image_select_polygon (gfig_context->image_id,
selopt.type,
i, line_pnts);
gimp_context_pop ();
paint_layer_fill (min_max[0], min_max[1], min_max[2], min_max[3]);
gimp_selection_none (gfig_context->image_id);
}
if (obj->style.paint_type == PAINT_BRUSH_TYPE)
gfig_paint (selvals.brshtype, gfig_context->drawable_id, i, line_pnts);
g_free (line_pnts);
g_free (min_max);
}
/* --------------------------
* p_process_layer
* --------------------------
*/
static gint32
p_process_layer(gint32 image_id, gint32 drawable_id, TransValues *val_ptr)
{
gboolean has_selection;
gboolean non_empty;
gboolean alt_selection_success;
gint x1, y1, x2, y2;
gint32 trans_drawable_id;
if(gap_debug)
{
printf("corpus_border_radius: %d\n", (int)val_ptr->corpus_border_radius);
printf("alt_selection: %d\n", (int)val_ptr->alt_selection);
printf("seed: %d\n", (int)val_ptr->seed);
}
gimp_image_undo_group_start(image_id);
trans_drawable_id = -1;
alt_selection_success = FALSE;
if(val_ptr->alt_selection >= 0)
{
if(gap_debug)
{
printf("p_process_layer creating alt_selection: %d\n", (int)val_ptr->alt_selection);
}
alt_selection_success = p_set_alt_selection(image_id, drawable_id, val_ptr);
}
has_selection = gimp_selection_bounds(image_id, &non_empty, &x1, &y1, &x2, &y2);
if(gap_debug)
{
printf("p_process_layer has_selection: %d\n", (int)has_selection);
}
/* here the action starts, we create the corpus_layer_id that builds the reference pattern
* (the corpus is created in a spearate image and has an expanded selection
* that excludes the unwanted parts)
* then start the resynthesizer plug-in to replace selected (i.e. unwanted parts) of the
* processed layer (i.e. drawable_id)
*/
if (non_empty)
{
gint32 corpus_layer_id;
gint32 corpus_image_id;
trans_drawable_id = drawable_id;
corpus_layer_id = p_create_corpus_layer(image_id, drawable_id, val_ptr);
p_pdb_call_resynthesizer(image_id, drawable_id, corpus_layer_id, val_ptr->seed);
/* delete the temporary working duplicate */
corpus_image_id = gimp_item_get_image(corpus_layer_id);
gimp_image_delete(corpus_image_id);
}
else
{
g_message("Please make a selection (cant operate on empty selection)");
}
if(alt_selection_success)
{
gimp_selection_none(image_id);
}
gimp_image_undo_group_end(image_id);
return (trans_drawable_id);
} /* end p_process_layer */
static void
d_paint_circle (GfigObject *obj)
{
DobjPoints *center_pnt;
DobjPoints *edge_pnt;
gint radius;
gdouble dpnts[4];
g_assert (obj != NULL);
center_pnt = obj->points;
if (!center_pnt)
return; /* End-of-line */
edge_pnt = center_pnt->next;
if (!edge_pnt)
{
g_error ("Internal error - circle no edge pnt");
}
radius = calc_radius (¢er_pnt->pnt, &edge_pnt->pnt);
dpnts[0] = (gdouble) center_pnt->pnt.x - radius;
dpnts[1] = (gdouble) center_pnt->pnt.y - radius;
dpnts[3] = dpnts[2] = (gdouble) radius * 2;
/* Scale before drawing */
if (selvals.scaletoimage)
scale_to_original_xy (&dpnts[0], 2);
else
scale_to_xy (&dpnts[0], 2);
if (gfig_context_get_current_style ()->fill_type != FILL_NONE)
{
gimp_context_push ();
gimp_context_set_antialias (selopt.antia);
gimp_context_set_feather (selopt.feather);
gimp_context_set_feather_radius (selopt.feather_radius, selopt.feather_radius);
gimp_image_select_ellipse (gfig_context->image_id,
selopt.type,
dpnts[0], dpnts[1],
dpnts[2], dpnts[3]);
gimp_context_pop ();
paint_layer_fill (center_pnt->pnt.x - radius,
center_pnt->pnt.y - radius,
center_pnt->pnt.x + radius,
center_pnt->pnt.y + radius);
gimp_selection_none (gfig_context->image_id);
}
/* Drawing a circle may be harder than stroking a circular selection,
* but we have to do it or we will not be able to draw outside of the
* layer. */
if (obj->style.paint_type == PAINT_BRUSH_TYPE)
{
const gdouble r = dpnts[2] / 2;
const gdouble cx = dpnts[0] + r, cy = dpnts[1] + r;
gdouble line_pnts[362];
gdouble angle = 0;
gint i = 0;
while (i < 362)
{
static const gdouble step = 2 * G_PI / 180;
line_pnts[i++] = cx + r * cos (angle);
line_pnts[i++] = cy + r * sin (angle);
angle += step;
}
gfig_paint (selvals.brshtype, gfig_context->drawable_id, i, line_pnts);
}
}
