static void
make_preview (void)
{
destroy_preview ();
if (jsvals.preview)
{
gchar *tn = gimp_temp_name ("jpeg");
if (! undo_touched)
{
/* we freeze undo saving so that we can avoid sucking up
* tile cache with our unneeded preview steps. */
gimp_image_undo_freeze (preview_image_ID);
undo_touched = TRUE;
}
save_image (tn,
preview_image_ID,
drawable_ID_global,
orig_image_ID_global,
TRUE, NULL);
if (display_ID == -1)
display_ID = gimp_display_new (preview_image_ID);
}
else
{
gtk_label_set_text (GTK_LABEL (preview_size), _("File size: unknown"));
gimp_displays_flush ();
}
}
/*
* 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;
}
/* --------------------------
* 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 */
static GimpObject *
gui_display_create (Gimp *gimp,
GimpImage *image,
GimpUnit unit,
gdouble scale)
{
GimpContext *context = gimp_get_user_context (gimp);
GimpDisplay *display = GIMP_DISPLAY (gui_get_empty_display (gimp));
if (display)
{
gimp_display_fill (display, image, unit, scale);
}
else
{
GList *image_managers = gimp_ui_managers_from_name ("<Image>");
g_return_val_if_fail (image_managers != NULL, NULL);
display = gimp_display_new (gimp, image, unit, scale,
global_menu_factory,
image_managers->data,
global_display_factory);
}
if (gimp_context_get_display (context) == display)
{
gimp_context_set_image (context, image);
gimp_context_display_changed (context);
}
else
{
gimp_context_set_display (context, display);
}
gimp_ui_manager_update (GIMP_DISPLAY_SHELL (display->shell)->menubar_manager,
display);
return GIMP_OBJECT (display);
}
static void
run (const gchar *name,
gint nparams,
const GimpParam *param,
gint *nreturn_vals,
GimpParam **return_vals)
{
static GimpParam values[3];
GimpRunMode run_mode;
GimpPDBStatusType status = GIMP_PDB_SUCCESS;
gint32 new_layer = -1;
gint width;
gint height;
run_mode = param[0].data.d_int32;
INIT_I18N ();
*nreturn_vals = 3;
*return_vals = values;
values[0].type = GIMP_PDB_STATUS;
values[0].data.d_status = status;
values[1].type = GIMP_PDB_IMAGE;
values[2].type = GIMP_PDB_LAYER;
width = gimp_drawable_width (param[2].data.d_drawable);
height = gimp_drawable_height (param[2].data.d_drawable);
switch (run_mode)
{
case GIMP_RUN_INTERACTIVE:
/* Possibly retrieve data */
gimp_get_data (PLUG_IN_PROC, &tvals);
/* First acquire information with a dialog */
if (! tile_dialog (param[1].data.d_image,
param[2].data.d_drawable))
return;
break;
case GIMP_RUN_NONINTERACTIVE:
/* Make sure all the arguments are there! */
if (nparams != 6)
{
status = GIMP_PDB_CALLING_ERROR;
}
else
{
tvals.new_width = param[3].data.d_int32;
tvals.new_height = param[4].data.d_int32;
tvals.new_image = param[5].data.d_int32 ? TRUE : FALSE;
if (tvals.new_width < 0 || tvals.new_height < 0)
status = GIMP_PDB_CALLING_ERROR;
}
break;
case GIMP_RUN_WITH_LAST_VALS:
/* Possibly retrieve data */
gimp_get_data (PLUG_IN_PROC, &tvals);
break;
default:
break;
}
if (status == GIMP_PDB_SUCCESS)
{
gimp_progress_init (_("Tiling"));
values[1].data.d_image = tile (param[1].data.d_image,
param[2].data.d_drawable,
&new_layer);
values[2].data.d_layer = new_layer;
/* Store data */
if (run_mode == GIMP_RUN_INTERACTIVE)
gimp_set_data (PLUG_IN_PROC, &tvals, sizeof (TileVals));
if (run_mode != GIMP_RUN_NONINTERACTIVE)
{
if (tvals.new_image)
gimp_display_new (values[1].data.d_image);
else
gimp_displays_flush ();
}
}
values[0].data.d_status = status;
}
static void
guillotine (gint32 image_ID)
{
gint guide;
gint image_width;
gint image_height;
gboolean guides_found = FALSE;
GList *hguides, *hg;
GList *vguides, *vg;
image_width = gimp_image_width (image_ID);
image_height = gimp_image_height (image_ID);
hguides = g_list_append (NULL, GINT_TO_POINTER (0));
hguides = g_list_append (hguides, GINT_TO_POINTER (image_height));
vguides = g_list_append (NULL, GINT_TO_POINTER (0));
vguides = g_list_append (vguides, GINT_TO_POINTER (image_width));
for (guide = gimp_image_find_next_guide (image_ID, 0);
guide > 0;
guide = gimp_image_find_next_guide (image_ID, guide))
{
gint position = gimp_image_get_guide_position (image_ID, guide);
switch (gimp_image_get_guide_orientation (image_ID, guide))
{
case GIMP_ORIENTATION_HORIZONTAL:
if (! g_list_find (hguides, GINT_TO_POINTER (position)))
{
hguides = g_list_insert_sorted (hguides,
GINT_TO_POINTER (position),
guide_sort_func);
guides_found = TRUE;
}
break;
case GIMP_ORIENTATION_VERTICAL:
if (! g_list_find (vguides, GINT_TO_POINTER (position)))
{
vguides = g_list_insert_sorted (vguides,
GINT_TO_POINTER (position),
guide_sort_func);
guides_found = TRUE;
}
break;
case GIMP_ORIENTATION_UNKNOWN:
g_assert_not_reached ();
break;
}
}
if (guides_found)
{
gchar *filename;
gint h, v, hpad, vpad;
gint x, y;
gchar *hformat;
gchar *format;
filename = gimp_image_get_filename (image_ID);
if (!filename)
filename = g_strdup (_("Untitled"));
/* get the number horizontal and vertical slices */
h = g_list_length (hguides);
v = g_list_length (vguides);
/* need the number of digits of h and v for the padding */
hpad = log10(h) + 1;
vpad = log10(v) + 1;
/* format for the x-y coordinates in the filename */
hformat = g_strdup_printf ("%%0%i", MAX (hpad, vpad));
format = g_strdup_printf ("-%si-%si", hformat, hformat);
/* Do the actual dup'ing and cropping... this isn't a too naive a
* way to do this since we got copy-on-write tiles, either.
*/
for (y = 0, hg = hguides; hg && hg->next; y++, hg = hg->next)
{
for (x = 0, vg = vguides; vg && vg->next; x++, vg = vg->next)
{
gint32 new_image = gimp_image_duplicate (image_ID);
GString *new_filename;
gchar *fileextension;
gchar *fileindex;
gint pos;
if (new_image == -1)
{
g_warning ("Couldn't create new image.");
return;
}
gimp_image_undo_disable (new_image);
gimp_image_crop (new_image,
GPOINTER_TO_INT (vg->next->data) -
GPOINTER_TO_INT (vg->data),
GPOINTER_TO_INT (hg->next->data) -
GPOINTER_TO_INT (hg->data),
GPOINTER_TO_INT (vg->data),
GPOINTER_TO_INT (hg->data));
new_filename = g_string_new (filename);
/* show the rough coordinates of the image in the title */
fileindex = g_strdup_printf (format, x, y);
/* get the position of the file extension - last . in filename */
fileextension = strrchr (new_filename->str, '.');
pos = fileextension - new_filename->str;
/* insert the coordinates before the extension */
g_string_insert (new_filename, pos, fileindex);
g_free (fileindex);
gimp_image_set_filename (new_image, new_filename->str);
g_string_free (new_filename, TRUE);
while ((guide = gimp_image_find_next_guide (new_image, 0)))
gimp_image_delete_guide (new_image, guide);
gimp_image_undo_enable (new_image);
gimp_display_new (new_image);
}
}
g_free (filename);
g_free (hformat);
g_free (format);
}
g_list_free (hguides);
g_list_free (vguides);
}
static void
run (const gchar *name,
gint nparams,
const GimpParam *param,
gint *nreturn_vals,
GimpParam **return_vals)
{
GimpRunMode run_mode = param[0].data.d_int32;
GimpPDBStatusType status = GIMP_PDB_SUCCESS;
GdkScreen *screen = NULL;
gint32 image_ID;
static GimpParam values[2];
/* initialize the return of the status */
values[0].type = GIMP_PDB_STATUS;
values[0].data.d_status = status;
*nreturn_vals = 1;
*return_vals = values;
INIT_I18N ();
/* how are we running today? */
switch (run_mode)
{
case GIMP_RUN_INTERACTIVE:
/* Possibly retrieve data from a previous run */
gimp_get_data (PLUG_IN_PROC, &shootvals);
shootvals.window_id = 0;
/* Get information from the dialog */
if (! shoot_dialog (&screen))
status = GIMP_PDB_CANCEL;
break;
case GIMP_RUN_NONINTERACTIVE:
if (nparams == 3)
{
gboolean do_root = param[1].data.d_int32;
shootvals.shoot_type = do_root ? SHOOT_ROOT : SHOOT_WINDOW;
shootvals.window_id = param[2].data.d_int32;
shootvals.select_delay = 0;
}
else if (nparams == 7)
{
shootvals.shoot_type = SHOOT_REGION;
shootvals.window_id = param[2].data.d_int32;
shootvals.select_delay = 0;
shootvals.x1 = param[3].data.d_int32;
shootvals.y1 = param[4].data.d_int32;
shootvals.x2 = param[5].data.d_int32;
shootvals.y2 = param[6].data.d_int32;
}
else
{
status = GIMP_PDB_CALLING_ERROR;
}
if (! gdk_init_check (NULL, NULL))
status = GIMP_PDB_CALLING_ERROR;
break;
case GIMP_RUN_WITH_LAST_VALS:
/* Possibly retrieve data from a previous run */
gimp_get_data (PLUG_IN_PROC, &shootvals);
break;
default:
break;
}
if (status == GIMP_PDB_SUCCESS)
{
if (shootvals.select_delay > 0)
shoot_delay (shootvals.select_delay);
if (shootvals.shoot_type != SHOOT_ROOT && ! shootvals.window_id)
{
shootvals.window_id = select_window (screen);
if (! shootvals.window_id)
status = GIMP_PDB_CANCEL;
}
}
if (status == GIMP_PDB_SUCCESS)
{
image_ID = shoot (screen);
if (image_ID == -1)
status = GIMP_PDB_EXECUTION_ERROR;
}
if (status == GIMP_PDB_SUCCESS)
{
if (run_mode == GIMP_RUN_INTERACTIVE)
{
/* Store variable states for next run */
gimp_set_data (PLUG_IN_PROC, &shootvals, sizeof (ScreenshotValues));
gimp_display_new (image_ID);
}
/* set return values */
*nreturn_vals = 2;
values[1].type = GIMP_PDB_IMAGE;
values[1].data.d_image = image_ID;
}
values[0].data.d_status = status;
}
gint32
gap_xanim_decode(GimpRunModeType run_mode)
{
gint32 l_rc;
gint32 first_frame;
gint32 last_frame;
char filename[200];
char basename[200];
char extension[20];
char extension2[20];
t_gap_xa_formats Format;
gint32 extract_audio;
gint32 extract_video;
gint32 jpeg_quality;
gint32 autoload;
gint32 run_xanim_asynchron;
char l_cmd[300];
char l_one_past_last_frame[200];
char l_first_to_laod[200];
char *l_dst_dir;
pid_t l_xanim_pid;
int l_input_dir_created_by_myself;
l_rc = 0;
l_input_dir_created_by_myself = FALSE;
global_errlist = NULL;
p_init_xanim_global_name();
filename[0] = '\0';
strcpy(&basename[0], "frame_");
l_rc = p_xanim_dialog (&first_frame,
&last_frame,
filename, sizeof(filename),
basename, sizeof(basename),
&Format,
&extract_video,
&extract_audio,
&jpeg_quality,
&autoload,
&run_xanim_asynchron);
if(l_rc != 0)
{
return(l_rc);
}
if(!p_file_exists(filename))
{
global_errlist = g_strdup_printf(
_("videofile %s not existent or empty\n"),
filename);
l_rc = 10;
}
else
{
l_rc = p_check_xanim();
}
if (l_rc == 0)
{
switch(Format)
{
case XAENC_PPMRAW:
strcpy(extension, "ppm");
strcpy(extension2, ".ppm");
break;
case XAENC_JPEG:
strcpy(extension, "jpg");
strcpy(extension2, ".jpg");
break;
default:
strcpy(extension, "ppm");
strcpy(extension2, ".xcf");
break;
}
p_build_xanim_framename(l_one_past_last_frame, last_frame +1 , extension);
if (extract_video)
{
/* for the frames we need a directory named "input" */
if (p_is_directory(global_xanim_input_dir))
{
/* the input directory already exists,
* remove frames
*/
sprintf(l_cmd, "rm -f %s/*.%s", global_xanim_input_dir, extension);
system(l_cmd);
}
else
{
/* create input directory (needed by xanim to store the frames) */
mkdir(global_xanim_input_dir, MKDIR_MODE);
if (p_is_directory(global_xanim_input_dir))
{
l_input_dir_created_by_myself = TRUE;
}
else
{
global_errlist = g_strdup_printf(
_("could not create %s directory\n"
"(that is required for xanim frame export)"),
global_xanim_input_dir);
l_rc = 10;
}
}
}
}
if(l_rc == 0)
{
gimp_progress_init (_("extracting frames..."));
gimp_progress_update (0.1); /* fake some progress */
/* note:
* we can't show realistic progress for the extracting process
* because we know nothing about videofileformat and how much frames
* are realy stored in the videofile.
*
* one guess could assume, that xanim will write 0 upto last_frame
* to disk, and check for the frames that the xanim process creates.
* The periodically checking can be done in the poll procedure for asynchron
* startmode only.
*/
l_xanim_pid = p_start_xanim_process(first_frame, last_frame,
filename,
Format,
extract_video,
extract_audio,
jpeg_quality,
l_one_past_last_frame,
run_xanim_asynchron);
if (l_xanim_pid == -1 )
{
global_errlist = g_strdup_printf(
_("could not start xanim process\n(program=%s)"),
global_xanim_prog );
l_rc = -1;
}
}
if(l_rc == 0)
{
if(run_xanim_asynchron)
{
p_poll(l_xanim_pid, l_one_past_last_frame, first_frame, last_frame, extension);
}
p_delete_frames(99999, first_frame, last_frame, extension);
remove(l_one_past_last_frame);
gimp_progress_update (1.0);
if (p_find_max_xanim_frame (first_frame, extension) < first_frame)
{
global_errlist = g_strdup_printf(
_("can't find any extracted frames,\n"
"xanim has failed or was cancelled"));
l_rc = -1;
}
else
{
/* if destination directorypart does not exist, try to create it */
l_dst_dir = g_strdup(basename);
p_dirname(l_dst_dir);
if (*l_dst_dir != '\0')
{
if ( !p_is_directory(l_dst_dir) )
{
mkdir (l_dst_dir, MKDIR_MODE);
}
}
if(strcmp(extension, &extension2[1]) == 0)
{
gimp_progress_init (_("renaming frames..."));
l_rc = p_rename_frames(first_frame, last_frame, basename, extension);
}
else
{
gimp_progress_init (_("converting frames..."));
l_rc = p_convert_frames(first_frame, last_frame, basename, extension, extension2);
}
if (l_input_dir_created_by_myself)
{
if (strcmp(l_dst_dir, global_xanim_input_dir) != 0)
{
/* remove input dir with all files */
sprintf(l_cmd, "rm -rf \"%s\"", global_xanim_input_dir);
system(l_cmd);
}
}
g_free(l_dst_dir);
gimp_progress_update (1.0);
}
}
if(l_rc != 0)
{
if(global_errlist == NULL)
{
p_xanim_info("ERROR: could not execute xanim");
}
else
{
p_xanim_info(global_errlist);
}
l_rc = -1;
}
else
{
if(autoload)
{
/* load first frame and add a display */
p_build_gap_framename(l_first_to_laod, first_frame, basename, &extension2[1]);
l_rc = p_load_image(l_first_to_laod);
if(l_rc >= 0) gimp_display_new(l_rc);
}
}
return(l_rc);
} /* end gap_xanim_decode */
static void
run (const gchar *name,
gint nparams,
const GimpParam *param,
gint *nreturn_vals,
GimpParam **return_vals)
{
static GimpParam values[MAX_EXTRACT_IMAGES + 1];
GimpPDBStatusType status = GIMP_PDB_SUCCESS;
gint32 num_images;
gint32 image_ID_extract[MAX_EXTRACT_IMAGES];
gint32 layer_ID_extract[MAX_EXTRACT_IMAGES];
gint j;
gint32 layer;
gint32 num_layers;
gint32 image_ID;
INIT_I18N ();
run_mode = param[0].data.d_int32;
image_ID = param[1].data.d_image;
layer = param[2].data.d_drawable;
*nreturn_vals = MAX_EXTRACT_IMAGES+1;
*return_vals = values;
values[0].type = GIMP_PDB_STATUS;
values[0].data.d_status = status;
for (j = 0; j < MAX_EXTRACT_IMAGES; j++)
{
values[j+1].type = GIMP_PDB_IMAGE;
values[j+1].data.d_int32 = -1;
}
switch (run_mode)
{
case GIMP_RUN_INTERACTIVE:
/* Possibly retrieve data */
gimp_get_data (PLUG_IN_PROC, &decovals);
/* First acquire information with a dialog */
if (! decompose_dialog ())
return;
break;
case GIMP_RUN_NONINTERACTIVE:
/* Make sure all the arguments are there! */
if (nparams != 4 && nparams != 5 && nparams != 6)
{
status = GIMP_PDB_CALLING_ERROR;
}
else
{
strncpy (decovals.extract_type, param[3].data.d_string,
sizeof (decovals.extract_type));
decovals.extract_type[sizeof (decovals.extract_type)-1] = '\0';
decovals.as_layers = nparams > 4 ? param[4].data.d_int32 : FALSE;
decovals.use_registration = (strcmp (name, PLUG_IN_PROC_REG) == 0);
}
break;
case GIMP_RUN_WITH_LAST_VALS:
/* Possibly retrieve data */
gimp_get_data (PLUG_IN_PROC, &decovals);
break;
default:
break;
}
/* Make sure that the drawable is RGB color */
if (gimp_drawable_type_with_alpha (layer) != GIMP_RGBA_IMAGE)
{
g_message ("Can only work on RGB images.");
status = GIMP_PDB_CALLING_ERROR;
}
if (status == GIMP_PDB_SUCCESS)
{
gimp_progress_init (_("Decomposing"));
num_images = decompose (image_ID, layer,
decovals.extract_type,
image_ID_extract,
&num_layers,
layer_ID_extract);
if (num_images <= 0)
{
status = GIMP_PDB_EXECUTION_ERROR;
}
else
{
/* create decompose-data parasite */
GString *data = g_string_new ("");
g_string_printf (data, "source=%d type=%s ",
layer, decovals.extract_type);
for (j = 0; j < num_layers; j++)
g_string_append_printf (data, "%d ", layer_ID_extract[j]);
for (j = 0; j < num_images; j++)
{
values[j+1].data.d_int32 = image_ID_extract[j];
gimp_image_undo_enable (image_ID_extract[j]);
gimp_image_clean_all (image_ID_extract[j]);
gimp_image_attach_new_parasite (image_ID_extract[j],
"decompose-data",
0, data->len + 1, data->str);
if (run_mode != GIMP_RUN_NONINTERACTIVE)
gimp_display_new (image_ID_extract[j]);
}
/* Store data */
if (run_mode == GIMP_RUN_INTERACTIVE)
gimp_set_data (PLUG_IN_PROC, &decovals, sizeof (DecoVals));
}
}
values[0].data.d_status = status;
}
/* -------------------------------------
* run
* -------------------------------------
*/
static void
run (const gchar *name, /* name of plugin */
gint nparams, /* number of in-parameters */
const GimpParam * param, /* in-parameters */
gint *nreturn_vals, /* number of out-parameters */
GimpParam ** return_vals) /* out-parameters */
{
const gchar *l_env;
gint32 image_id = -1;
gint32 drawable_id = -1;
GapMorphGlobalParams *mgpp = &global_params;
gboolean run_flag;
/* Get the runmode from the in-parameters */
GimpRunMode run_mode = param[0].data.d_int32;
/* status variable, use it to check for errors in invocation usually only
* during non-interactive calling
*/
GimpPDBStatusType status = GIMP_PDB_SUCCESS;
/* always return at least the status to the caller. */
static GimpParam values[2];
INIT_I18N();
l_env = g_getenv("GAP_DEBUG");
if(l_env != NULL)
{
if((*l_env != 'n') && (*l_env != 'N')) gap_debug = 1;
}
if(gap_debug)
{
printf("\n\nDEBUG: run %s RUN_MODE:%d\n", name, (int)run_mode);
}
run_flag = FALSE;
if ((strcmp(name, PLUG_IN_NAME_TWEEN) == 0)
|| (strcmp(name, PLUG_IN_NAME_WORKPOINTS) == 0))
{
run_flag = TRUE;
}
/* initialize the return of the status */
values[0].type = GIMP_PDB_STATUS;
values[0].data.d_status = status;
*nreturn_vals = 1;
*return_vals = values;
/* get image */
image_id = param[1].data.d_int32;
drawable_id = param[2].data.d_drawable;
mgpp->do_progress = FALSE;
mgpp->image_id = image_id;
mgpp->run_mode = run_mode;
switch (run_mode)
{
case GIMP_RUN_INTERACTIVE:
if (strcmp(name, PLUG_IN_NAME) == 0)
{
/* Possibly retrieve data from a previous run */
gimp_get_data (PLUG_IN_NAME, mgpp);
mgpp->osrc_layer_id = drawable_id;
mgpp->fdst_layer_id = gap_morph_exec_find_dst_drawable(image_id, drawable_id);
run_flag = gap_morph_dialog(mgpp);
mgpp->do_progress = TRUE;
mgpp->master_progress_callback_fptr = NULL;
mgpp->progress_callback_fptr = NULL;
}
else if (strcmp(name, PLUG_IN_NAME_ONE_TWEEN) == 0)
{
mgpp->tween_mix_factor = 0.5;
/* Possibly retrieve data from a previous run */
gimp_get_data (PLUG_IN_NAME_ONE_TWEEN, mgpp);
mgpp->osrc_layer_id = drawable_id;
mgpp->fdst_layer_id = gap_morph_exec_find_dst_drawable(image_id, drawable_id);
run_flag = gap_morph_one_tween_dialog(mgpp);
mgpp->do_progress = TRUE;
mgpp->master_progress_callback_fptr = NULL;
mgpp->progress_callback_fptr = NULL;
}
/* dialog for other frame tween processing plug ins see
* p_handle_tween_processing_pug_ins
*/
break;
case GIMP_RUN_NONINTERACTIVE:
/* check to see if invoked with the correct number of parameters */
if ((nparams == G_N_ELEMENTS (in_args))
&& (strcmp(name, PLUG_IN_NAME) == 0))
{
mgpp->have_workpointsets = TRUE; /* use pointset(s) from file */
/* set defaults for params that may be specified in the workpointfiles
* (the defaults will take effect only if the file does not contain such settings)
*/
mgpp->use_quality_wp_selection = FALSE;
mgpp->use_gravity = FALSE;
mgpp->gravity_intensity = 2.0;
mgpp->affect_radius = 100.0;
mgpp->osrc_layer_id = param[2].data.d_drawable;
mgpp->fdst_layer_id = param[3].data.d_drawable;
mgpp->tween_steps = param[4].data.d_int32;
mgpp->render_mode = param[5].data.d_int32;
mgpp->create_tween_layers = param[6].data.d_int32;
if(param[7].data.d_string != NULL)
{
if(param[7].data.d_string[0] != '\0')
{
g_snprintf(mgpp->workpoint_file_lower
, sizeof(mgpp->workpoint_file_lower)
, "%s", param[7].data.d_string);
g_snprintf(mgpp->workpoint_file_upper
, sizeof(mgpp->workpoint_file_upper)
, "%s", param[7].data.d_string);
}
else
{
printf("%s: non-interactive call requires a not-empty workpoint_file_1 parameter\n"
, PLUG_IN_NAME
);
status = GIMP_PDB_CALLING_ERROR;
}
}
else
{
printf("%s: non-interactive call requires a not-NULL workpoint_file_1 parameter\n"
, PLUG_IN_NAME
);
status = GIMP_PDB_CALLING_ERROR;
}
if(param[8].data.d_string != NULL)
{
if(param[8].data.d_string[0] != '\0')
{
g_snprintf(mgpp->workpoint_file_upper
, sizeof(mgpp->workpoint_file_upper)
, "%s", param[8].data.d_string);
}
}
run_flag = TRUE;
}
else if ((nparams == G_N_ELEMENTS (in_one_tween_args))
&& (strcmp(name, PLUG_IN_NAME_ONE_TWEEN) == 0))
{
/* set defaults for params that may be specified in the workpointfiles
* (the defaults will take effect only if the file does not contain such settings)
*/
mgpp->use_quality_wp_selection = FALSE;
mgpp->have_workpointsets = FALSE; /* operate with a single workpointfile */
mgpp->use_gravity = FALSE;
mgpp->gravity_intensity = 2.0;
mgpp->affect_radius = 100.0;
mgpp->tween_steps = 1; /* (in this mode always render only one tween) */
mgpp->render_mode = GAP_MORPH_RENDER_MODE_MORPH;
mgpp->create_tween_layers = TRUE;
mgpp->osrc_layer_id = param[2].data.d_drawable;
mgpp->fdst_layer_id = param[3].data.d_drawable;
mgpp->tween_mix_factor = param[4].data.d_float;
mgpp->do_simple_fade = (param[5].data.d_int32 != 0);
if(param[6].data.d_string != NULL)
{
if(param[6].data.d_string[0] != '\0')
{
g_snprintf(mgpp->workpoint_file_lower
, sizeof(mgpp->workpoint_file_lower)
, "%s", param[6].data.d_string);
g_snprintf(mgpp->workpoint_file_upper
, sizeof(mgpp->workpoint_file_upper)
, "%s", param[6].data.d_string);
}
else
{
mgpp->have_workpointsets = FALSE; /* no pointset file available */
}
run_flag = TRUE;
}
else
{
printf("%s: non-interactive call requires a not-NULL workpoint_file parameter\n"
, PLUG_IN_NAME_ONE_TWEEN
);
status = GIMP_PDB_CALLING_ERROR;
}
}
else if ((nparams == G_N_ELEMENTS (in_one_tween_args))
&& (strcmp(name, PLUG_IN_NAME_TWEEN) == 0))
{
/* set defaults for params that may be specified in the workpointfiles
* (the defaults will take effect only if the file does not contain such settings)
*/
mgpp->use_quality_wp_selection = FALSE;
mgpp->have_workpointsets = FALSE; /* operate with a single workpointfile */
mgpp->use_gravity = FALSE;
mgpp->gravity_intensity = 2.0;
mgpp->affect_radius = 100.0;
mgpp->tween_steps = 1; /* (will be calculated later as difference of handled frame numbers) */
mgpp->render_mode = GAP_MORPH_RENDER_MODE_MORPH;
mgpp->create_tween_layers = TRUE;
mgpp->osrc_layer_id = -1; /* is created later as merged copy of the specified image */
mgpp->fdst_layer_id = -1; /* is created later as merged copy of the frame rfered by to_frame_nr parameter */
mgpp->range_to = param[3].data.d_int32;
mgpp->overwrite_flag = (param[4].data.d_int32 != 0);
mgpp->do_simple_fade = (param[5].data.d_int32 != 0);
mgpp->tween_mix_factor = 1.0; /* not relevant here */
if(param[6].data.d_string != NULL)
{
if(param[6].data.d_string[0] != '\0')
{
g_snprintf(mgpp->workpoint_file_lower
, sizeof(mgpp->workpoint_file_lower)
, "%s", param[6].data.d_string);
g_snprintf(mgpp->workpoint_file_upper
, sizeof(mgpp->workpoint_file_upper)
, "%s", param[6].data.d_string);
}
else
{
mgpp->have_workpointsets = FALSE; /* no pointset file available */
}
run_flag = TRUE;
}
else
{
printf("%s: non-interactive call requires a not-NULL workpoint_file parameter\n"
, PLUG_IN_NAME_TWEEN
);
status = GIMP_PDB_CALLING_ERROR;
}
}
else if ((nparams == G_N_ELEMENTS (in_workpoint_args))
&& (strcmp(name, PLUG_IN_NAME_WORKPOINTS) == 0))
{
mgpp->osrc_layer_id = -1; /* is created later as merged copy of the specified image */
mgpp->fdst_layer_id = -1; /* is created later as merged copy of the frame rfered by to_frame_nr parameter */
mgpp->range_to = param[3].data.d_int32;
mgpp->numWorkpoints = param[4].data.d_int32;
mgpp->numOutlinePoints = param[5].data.d_int32;
mgpp->locateDetailMoveRadius = param[6].data.d_int32;
mgpp->locateDetailShapeRadius = param[7].data.d_int32;
mgpp->locateColordiffThreshold = param[8].data.d_float;
mgpp->edgeColordiffThreshold = param[9].data.d_float;
run_flag = TRUE;
}
else
{
printf("%s: non-interactive call wrong nuber %d of params were passed. (%d params are required)\n"
, PLUG_IN_NAME
, (int)nparams
, (int)G_N_ELEMENTS (in_args)
);
status = GIMP_PDB_CALLING_ERROR;
}
break;
case GIMP_RUN_WITH_LAST_VALS:
if (strcmp(name, PLUG_IN_NAME) == 0)
{
/* Possibly retrieve data from a previous run */
gimp_get_data (PLUG_IN_NAME, mgpp);
mgpp->osrc_layer_id = drawable_id;
mgpp->fdst_layer_id = gap_morph_exec_find_dst_drawable(image_id, drawable_id);
run_flag = gap_morph_dialog(mgpp);
mgpp->do_progress = TRUE;
mgpp->master_progress_callback_fptr = NULL;
mgpp->progress_callback_fptr = NULL;
}
break;
default:
break;
}
if ((status == GIMP_PDB_SUCCESS)
&& (run_flag))
{
if (strcmp(name, PLUG_IN_NAME) == 0)
{
gap_morph_execute(mgpp);
/* Store variable states for next run */
if (run_mode == GIMP_RUN_INTERACTIVE)
{
gimp_set_data (PLUG_IN_NAME, mgpp, sizeof (GapMorphGlobalParams));
}
}
else if ((strcmp(name, PLUG_IN_NAME_ONE_TWEEN) == 0)
|| (strcmp(name, PLUG_IN_NAME_TWEEN) == 0)
|| (strcmp(name, PLUG_IN_NAME_WORKPOINTS) == 0))
{
gint32 tween_layer_id;
if (strcmp(name, PLUG_IN_NAME_ONE_TWEEN) == 0)
{
tween_layer_id = gap_morph_render_one_tween(mgpp);
}
else
{
/* handle processing for PLUG_IN_NAME_TWEEN or PLUG_IN_NAME_WORKPOINTS */
tween_layer_id = p_handle_tween_processing_pug_ins(mgpp, name);
}
values[1].type = GIMP_PDB_DRAWABLE;
values[1].data.d_int32 = tween_layer_id;
values[1].data.d_drawable = tween_layer_id;
*nreturn_vals = 2;
if (tween_layer_id < 0)
{
status = GIMP_PDB_EXECUTION_ERROR;
}
else
{
if (run_mode == GIMP_RUN_INTERACTIVE)
{
/* Store variable states for next run */
gimp_set_data (name, mgpp, sizeof (GapMorphGlobalParams));
if(strcmp(name, PLUG_IN_NAME_WORKPOINTS) != 0)
{
gimp_display_new(gimp_drawable_get_image(tween_layer_id));
}
}
}
}
}
values[0].data.d_status = status;
} /* end run */
static void run ( const gchar *name, gint nparams, const GimpParam *param,
gint *nreturn_vals, GimpParam **return_vals)
{
static GimpParam values[3];
GimpRunMode run_mode;
GimpPDBStatusType status = GIMP_PDB_SUCCESS;
SeparateContext mysc;
//enum separate_function func = SEP_NONE;
run_mode = param[0].data.d_int32;
/* setup for localization */
INIT_I18N ();
cmsErrorAction( LCMS_ERROR_IGNORE );
mysc.filename = NULL;
if( nparams != ( run_mode == GIMP_RUN_NONINTERACTIVE ? 2 : 1 ) )
status = GIMP_PDB_CALLING_ERROR;
else if( run_mode == GIMP_RUN_NONINTERACTIVE ) {
if( param[1].type != GIMP_PDB_STRING || strlen( param[1].data.d_string ) == 0 )
status = GIMP_PDB_CALLING_ERROR;
else
mysc.filename = g_strdup( param[1].data.d_string );
} else {
gint size = gimp_get_data_size( "plug-in-separate-import/lastpath" );
if( size ) {
mysc.filename = g_malloc( size );
gimp_get_data( "plug-in-separate-import/lastpath", mysc.filename );
}
}
if( status == GIMP_PDB_SUCCESS && ( run_mode == GIMP_RUN_NONINTERACTIVE || separate_import_dialog( &mysc ) ) ) {
gint i, j, x, y;
TIFF *in;
guint32 width, height, stripSize, stripCount, stripHeight;
gint16 bps, spp, step, planerConfig, photometric, inkset, resolutionUnit;
float xres, yres;
const gchar *layerNames[] = { "C", "M", "Y", "K" };
guchar *buf, *maskbuf[4], *srcbuf, *destbuf[4], *iccProfile;
gint32 layers[5], masks[4];
GimpDrawable *drw[4];
GimpPixelRgn rgn[4];
GimpRGB primaries[4] = { { .180, .541, .870, 1.0 },
{ .925, .149, .388, 1.0 },
{ .929, .862, .129, 1.0 },
{ 0, 0, 0, 1.0 } };
gchar *str = NULL;
gchar *baseName = g_path_get_basename( gimp_filename_to_utf8( mysc.filename ) );
#ifdef G_OS_WIN32
{
gchar *_filename = NULL; // win32 filename encoding(not UTF-8)
_filename = g_win32_locale_filename_from_utf8( mysc.filename );
in = TIFFOpen( _filename ? _filename : mysc.filename, "r" );
g_free( _filename );
}
#else
in = TIFFOpen( mysc.filename, "r" );
#endif
if( !in ) {
str = g_strdup_printf( _( "Cannot open : \"%s\"" ), baseName );
gimp_message( str );
g_free( str );
status = GIMP_PDB_EXECUTION_ERROR;
} else {
if( ( TIFFGetField( in, TIFFTAG_BITSPERSAMPLE, &bps ) == FALSE || ( bps != 8 && bps != 16 ) ) ||
( TIFFGetField( in, TIFFTAG_SAMPLESPERPIXEL, &spp ) == FALSE || spp != 4 ) ||
( TIFFGetField( in, TIFFTAG_PHOTOMETRIC, &photometric ) == FALSE || photometric != PHOTOMETRIC_SEPARATED ) ||
( TIFFGetField( in, TIFFTAG_PLANARCONFIG, &planerConfig ) == FALSE || planerConfig != PLANARCONFIG_CONTIG ) ||
( TIFFGetField( in, TIFFTAG_INKSET, &inkset ) == TRUE && inkset != INKSET_CMYK ) ) {
str = g_strdup_printf( _( "\"%s\" is unsupported." ), baseName );
gimp_message( str );
g_free( str );
status = GIMP_PDB_EXECUTION_ERROR;
} else {
stripCount = TIFFNumberOfStrips( in );
stripSize = TIFFStripSize( in );
TIFFGetField( in, TIFFTAG_IMAGEWIDTH, &width );
TIFFGetField( in, TIFFTAG_IMAGELENGTH, &height );
TIFFGetField( in, TIFFTAG_ROWSPERSTRIP, &stripHeight );
TIFFGetField( in, TIFFTAG_RESOLUTIONUNIT, &resolutionUnit );
TIFFGetField( in, TIFFTAG_XRESOLUTION, &xres );
TIFFGetField( in, TIFFTAG_YRESOLUTION, &yres );
#if 0
str = g_strdup_printf( "Photometric : %d BPS : %d SPP : %d\nInkset : %d StripCount : %d", photometric, bps, spp, inkset, stripCount );
gimp_message( str );
g_free( str );
#endif
step = ( bps == 16 ) ? 2 : 1;
buf = g_malloc( stripSize );
values[1].data.d_image = gimp_image_new( width, height, GIMP_RGB );
gimp_image_set_resolution( values[1].data.d_image, xres, yres );
gimp_context_push();
for( i = 0; i < 4; i++ ) {
layers[i] = gimp_layer_new( values[1].data.d_image, layerNames[i], width, height, GIMP_RGBA_IMAGE, 100.0, GIMP_DARKEN_ONLY_MODE );
gimp_context_set_foreground( &primaries[i] );
gimp_drawable_fill( layers[i], GIMP_FOREGROUND_FILL );
gimp_image_add_layer( values[1].data.d_image, layers[i], i );
masks[i] = gimp_layer_create_mask( layers[i], GIMP_ADD_BLACK_MASK );
gimp_layer_add_mask( layers[i], masks[i] );
drw[i] = gimp_drawable_get( masks[i] );
maskbuf[i] = g_malloc( width * stripHeight );
}
gimp_context_pop();
layers[4] = gimp_layer_new( values[1].data.d_image, _( "Background" ), width, height, GIMP_RGB_IMAGE, 100.0, GIMP_NORMAL_MODE );
gimp_drawable_fill( layers[4], GIMP_WHITE_FILL );
gimp_image_add_layer( values[1].data.d_image, layers[4], 4 );
str = g_strdup_printf( _( "Reading \"%s\"..." ), baseName );
gimp_progress_init( str );
g_free( str );
for( i = 0; i < stripCount; i++ ) {
guint32 size = TIFFReadEncodedStrip( in, i, buf, stripSize );
guint32 rowCount = ( size < stripSize ? height % stripHeight : stripHeight );
srcbuf = buf;
if( bps == 16 )
srcbuf++;
for( j = 0; j < 4; j++ ) {
gimp_pixel_rgn_init( &( rgn[j] ), drw[j],
0, stripHeight * i, width, rowCount,
FALSE, FALSE );
destbuf[j] = maskbuf[j];
}
for( y = 0; y < rowCount; y++ ) {
for( x = 0; x < width; x++ ) {
*destbuf[0]++ = *srcbuf;
srcbuf += step;
*destbuf[1]++ = *srcbuf;
srcbuf += step;
*destbuf[2]++ = *srcbuf;
srcbuf += step;
*destbuf[3]++ = *srcbuf;
srcbuf += step;
//srcbuf += spp > 4 ? spp - 4 : 0;
}
}
gimp_pixel_rgn_set_rect( &( rgn[0] ), maskbuf[0], 0, stripHeight * i, width, rowCount );
gimp_pixel_rgn_set_rect( &( rgn[1] ), maskbuf[1], 0, stripHeight * i, width, rowCount );
gimp_pixel_rgn_set_rect( &( rgn[2] ), maskbuf[2], 0, stripHeight * i, width, rowCount );
gimp_pixel_rgn_set_rect( &( rgn[3] ), maskbuf[3], 0, stripHeight * i, width, rowCount );
gimp_progress_update( (gdouble)i / stripCount );
}
g_free( buf );
for( i = 0; i < 4; i++ ) {
g_free( maskbuf[i] );
gimp_drawable_detach( drw[i] );
}
#ifdef ENABLE_COLOR_MANAGEMENT
if ( TIFFGetField( in, TIFFTAG_ICCPROFILE, &width, &iccProfile ) ) {
GimpParasite *parasite;
parasite = gimp_parasite_new( CMYKPROFILE, 0, width, iccProfile );
gimp_image_parasite_attach( values[1].data.d_image, parasite );
gimp_parasite_free( parasite );
//g_free( iccProfile ); // This causes clash on TIFFClose( in ).
}
#endif
}
TIFFClose( in );
}
g_free( baseName );
} else
status = GIMP_PDB_CANCEL;
*return_vals = values;
values[0].type = GIMP_PDB_STATUS;
values[0].data.d_status = status;
if( status == GIMP_PDB_SUCCESS ) {
*nreturn_vals = 2;
values[1].type = GIMP_PDB_IMAGE;
if( run_mode != GIMP_RUN_NONINTERACTIVE ) {
gimp_image_undo_enable( values[1].data.d_image );
gimp_display_new( values[1].data.d_image );
gimp_displays_flush();
}
gimp_set_data( "plug-in-separate-import/lastpath", mysc.filename, strlen( mysc.filename ) + 1 );
} else
*nreturn_vals = 1;
g_free( mysc.filename );
}
static gint32
load_image (PopplerDocument *doc,
const gchar *filename,
GimpRunMode run_mode,
GimpPageSelectorTarget target,
guint32 resolution,
PdfSelectedPages *pages)
{
gint32 image_ID = 0;
gint32 *images = NULL;
gint i;
gdouble scale;
gdouble doc_progress = 0;
if (target == GIMP_PAGE_SELECTOR_TARGET_IMAGES)
images = g_new0 (gint32, pages->n_pages);
gimp_progress_init_printf (_("Opening '%s'"),
gimp_filename_to_utf8 (filename));
scale = resolution / gimp_unit_get_factor (GIMP_UNIT_POINT);
/* read the file */
for (i = 0; i < pages->n_pages; i++)
{
PopplerPage *page;
gchar *page_label;
gdouble page_width;
gdouble page_height;
GdkPixbuf *buf;
gint width;
gint height;
page = poppler_document_get_page (doc, pages->pages[i]);
poppler_page_get_size (page, &page_width, &page_height);
width = page_width * scale;
height = page_height * scale;
g_object_get (G_OBJECT (page), "label", &page_label, NULL);
if (! image_ID)
{
gchar *name;
image_ID = gimp_image_new (width, height, GIMP_RGB);
gimp_image_undo_disable (image_ID);
if (target == GIMP_PAGE_SELECTOR_TARGET_IMAGES)
name = g_strdup_printf (_("%s-%s"), filename, page_label);
else
name = g_strdup_printf (_("%s-pages"), filename);
gimp_image_set_filename (image_ID, name);
g_free (name);
gimp_image_set_resolution (image_ID, resolution, resolution);
}
buf = gdk_pixbuf_new (GDK_COLORSPACE_RGB, FALSE, 8, width, height);
poppler_page_render_to_pixbuf (page, 0, 0, width, height, scale, 0, buf);
layer_from_pixbuf (image_ID, page_label, i, buf,
doc_progress, 1.0 / pages->n_pages);
g_free (page_label);
g_object_unref (buf);
doc_progress = (double) (i + 1) / pages->n_pages;
gimp_progress_update (doc_progress);
if (target == GIMP_PAGE_SELECTOR_TARGET_IMAGES)
{
images[i] = image_ID;
gimp_image_undo_enable (image_ID);
gimp_image_clean_all (image_ID);
image_ID = 0;
}
}
if (image_ID)
{
gimp_image_undo_enable (image_ID);
gimp_image_clean_all (image_ID);
}
if (target == GIMP_PAGE_SELECTOR_TARGET_IMAGES)
{
if (run_mode != GIMP_RUN_NONINTERACTIVE)
{
/* Display images in reverse order. The last will be
* displayed by GIMP itself
*/
for (i = pages->n_pages - 1; i > 0; i--)
gimp_display_new (images[i]);
}
image_ID = images[0];
g_free (images);
}
return image_ID;
}
static void
run (const gchar *name,
gint nparams,
const GimpParam *param,
gint *nreturn_vals,
GimpParam **return_vals)
{
GimpRunMode run_mode = param[0].data.d_int32;
GimpPDBStatusType status = GIMP_PDB_EXECUTION_ERROR;
static GimpParam values[2];
gint32 image_id;
WebpageSaveVals save = {"https://www.gimp.org/", 1024, 12};
INIT_I18N ();
/* initialize the return of the status */
*nreturn_vals = 1;
*return_vals = values;
values[0].type = GIMP_PDB_STATUS;
gimp_get_data (PLUG_IN_PROC, &save);
webpagevals.url = g_strdup (save.url);
webpagevals.width = save.width;
webpagevals.font_size = save.font_size;
/* how are we running today? */
switch (run_mode)
{
case GIMP_RUN_INTERACTIVE:
if (webpage_dialog ())
status = GIMP_PDB_SUCCESS;
else
status = GIMP_PDB_CANCEL;
break;
case GIMP_RUN_WITH_LAST_VALS:
/* This is currently not supported. */
break;
case GIMP_RUN_NONINTERACTIVE:
webpagevals.url = param[1].data.d_string;
webpagevals.width = param[2].data.d_int32;
webpagevals.font_size = param[3].data.d_int32;
status = GIMP_PDB_SUCCESS;
break;
default:
break;
}
if (status == GIMP_PDB_SUCCESS)
{
image_id = webpage_capture ();
if (image_id == -1)
{
status = GIMP_PDB_EXECUTION_ERROR;
if (webpagevals.error)
{
*nreturn_vals = 2;
values[1].type = GIMP_PDB_STRING;
values[1].data.d_string = webpagevals.error->message;
}
}
else
{
save.width = webpagevals.width;
save.font_size = webpagevals.font_size;
if (strlen (webpagevals.url) < MAX_URL_LEN)
{
strncpy (save.url, webpagevals.url, MAX_URL_LEN);
save.url[MAX_URL_LEN - 1] = 0;
}
else
{
memset (save.url, 0, MAX_URL_LEN);
}
gimp_set_data (PLUG_IN_PROC, &save, sizeof save);
if (run_mode == GIMP_RUN_INTERACTIVE)
gimp_display_new (image_id);
*nreturn_vals = 2;
values[1].type = GIMP_PDB_IMAGE;
values[1].data.d_image = image_id;
}
}
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[2];
GimpPDBStatusType status = GIMP_PDB_SUCCESS;
gint32 image_ID;
gint k;
INIT_I18N ();
run_mode = param[0].data.d_int32;
*nreturn_vals = 2;
*return_vals = values;
values[0].type = GIMP_PDB_STATUS;
values[0].data.d_status = status;
values[1].type = GIMP_PDB_IMAGE;
values[1].data.d_int32 = -1;
switch (run_mode)
{
case GIMP_RUN_INTERACTIVE:
/* Possibly retrieve data */
gimp_get_data (PLUG_IN_PROC, &filmvals);
/* First acquire information with a dialog */
if (! film_dialog (param[1].data.d_int32))
return;
break;
case GIMP_RUN_NONINTERACTIVE:
/* Make sure all the arguments are there! */
/* Also we want to have some images to compose */
if ((nparams != 12) || (param[10].data.d_int32 < 1))
{
status = GIMP_PDB_CALLING_ERROR;
}
else
{
filmvals.keep_height = (param[3].data.d_int32 <= 0);
filmvals.film_height = (filmvals.keep_height ?
128 : param[3].data.d_int32);
filmvals.film_color = param[4].data.d_color;
filmvals.number_start = param[5].data.d_int32;
g_strlcpy (filmvals.number_font, param[6].data.d_string, FONT_LEN);
filmvals.number_color = param[7].data.d_color;
filmvals.number_pos[0] = param[8].data.d_int32;
filmvals.number_pos[1] = param[9].data.d_int32;
filmvals.num_images = param[10].data.d_int32;
if (filmvals.num_images > MAX_FILM_PICTURES)
filmvals.num_images = MAX_FILM_PICTURES;
for (k = 0; k < filmvals.num_images; k++)
filmvals.image[k] = param[11].data.d_int32array[k];
}
break;
case GIMP_RUN_WITH_LAST_VALS:
/* Possibly retrieve data */
gimp_get_data (PLUG_IN_PROC, &filmvals);
break;
default:
break;
}
if (! check_filmvals ())
status = GIMP_PDB_CALLING_ERROR;
if (status == GIMP_PDB_SUCCESS)
{
gimp_progress_init (_("Composing images"));
image_ID = film ();
if (image_ID < 0)
{
status = GIMP_PDB_EXECUTION_ERROR;
}
else
{
values[1].data.d_int32 = image_ID;
gimp_image_undo_enable (image_ID);
gimp_image_clean_all (image_ID);
if (run_mode != GIMP_RUN_NONINTERACTIVE)
gimp_display_new (image_ID);
}
/* Store data */
if (run_mode == GIMP_RUN_INTERACTIVE)
gimp_set_data (PLUG_IN_PROC, &filmvals, sizeof (FilmVals));
}
values[0].data.d_status = status;
}
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;
gint32 new_image_id=0;
*nreturn_vals = 1;
*return_vals = values;
/* Initialize i18n support */
bindtextdomain (GETTEXT_PACKAGE, LOCALEDIR);
#ifdef HAVE_BIND_TEXTDOMAIN_CODESET
bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
#endif
textdomain (GETTEXT_PACKAGE);
run_mode = (GimpRunMode)param[0].data.d_int32;
image_ID = param[1].data.d_int32;
drawable = gimp_drawable_get (param[2].data.d_drawable);
/* Initialize with default values */
vals = default_vals;
image_vals = default_image_vals;
drawable_vals = default_drawable_vals;
ui_vals = default_ui_vals;
if (strcmp (name, PROCEDURE_NAME) == 0) {
switch (run_mode) {
case GIMP_RUN_NONINTERACTIVE:
if (n_params != 8) {
status = GIMP_PDB_CALLING_ERROR;
} else {
vals.random_seed = param[7].data.d_int32;
if (vals.random_seed)
vals.seed = g_random_int ();
}
break;
case GIMP_RUN_INTERACTIVE:
/* Possibly retrieve data */
gimp_get_data (DATA_KEY_VALS, &vals);
gimp_get_data (DATA_KEY_UI_VALS, &ui_vals);
if (! dialog(image_ID, drawable,
&vals, &image_vals, &drawable_vals, &ui_vals)) {
status = GIMP_PDB_CANCEL;
}
break;
case GIMP_RUN_WITH_LAST_VALS:
/* Possibly retrieve data */
gimp_get_data (DATA_KEY_VALS, &vals);
if (vals.random_seed)
vals.seed = g_random_int ();
break;
default:
break;
}
} else {
status = GIMP_PDB_CALLING_ERROR;
}
if (status == GIMP_PDB_SUCCESS) {
new_image_id = render (image_ID, drawable, &vals, &image_vals, &drawable_vals);
if (run_mode != GIMP_RUN_NONINTERACTIVE)
gimp_displays_flush ();
if (run_mode == GIMP_RUN_INTERACTIVE) {
gimp_set_data (DATA_KEY_VALS, &vals, sizeof (vals));
gimp_set_data (DATA_KEY_UI_VALS, &ui_vals, sizeof (ui_vals));
}
gimp_drawable_detach (drawable);
}
values[0].type = GIMP_PDB_STATUS;
values[0].data.d_status = status;
// If new_image_id = -1, there has been an error (indexed colors ?).
if (new_image_id != -1)
gimp_display_new(new_image_id);
else {
g_message(_("There was a problem when opening the new image."));
}
}
/* --------------------------------
* gap_moprhShapeDetectionEdgeBased
* --------------------------------
*
* generates morph workpoints via edge based shape detection.
* This is done by edge detection in the source image
* (specified via mgup->mgpp->osrc_layer_id)
*
* and picking workpoints on the detected edges
* and locating the corresponding point in the destination image.
*
* IN: mgup->num_shapepoints specifies the number of workpoints to be generated.
*/
void
gap_moprhShapeDetectionEdgeBased(GapMorphGUIParams *mgup, gboolean *cancelFlagPtr)
{
GapMorphShapeContext morphShapeContext;
GapMorphShapeContext *msctx;
gboolean deleteEdgeImage;
GapMorphGlobalParams *mgpp;
mgpp = mgup->mgpp;
if(mgup->workpointGenerationBusy == TRUE)
{
return;
}
mgup->workpointGenerationBusy = TRUE;
deleteEdgeImage = TRUE;
/* init context */
msctx = &morphShapeContext;
msctx->edgeColordiffThreshold = CLAMP(mgpp->edgeColordiffThreshold, 0.0, 1.0);
msctx->locateColordiffThreshold = CLAMP(mgpp->locateColordiffThreshold, 0.0, 1.0);
msctx->locateDetailShapeRadius = mgpp->locateDetailShapeRadius;
msctx->locateDetailMoveRadius = mgpp->locateDetailMoveRadius;
msctx->colorSensitivity = GAP_COLORDIFF_DEFAULT_SENSITIVITY;
msctx->refLayerId = mgpp->osrc_layer_id;
msctx->targetLayerId = mgpp->fdst_layer_id;
msctx->numShapePoints = mgpp->numWorkpoints;
msctx->countGeneratedPoints = 0;
msctx->doProgress = TRUE;
msctx->progressBar = mgup->progressBar;
if(msctx->progressBar == NULL)
{
msctx->doProgress = FALSE;
}
msctx->cancelWorkpointGenerationPtr = cancelFlagPtr;
if(gap_debug)
{
printf("gap_moprhShapeDetectionEdgeBased START edgeThres:%.5f locateThres:%.5f locateRadius:%d\n"
, (float)msctx->edgeColordiffThreshold
, (float)msctx->locateDetailMoveRadius
, (int)msctx->locateDetailMoveRadius
);
}
msctx->edgeLayerId = gap_edgeDetection(mgup->mgpp->osrc_layer_id /* refDrawableId */
,mgup->mgpp->edgeColordiffThreshold
,&msctx->countEdgePixels
);
msctx->edgeImageId = gimp_drawable_get_image(msctx->edgeLayerId);
if(gap_debug)
{
/* show the edge image for debug purpose
* (this image is intended for internal processing usage)
*/
gimp_display_new(msctx->edgeImageId);
deleteEdgeImage = FALSE;
}
msctx->edgeDrawable = gimp_drawable_get(msctx->edgeLayerId);
if(msctx->edgeDrawable != NULL)
{
gint maxWidth;
gint maxHeight;
maxWidth = msctx->edgeDrawable->width-1;
maxHeight = msctx->edgeDrawable->height-1;
if((mgup->src_win.zoom < 1.0) && (mgup->src_win.zoom > 0.0))
{
gdouble fwidth;
gdouble fheight;
gint width;
gint height;
fwidth = mgup->src_win.zoom * (gdouble)mgup->src_win.pv_ptr->pv_width;
fheight = mgup->src_win.zoom * (gdouble)mgup->src_win.pv_ptr->pv_height;
width = CLAMP((gint)fwidth, 1, maxWidth);
height = CLAMP((gint)fheight, 1, maxHeight);
msctx->sel1X = CLAMP(mgup->src_win.offs_x, 0, maxWidth);
msctx->sel1Y = CLAMP(mgup->src_win.offs_y, 0, maxHeight);
msctx->sel2X = CLAMP((msctx->sel1X + width), 0, maxWidth);
msctx->sel2Y = CLAMP((msctx->sel1Y + height), 0, maxHeight);
}
else
{
msctx->sel1X = 0;
msctx->sel1Y = 0;
msctx->sel2X = maxWidth;
msctx->sel2Y = maxHeight;
}
if(gap_debug)
{
printf("Boundaries: sel1: %d / %d sel2: %d / %d zoom:%.5f\n"
, (int)msctx->sel1X
, (int)msctx->sel1Y
, (int)msctx->sel2X
, (int)msctx->sel2Y
, (float)mgup->src_win.zoom
);
}
msctx->pftEdge = gimp_pixel_fetcher_new (msctx->edgeDrawable, FALSE /* shadow */);
gimp_pixel_fetcher_set_edge_mode (msctx->pftEdge, GIMP_PIXEL_FETCHER_EDGE_BLACK);
p_generateWorkpoints(msctx, mgpp);
gimp_pixel_fetcher_destroy (msctx->pftEdge);
}
if(msctx->edgeDrawable != NULL)
{
gimp_drawable_detach(msctx->edgeDrawable);
msctx->edgeDrawable = NULL;
}
if(deleteEdgeImage == TRUE)
{
gap_image_delete_immediate(msctx->edgeImageId);
}
if(gap_debug)
{
printf("gap_moprhShapeDetectionEdgeBased END\n");
}
mgup->workpointGenerationBusy = FALSE;
return ;
} /* end gap_moprhShapeDetectionEdgeBased */
