/* -------------------------------------------
* gap_morph_shape_generate_outline_workpoints
* -------------------------------------------
*/
void
gap_morph_shape_generate_outline_workpoints(GapMorphGlobalParams *mgpp)
{
GapMorphWorkPoint *wp;
GimpPixelFetcher *src_pixfet;
GimpPixelFetcher *dst_pixfet;
GimpDrawable *dst_drawable;
GimpDrawable *src_drawable;
gdouble alpha_rad;
gdouble step_rad;
gint ii;
src_drawable = gimp_drawable_get (mgpp->osrc_layer_id);
dst_drawable = gimp_drawable_get (mgpp->fdst_layer_id);
src_pixfet = gimp_pixel_fetcher_new (src_drawable, FALSE /*shadow*/);
dst_pixfet = gimp_pixel_fetcher_new (dst_drawable, FALSE /*shadow*/);
step_rad = (2.0 * G_PI) / MAX(1, mgpp->numOutlinePoints);
alpha_rad = 0.0;
/* loop from 0 to 360 degree */
for(ii=0; ii < mgpp->numOutlinePoints; ii++)
{
gdouble sx, sy, dx, dy;
p_find_outmost_opaque_pixel(src_pixfet
,src_drawable->bpp
,alpha_rad
,src_drawable->width
,src_drawable->height
,&sx
,&sy
);
p_find_outmost_opaque_pixel(dst_pixfet
,dst_drawable->bpp
,alpha_rad
,dst_drawable->width
,dst_drawable->height
,&dx
,&dy
);
/* create a new workpoint with sx,sy, dx, dy coords */
wp = gap_morph_shape_new_workpont(sx ,sy ,dx ,dy);
wp->next = mgpp->master_wp_list;
mgpp->master_wp_list = wp;
alpha_rad += step_rad;
}
gimp_pixel_fetcher_destroy (src_pixfet);
gimp_pixel_fetcher_destroy (dst_pixfet);
gimp_drawable_detach(src_drawable);
gimp_drawable_detach(dst_drawable);
} /* end gap_morph_shape_generate_outline_workpoints */
static void
compute_image (GimpDrawable *drawable)
{
GimpDrawable *effect;
guchar *scalarfield = NULL;
/* Get some useful info on the input drawable */
/* ========================================== */
if (! gimp_drawable_mask_intersect (drawable->drawable_id,
&border_x, &border_y, &border_w, &border_h))
return;
gimp_progress_init (_("Van Gogh (LIC)"));
if (licvals.effect_convolve == 0)
generatevectors ();
if (licvals.filtlen < 0.1)
licvals.filtlen = 0.1;
l = licvals.filtlen;
dx = dy = licvals.noisemag;
minv = licvals.minv / 10.0;
maxv = licvals.maxv / 10.0;
isteps = licvals.intsteps;
source_drw_has_alpha = gimp_drawable_has_alpha (drawable->drawable_id);
effect = gimp_drawable_get (licvals.effect_image_id);
effect_width = effect->width;
effect_height = effect->height;
switch (licvals.effect_channel)
{
case 0:
scalarfield = rgb_to_hsl (effect, LIC_HUE);
break;
case 1:
scalarfield = rgb_to_hsl (effect, LIC_SATURATION);
break;
case 2:
scalarfield = rgb_to_hsl (effect, LIC_BRIGHTNESS);
break;
}
compute_lic (drawable, scalarfield, licvals.effect_operator);
g_free (scalarfield);
/* Update image */
/* ============ */
gimp_drawable_flush (drawable);
gimp_drawable_merge_shadow (drawable->drawable_id, TRUE);
gimp_drawable_update (drawable->drawable_id, border_x, border_y,
border_w, border_h);
gimp_displays_flush ();
}
static void
prepare (GeglOperation *operation)
{
GeglChantO *o = GEGL_CHANT_PROPERTIES (operation);
if (o->drawableID)
{
const Babl *format;
GimpDrawable * drawable;
guint bpp;
// GEGL_MARK()
g_printf("Prepare\n");
drawable = gimp_drawable_get(o->drawableID);
// drawable = (GimpDrawable*) o->drawableID;
bpp = drawable->bpp;
// defined in app/gegl/gegl-utils.c
/*
if (self->linear)
format = gimp_bpp_to_babl_format_linear (bpp);
else
format = gimp_bpp_to_babl_format (bpp);
*/
// format = gimp_bpp_to_babl_format (bpp);
format = babl_format ("RGBA u8");
gegl_operation_set_format (operation, "output", format);
}
}
static void
run (const gchar *name,
gint n_params,
const GimpParam *param,
gint *nreturn_vals,
GimpParam **return_vals)
{
static GimpParam values[1];
GimpDrawable *drawable;
GimpRunMode run_mode;
GimpPDBStatusType status = GIMP_PDB_SUCCESS;
gint32 image_id;
*nreturn_vals = 1;
*return_vals = values;
run_mode = param[0].data.d_int32;
if (run_mode == GIMP_RUN_NONINTERACTIVE)
{
if (n_params != 3)
{
status = GIMP_PDB_CALLING_ERROR;
}
}
if (status == GIMP_PDB_SUCCESS)
{
/* Get the specified drawable */
drawable = gimp_drawable_get(param[2].data.d_drawable);
image_id = param[1].data.d_image;
/* Make sure that the drawable is gray or RGB or indexed */
if (gimp_drawable_is_rgb (drawable->drawable_id) ||
gimp_drawable_is_gray (drawable->drawable_id) ||
gimp_drawable_is_indexed (drawable->drawable_id))
{
gimp_progress_init ("Autocropping...");
gimp_tile_cache_ntiles (1 +
(drawable->width > drawable->height ?
(drawable->width / gimp_tile_width()) :
(drawable->height / gimp_tile_height())));
do_acrop(drawable, image_id);
if (run_mode != GIMP_RUN_NONINTERACTIVE)
gimp_displays_flush ();
gimp_drawable_detach (drawable);
}
else
{
status = GIMP_PDB_EXECUTION_ERROR;
}
}
values[0].type = GIMP_PDB_STATUS;
values[0].data.d_status = status;
}
static void preview_specular_only(gint32 image_ID) {
gint32 drawableSpecular_ID = -1;
gint32 nResult = 0;
preview_ambient_occlusion_only(image_ID);
if(local_vals.EdgeSpecular)
{
gtk_label_set_text(GTK_LABEL(progress_label), "Specular Edging");
drawableSpecular_ID = specularEdgeWorker(image_ID, local_vals.defSpecular, local_vals.ao, FALSE);
if (drawableSpecular_ID == -1) {
gimp_message("Specular Edge Worker returned -1!");
nResult = 0;
} else nResult = 1;
}
else
{
gtk_label_set_text(GTK_LABEL(progress_label), "Specular Smoothing");
drawableSpecular_ID = specularSmoothWorker(image_ID, local_vals.defSpecular, local_vals.ao, FALSE);
if (drawableSpecular_ID == -1) {
gimp_message("Specular Smooth Worker returned -1!");
nResult = 0;
} else nResult = 1;
}
gtk_label_set_text(GTK_LABEL(progress_label), "Idle...");
gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR(progress), 1.0);
if (nResult == 1) {
pDrawables.drawable_s = gimp_drawable_get(drawableSpecular_ID);
} else {
pDrawables.drawable_s = NULL;
}
}
void imgproc::dilate::run(GimpRunMode, gint32 /*imageId*/, gint32 drawableId)
{
boost::optional<Arguments> arguments = presentDialog();
if (!arguments)
{
return;
}
GimpDrawable* const drawable = gimp_drawable_get(drawableId);
try
{
cv::Mat src = drawableToMat(drawable);
cv::Mat dst;
cv::dilate(src, dst, UNPACK_TUPLE(*arguments, 0, 4));
setMatToDrawable(dst, drawable);
}
catch (cv::Exception const& e)
{
messageDialog(e.what());
}
catch (IncompatibleMat const& e)
{
messageDialog(e.what());
}
gimp_displays_flush();
gimp_drawable_detach(drawable);
}
static void
run (const gchar *name,
gint nparams,
const GimpParam *param,
gint *nreturn_vals,
GimpParam **return_vals)
{
static GimpParam values[1];
GimpPDBStatusType status = GIMP_PDB_SUCCESS;
GimpRunMode run_mode;
GimpDrawable *drawable;
/* Setting mandatory output values */
*nreturn_vals = 1;
*return_vals = values;
values[0].type = GIMP_PDB_STATUS;
values[0].data.d_status = status;
/* Getting run_mode - we won't display a dialog if
* we are in NONINTERACTIVE mode */
run_mode = param[0].data.d_int32;
/* Get the specified drawable */
drawable = gimp_drawable_get (param[2].data.d_drawable);
blur (drawable);
gimp_displays_flush ();
gimp_drawable_detach (drawable);
return;
}
static void
run (const gchar *name,
gint nparams,
const GimpParam *param,
gint *nreturn_vals,
GimpParam **return_vals)
{
static GimpParam values[1];
GimpPDBStatusType status = GIMP_PDB_SUCCESS;
*nreturn_vals = 1;
*return_vals = values;
INIT_I18N ();
values[0].type = GIMP_PDB_STATUS;
values[0].data.d_status = status;
Current.drawable = gimp_drawable_get (param[2].data.d_drawable);
Current.mask = gimp_drawable_get (gimp_image_get_selection (param[1].data.d_image));
if (gimp_drawable_is_rgb (Current.drawable->drawable_id))
{
if (color_rotate_dialog ())
{
gimp_progress_init (_("Rotating the colors"));
gimp_tile_cache_ntiles (2 * (Current.drawable->width /
gimp_tile_width () + 1));
color_rotate (Current.drawable);
gimp_displays_flush ();
}
else
{
status = GIMP_PDB_CANCEL;
}
}
else
{
status = GIMP_PDB_EXECUTION_ERROR;
}
values[0].data.d_status = status;
if (status == GIMP_PDB_SUCCESS)
gimp_drawable_detach (Current.drawable);
}
/* Draw the number of the picture onto the film */
static void
draw_number (gint32 layer_ID,
gint num,
gint x,
gint y,
gint height)
{
gchar buf[32];
GimpDrawable *drw;
gint k, delta, max_delta;
gint32 image_ID;
gint32 text_layer_ID;
gint text_width, text_height, text_ascent, descent;
gchar *fontname = filmvals.number_font;
g_snprintf (buf, sizeof (buf), "%d", num);
drw = gimp_drawable_get (layer_ID);
image_ID = gimp_item_get_image (layer_ID);
max_delta = height / 10;
if (max_delta < 1)
max_delta = 1;
/* Numbers dont need the descent. Inquire it and move the text down */
for (k = 0; k < max_delta * 2 + 1; k++)
{
/* Try different font sizes if inquire of extent failed */
gboolean success;
delta = (k+1) / 2;
if ((k & 1) == 0)
delta = -delta;
success = gimp_text_get_extents_fontname (buf,
height + delta, GIMP_PIXELS,
fontname,
&text_width, &text_height,
&text_ascent, &descent);
if (success)
{
height += delta;
break;
}
}
text_layer_ID = gimp_text_fontname (image_ID, layer_ID,
x, y + descent / 2,
buf, 1, FALSE,
height, GIMP_PIXELS,
fontname);
if (text_layer_ID == -1)
g_message ("draw_number: Error in drawing text\n");
gimp_drawable_detach (drw);
}
/*
* sendBMPToGIMP
*
* Take the captured data and send it across
* to GIMP.
*/
static void
sendBMPToGimp(HBITMAP hBMP, HDC hDC, RECT rect)
{
int width, height;
int imageType, layerType;
gint32 image_id;
gint32 layer_id;
GimpPixelRgn pixel_rgn;
GimpDrawable *drawable;
/* Our width and height */
width = (rect.right - rect.left);
height = (rect.bottom - rect.top);
/* Check that we got the memory */
if (!capBytes) {
g_message (_("No data captured"));
return;
}
/* Flip the red and blue bytes */
flipRedAndBlueBytes(width, height);
/* Set up the image and layer types */
imageType = GIMP_RGB;
layerType = GIMP_RGB_IMAGE;
/* Create the GIMP image and layers */
image_id = gimp_image_new(width, height, imageType);
layer_id = gimp_layer_new(image_id, _("Background"),
ROUND4(width), height,
layerType, 100, GIMP_NORMAL_MODE);
gimp_image_insert_layer(image_id, layer_id, -1, 0);
/* Get our drawable */
drawable = gimp_drawable_get(layer_id);
gimp_tile_cache_size(ROUND4(width) * gimp_tile_height() * 3);
/* Initialize a pixel region for writing to the image */
gimp_pixel_rgn_init(&pixel_rgn, drawable, 0, 0,
ROUND4(width), height, TRUE, FALSE);
gimp_pixel_rgn_set_rect(&pixel_rgn, (guchar *) capBytes,
0, 0, ROUND4(width), height);
/* HB: update data BEFORE size change */
gimp_drawable_flush(drawable);
/* Now resize the layer down to the correct size if necessary. */
if (width != ROUND4(width)) {
gimp_layer_resize (layer_id, width, height, 0, 0);
gimp_image_resize (image_id, width, height, 0, 0);
}
/* Finish up */
gimp_drawable_detach(drawable);
gimp_display_new (image_id);
return;
}
static void
run (const gchar *name,
gint nparams,
const GimpParam *param,
gint *nreturn_vals,
GimpParam **return_vals)
{
static GimpParam values[1];
GimpPDBStatusType status = GIMP_PDB_SUCCESS;
GimpRunMode run_mode;
GimpDrawable *drawable;
INIT_I18N ();
run_mode = param[0].data.d_int32;
drawable = gimp_drawable_get (param[2].data.d_int32);
*nreturn_vals = 1;
*return_vals = values;
values[0].type = GIMP_PDB_STATUS;
values[0].data.d_status = status;
switch (run_mode)
{
case GIMP_RUN_INTERACTIVE:
gimp_get_data (HSV_NOISE_PROC, &VALS);
if (!gimp_drawable_is_rgb (drawable->drawable_id))
{
g_message (_("Can only operate on RGB drawables."));
return;
}
if (! scatter_hsv_dialog (drawable))
return;
break;
case GIMP_RUN_NONINTERACTIVE:
VALS.holdness = CLAMP (param[3].data.d_int32, 1, 8);
VALS.hue_distance = CLAMP (param[4].data.d_int32, 0, 180);
VALS.saturation_distance = CLAMP (param[5].data.d_int32, 0, 255);
VALS.value_distance = CLAMP (param[6].data.d_int32, 0, 255);
break;
case GIMP_RUN_WITH_LAST_VALS:
gimp_get_data (HSV_NOISE_PROC, &VALS);
break;
}
scatter_hsv (drawable);
if (run_mode != GIMP_RUN_NONINTERACTIVE)
gimp_displays_flush();
if (run_mode == GIMP_RUN_INTERACTIVE && status == GIMP_PDB_SUCCESS )
gimp_set_data (HSV_NOISE_PROC, &VALS, sizeof (ValueType));
values[0].type = GIMP_PDB_STATUS;
values[0].data.d_status = status;
}
/* main function */
static void
run (const gchar *name,
gint n_params,
const GimpParam *param,
gint *nreturn_vals,
GimpParam **return_vals)
{
static GimpParam values[2];
GimpRunMode run_mode;
GimpPDBStatusType status = GIMP_PDB_SUCCESS;
GimpDrawable *drawable;
run_mode = param[0].data.d_int32;
INIT_I18N ();
*nreturn_vals = 2;
*return_vals = values;
if (run_mode == GIMP_RUN_NONINTERACTIVE)
{
if (n_params != 3)
status = GIMP_PDB_CALLING_ERROR;
}
if (status == GIMP_PDB_SUCCESS)
{
drawable = gimp_drawable_get (param[2].data.d_drawable);
imageID = param[1].data.d_image;
if (gimp_drawable_is_rgb (drawable->drawable_id) ||
gimp_drawable_is_gray (drawable->drawable_id) ||
gimp_drawable_is_indexed (drawable->drawable_id))
{
memset (hist_red, 0, sizeof (hist_red));
memset (hist_green, 0, sizeof (hist_green));
memset (hist_blue, 0, sizeof (hist_blue));
gimp_tile_cache_ntiles (2 *
(drawable->width / gimp_tile_width () + 1));
analyze (drawable);
/* show dialog after we analyzed image */
if (run_mode != GIMP_RUN_NONINTERACTIVE)
doDialog ();
}
else
status = GIMP_PDB_EXECUTION_ERROR;
gimp_drawable_detach (drawable);
}
values[0].type = GIMP_PDB_STATUS;
values[0].data.d_status = status;
values[1].type = GIMP_PDB_INT32;
values[1].data.d_int32 = uniques;
}
static void
run (const gchar *name,
gint n_params,
const GimpParam *param,
gint *nreturn_vals,
GimpParam **return_vals)
{
static GimpParam values[1];
GimpDrawable *drawable;
gint32 image_ID;
GimpRunMode run_mode;
GimpPDBStatusType status = GIMP_PDB_SUCCESS;
*nreturn_vals = 1;
*return_vals = values;
run_mode = param[0].data.d_int32;
image_ID = param[1].data.d_int32;
drawable = gimp_drawable_get (param[2].data.d_drawable);
static PlugInVals vals; // Not initialized with default values, no GUI
if (strcmp (name, PROCEDURE_NAME) == 0)
{
switch (run_mode)
{
case GIMP_RUN_NONINTERACTIVE:
if (n_params != PROCEDURE_ARGS_COUNT) { status = GIMP_PDB_CALLING_ERROR; }
else
{
//< flesh out instance of extra args to render()
vals.dummy1 = param[3].data.d_int32;
}
break;
case GIMP_RUN_INTERACTIVE:
case GIMP_RUN_WITH_LAST_VALS:
// illegal to call in interactive mode because this plugin is an engine w/o gui
status = GIMP_PDB_CALLING_ERROR;
break;
default:
break;
}
}
else { status = GIMP_PDB_CALLING_ERROR; }
if (status == GIMP_PDB_SUCCESS)
{
g_assert(run_mode == GIMP_RUN_NONINTERACTIVE);
render (image_ID, drawable, &vals);
// result is not visible to user, display not flushed since non-interactive
gimp_drawable_detach (drawable);
}
values[0].type = GIMP_PDB_STATUS;
values[0].data.d_status = status;
}
static void preview_normal_only(gint32 image_ID) {
gint32 drawableNormal_ID = -1;
/**
* Do not do this for preview.
* gint32 diffuse_ID = gimp_image_get_active_layer(image_ID);
* gimp_drawable_set_visible(diffuse_ID, 0);
* gimp_image_merge_visible_layers(image_ID, 0);
*
* The theory here is to leave the original layer untouched,
* copy the active original layer, make the copy active,
* then modify the active layer. Show this layer to the
* preview slot, then delete the active layer, Leaving
* the original drawing untouched for previews.
*/
preview_diffuse_only(image_ID);
preview_alt_normal(image_ID);
/** Just grab. */
drawableNormal_ID = gimp_image_get_active_layer(image_ID);
/**
* We just copied the active layer and made it active, don't need to do it again.
*
* drawableNormalPrev_ID = gimp_image_get_active_layer(image_ID);
*/
/**
* Filter "Normalmap" applied
* Non-Standard plug-in. Source code included.
*
* original values:
* plug_in_normalmap_derby(image, drawable, 0, 0.0, 1.0, 0, 0, 0, 8, 0, 0, 0, 0, 0.0, drawable)
*/
nmapvals.filter = 0;
nmapvals.minz = 0.0f;
nmapvals.scale = 1.0f;
nmapvals.wrap = 0;
nmapvals.height_source = 0;
nmapvals.alpha = 0;
nmapvals.conversion = 8;
nmapvals.dudv = 0;
nmapvals.xinvert = 0;
nmapvals.yinvert = 0;
nmapvals.swapRGB = 0;
nmapvals.contrast = 0.0f;
nmapvals.alphamap_id = drawableNormal_ID;
gtk_label_set_text(GTK_LABEL(progress_label), "Normal map");
normalmap(drawableNormal_ID, 0);
gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR(progress), 0.80);
if (gcNeedNormal == 'n') {
pDrawables.drawable_n = gimp_drawable_get(drawableNormal_ID);
}
gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR(progress), 0.85);
}
static void
preview_update_preview (GimpPreview *preview,
GimpDrawable *drawable)
{
gint x1, y1;
gint width, height;
gint bpp;
guchar *buffer;
GimpPixelRgn src_rgn;
GimpPixelRgn preview_rgn;
gint32 image_id, src_image_id;
gint32 preview_id;
GimpDrawable *preview_drawable;
bpp = gimp_drawable_bpp (drawable->drawable_id);
gimp_preview_get_position (preview, &x1, &y1);
gimp_preview_get_size (preview, &width, &height);
buffer = g_new (guchar, width * height * bpp);
gimp_pixel_rgn_init (&src_rgn, drawable,
x1, y1, width, height, FALSE, FALSE);
gimp_pixel_rgn_get_rect (&src_rgn, buffer,
x1, y1, width, height);
/* set up gimp drawable for rendering preview into */
src_image_id = gimp_drawable_get_image (drawable->drawable_id);
image_id = gimp_image_new (width, height,
gimp_image_base_type (src_image_id));
preview_id = gimp_layer_new (image_id, "preview", width, height,
gimp_drawable_type (drawable->drawable_id),
100,
GIMP_NORMAL_MODE);
preview_drawable = gimp_drawable_get (preview_id);
gimp_image_add_layer (image_id, preview_id, 0);
gimp_layer_set_offsets (preview_id, 0, 0);
gimp_pixel_rgn_init (&preview_rgn, preview_drawable,
0, 0, width, height, TRUE, TRUE);
gimp_pixel_rgn_set_rect (&preview_rgn, buffer,
0, 0, width, height);
gimp_drawable_flush (preview_drawable);
gimp_drawable_merge_shadow (preview_id, TRUE);
gimp_drawable_update (preview_id, 0, 0, width, height);
dog (image_id, preview_drawable, dogvals.inner, dogvals.outer, FALSE);
gimp_pixel_rgn_get_rect (&preview_rgn, buffer,
0, 0, width, height);
gimp_preview_draw_buffer (preview, buffer, width * bpp);
gimp_image_delete (image_id);
g_free (buffer);
}
static void run(const gchar G_GNUC_UNUSED *nome, gint nparams, const GimpParam * params, gint *nretvals, GimpParam ** retparams)
{
static GimpParam ret[1];
GimpPDBStatusType* status;
GimpDrawable* drawable;
param_type p = VIZ4;
*nretvals = 1;
*retparams = ret;
ret[0].type = GIMP_PDB_STATUS;
status = (GimpPDBStatusType*) &(ret[0].data.d_status);
*status = GIMP_PDB_CALLING_ERROR;
drawable = gimp_drawable_get(params[2].data.d_drawable);
if (!gimp_get_data(nome, &p))
p = VIZ4;
switch (params[0].data.d_int32)
{
case GIMP_RUN_INTERACTIVE:
if (!show_dialog(&p))
{
ret[0].data.d_status = GIMP_PDB_CANCEL;
return;
}
break;
case GIMP_RUN_WITH_LAST_VALS:
break;
case GIMP_RUN_NONINTERACTIVE:
if (nparams != 4)
{
/* retorna o erro de chamadoa para o gimp */
ret[0].data.d_status = GIMP_PDB_CALLING_ERROR;
return;
}
p = params[3].data.d_int8;
break;
default:
g_error("programa no lugar errado");
ret[0].data.d_status = GIMP_PDB_EXECUTION_ERROR;
return;
}
gimp_set_data(nome, &p, sizeof(param_type));
*status = execute_plugin(drawable, nome, &p);
ret[0].data.d_status = GIMP_PDB_SUCCESS;
return;
}
static void
run (const gchar *name,
gint nparams,
const GimpParam *param,
gint *nreturn_vals,
GimpParam **return_vals)
{
GimpDrawable *drawable;
static GimpParam values[1];
GimpPDBStatusType status = GIMP_PDB_EXECUTION_ERROR;
GimpRunMode run_mode;
run_mode = param[0].data.d_int32;
drawable = gimp_drawable_get (param[2].data.d_drawable);
INIT_I18N ();
*nreturn_vals = 1;
*return_vals = values;
values[0].type = GIMP_PDB_STATUS;
values[0].data.d_status = status;
switch (run_mode)
{
case GIMP_RUN_INTERACTIVE:
gimp_get_data (PLUG_IN_PROC, &pvals);
/* Since a channel might be selected, we must check wheter RGB or not. */
if (!gimp_drawable_is_rgb (drawable->drawable_id))
{
g_message (_("Can only operate on RGB drawables."));
return;
}
if (! max_rgb_dialog (drawable))
return;
break;
case GIMP_RUN_NONINTERACTIVE:
/* You must copy the values of parameters to pvals or dialog variables. */
pvals.max_p = param[3].data.d_int32;
break;
case GIMP_RUN_WITH_LAST_VALS:
gimp_get_data (PLUG_IN_PROC, &pvals);
break;
}
status = main_function (drawable, NULL);
if (run_mode != GIMP_RUN_NONINTERACTIVE)
gimp_displays_flush ();
if (run_mode == GIMP_RUN_INTERACTIVE && status == GIMP_PDB_SUCCESS)
gimp_set_data (PLUG_IN_PROC, &pvals, sizeof (ValueType));
values[0].data.d_status = status;
}
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 = GIMP_PDB_SUCCESS;
GimpRunMode run_mode;
gint32 image_ID;
INIT_I18N();
run_mode = param[0].data.d_int32;
/* Get the specified drawable */
drawable = gimp_drawable_get (param[2].data.d_drawable);
image_ID = param[1].data.d_image;
/* Make sure that the drawable is gray or RGB color */
if (gimp_drawable_is_rgb (drawable->drawable_id) ||
gimp_drawable_is_gray (drawable->drawable_id))
{
gimp_progress_init (_("Auto-Stretching HSV"));
gimp_tile_cache_ntiles (2 * (drawable->width / gimp_tile_width () + 1));
autostretch_hsv (drawable);
if (run_mode != GIMP_RUN_NONINTERACTIVE)
gimp_displays_flush ();
}
else if (gimp_drawable_is_indexed (drawable->drawable_id))
{
indexed_autostretch_hsv (image_ID);
if (run_mode != GIMP_RUN_NONINTERACTIVE)
gimp_displays_flush ();
}
else
{
/* gimp_message ("autostretch_hsv: cannot operate on indexed color images"); */
status = GIMP_PDB_EXECUTION_ERROR;
}
*nreturn_vals = 1;
*return_vals = values;
values[0].type = GIMP_PDB_STATUS;
values[0].data.d_status = status;
gimp_drawable_detach (drawable);
}
static GimpPDBStatusType
run_pspi (const gchar *pdb_name,
gint n_params,
const GimpParam *param)
{
GimpRunMode run_mode = param[0].data.d_int32;
GimpDrawable *drawable;
GimpPDBStatusType status = GIMP_PDB_SUCCESS;
PSPlugInEntry *pspie;
gint x1, y1, x2, y2;
get_saved_plugin_data ();
if ((pspie = g_hash_table_lookup (entry_hash, pdb_name)) != NULL)
{
gchar *name;
if (run_mode == GIMP_RUN_NONINTERACTIVE)
{
if (n_params != standard_nargs)
return GIMP_PDB_CALLING_ERROR;
}
else if (run_mode == GIMP_RUN_INTERACTIVE)
{
if ((status = pspi_params (pspie)) != GIMP_PDB_SUCCESS)
return status;
}
drawable = gimp_drawable_get (param[2].data.d_drawable);
gimp_ui_init (PLUGIN_NAME, TRUE);
if ((status = pspi_prepare (pspie, drawable)) != GIMP_PDB_SUCCESS)
return status;
name = g_strdup_printf (_("Applying %s:"),
strrchr (pspie->menu_path, '/') + 1);
gimp_progress_init (name);
g_free (name);
if ((status = pspi_apply (pspie, drawable)) != GIMP_PDB_SUCCESS)
return status;
gimp_drawable_flush (drawable);
gimp_drawable_merge_shadow (drawable->drawable_id, TRUE);
gimp_drawable_mask_bounds (drawable->drawable_id, &x1, &y1, &x2, &y2);
gimp_drawable_update (drawable->drawable_id, x1, y1, (x2 - x1), (y2 - y1));
gimp_displays_flush ();
return GIMP_PDB_SUCCESS;
}
return GIMP_PDB_CALLING_ERROR;
}
static void dialog_marked_cb(GtkWidget *widget, gpointer data)
{
GimpDrawable **drawable = data;
gint32 marked_id;
gimp_int_combo_box_get_active(GIMP_INT_COMBO_BOX(widget), &marked_id);
if (marked_id != colorizevals.marked_id) {
gimp_drawable_detach(*drawable);
colorizevals.marked_id = marked_id;
*drawable = gimp_drawable_get(marked_id);
}
}
// !!! Note GIMP abbreviates Rgn instead of region, and gimp_ prefix to functions
// Compare to plug-ins/pygimp/pygimp-tile.c
static gboolean
process (GeglOperation *operation,
GeglBuffer *data,
const GeglRectangle *result)
{
GeglChantO *o = GEGL_CHANT_PROPERTIES (operation);
g_printf("Process sink\n");
if (! o->drawableID)
return FALSE;
else
{
GimpDrawable *drawable;
const Babl *format;
GimpPixelRgn io_pixel_region;
gpointer pr;
g_printf("result width %d\n", result->width);
drawable = gimp_drawable_get(o->drawableID);
// format = gegl_operation_get_format (operation, "output");
format = babl_format ("RGBA u8");
// TODO test format of operation with format of drawable
gimp_pixel_rgn_init (&io_pixel_region, drawable,
result->x, result->y,
result->width, result->height,
TRUE, TRUE);
for (pr = gimp_pixel_rgns_register (1, &io_pixel_region);
pr;
pr = gimp_pixel_rgns_process (pr))
{
GeglRectangle rect = { io_pixel_region.x, io_pixel_region.y, io_pixel_region.w, io_pixel_region.h };
gegl_buffer_get (data, GIMP_SINK_SCALE, &rect, format, io_pixel_region.data, io_pixel_region.rowstride);
}
/*
Drawable is set of tiles private to this sink.
Not the same as the caller's, nor the same as the source node's.
*/
gimp_drawable_flush(drawable);
gimp_drawable_merge_shadow(o->drawableID, FALSE);
gimp_drawable_update(o->drawableID, result->x, result->y,
result->width, result->height);
return TRUE;
}
}
void update_mask(PlugInVals *vals) {
#ifdef DEBUG
g_warning("update_mask to id = %d",vals->mask_drawable_id);
#endif
if (interface_vals.mask_drawable != NULL) gimp_drawable_detach(interface_vals.mask_drawable);
interface_vals.mask_drawable = gimp_drawable_get(vals->mask_drawable_id);
util_fillReducedBuffer (interface_vals.previewMask,
interface_vals.previewWidth,
interface_vals.previewHeight,
1, FALSE,
interface_vals.mask_drawable,
interface_vals.selectionX0, interface_vals.selectionY0,
interface_vals.selectionWidth, interface_vals.selectionHeight);
}
static gboolean
sel2path (gint32 image_ID)
{
gint32 selection_ID;
GimpDrawable *sel_drawable;
pixel_outline_list_type olt;
spline_list_array_type splines;
gimp_selection_bounds (image_ID, &has_sel,
&sel_x1, &sel_y1, &sel_x2, &sel_y2);
sel_width = sel_x2 - sel_x1;
sel_height = sel_y2 - sel_y1;
/* Now get the selection channel */
selection_ID = gimp_image_get_selection (image_ID);
if (selection_ID < 0)
return FALSE;
sel_drawable = gimp_drawable_get (selection_ID);
if (gimp_drawable_bpp (selection_ID) != 1)
{
g_warning ("Internal error. Selection bpp > 1");
return FALSE;
}
gimp_pixel_rgn_init (&selection_rgn, sel_drawable,
sel_x1, sel_y1, sel_width, sel_height,
FALSE, FALSE);
gimp_tile_cache_ntiles (2 * (sel_drawable->width + gimp_tile_width () - 1) /
gimp_tile_width ());
olt = find_outline_pixels ();
splines = fitted_splines (olt);
do_points (splines, image_ID);
gimp_drawable_detach (sel_drawable);
gimp_displays_flush ();
return TRUE;
}
void update_image(PlugInVals *vals) {
#ifdef DEBUG
g_warning("update_image to id = %d",vals->image_drawable_id);
#endif
if (interface_vals.image_drawable != NULL) gimp_drawable_detach(interface_vals.image_drawable);
interface_vals.image_drawable = gimp_drawable_get(vals->image_drawable_id);
util_fillReducedBuffer (interface_vals.previewImage,
interface_vals.previewWidth,
interface_vals.previewHeight,
4, TRUE,
interface_vals.image_drawable,
interface_vals.selectionX0, interface_vals.selectionY0,
interface_vals.selectionWidth, interface_vals.selectionHeight);
}
static void
run (const gchar *name,
gint nparams,
const GimpParam *param,
gint *nreturn_vals,
GimpParam **return_vals)
{
static GimpParam values[1];
GimpPDBStatusType status = GIMP_PDB_SUCCESS;
GimpRunMode run_mode;
GimpDrawable *drawable;
/* Setting mandatory output values */
*nreturn_vals = 1;
*return_vals = values;
values[0].type = GIMP_PDB_STATUS;
values[0].data.d_status = status;
/* Getting run_mode - we won't display a dialog if
* we are in NONINTERACTIVE mode
*/
run_mode = param[0].data.d_int32;
/* Get the specified drawable */
drawable = gimp_drawable_get (param[2].data.d_drawable);
gimp_progress_init ("Exponential Range ...");
/*
*
* GTimer timer = g_timer_new time ();
*/
exponentialrange (drawable);
/* g_print ("blur() took %g seconds.\n", g_timer_elapsed (timer));
* g_timer_destroy (timer);
*/
gimp_displays_flush ();
gimp_drawable_detach (drawable);
}
// !!! Note GIMP abbreviates Rgn instead of region, and gimp_ prefix to functions
// Compare to plug-ins/pygimp/pygimp-tile.c
static gboolean
process (GeglOperation *operation,
GeglBuffer *data,
const GeglRectangle *result)
{
GeglChantO *o = GEGL_CHANT_PROPERTIES (operation);
g_printf("Process\n");
if (! o->drawableID)
return FALSE;
else
{
GimpDrawable *drawable;
const Babl *format;
GimpPixelRgn io_pixel_region;
gpointer pr;
g_printf("result width %d\n", result->width);
drawable = gimp_drawable_get(o->drawableID);
// drawable = o->drawableID;
// format = gegl_operation_get_format (operation, "output");
format = babl_format ("RGBA u8");
gimp_pixel_rgn_init (&io_pixel_region, drawable,
result->x, result->y,
result->width, result->height,
FALSE, FALSE);
for (pr = gimp_pixel_rgns_register (1, &io_pixel_region);
pr;
pr = gimp_pixel_rgns_process (pr))
{
GeglRectangle rect = { io_pixel_region.x, io_pixel_region.y, io_pixel_region.w, io_pixel_region.h };
gegl_buffer_set (data, &rect, format, io_pixel_region.data, io_pixel_region.rowstride);
}
return TRUE;
}
}
static void
align_layers_get_align_offsets (gint32 drawable_id,
gint *x,
gint *y)
{
GimpDrawable *layer = gimp_drawable_get (drawable_id);
switch (VALS.h_base)
{
case H_BASE_LEFT:
*x = 0;
break;
case H_BASE_CENTER:
*x = layer->width / 2;
break;
case H_BASE_RIGHT:
*x = layer->width;
break;
default:
*x = 0;
break;
}
switch (VALS.v_base)
{
case V_BASE_TOP:
*y = 0;
break;
case V_BASE_CENTER:
*y = layer->height / 2;
break;
case V_BASE_BOTTOM:
*y = layer->height;
break;
default:
*y = 0;
break;
}
gimp_drawable_detach (layer);
}
static gint32 create_new_layer(
gint32 img,
gint position,
const gchar* layername,
guint width,
guint height,
GimpImageBaseType bas_type,
GimpDrawable** drawable,
GimpPixelRgn* pixel_rgn)
{
gint32 layer;
GimpImageType img_type = GIMP_RGB_IMAGE;
/* TODO: add support for GIMP_RGBA_IMAGE in case of RGBA888 */
switch (bas_type)
{
case GIMP_RGB:
img_type = GIMP_RGB_IMAGE;
break;
case GIMP_GRAY:
img_type = GIMP_GRAY_IMAGE;
break;
case GIMP_INDEXED:
img_type = GIMP_INDEXED_IMAGE;
break;
}
if (!layername) {
layername = "background";
}
layer = gimp_layer_new(img, layername, width, height, img_type, 100,
GIMP_NORMAL_MODE);
gimp_image_add_layer(img, layer, position);
*drawable = gimp_drawable_get(layer);
gimp_pixel_rgn_init(pixel_rgn, *drawable, 0, 0, (*drawable)->width,
(*drawable)->height, TRUE, FALSE);
return layer;
}
/* ----------------------------------------
* p_createEmptyEdgeDrawable
* ----------------------------------------
* create the (empty) edge drawable as layer of a new image
*
*/
static void
p_createEmptyEdgeDrawable(GapEdgeContext *ectx)
{
ectx->edgeImageId = gimp_image_new(ectx->refDrawable->width
, ectx->refDrawable->height
, GIMP_GRAY
);
ectx->edgeDrawableId = gimp_layer_new(ectx->edgeImageId
, "edge"
, ectx->refDrawable->width
, ectx->refDrawable->height
, GIMP_GRAY_IMAGE
, 100.0 /* full opacity */
, 0 /* normal mode */
);
gimp_image_add_layer (ectx->edgeImageId, ectx->edgeDrawableId, 0 /* stackposition */ );
ectx->edgeDrawable = gimp_drawable_get(ectx->edgeDrawableId);
} /* end p_createEmptyEdgeDrawable */
static gint32
create_new_layer (gint32 image_ID,
gint position,
const gchar *layername,
guint width,
guint height,
GimpImageBaseType type,
GimpDrawable **drawable,
GimpPixelRgn *pixel_rgn)
{
gint32 layer_ID;
GimpImageType gdtype = GIMP_RGB_IMAGE;
switch (type)
{
case GIMP_RGB:
gdtype = GIMP_RGB_IMAGE;
break;
case GIMP_GRAY:
gdtype = GIMP_GRAY_IMAGE;
break;
case GIMP_INDEXED:
gdtype = GIMP_INDEXED_IMAGE;
break;
}
if (!layername)
layername = _("Background");
layer_ID = gimp_layer_new (image_ID, layername, width, height,
gdtype, 100, GIMP_NORMAL_MODE);
gimp_image_add_layer (image_ID, layer_ID, position);
*drawable = gimp_drawable_get (layer_ID);
gimp_pixel_rgn_init (pixel_rgn, *drawable, 0, 0, (*drawable)->width,
(*drawable)->height, TRUE, FALSE);
return layer_ID;
}
