static void image_scale_callback (GtkWidget *dialog, GimpViewable *viewable, gint width, gint height, GimpUnit unit, GimpInterpolationType interpolation, gdouble xresolution, gdouble yresolution, GimpUnit resolution_unit, gpointer user_data) { GimpImage *image = GIMP_IMAGE (viewable); gdouble xres; gdouble yres; image_scale_unit = unit; image_scale_interp = interpolation; gimp_image_get_resolution (image, &xres, &yres); if (width > 0 && height > 0) { if (width == gimp_image_get_width (image) && height == gimp_image_get_height (image) && xresolution == xres && yresolution == yres && resolution_unit == gimp_image_get_unit (image)) return; gimp_image_undo_group_start (image, GIMP_UNDO_GROUP_IMAGE_SCALE, _("Scale Image")); gimp_image_set_resolution (image, xresolution, yresolution); gimp_image_set_unit (image, resolution_unit); if (width != gimp_image_get_width (image) || height != gimp_image_get_height (image)) { GimpProgress *progress; progress = gimp_progress_start (GIMP_PROGRESS (user_data), _("Scaling"), FALSE); gimp_image_scale (image, width, height, interpolation, progress); if (progress) gimp_progress_end (progress); } gimp_image_undo_group_end (image); gimp_image_flush (image); } else { g_warning ("Scale Error: " "Both width and height must be greater than zero."); } }
/* Create an image. Sets layer_ID, drawable and rgn. Returns image_ID */ static gint32 create_new_image (const gchar *filename, const gchar *layername, guint width, guint height, GimpImageBaseType type, gdouble xres, gdouble yres, gint32 *layer_ID, GimpDrawable **drawable, GimpPixelRgn *pixel_rgn) { gint32 image_ID; image_ID = gimp_image_new (width, height, type); gimp_image_undo_disable (image_ID); gimp_image_set_filename (image_ID, filename); gimp_image_set_resolution (image_ID, xres, yres); *layer_ID = create_new_layer (image_ID, 0, layername, width, height, type, drawable, pixel_rgn); return image_ID; }
static void image_print_size_callback (GtkWidget *dialog, GimpImage *image, gdouble xresolution, gdouble yresolution, GimpUnit resolution_unit, gpointer data) { gdouble xres; gdouble yres; gtk_widget_destroy (dialog); gimp_image_get_resolution (image, &xres, &yres); if (xresolution == xres && yresolution == yres && resolution_unit == gimp_image_get_unit (image)) return; gimp_image_undo_group_start (image, GIMP_UNDO_GROUP_IMAGE_SCALE, _("Change Print Size")); gimp_image_set_resolution (image, xresolution, yresolution); gimp_image_set_unit (image, resolution_unit); gimp_image_undo_group_end (image); gimp_image_flush (image); }
/* ============================================================================ * gap_image_new_with_layer_of_samesize * ============================================================================ * create empty image * if layer_id is NOT NULL then create one full transparent layer at full image size * and return the layer_id */ gint32 gap_image_new_with_layer_of_samesize(gint32 old_image_id, gint32 *layer_id) { GimpImageBaseType l_type; guint l_width; guint l_height; gint32 new_image_id; gdouble l_xresoulution, l_yresoulution; gint32 l_unit; /* create empty image */ l_width = gimp_image_width(old_image_id); l_height = gimp_image_height(old_image_id); l_type = gimp_image_base_type(old_image_id); l_unit = gimp_image_get_unit(old_image_id); gimp_image_get_resolution(old_image_id, &l_xresoulution, &l_yresoulution); new_image_id = gimp_image_new(l_width, l_height,l_type); gimp_image_set_resolution(new_image_id, l_xresoulution, l_yresoulution); gimp_image_set_unit(new_image_id, l_unit); if(layer_id) { l_type = (l_type * 2); /* convert from GimpImageBaseType to GimpImageType */ *layer_id = gimp_layer_new(new_image_id, "dummy", l_width, l_height, l_type, 0.0, /* Opacity full transparent */ 0); /* NORMAL */ gimp_image_insert_layer(new_image_id, *layer_id, 0, 0); } return (new_image_id); } /* end gap_image_new_with_layer_of_samesize */
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 gimp_image_duplicate_resolution (GimpImage *image, GimpImage *new_image) { gdouble xres; gdouble yres; gimp_image_get_resolution (image, &xres, &yres); gimp_image_set_resolution (new_image, xres, yres); gimp_image_set_unit (new_image, gimp_image_get_unit (image)); }
static gint32 load_image (const gchar *filename, GError **load_error) { gint32 image; gint32 layer; GdkPixbuf *pixbuf; gint width; gint height; GError *error = NULL; pixbuf = load_rsvg_pixbuf (filename, &load_vals, &error); if (! pixbuf) { /* Do not rely on librsvg setting GError on failure! */ g_set_error (load_error, error ? error->domain : 0, error ? error->code : 0, _("Could not open '%s' for reading: %s"), gimp_filename_to_utf8 (filename), error ? error->message : _("Unknown reason")); g_clear_error (&error); return -1; } gimp_progress_init (_("Rendering SVG")); 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_image_set_filename (image, filename); gimp_image_set_resolution (image, load_vals.resolution, load_vals.resolution); layer = gimp_layer_new_from_pixbuf (image, _("Rendered SVG"), pixbuf, 100, GIMP_NORMAL_MODE, 0.0, 1.0); gimp_image_insert_layer (image, layer, -1, 0); gimp_image_undo_enable (image); return image; }
static gboolean jpeg_load_resolution (gint32 image_ID, struct jpeg_decompress_struct *cinfo) { if (cinfo->saw_JFIF_marker && cinfo->X_density != 0 && cinfo->Y_density != 0) { gdouble xresolution = cinfo->X_density; gdouble yresolution = cinfo->Y_density; gdouble asymmetry = 1.0; switch (cinfo->density_unit) { case 0: /* unknown -> set the aspect ratio but use the default * image resolution */ asymmetry = xresolution / yresolution; gimp_image_get_resolution (image_ID, &xresolution, &yresolution); xresolution *= asymmetry; break; case 1: /* dots per inch */ break; case 2: /* dots per cm */ xresolution *= 2.54; yresolution *= 2.54; gimp_image_set_unit (image_ID, GIMP_UNIT_MM); break; default: g_message ("Unknown density unit %d, assuming dots per inch.", cinfo->density_unit); break; } gimp_image_set_resolution (image_ID, xresolution, yresolution); return TRUE; } return FALSE; }
static gboolean jpeg_load_exif_resolution (gint32 image_ID, ExifData *exif_data) { gboolean success; gdouble xresolution; gdouble yresolution; gint unit; if (!exif_data) return FALSE; if (!jpeg_exif_get_resolution (exif_data, &xresolution, &yresolution, &unit)) return FALSE; switch (unit) { case 2: success = TRUE; break; case 3: /* dots per cm */ xresolution *= 2.54; yresolution *= 2.54; gimp_image_set_unit (image_ID, GIMP_UNIT_MM); success = TRUE; break; default: g_warning ("Unknown EXIF resolution unit %d; skipping EXIF resolution.", unit); success = FALSE; } if (success) { gimp_image_set_resolution (image_ID, xresolution, yresolution); } return success; }
/* Create an image. Sets layer_ID, drawable and rgn. Returns image_ID */ static gint32 create_new_image (const gchar *filename, const gchar *layername, guint width, guint height, GimpImageBaseType type, GimpPrecision precision, gdouble xres, gdouble yres, gint32 *layer_ID) { gint32 image_ID; image_ID = gimp_image_new_with_precision (width, height, type, precision); gimp_image_undo_disable (image_ID); gimp_image_set_filename (image_ID, filename); gimp_image_set_resolution (image_ID, xres, yres); *layer_ID = create_new_layer (image_ID, 0, layername, width, height, type); return image_ID; }
static gboolean apply_resize(resize_settings settings, image_output out) { gboolean success = FALSE; gint orig_w, orig_h, final_w, final_h, view_w, view_h; gdouble orig_res_x, orig_res_y; if (settings->change_res) { success = gimp_image_get_resolution( out->image_id, &orig_res_x, &orig_res_y ); if ((settings->new_res_x != orig_res_x) || (settings->new_res_y != orig_res_y)) { // change resolution success = gimp_image_set_resolution( out->image_id, settings->new_res_x, settings->new_res_y ); } } orig_w = gimp_image_width(out->image_id); orig_h = gimp_image_height(out->image_id); if (settings->resize_mode == RESIZE_PERCENT) { if (settings->stretch_mode == STRETCH_ASPECT) { gdouble newpct = min(settings->new_w_pc, settings->new_h_pc); final_w = view_w = round((orig_w * newpct) / 100.0); final_h = view_h = round((orig_h * newpct) / 100.0); } else if (settings->stretch_mode == STRETCH_PADDED) { gdouble newpct = min(settings->new_w_pc, settings->new_h_pc); final_w = round((orig_w * newpct) / 100.0); final_h = round((orig_h * newpct) / 100.0); view_w = round((orig_w * settings->new_w_pc) / 100.0); view_h = round((orig_h * settings->new_h_pc) / 100.0); } else { final_w = view_w = round((orig_w * settings->new_w_pc) / 100.0); final_h = view_h = round((orig_h * settings->new_h_pc) / 100.0); } } else { // user typed exact pixel size if (settings->resize_mode == RESIZE_PIXEL_WIDTH) { view_w = settings->new_w_px; // width is fixed if (settings->stretch_mode == STRETCH_ASPECT) { final_w = view_w; final_h = view_h = round(((float)final_w * orig_h) / orig_w); } else if (settings->stretch_mode == STRETCH_PADDED) { final_w = min(view_w, orig_w); final_h = round(((float)final_w * orig_h) / orig_w); view_h = max(orig_h, final_h); } else { final_w = view_w; final_h = view_h = orig_h; } } else if (settings->resize_mode == RESIZE_PIXEL_HEIGHT) { view_h = settings->new_h_px; // height is fixed if (settings->stretch_mode == STRETCH_ASPECT) { final_h = view_h; final_w = view_w = round(((float)final_h * orig_w) / orig_h); } else if (settings->stretch_mode == STRETCH_PADDED) { final_h = min(view_h, orig_h); final_w = round(((float)final_h * orig_w) / orig_h); view_w = max(orig_w, final_w); } else { final_h = view_h; final_w = view_w = orig_w; } } else { // both dimensions are defined if (settings->stretch_mode == STRETCH_ASPECT) { // Find which new dimension is the smallest percentage of the existing image dimension gdouble newwpct = (float)settings->new_w_px / (float)orig_w; gdouble newhpct = (float)settings->new_h_px / (float)orig_h; gdouble newpct = min(newwpct, newhpct); final_w = view_w = round(orig_w * newpct); final_h = view_h = round(orig_h * newpct); } else if (settings->stretch_mode == STRETCH_PADDED) { // Find which new dimension is the smallest percentage of the existing image dimension gdouble newwpct = (float)settings->new_w_px / (float)orig_w; gdouble newhpct = (float)settings->new_h_px / (float)orig_h; gdouble newpct = min(newwpct, newhpct); final_w = round(orig_w * newpct); final_h = round(orig_h * newpct); view_w = round(orig_w * newwpct); view_h = round(orig_h * newhpct); } else { final_w = view_w = settings->new_w_px; final_h = view_h = settings->new_h_px; } } } // do resize #if USE_API26 success = gimp_image_scale_full ( out->image_id, final_w, final_h, settings->interpolation ); #else // starting from 2.8, gimp_image_scale_full is deprecated. // use gimp_image_scale instead GimpInterpolationType old_interpolation; old_interpolation = gimp_context_get_interpolation(); success = gimp_context_set_interpolation (settings->interpolation); success = gimp_image_scale ( out->image_id, final_w, final_h ); success = gimp_context_set_interpolation (old_interpolation); #endif // add a padding if requested if (settings->stretch_mode == STRETCH_PADDED) { // the padding will be drawn using a coloured layer at the bottom of the image gint32 layerId = gimp_layer_new( out->image_id, "padding_layer", view_w, view_h, GIMP_RGBA_IMAGE, (settings->padding_color_alpha / (float)G_MAXUINT16) * 100, GIMP_NORMAL_MODE ); #if USE_API26 gimp_image_add_layer ( out->image_id, layerId, 0 ); gimp_image_lower_layer_to_bottom(out->image_id, layerId); #else gimp_image_insert_layer( out->image_id, layerId, 0, 0 ); gimp_image_lower_item_to_bottom(out->image_id, layerId); #endif // fill it with the selected color GimpRGB old_background, new_background; gimp_context_get_background(&old_background); gimp_rgb_parse_hex (&new_background, gdk_color_to_string(&(settings->padding_color)), strlen(gdk_color_to_string(&(settings->padding_color)))); gimp_context_set_background(&new_background); gimp_drawable_fill(layerId, GIMP_BACKGROUND_FILL); gimp_context_set_background(&old_background); // move it to the center gimp_layer_translate(layerId, -abs(view_w - final_w) / 2, -abs(view_h - final_h) / 2); // finish changing the canvas size accordingly success = gimp_image_resize_to_layers(out->image_id); } return success; }
static void gimp_display_shell_drop_drawable (GtkWidget *widget, gint x, gint y, GimpViewable *viewable, gpointer data) { GimpDisplayShell *shell = GIMP_DISPLAY_SHELL (data); GimpImage *image = shell->display->image; GType new_type; GimpItem *new_item; gboolean new_image = FALSE; GIMP_LOG (DND, NULL); if (shell->display->gimp->busy) return; if (! image) { GimpImage *src_image = gimp_item_get_image (GIMP_ITEM (viewable)); GimpDrawable *drawable = GIMP_DRAWABLE (viewable); GimpImageBaseType type; gdouble xres; gdouble yres; type = GIMP_IMAGE_TYPE_BASE_TYPE (gimp_drawable_type (drawable)); image = gimp_create_image (shell->display->gimp, gimp_item_width (GIMP_ITEM (viewable)), gimp_item_height (GIMP_ITEM (viewable)), type, TRUE); gimp_image_undo_disable (image); if (type == GIMP_INDEXED) gimp_image_set_colormap (image, gimp_image_get_colormap (src_image), gimp_image_get_colormap_size (src_image), FALSE); gimp_image_get_resolution (src_image, &xres, &yres); gimp_image_set_resolution (image, xres, yres); gimp_image_set_unit (image, gimp_image_get_unit (src_image)); gimp_create_display (image->gimp, image, GIMP_UNIT_PIXEL, 1.0); g_object_unref (image); new_image = TRUE; } if (GIMP_IS_LAYER (viewable)) new_type = G_TYPE_FROM_INSTANCE (viewable); else new_type = GIMP_TYPE_LAYER; new_item = gimp_item_convert (GIMP_ITEM (viewable), image, new_type); if (new_item) { GimpLayer *new_layer = GIMP_LAYER (new_item); gimp_image_undo_group_start (image, GIMP_UNDO_GROUP_EDIT_PASTE, _("Drop New Layer")); if (! new_image) gimp_display_shell_dnd_position_item (shell, new_item); gimp_item_set_visible (new_item, TRUE, FALSE); gimp_item_set_linked (new_item, FALSE, FALSE); gimp_image_add_layer (image, new_layer, -1); gimp_image_undo_group_end (image); gimp_display_shell_dnd_flush (shell, image); } if (new_image) gimp_image_undo_enable (image); }
static gboolean apply_resize(resize_settings settings, image_output out) { gboolean success = FALSE; gint final_w, final_h; gdouble orig_res_x, orig_res_y; if (settings->change_res) { success = gimp_image_get_resolution( out->image_id, &orig_res_x, &orig_res_y ); if ((settings->new_res_x != orig_res_x) || (settings->new_res_y != orig_res_y)) { /* change resolution */ success = gimp_image_set_resolution( out->image_id, settings->new_res_x, settings->new_res_y ); } } if (settings->resize_mode == RESIZE_PERCENT) { /* user selected a percentage of the original size */ final_w = round((gimp_image_width(out->image_id) * settings->new_w_pc) / 100.0); final_h = round((gimp_image_height(out->image_id) * settings->new_h_pc) / 100.0); } else { /* user typed exact pixel size */ if (settings->resize_mode == RESIZE_PIXEL_WIDTH) { /* width only */ final_w = settings->new_w_px; if (settings->aspect_ratio) { /* and maintain aspect ratio */ final_h = round(((float)settings->new_w_px * gimp_image_height(out->image_id)) / gimp_image_width(out->image_id)); } else { final_h = gimp_image_height(out->image_id); } } else if (settings->resize_mode == RESIZE_PIXEL_HEIGHT) { /* height only */ final_h = settings->new_h_px; if (settings->aspect_ratio) { /* and maintain aspect ratio */ final_w = round(((float)settings->new_h_px * gimp_image_width(out->image_id)) / gimp_image_height(out->image_id)); } else { final_w = gimp_image_width(out->image_id); } } else { /* both dimensions are defined */ if (settings->aspect_ratio) { // Find which new dimension is the smallest percentage of the existing image dimension gdouble newwpct = (float)settings->new_w_px / (float)gimp_image_width(out->image_id); gdouble newhpct = (float)settings->new_h_px / (float)gimp_image_height(out->image_id); gdouble newpct = (newwpct < newhpct) ? newwpct : newhpct; final_w = round((float)gimp_image_width(out->image_id) * newpct); final_h = round((float)gimp_image_height(out->image_id) * newpct); } else { final_w = settings->new_w_px; final_h = settings->new_h_px; } } } /* do resize */ #if defined _WIN32 || (!defined _WIN32 && (GIMP_MAJOR_VERSION == 2) && (GIMP_MINOR_VERSION <= 6)) success = gimp_image_scale_full ( out->image_id, final_w, final_h, settings->interpolation ); #else /* starting from 2.8, gimp_image_scale_full is deprecated. * use gimp_image_scale instead */ GimpInterpolationType oldInterpolation; oldInterpolation = gimp_context_get_interpolation(); success = gimp_context_set_interpolation (settings->interpolation); success = gimp_image_scale ( out->image_id, final_w, final_h ); success = gimp_context_set_interpolation (oldInterpolation); #endif return success; }
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; }
void gimp_image_rotate (GimpImage *image, GimpContext *context, GimpRotationType rotate_type, GimpProgress *progress) { GList *list; gdouble center_x; gdouble center_y; gdouble progress_max; gdouble progress_current = 1.0; gint new_image_width; gint new_image_height; gint previous_image_width; gint previous_image_height; gint offset_x; gint offset_y; gboolean size_changed; g_return_if_fail (GIMP_IS_IMAGE (image)); g_return_if_fail (GIMP_IS_CONTEXT (context)); g_return_if_fail (progress == NULL || GIMP_IS_PROGRESS (progress)); gimp_set_busy (image->gimp); previous_image_width = gimp_image_get_width (image); previous_image_height = gimp_image_get_height (image); center_x = previous_image_width / 2.0; center_y = previous_image_height / 2.0; progress_max = (gimp_container_get_n_children (gimp_image_get_channels (image)) + gimp_container_get_n_children (gimp_image_get_layers (image)) + gimp_container_get_n_children (gimp_image_get_vectors (image)) + 1 /* selection */); g_object_freeze_notify (G_OBJECT (image)); gimp_image_undo_group_start (image, GIMP_UNDO_GROUP_IMAGE_ROTATE, NULL); /* Resize the image (if needed) */ switch (rotate_type) { case GIMP_ROTATE_90: case GIMP_ROTATE_270: new_image_width = gimp_image_get_height (image); new_image_height = gimp_image_get_width (image); size_changed = TRUE; offset_x = (gimp_image_get_width (image) - new_image_width) / 2; offset_y = (gimp_image_get_height (image) - new_image_height) / 2; break; case GIMP_ROTATE_180: new_image_width = gimp_image_get_width (image); new_image_height = gimp_image_get_height (image); size_changed = FALSE; offset_x = 0; offset_y = 0; break; default: g_assert_not_reached (); return; } /* Rotate all channels */ for (list = gimp_image_get_channel_iter (image); list; list = g_list_next (list)) { GimpItem *item = list->data; gimp_item_rotate (item, context, rotate_type, center_x, center_y, FALSE); gimp_item_set_offset (item, 0, 0); if (progress) gimp_progress_set_value (progress, progress_current++ / progress_max); } /* Rotate all vectors */ for (list = gimp_image_get_vectors_iter (image); list; list = g_list_next (list)) { GimpItem *item = list->data; gimp_item_rotate (item, context, rotate_type, center_x, center_y, FALSE); gimp_item_set_offset (item, 0, 0); gimp_item_set_size (item, new_image_width, new_image_height); gimp_item_translate (item, (new_image_width - gimp_image_get_width (image)) / 2, (new_image_height - gimp_image_get_height (image)) / 2, FALSE); if (progress) gimp_progress_set_value (progress, progress_current++ / progress_max); } /* Don't forget the selection mask! */ { GimpChannel *mask = gimp_image_get_mask (image); gimp_item_rotate (GIMP_ITEM (mask), context, rotate_type, center_x, center_y, FALSE); gimp_item_set_offset (GIMP_ITEM (mask), 0, 0); if (progress) gimp_progress_set_value (progress, progress_current++ / progress_max); } /* Rotate all layers */ for (list = gimp_image_get_layer_iter (image); list; list = g_list_next (list)) { GimpItem *item = list->data; gint off_x; gint off_y; gimp_item_get_offset (item, &off_x, &off_y); gimp_item_rotate (item, context, rotate_type, center_x, center_y, FALSE); gimp_image_rotate_item_offset (image, rotate_type, item, off_x, off_y); if (progress) gimp_progress_set_value (progress, progress_current++ / progress_max); } /* Rotate all Guides */ gimp_image_rotate_guides (image, rotate_type); /* Rotate all sample points */ gimp_image_rotate_sample_points (image, rotate_type); /* Resize the image (if needed) */ if (size_changed) { gdouble xres; gdouble yres; gimp_image_undo_push_image_size (image, NULL, offset_x, offset_y, new_image_width, new_image_height); g_object_set (image, "width", new_image_width, "height", new_image_height, NULL); gimp_image_get_resolution (image, &xres, &yres); if (xres != yres) gimp_image_set_resolution (image, yres, xres); } gimp_image_undo_group_end (image); if (size_changed) gimp_image_size_changed_detailed (image, -offset_x, -offset_y, previous_image_width, previous_image_height); g_object_thaw_notify (G_OBJECT (image)); gimp_unset_busy (image->gimp); }
/* * 'load_image()' - Load a WMF image into a new image window. */ static gint32 load_image (const gchar *filename, GError **error) { gint32 image; gint32 layer; GimpDrawable *drawable; guchar *pixels; GimpPixelRgn pixel_rgn; guint width, height; guint rowstride; guint count = 0; guint done = 0; gpointer pr; pixels = wmf_load_file (filename, &width, &height, error); if (! pixels) return -1; rowstride = width * 4; gimp_progress_init_printf (_("Opening '%s'"), gimp_filename_to_utf8 (filename)); image = gimp_image_new (width, height, GIMP_RGB); gimp_image_set_filename (image, filename); gimp_image_set_resolution (image, load_vals.resolution, load_vals.resolution); layer = gimp_layer_new (image, _("Rendered WMF"), width, height, GIMP_RGBA_IMAGE, 100, GIMP_NORMAL_MODE); drawable = gimp_drawable_get (layer); gimp_pixel_rgn_init (&pixel_rgn, drawable, 0, 0, width, height, TRUE, FALSE); for (pr = gimp_pixel_rgns_register (1, &pixel_rgn); pr != NULL; pr = gimp_pixel_rgns_process (pr)) { const guchar *src = pixels + pixel_rgn.y * rowstride + pixel_rgn.x * 4; guchar *dest = pixel_rgn.data; gint y; for (y = 0; y < pixel_rgn.h; y++) { memcpy (dest, src, pixel_rgn.w * pixel_rgn.bpp); src += rowstride; dest += pixel_rgn.rowstride; } done += pixel_rgn.h * pixel_rgn.w; if (count++ % 16 == 0) gimp_progress_update ((gdouble) done / (width * height)); } g_free (pixels); gimp_drawable_detach (drawable); gimp_progress_update (1.0); /* Tell GIMP to display the image. */ gimp_image_insert_layer (image, layer, -1, 0); gimp_drawable_flush (drawable); return image; }
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 ); }
/* ---------------------------- * gap_frame_fetch_dup_image * ---------------------------- * returns merged or selected layer_id * (that is the only visible layer in temporary created scratch image) * the caller is resonsible to delete the scratch image when processing is done. * this can be done by calling gap_frame_fetch_delete_list_of_duplicated_images() */ gint32 gap_frame_fetch_dup_image(gint32 ffetch_user_id ,const char *filename /* full filename of the image (already contains framenr) */ ,gint32 stackpos /* 0 pick layer on top of stack, -1 merge visible layers */ ,gboolean addToCache /* enable caching */ ) { gint32 resulting_layer; gint32 image_id; gint32 dup_image_id; resulting_layer = -1; dup_image_id = -1; image_id = p_load_cache_image(filename, ffetch_user_id, addToCache); if (image_id < 0) { return(-1); } if (stackpos < 0) { dup_image_id = gimp_image_duplicate(image_id); gap_frame_fetch_remove_parasite(dup_image_id); resulting_layer = gap_image_merge_visible_layers(dup_image_id, GIMP_CLIP_TO_IMAGE); } else { gint l_nlayers; gint32 *l_layers_list; l_layers_list = gimp_image_get_layers(image_id, &l_nlayers); if(l_layers_list != NULL) { if (stackpos < l_nlayers) { gint32 src_layer_id; gdouble l_xresoulution, l_yresoulution; gint32 l_unit; src_layer_id = l_layers_list[stackpos]; dup_image_id = gimp_image_new (gimp_image_width(image_id) , gimp_image_height(image_id) , gimp_image_base_type(image_id) ); gimp_image_get_resolution(image_id, &l_xresoulution, &l_yresoulution); gimp_image_set_resolution(dup_image_id, l_xresoulution, l_yresoulution); l_unit = gimp_image_get_unit(image_id); gimp_image_set_unit(dup_image_id, l_unit); resulting_layer = gap_layer_copy_to_image (dup_image_id, src_layer_id); } g_free (l_layers_list); } } p_add_image_to_list_of_duplicated_images(dup_image_id, ffetch_user_id); if (addToCache != TRUE) { GimpParasite *l_parasite; l_parasite = gimp_image_parasite_find(image_id, GAP_IMAGE_CACHE_PARASITE); if(l_parasite) { gimp_parasite_free(l_parasite); } else { /* the original image is not cached * (delete it because the caller gets the preprocessed duplicate) */ gap_image_delete_immediate(image_id); } } return(resulting_layer); } /* end gap_frame_fetch_dup_image */