//------------------------------------------------------------------------- static void c2g_mask (GimpDrawable *drawable, gdouble radius, gdouble amount, gdouble gamma) { GimpPixelRgn srcPR, destPR; gint x1, y1, x2, y2; /* initialize pixel regions */ gimp_pixel_rgn_init (&srcPR, drawable, 0, 0, drawable->width, drawable->height, FALSE, FALSE); gimp_pixel_rgn_init (&destPR, drawable, 0, 0, drawable->width, drawable->height, TRUE, TRUE); /* Get the input */ gimp_drawable_mask_bounds (drawable->drawable_id, &x1, &y1, &x2, &y2); c2g_region (&srcPR, &destPR, drawable->bpp, radius, amount, gamma, x1, x2, y1, y2, TRUE); gimp_drawable_flush (drawable); gimp_drawable_merge_shadow (drawable->drawable_id, TRUE); gimp_drawable_update (drawable->drawable_id, x1, y1, x2 - x1, y2 - y1); }
/* This function operates on PixelArea, whose width and height are multiply of pixel width, and less than the tile size (to enhance its speed). If any coordinates of mask boundary is not multiply of pixel width (e.g. x1 % pixelwidth != 0), operates on the region whose width or height is the remainder. */ static void pixelize_small (GimpDrawable *drawable, gint pixelwidth, gint pixelheight, gint tile_width, gint tile_height) { GimpPixelRgn src_rgn, dest_rgn; gint bpp, has_alpha; gint x1, y1, x2, y2; gint progress, max_progress; gimp_drawable_mask_bounds (drawable->drawable_id, &x1, &y1, &x2, &y2); gimp_pixel_rgn_init (&src_rgn, drawable, x1, y1, x2-x1, y2-y1, FALSE, FALSE); gimp_pixel_rgn_init (&dest_rgn, drawable, x1, y1, x2-x1, y2-y1, TRUE, TRUE); /* Initialize progress */ progress = 0; max_progress = (x2 - x1) * (y2 - y1); bpp = drawable->bpp; has_alpha = gimp_drawable_has_alpha (drawable->drawable_id); area.width = (tile_width / pixelwidth) * pixelwidth; area.height = (tile_height / pixelheight) * pixelheight; area.data= g_new (guchar, (glong) bpp * area.width * area.height); for (area.y = y1; area.y < y2; area.y += area.height - (area.y % area.height)) { area.h = area.height - (area.y % area.height); area.h = MIN (area.h, y2 - area.y); for (area.x = x1; area.x < x2; area.x += area.width - (area.x % area.width)) { area.w = area.width - (area.x % area.width); area.w = MIN(area.w, x2 - area.x); gimp_pixel_rgn_get_rect (&src_rgn, area.data, area.x, area.y, area.w, area.h); pixelize_sub (pixelwidth, pixelheight, bpp, has_alpha); gimp_pixel_rgn_set_rect (&dest_rgn, area.data, area.x, area.y, area.w, area.h); /* Update progress */ progress += area.w * area.h; gimp_progress_update ((double) progress / (double) max_progress); } } g_free(area.data); /* update the pixelized region */ gimp_drawable_flush (drawable); gimp_drawable_merge_shadow (drawable->drawable_id, TRUE); gimp_drawable_update (drawable->drawable_id, x1, y1, (x2 - x1), (y2 - y1)); }
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 waves (GimpDrawable *drawable) { GimpPixelRgn srcPr, dstPr; guchar *src, *dst; guint width, height, bpp, has_alpha; width = drawable->width; height = drawable->height; bpp = drawable->bpp; has_alpha = gimp_drawable_has_alpha (drawable->drawable_id); src = g_new (guchar, width * height * bpp); dst = g_new (guchar, width * height * bpp); gimp_pixel_rgn_init (&srcPr, drawable, 0, 0, width, height, FALSE, FALSE); gimp_pixel_rgn_init (&dstPr, drawable, 0, 0, width, height, TRUE, TRUE); gimp_pixel_rgn_get_rect (&srcPr, src, 0, 0, width, height); wave (src, dst, width, height, bpp, has_alpha, width / 2.0, height / 2.0, wvals.amplitude, wvals.wavelength, wvals.phase, wvals.type == MODE_SMEAR, wvals.reflective, TRUE); gimp_pixel_rgn_set_rect (&dstPr, dst, 0, 0, width, height); g_free (src); g_free (dst); gimp_drawable_flush (drawable); gimp_drawable_merge_shadow (drawable->drawable_id, TRUE); gimp_drawable_update (drawable->drawable_id, 0, 0, width, height); gimp_displays_flush (); }
static void octave (GimpDrawable *drawable) { GimpPixelRgn srcPR, destPR; gint x1, y1, x2, y2; gint x, y, width, height; /* initialize pixel regions */ gimp_pixel_rgn_init (&srcPR, drawable, 0, 0, drawable->width, drawable->height, FALSE, FALSE); gimp_pixel_rgn_init (&destPR, drawable, 0, 0, drawable->width, drawable->height, TRUE, TRUE); /* Get the input */ gimp_drawable_mask_bounds (drawable->drawable_id, &x1, &y1, &x2, &y2); x=x1; y=y1; width=x2-x1; height=y2-y1; /* Run */ octave_region (&srcPR, &destPR, drawable->bpp, x, y, width, height); gimp_drawable_flush (drawable); gimp_drawable_merge_shadow (drawable->drawable_id, TRUE); gimp_drawable_update (drawable->drawable_id, x1, y1, x2 - x1, y2 - y1); }
/* * 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 sinus (void) { params p; gint bytes; GimpPixelRgn dest_rgn; gint x1, y1, x2, y2; gpointer pr; gint progress, max_progress; prepare_coef(&p); gimp_drawable_mask_bounds(drawable->drawable_id, &x1, &y1, &x2, &y2); p.width = drawable->width; p.height = drawable->height; bytes = drawable->bpp; gimp_pixel_rgn_init (&dest_rgn, drawable, x1, y1, x2 - x1, y2 - y1, TRUE,TRUE); progress = 0; max_progress = (x2 - x1) * (y2 - y1); for (pr = gimp_pixel_rgns_register (1, &dest_rgn); pr != NULL; pr = gimp_pixel_rgns_process (pr)) { switch (bytes) { case 4: compute_block_x (dest_rgn.data, dest_rgn.rowstride, dest_rgn.x, dest_rgn.y, dest_rgn.w, dest_rgn.h, 4, assign_block_4, &p); break; case 3: compute_block_x (dest_rgn.data, dest_rgn.rowstride, dest_rgn.x, dest_rgn.y, dest_rgn.w, dest_rgn.h, 3, assign_block_3, &p); break; case 2: compute_block_x (dest_rgn.data, dest_rgn.rowstride, dest_rgn.x, dest_rgn.y, dest_rgn.w, dest_rgn.h, 2, assign_block_2, &p); break; case 1: compute_block_x (dest_rgn.data, dest_rgn.rowstride, dest_rgn.x, dest_rgn.y, dest_rgn.w, dest_rgn.h, 1, assign_block_1, &p); break; } progress += dest_rgn.w * dest_rgn.h; gimp_progress_update ((double) progress / (double) max_progress); } gimp_drawable_flush (drawable); gimp_drawable_merge_shadow (drawable->drawable_id, TRUE); gimp_drawable_update (drawable->drawable_id, x1, y1, x2 - x1, y2 - y1); }
gint32 execute_plugin(GimpDrawable* d, const char *nome, param_type *p) { // gint i; guchar *img, *org; gint x,y,x2,y2,w,h; // guchar *work; GimpPixelRgn region, rgn_org; gint bpp = d->bpp; gimp_drawable_mask_bounds(d->drawable_id, &x, &y, &x2, &y2); w = x2 - x; h = y2 - y; img = malloc(w * h * bpp); org = malloc(w * h * bpp); // work = malloc(d.width * d.height * bpp); gimp_pixel_rgn_init(®ion, d, x, y, w, h, TRUE, TRUE); //este é buffer para gravar a imagem modificada. gimp_pixel_rgn_init(&rgn_org, d, x, y, w, h, FALSE, FALSE); // Esta é a imagem em si gimp_pixel_rgn_get_rect(®ion, img, x, y, w, h); gimp_pixel_rgn_get_rect(&rgn_org, org, x, y, w, h); switch (*nome) { case 'S': super_grow(p, org, img, w, h, bpp); break; case 'G': memcpy(img, org, w * h * bpp); grow(p, org, img, w, h, bpp); break; case 'A': find_iso(p, org, img, w, h, bpp); break; default: make_height_field(p, org, img, w, h, bpp); break; } gimp_pixel_rgn_set_rect(®ion, img, x, y, w, h); /* finish the process */ gimp_drawable_flush (d); gimp_drawable_merge_shadow (d->drawable_id, TRUE); gimp_drawable_update (d->drawable_id, x, y, w, h); gimp_displays_flush(); gimp_drawable_detach(d); free(img); free(org); return GIMP_PDB_SUCCESS; }
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); }
/* ---------------------------------------- * p_subtract_ref_layer * ---------------------------------------- * setup pixel regions and perform edge detection by subtracting RGB channels * of the orignal (refDrawable) from the blurred copy (edgeDrawable) * and convert the rgb differences to lightness. * * as result of this processing in the edgeDrawable contains a desaturated * colordifference of the original versus blured copy. */ static void p_subtract_ref_layer(gint32 image_id, GimpDrawable *edgeDrawable, GimpDrawable *refDrawable , gdouble threshold, gint32 shift, gboolean invert) { GimpPixelRgn edgePR; GimpPixelRgn refPR; GimpPixelRgn ref2PR; gpointer pr; gdouble threshold01f; gdouble threshold255f; gint threshold255; gint cx; gint cy; threshold01f = CLAMP((threshold / 100.0), 0, 1); threshold255f = 255.0 * threshold01f; threshold255 = threshold255f; p_get_debug_coords_from_guides(image_id, &cx, &cy); gimp_pixel_rgn_init (&edgePR, edgeDrawable, 0, 0 , edgeDrawable->width - shift, edgeDrawable->height - shift , TRUE /* dirty */ , FALSE /* shadow */ ); /* start at shifted offset 0/+1 */ gimp_pixel_rgn_init (&refPR, refDrawable, 0, shift , refDrawable->width - shift, refDrawable->height - shift , FALSE /* dirty */ , FALSE /* shadow */ ); /* start at shifted offset +1/0 */ gimp_pixel_rgn_init (&ref2PR, refDrawable, shift, 0 , refDrawable->width - shift, refDrawable->height - shift , FALSE /* dirty */ , FALSE /* shadow */ ); /* compare pixel areas in tiled portions via pixel region processing loops. */ for (pr = gimp_pixel_rgns_register (3, &edgePR, &refPR, &ref2PR); pr != NULL; pr = gimp_pixel_rgns_process (pr)) { p_colordiffProcessingForOneRegion (&edgePR, &refPR, &ref2PR, threshold01f, invert, cx, cy); } gimp_drawable_flush (edgeDrawable); gimp_drawable_update (edgeDrawable->drawable_id , 0, 0 , edgeDrawable->width, edgeDrawable->height ); } /* end p_subtract_ref_layer */
/* Update Gimp image from local pixmap. Canonical postlude for plugins. !!! Called in the postlude but also for debugging: animate results during processing. */ static void post_results_to_gimp( GimpDrawable *drawable, Map targetMap) { pixmap_to_drawable(targetMap, drawable, FIRST_PIXELEL_INDEX); // our pixels to region gimp_drawable_flush(drawable); // regions back to core gimp_drawable_merge_shadow(drawable->drawable_id,TRUE); // temp buffers merged gimp_drawable_update(drawable->drawable_id,0,0,targetMap.width,targetMap.height); gimp_displays_flush(); }
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 mblur (GimpDrawable *drawable, GimpPreview *preview) { gint x, y; gint width, height; if (preview) { gimp_preview_get_position (preview, &x, &y); gimp_preview_get_size (preview, &width, &height); } else { gimp_drawable_mask_bounds (drawable->drawable_id, &x, &y, &width, &height); width -= x; height -= y; } if (width < 1 || height < 1) return; if (! preview) gimp_progress_init (_("Motion blurring")); switch (mbvals.mblur_type) { case MBLUR_LINEAR: mblur_linear (drawable, preview, x, y, width, height); break; case MBLUR_RADIAL: mblur_radial (drawable, preview, x, y, width, height); break; case MBLUR_ZOOM: mblur_zoom (drawable, preview, x, y, width, height); break; default: break; } if (! preview) { gimp_drawable_flush (drawable); gimp_drawable_merge_shadow (drawable->drawable_id, TRUE); gimp_drawable_update (drawable->drawable_id, x, y, width, height); } }
static void color_rotate (GimpDrawable *drawable) { GimpPixelRgn srcPR, destPR; gint width, height; gint bytes; guchar *src_row, *dest_row; gint row; gint x, y; if (! gimp_drawable_mask_intersect (drawable->drawable_id, &x, &y, &width, &height)) { return; } bytes = drawable->bpp; src_row = g_new (guchar, width * bytes); dest_row = g_new (guchar, width * bytes); gimp_pixel_rgn_init (&srcPR, drawable, 0, 0, drawable->width, drawable->height, FALSE, FALSE); gimp_pixel_rgn_init (&destPR, drawable, 0, 0, drawable->width, drawable->height, TRUE, TRUE); for (row = y; row < (y + height); row++) { gimp_pixel_rgn_get_row (&srcPR, src_row, x, row, width); color_rotate_row (src_row, dest_row, row, width, bytes); gimp_pixel_rgn_set_row (&destPR, dest_row, x, row, width); if ((row % 10) == 0) gimp_progress_update ((double) row / (double) height); } /* update the processed region */ gimp_progress_update (1.0); gimp_drawable_flush (drawable); gimp_drawable_merge_shadow (drawable->drawable_id, TRUE); gimp_drawable_update (drawable->drawable_id, x, y, width, height); g_free (src_row); g_free (dest_row); }
void focusblur_fft_buffer_draw (FblurFftBuffer *fft) { GimpDrawablePreview *preview; gboolean dirty; guint8 *data; GimpPixelRgn pr; if (! fft->source.preview) { preview = NULL; dirty = TRUE; data = fft->source.data; } else { preview = GIMP_DRAWABLE_PREVIEW (fft->source.preview); g_assert (preview != NULL); dirty = FALSE; data = fft->source.data_preview; } g_assert (data != NULL); gimp_pixel_rgn_init (&pr, fft->source.drawable, fft->source.x1, fft->source.y1, fft->source.width, fft->source.height, dirty, TRUE); gimp_pixel_rgn_set_rect (&pr, data, fft->source.x1, fft->source.y1, fft->source.width, fft->source.height); if (! preview) { gimp_drawable_flush (fft->source.drawable); gimp_drawable_merge_shadow (fft->source.drawable->drawable_id, TRUE); gimp_drawable_update (fft->source.drawable->drawable_id, fft->source.x1, fft->source.y1, fft->source.width, fft->source.height); /* this buffer has been dirty */ focusblur_fft_buffer_clear_source (fft); } else { gimp_drawable_preview_draw_region (preview, &pr); } }
// !!! 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; } }
/** * gimp_drawable_detach: * @drawable: The #GimpDrawable to detach from the core * * This function is called when a plug-in is finished working * with a drawable. It forces all tile data held in the tile * list of the #GimpDrawable to be transferred to the core, and * then frees all associated memory. You must not access the * @drawable after having called gimp_drawable_detach(). **/ void gimp_drawable_detach (GimpDrawable *drawable) { g_return_if_fail (drawable != NULL); gimp_drawable_flush (drawable); if (drawable->tiles) g_free (drawable->tiles); if (drawable->shadow_tiles) g_free (drawable->shadow_tiles); g_slice_free (GimpDrawable, drawable); }
void gimp_rgn_iterate2 (GimpDrawable *drawable, GimpRunMode unused, GimpRgnFunc2 func, gpointer data) { GimpPixelRgn srcPR, destPR; gint x1, y1, x2, y2; gpointer pr; gint total_area; gint area_so_far; gint progress_skip; g_return_if_fail (drawable != NULL); gimp_drawable_mask_bounds (drawable->drawable_id, &x1, &y1, &x2, &y2); total_area = (x2 - x1) * (y2 - y1); if (total_area <= 0) return; area_so_far = 0; progress_skip = 0; /* Initialize the pixel regions. */ gimp_pixel_rgn_init (&srcPR, drawable, x1, y1, (x2 - x1), (y2 - y1), FALSE, FALSE); gimp_pixel_rgn_init (&destPR, drawable, x1, y1, (x2 - x1), (y2 - y1), TRUE, TRUE); for (pr = gimp_pixel_rgns_register (2, &srcPR, &destPR); pr != NULL; pr = gimp_pixel_rgns_process (pr)) { gimp_rgn_render_region (&srcPR, &destPR, func, data); area_so_far += srcPR.w * srcPR.h; if (((progress_skip++) % 10) == 0) gimp_progress_update ((gdouble) area_so_far / (gdouble) total_area); } /* update the processed region */ gimp_drawable_flush (drawable); gimp_drawable_merge_shadow (drawable->drawable_id, TRUE); gimp_drawable_update (drawable->drawable_id, x1, y1, (x2 - x1), (y2 - y1)); }
/* * Red Eye Removal Alorithm, based on using a threshold to detect * red pixels. Having a user-made selection around the eyes will * prevent incorrect pixels from being selected. */ static void remove_redeye (GimpDrawable *drawable) { GimpPixelRgn src_rgn; GimpPixelRgn dest_rgn; gint progress, max_progress; gboolean has_alpha; gint x, y; gint width, height; gint i; gpointer pr; if (! gimp_drawable_mask_intersect (drawable->drawable_id, &x, &y, &width, &height)) return; gimp_progress_init (_("Removing red eye")); has_alpha = gimp_drawable_has_alpha (drawable->drawable_id); progress = 0; max_progress = width * height; gimp_pixel_rgn_init (&src_rgn, drawable, x, y, width, height, FALSE, FALSE); gimp_pixel_rgn_init (&dest_rgn, drawable, x, y, width, height, TRUE, TRUE); for (pr = gimp_pixel_rgns_register (2, &src_rgn, &dest_rgn), i = 0; pr != NULL; pr = gimp_pixel_rgns_process (pr), i++) { redeye_inner_loop (src_rgn.data, dest_rgn.data, src_rgn.w, src_rgn.h, src_rgn.bpp, has_alpha, src_rgn.rowstride); progress += src_rgn.w * src_rgn.h; if (i % 16 == 0) gimp_progress_update ((gdouble) progress / (gdouble) max_progress); } gimp_progress_update (1.0); gimp_drawable_flush (drawable); gimp_drawable_merge_shadow (drawable->drawable_id, TRUE); gimp_drawable_update (drawable->drawable_id, x, y, width, height); }
static void blur (GimpDrawable *drawable) { gint i, j, k, channels; gint x1, y1, x2, y2; GimpPixelRgn rgn_in, rgn_out; guchar *row1, *row2, *row3; guchar *outrow; gimp_drawable_mask_bounds (drawable->drawable_id, &x1, &y1, &x2, &y2); channels = gimp_drawable_bpp (drawable->drawable_id); gimp_pixel_rgn_init (&rgn_in, drawable, x1, y1, x2 - x1, y2 - y1, FALSE, FALSE); gimp_pixel_rgn_init (&rgn_out, drawable, x1, y1, x2 - x1, y2 - y1, TRUE, TRUE); /* Initialise enough memory for row1, row2, row3, outrow */ row1 = g_new (guchar, channels * (x2 - x1)); outrow = g_new (guchar, channels * (x2 - x1)); for (i = y1; i < y2; i++) { /* Get row i-1, i, i+1 */ gimp_pixel_rgn_get_row (&rgn_in, row1, x1, MAX (y1, i - 1), x2 - x1); for (j = x1; j < x2; j++) { /* For each layer, compute the average of the nine pixels */ for (k = 0; k < channels; k++) { int in = row1[channels * (j - x1) + k]; int a = (1.0 - (in / 255.0)) * 100.0; int r = rand() % 100; outrow[channels * (j - x1) + k] = r < a ? 0 : 255; } } gimp_pixel_rgn_set_row (&rgn_out, outrow, x1, i, x2 - x1); if (i % 10 == 0) gimp_progress_update ((gdouble) (i - y1) / (gdouble) (y2 - y1)); } g_free (row1); g_free (outrow); gimp_drawable_flush (drawable); gimp_drawable_merge_shadow (drawable->drawable_id, TRUE); gimp_drawable_update (drawable->drawable_id, x1, y1, x2 - x1, y2 - y1); }
/** * Close the tile stream, writing changes back (I hope). */ void tile_stream_close (int id) { if (! valid_stream_id (id)) return; TileStream *stream = streams[id]; gimp_drawable_flush (stream->target); gimp_drawable_merge_shadow (stream->drawable, TRUE); gimp_drawable_update (stream->drawable, stream->left, stream->top, stream->width, stream->height); gimp_displays_flush (); gimp_drawable_detach (stream->source); gimp_drawable_detach (stream->target); g_free (stream); streams[id] = NULL; #ifdef DEBUG fprintf (stderr, "closed %d\n", id); #endif } // tile_stream_close
void gimp_rgn_iterator_dest (GimpRgnIterator *iter, GimpRgnFuncDest func, gpointer data) { GimpPixelRgn destPR; g_return_if_fail (iter != NULL); gimp_pixel_rgn_init (&destPR, iter->drawable, iter->x1, iter->y1, iter->x2 - iter->x1, iter->y2 - iter->y1, TRUE, TRUE); gimp_rgn_iterator_iter_single (iter, &destPR, (GimpRgnFuncSrc) func, data); /* update the processed region */ gimp_drawable_flush (iter->drawable); gimp_drawable_merge_shadow (iter->drawable->drawable_id, TRUE); gimp_drawable_update (iter->drawable->drawable_id, iter->x1, iter->y1, iter->x2 - iter->x1, iter->y2 - iter->y1); }
static void despeckle (void) { GimpPixelRgn src_rgn; /* Source image region */ GimpPixelRgn dst_rgn; guchar *src; guchar *dst; gint img_bpp; gint x, y; gint width, height; img_bpp = gimp_drawable_bpp (drawable->drawable_id); if (! gimp_drawable_mask_intersect (drawable->drawable_id, &x, &y, &width, &height)) return; gimp_pixel_rgn_init (&src_rgn, drawable, x, y, width, height, FALSE, FALSE); gimp_pixel_rgn_init (&dst_rgn, drawable, x, y, width, height, TRUE, TRUE); src = g_new (guchar, width * height * img_bpp); dst = g_new (guchar, width * height * img_bpp); gimp_pixel_rgn_get_rect (&src_rgn, src, x, y, width, height); despeckle_median (src, dst, width, height, img_bpp, despeckle_radius, FALSE); gimp_pixel_rgn_set_rect (&dst_rgn, dst, x, y, width, height); gimp_drawable_flush (drawable); gimp_drawable_merge_shadow (drawable->drawable_id, TRUE); gimp_drawable_update (drawable->drawable_id, x, y, width, height); g_free (dst); g_free (src); }
/* ---------------------------------------- * p_edgeDetection * ---------------------------------------- * setup pixel regions and perform edge detection processing per region. * as result of this processing the edgeDrawable is created and rendered. */ static void p_edgeDetection(GapEdgeContext *ectx) { GimpPixelRgn refPR; GimpPixelRgn edgePR; gpointer pr; p_createEmptyEdgeDrawable(ectx); if(ectx->edgeDrawable == NULL) { return; } gimp_pixel_rgn_init (&refPR, ectx->refDrawable, 0, 0 , ectx->refDrawable->width, ectx->refDrawable->height , FALSE /* dirty */ , FALSE /* shadow */ ); gimp_pixel_rgn_init (&edgePR, ectx->edgeDrawable, 0, 0 , ectx->edgeDrawable->width, ectx->edgeDrawable->height , TRUE /* dirty */ , FALSE /* shadow */ ); /* compare pixel areas in tiled portions via pixel region processing loops. */ for (pr = gimp_pixel_rgns_register (2, &refPR, &edgePR); pr != NULL; pr = gimp_pixel_rgns_process (pr)) { p_edgeProcessingForOneRegion (&refPR, &edgePR, ectx); } gimp_drawable_flush (ectx->edgeDrawable); }
/* This function operates on the image when pixelwidth >= tile_width. It simply sets the size of GimpPixelRgn as pixelwidth and proceeds. */ static void pixelize_large (GimpDrawable *drawable, gint pixelwidth, gint pixelheight, GimpPreview *preview) { GimpPixelRgn src_rgn, dest_rgn; guchar *src_row, *dest_row; guchar *src, *dest = NULL, *d; gulong average[4]; gint row, col, b, bpp, has_alpha; gint x, y, x_step, y_step; gint i, j; gulong count; gint x1, y1, x2, y2; gint width, height; gint progress = 0, max_progress = 1; gpointer pr; bpp = gimp_drawable_bpp (drawable->drawable_id); has_alpha = gimp_drawable_has_alpha (drawable->drawable_id); if (preview) { gimp_preview_get_position (preview, &x1, &y1); gimp_preview_get_size (preview, &width, &height); x2 = x1 + width; y2 = y1 + height; dest = g_new (guchar, width * height * bpp); } else { gimp_drawable_mask_bounds (drawable->drawable_id, &x1, &y1, &x2, &y2); width = x2 - x1; height = y2 - y1; /* Initialize progress */ progress = 0; max_progress = 2 * width * height; } for (y = y1; y < y2; y += pixelheight - (y % pixelheight)) { for (x = x1; x < x2; x += pixelwidth - (x % pixelwidth)) { x_step = pixelwidth - (x % pixelwidth); y_step = pixelheight - (y % pixelheight); x_step = MIN (x_step, x2 - x); y_step = MIN (y_step, y2 - y); gimp_pixel_rgn_init (&src_rgn, drawable, x, y, x_step, y_step, FALSE, FALSE); for (b = 0; b < bpp; b++) average[b] = 0; count = 0; for (pr = gimp_pixel_rgns_register (1, &src_rgn); pr != NULL; pr = gimp_pixel_rgns_process (pr)) { src_row = src_rgn.data; for (row = 0; row < src_rgn.h; row++) { src = src_row; if (has_alpha) { for (col = 0; col < src_rgn.w; col++) { gulong alpha = src[bpp - 1]; average[bpp - 1] += alpha; for (b = 0; b < bpp - 1; b++) average[b] += src[b] * alpha; src += src_rgn.bpp; } } else { for (col = 0; col < src_rgn.w; col++) { for (b = 0; b < bpp; b++) average[b] += src[b]; src += src_rgn.bpp; } } src_row += src_rgn.rowstride; } count += src_rgn.w * src_rgn.h; if (!preview) { /* Update progress */ progress += src_rgn.w * src_rgn.h; gimp_progress_update ((double) progress / (double) max_progress); } } if (count > 0) { if (has_alpha) { gulong alpha = average[bpp - 1]; if ((average[bpp - 1] = alpha / count)) for (b = 0; b < bpp - 1; b++) average[b] /= alpha; } else { for (b = 0; b < bpp; b++) average[b] /= count; } } if (preview) { dest_row = dest + ((y - y1) * width + (x - x1)) * bpp; for (j = 0; j < y_step; j++) { d = dest_row; for (i = 0; i < x_step; i++) for (b = 0; b < bpp; b++) *d++ = average[b]; dest_row += width * bpp; } } else { gimp_pixel_rgn_init (&dest_rgn, drawable, x, y, x_step, y_step, TRUE, TRUE); for (pr = gimp_pixel_rgns_register (1, &dest_rgn); pr != NULL; pr = gimp_pixel_rgns_process (pr)) { dest_row = dest_rgn.data; for (row = 0; row < dest_rgn.h; row++) { dest = dest_row; for (col = 0; col < dest_rgn.w; col++) { for (b = 0; b < bpp; b++) dest[b] = average[b]; dest += dest_rgn.bpp; } dest_row += dest_rgn.rowstride; } /* Update progress */ progress += dest_rgn.w * dest_rgn.h; gimp_progress_update ((double) progress / (double) max_progress); } } } } if (preview) { gimp_preview_draw_buffer (preview, dest, width * bpp); g_free (dest); } else { /* update the blurred region */ gimp_drawable_flush (drawable); gimp_drawable_merge_shadow (drawable->drawable_id, TRUE); gimp_drawable_update (drawable->drawable_id, x1, y1, width, height); } }
static inline void filter (void) { static void (* overlap)(guchar *, const guchar *); GimpPixelRgn src; GimpPixelRgn dst; GimpRGB color; guchar pixel[4]; gint division_x; gint division_y; gint offset_x; gint offset_y; Tile *tiles; gint numof_tiles; Tile *t; gint i; gint x; gint y; gint move_max_pixels; gint clear_x0; gint clear_y0; gint clear_x1; gint clear_y1; gint clear_width; gint clear_height; guchar *pixels; guchar *buffer; gint dindex; gint sindex; gint px, py; GRand *gr; gr = g_rand_new (); /* INITIALIZE */ gimp_pixel_rgn_init (&src, p.drawable, 0, 0, p.drawable->width, p.drawable->height, FALSE, FALSE); gimp_pixel_rgn_init (&dst, p.drawable, 0, 0, p.drawable->width, p.drawable->height, TRUE, TRUE); pixels = g_new (guchar, p.drawable->bpp * p.drawable->width * p.drawable->height); buffer = g_new (guchar, p.drawable->bpp * p.params.tile_width * p.params.tile_height); overlap = p.drawable_has_alpha ? overlap_RGBA : overlap_RGB; gimp_progress_init (_("Paper Tile")); gimp_drawable_mask_bounds (p.drawable->drawable_id, &p.selection.x0, &p.selection.y0, &p.selection.x1, &p.selection.y1); p.selection.width = p.selection.x1 - p.selection.x0; p.selection.height = p.selection.y1 - p.selection.y0; gimp_tile_cache_ntiles (2 * (p.selection.width / gimp_tile_width () + 1)); /* TILES */ division_x = p.params.division_x; division_y = p.params.division_y; if (p.params.fractional_type == FRACTIONAL_TYPE_FORCE) { if (0 < p.drawable->width % p.params.tile_width) division_x++; if (0 < p.drawable->height % p.params.tile_height) division_y++; if (p.params.centering) { if (1 < p.drawable->width % p.params.tile_width) { division_x++; offset_x = (p.drawable->width % p.params.tile_width) / 2 - p.params.tile_width; } else { offset_x = 0; } if (1 < p.drawable->height % p.params.tile_height) { division_y++; offset_y = (p.drawable->height % p.params.tile_height) / 2 - p.params.tile_height; } else { offset_y = 0; } } else { offset_x = 0; offset_y = 0; } } else { if (p.params.centering) { offset_x = (p.drawable->width % p.params.tile_width) / 2; offset_y = (p.drawable->height % p.params.tile_height) / 2; } else { offset_x = 0; offset_y = 0; } } move_max_pixels = p.params.move_max_rate * p.params.tile_width / 100.0; numof_tiles = division_x * division_y; t = tiles = g_new(Tile, numof_tiles); for (y = 0; y < division_y; y++) { gint srcy = offset_y + p.params.tile_height * y; for (x = 0; x < division_x; x++, t++) { gint srcx = offset_x + p.params.tile_width * x; if (srcx < 0) { t->x = 0; t->width = srcx + p.params.tile_width; } else if (srcx + p.params.tile_width < p.drawable->width) { t->x = srcx; t->width = p.params.tile_width; } else { t->x = srcx; t->width = p.drawable->width - srcx; } if (srcy < 0) { t->y = 0; t->height = srcy + p.params.tile_height; } else if (srcy + p.params.tile_height < p.drawable->height) { t->y = srcy; t->height = p.params.tile_height; } else { t->y = srcy; t->height = p.drawable->height - srcy; } t->z = g_rand_int (gr); random_move (&t->move_x, &t->move_y, move_max_pixels); } } qsort (tiles, numof_tiles, sizeof *tiles, tile_compare); gimp_pixel_rgn_get_rect (&src, pixels, 0, 0, p.drawable->width, p.drawable->height); if (p.params.fractional_type == FRACTIONAL_TYPE_IGNORE) { clear_x0 = offset_x; clear_y0 = offset_y; clear_width = p.params.tile_width * division_x; clear_height = p.params.tile_height * division_y; } else { clear_x0 = 0; clear_y0 = 0; clear_width = p.drawable->width; clear_height = p.drawable->height; } clear_x1 = clear_x0 + clear_width; clear_y1 = clear_y0 + clear_height; switch (p.params.background_type) { case BACKGROUND_TYPE_TRANSPARENT: for (y = clear_y0; y < clear_y1; y++) { for (x = clear_x0; x < clear_x1; x++) { dindex = p.drawable->bpp * (p.drawable->width * y + x); for (i = 0; i < p.drawable->bpp; i++) { pixels[dindex+i] = 0; } } } break; case BACKGROUND_TYPE_INVERTED: for (y = clear_y0; y < clear_y1; y++) { for (x = clear_x0; x < clear_x1; x++) { dindex = p.drawable->bpp * (p.drawable->width * y + x); pixels[dindex+0] = 255 - pixels[dindex+0]; pixels[dindex+1] = 255 - pixels[dindex+1]; pixels[dindex+2] = 255 - pixels[dindex+2]; } } break; case BACKGROUND_TYPE_IMAGE: break; case BACKGROUND_TYPE_FOREGROUND: gimp_context_get_foreground (&color); gimp_rgb_get_uchar (&color, &pixel[0], &pixel[1], &pixel[2]); pixel[3] = 255; for (y = clear_y0; y < clear_y1; y++) { for (x = clear_x0; x < clear_x1; x++) { dindex = p.drawable->bpp * (p.drawable->width * y + x); for (i = 0; i < p.drawable->bpp; i++) { pixels[dindex+i] = pixel[i]; } } } break; case BACKGROUND_TYPE_BACKGROUND: gimp_context_get_background (&color); gimp_rgb_get_uchar (&color, &pixel[0], &pixel[1], &pixel[2]); pixel[3] = 255; for (y = clear_y0; y < clear_y1; y++) { for (x = clear_x0; x < clear_x1; x++) { dindex = p.drawable->bpp * (p.drawable->width * y + x); for(i = 0; i < p.drawable->bpp; i++) { pixels[dindex+i] = pixel[i]; } } } break; case BACKGROUND_TYPE_COLOR: gimp_rgba_get_uchar (&p.params.background_color, pixel, pixel + 1, pixel + 2, pixel + 3); for (y = clear_y0; y < clear_y1; y++) { for (x = clear_x0; x < clear_x1; x++) { dindex = p.drawable->bpp * (p.drawable->width * y + x); for(i = 0; i < p.drawable->bpp; i++) { pixels[dindex+i] = pixel[i]; } } } break; } /* DRAW */ for (t = tiles, i = 0; i < numof_tiles; i++, t++) { gint x0 = t->x + t->move_x; gint y0 = t->y + t->move_y; gimp_pixel_rgn_get_rect (&src, buffer, t->x, t->y, t->width, t->height); for (y = 0; y < t->height; y++) { py = y0 + y; for (x = 0; x < t->width; x++) { px = x0 + x; sindex = p.drawable->bpp * (t->width * y + x); if (0 <= px && px < p.drawable->width && 0 <= py && py < p.drawable->height) { dindex = p.drawable->bpp * (p.drawable->width * py + px); overlap(&pixels[dindex], &buffer[sindex]); } else if (p.params.wrap_around) { px = (px + p.drawable->width) % p.drawable->width; py = (py + p.drawable->height) % p.drawable->height; dindex = p.drawable->bpp * (p.drawable->width * py + px); overlap(&pixels[dindex], &buffer[sindex]); } } } gimp_progress_update ((gdouble) i / (gdouble) numof_tiles); } gimp_pixel_rgn_set_rect (&dst, pixels, 0, 0, p.drawable->width, p.drawable->height); gimp_progress_update (1.0); gimp_drawable_flush (p.drawable); gimp_drawable_merge_shadow (p.drawable->drawable_id, TRUE); gimp_drawable_update (p.drawable->drawable_id, p.selection.x0, p.selection.y0, p.selection.width, p.selection.height); g_rand_free (gr); g_free (buffer); g_free (pixels); g_free (tiles); }
static void gauss_rle (GimpDrawable *drawable, gdouble radius, gint pass, gboolean show_progress) { GimpPixelRgn src_rgn, dest_rgn; gint width, height; gint bytes; gint has_alpha; guchar *dest, *dp; guchar *src, *sp; gint *buf, *bb; gint pixels; gint total = 1; gint x1, y1, x2, y2; gint i, row, col, b; gint start, end; gdouble progress, max_progress; gint *curve; gint *sum = NULL; gint val; gint length; gint initial_p, initial_m; gdouble std_dev; if (radius <= 0.0) return; gimp_drawable_mask_bounds (drawable->drawable_id, &x1, &y1, &x2, &y2); width = (x2 - x1); height = (y2 - y1); if (width < 1 || height < 1) return; bytes = drawable->bpp; has_alpha = gimp_drawable_has_alpha(drawable->drawable_id); buf = g_new (gint, MAX (width, height) * 2); /* allocate buffers for source and destination pixels */ src = g_new (guchar, MAX (width, height) * bytes); dest = g_new (guchar, MAX (width, height) * bytes); gimp_pixel_rgn_init (&src_rgn, drawable, 0, 0, drawable->width, drawable->height, FALSE, FALSE); gimp_pixel_rgn_init (&dest_rgn, drawable, 0, 0, drawable->width, drawable->height, TRUE, TRUE); progress = 0.0; max_progress = 2 * width * height; /* First the vertical pass */ radius = fabs (radius) + 1.0; std_dev = sqrt (-(radius * radius) / (2 * log (1.0 / 255.0))); curve = make_curve (std_dev, &length); sum = g_new (gint, 2 * length + 1); sum[0] = 0; for (i = 1; i <= length*2; i++) sum[i] = curve[i-length-1] + sum[i-1]; sum += length; total = sum[length] - sum[-length]; for (col = 0; col < width; col++) { gimp_pixel_rgn_get_col (&src_rgn, src, col + x1, y1, (y2 - y1)); if (has_alpha) multiply_alpha (src, height, bytes); sp = src; dp = dest; for (b = 0; b < bytes; b++) { initial_p = sp[b]; initial_m = sp[(height-1) * bytes + b]; /* Determine a run-length encoded version of the row */ run_length_encode (sp + b, buf, bytes, height); for (row = 0; row < height; row++) { start = (row < length) ? -row : -length; end = (height <= (row + length) ? (height - row - 1) : length); val = 0; i = start; bb = buf + (row + i) * 2; if (start != -length) val += initial_p * (sum[start] - sum[-length]); while (i < end) { pixels = bb[0]; i += pixels; if (i > end) i = end; val += bb[1] * (sum[i] - sum[start]); bb += (pixels * 2); start = i; } if (end != length) val += initial_m * (sum[length] - sum[end]); dp[row * bytes + b] = val / total; } } if (has_alpha) separate_alpha (dest, height, bytes); gimp_pixel_rgn_set_col (&dest_rgn, dest, col + x1, y1, (y2 - y1)); if (show_progress) { progress += height; if ((col % 32) == 0) gimp_progress_update (0.5 * (pass + (progress / max_progress))); } } /* prepare for the horizontal pass */ gimp_pixel_rgn_init (&src_rgn, drawable, 0, 0, drawable->width, drawable->height, FALSE, TRUE); /* Now the horizontal pass */ for (row = 0; row < height; row++) { gimp_pixel_rgn_get_row (&src_rgn, src, x1, row + y1, (x2 - x1)); if (has_alpha) multiply_alpha (src, width, bytes); sp = src; dp = dest; for (b = 0; b < bytes; b++) { initial_p = sp[b]; initial_m = sp[(width-1) * bytes + b]; /* Determine a run-length encoded version of the row */ run_length_encode (sp + b, buf, bytes, width); for (col = 0; col < width; col++) { start = (col < length) ? -col : -length; end = (width <= (col + length)) ? (width - col - 1) : length; val = 0; i = start; bb = buf + (col + i) * 2; if (start != -length) val += initial_p * (sum[start] - sum[-length]); while (i < end) { pixels = bb[0]; i += pixels; if (i > end) i = end; val += bb[1] * (sum[i] - sum[start]); bb += (pixels * 2); start = i; } if (end != length) val += initial_m * (sum[length] - sum[end]); dp[col * bytes + b] = val / total; } } if (has_alpha) separate_alpha (dest, width, bytes); gimp_pixel_rgn_set_row (&dest_rgn, dest, x1, row + y1, (x2 - x1)); if (show_progress) { progress += width; if ((row % 32) == 0) gimp_progress_update (0.5 * (pass + (progress / max_progress))); } } /* merge the shadow, update the drawable */ gimp_drawable_flush (drawable); gimp_drawable_merge_shadow (drawable->drawable_id, TRUE); gimp_drawable_update (drawable->drawable_id, x1, y1, (x2 - x1), (y2 - y1)); /* free buffers */ g_free (buf); g_free (src); g_free (dest); }
static void dog (gint32 image_ID, GimpDrawable *drawable, gdouble inner, gdouble outer, gboolean show_progress) { GimpDrawable *drawable1; GimpDrawable *drawable2; gint32 drawable_id = drawable->drawable_id; gint32 layer1; gint32 layer2; gint width, height; gint x1, y1, x2, y2; guchar maxval = 255; gimp_drawable_mask_bounds (drawable_id, &x1, &y1, &x2, &y2); width = (x2 - x1); height = (y2 - y1); gimp_drawable_flush (drawable); layer1 = gimp_layer_copy (drawable_id); gimp_drawable_set_visible (layer1, FALSE); gimp_drawable_set_name (layer1, "dog_scratch_layer1"); gimp_image_add_layer (image_ID, layer1, 0); layer2 = gimp_layer_copy (drawable_id); gimp_drawable_set_visible (layer2, FALSE); gimp_drawable_set_name (layer2, "dog_scratch_layer2"); gimp_image_add_layer (image_ID, layer2, 0); drawable1 = gimp_drawable_get (layer1); drawable2 = gimp_drawable_get (layer2); gauss_rle (drawable1, inner, 0, show_progress); gauss_rle (drawable2, outer, 1, show_progress); compute_difference (drawable, drawable1, drawable2, &maxval); gimp_drawable_detach (drawable1); gimp_drawable_detach (drawable2); gimp_image_remove_layer (image_ID, layer1); gimp_image_remove_layer (image_ID, layer2); gimp_drawable_flush (drawable); gimp_drawable_merge_shadow (drawable_id, TRUE); gimp_drawable_update (drawable_id, x1, y1, width, height); if (dogvals.normalize) { normalize (drawable, maxval); gimp_drawable_flush (drawable); gimp_drawable_merge_shadow (drawable_id, TRUE); gimp_drawable_update (drawable_id, x1, y1, width, height); } if (dogvals.invert) gimp_invert (drawable_id); }
/* * '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; }
/* * Cartoon algorithm * ----------------- * Mask radius = radius of pixel neighborhood for intensity comparison * Threshold = relative intensity difference which will result in darkening * Ramp = amount of relative intensity difference before total black * Blur radius = mask radius / 3.0 * * Algorithm: * For each pixel, calculate pixel intensity value to be: avg (blur radius) * relative diff = pixel intensity / avg (mask radius) * If relative diff < Threshold * intensity mult = (Ramp - MIN (Ramp, (Threshold - relative diff))) / Ramp * pixel intensity *= intensity mult */ static void cartoon (GimpDrawable *drawable, GimpPreview *preview) { GimpPixelRgn src_rgn, dest_rgn; GimpPixelRgn *pr; gint width, height; gint bytes; gboolean has_alpha; guchar *dest1; guchar *dest2; guchar *src; guchar *src1, *sp_p1, *sp_m1; guchar *src2, *sp_p2, *sp_m2; gdouble n_p1[5], n_m1[5]; gdouble n_p2[5], n_m2[5]; gdouble d_p1[5], d_m1[5]; gdouble d_p2[5], d_m2[5]; gdouble bd_p1[5], bd_m1[5]; gdouble bd_p2[5], bd_m2[5]; gdouble *val_p1, *val_m1, *vp1, *vm1; gdouble *val_p2, *val_m2, *vp2, *vm2; gint x1, y1, x2, y2; gint i, j; gint row, col, b; gint terms; gint progress, max_progress; gint initial_p1[4]; gint initial_p2[4]; gint initial_m1[4]; gint initial_m2[4]; gdouble radius; gdouble std_dev1; gdouble std_dev2; gdouble ramp; guchar *preview_buffer = NULL; if (preview) { gimp_preview_get_position (preview, &x1, &y1); gimp_preview_get_size (preview, &width, &height); } else { gimp_drawable_mask_bounds (drawable->drawable_id, &x1, &y1, &x2, &y2); width = (x2 - x1); height = (y2 - y1); } bytes = drawable->bpp; has_alpha = gimp_drawable_has_alpha (drawable->drawable_id); val_p1 = g_new (gdouble, MAX (width, height) * bytes); val_p2 = g_new (gdouble, MAX (width, height) * bytes); val_m1 = g_new (gdouble, MAX (width, height) * bytes); val_m2 = g_new (gdouble, MAX (width, height) * bytes); src = g_new (guchar, MAX (width, height) * bytes); dest1 = g_new0 (guchar, width * height); dest2 = g_new0 (guchar, width * height); gimp_pixel_rgn_init (&src_rgn, drawable, 0, 0, drawable->width, drawable->height, FALSE, FALSE); progress = 0; max_progress = width * height * 2; /* Calculate the standard deviations */ radius = 1.0; /* blur radius */ radius = fabs (radius) + 1.0; std_dev1 = sqrt (-(radius * radius) / (2 * log (1.0 / 255.0))); radius = cvals.mask_radius; radius = fabs (radius) + 1.0; std_dev2 = sqrt (-(radius * radius) / (2 * log (1.0 / 255.0))); /* derive the constants for calculating the gaussian from the std dev */ find_constants (n_p1, n_m1, d_p1, d_m1, bd_p1, bd_m1, std_dev1); find_constants (n_p2, n_m2, d_p2, d_m2, bd_p2, bd_m2, std_dev2); /* First the vertical pass */ for (col = 0; col < width; col++) { memset (val_p1, 0, height * bytes * sizeof (gdouble)); memset (val_p2, 0, height * bytes * sizeof (gdouble)); memset (val_m1, 0, height * bytes * sizeof (gdouble)); memset (val_m2, 0, height * bytes * sizeof (gdouble)); gimp_pixel_rgn_get_col (&src_rgn, src, col + x1, y1, height); src1 = src; sp_p1 = src1; sp_m1 = src1 + (height - 1) * bytes; vp1 = val_p1; vp2 = val_p2; vm1 = val_m1 + (height - 1) * bytes; vm2 = val_m2 + (height - 1) * bytes; /* Set up the first vals */ for (i = 0; i < bytes; i++) { initial_p1[i] = sp_p1[i]; initial_m1[i] = sp_m1[i]; } for (row = 0; row < height; row++) { gdouble *vpptr1, *vmptr1; gdouble *vpptr2, *vmptr2; terms = (row < 4) ? row : 4; for (b = 0; b < bytes; b++) { vpptr1 = vp1 + b; vmptr1 = vm1 + b; vpptr2 = vp2 + b; vmptr2 = vm2 + b; for (i = 0; i <= terms; i++) { *vpptr1 += n_p1[i] * sp_p1[(-i * bytes) + b] - d_p1[i] * vp1[(-i * bytes) + b]; *vmptr1 += n_m1[i] * sp_m1[(i * bytes) + b] - d_m1[i] * vm1[(i * bytes) + b]; *vpptr2 += n_p2[i] * sp_p1[(-i * bytes) + b] - d_p2[i] * vp2[(-i * bytes) + b]; *vmptr2 += n_m2[i] * sp_m1[(i * bytes) + b] - d_m2[i] * vm2[(i * bytes) + b]; } for (j = i; j <= 4; j++) { *vpptr1 += (n_p1[j] - bd_p1[j]) * initial_p1[b]; *vmptr1 += (n_m1[j] - bd_m1[j]) * initial_m1[b]; *vpptr2 += (n_p2[j] - bd_p2[j]) * initial_p1[b]; *vmptr2 += (n_m2[j] - bd_m2[j]) * initial_m1[b]; } } sp_p1 += bytes; sp_m1 -= bytes; vp1 += bytes; vp2 += bytes; vm1 -= bytes; vm2 -= bytes; } transfer_pixels (val_p1, val_m1, dest1 + col, width, bytes, height); transfer_pixels (val_p2, val_m2, dest2 + col, width, bytes, height); if (!preview) { progress += height; if ((col % 5) == 0) gimp_progress_update ((gdouble) progress / (gdouble) max_progress); } } for (row = 0; row < height; row++) { memset (val_p1, 0, width * sizeof (gdouble)); memset (val_p2, 0, width * sizeof (gdouble)); memset (val_m1, 0, width * sizeof (gdouble)); memset (val_m2, 0, width * sizeof (gdouble)); src1 = dest1 + row * width; src2 = dest2 + row * width; sp_p1 = src1; sp_p2 = src2; sp_m1 = src1 + width - 1; sp_m2 = src2 + width - 1; vp1 = val_p1; vp2 = val_p2; vm1 = val_m1 + width - 1; vm2 = val_m2 + width - 1; /* Set up the first vals */ initial_p1[0] = sp_p1[0]; initial_p2[0] = sp_p2[0]; initial_m1[0] = sp_m1[0]; initial_m2[0] = sp_m2[0]; for (col = 0; col < width; col++) { gdouble *vpptr1, *vmptr1; gdouble *vpptr2, *vmptr2; terms = (col < 4) ? col : 4; vpptr1 = vp1; vmptr1 = vm1; vpptr2 = vp2; vmptr2 = vm2; for (i = 0; i <= terms; i++) { *vpptr1 += n_p1[i] * sp_p1[-i] - d_p1[i] * vp1[-i]; *vmptr1 += n_m1[i] * sp_m1[i] - d_m1[i] * vm1[i]; *vpptr2 += n_p2[i] * sp_p2[-i] - d_p2[i] * vp2[-i]; *vmptr2 += n_m2[i] * sp_m2[i] - d_m2[i] * vm2[i]; } for (j = i; j <= 4; j++) { *vpptr1 += (n_p1[j] - bd_p1[j]) * initial_p1[0]; *vmptr1 += (n_m1[j] - bd_m1[j]) * initial_m1[0]; *vpptr2 += (n_p2[j] - bd_p2[j]) * initial_p2[0]; *vmptr2 += (n_m2[j] - bd_m2[j]) * initial_m2[0]; } sp_p1 ++; sp_p2 ++; sp_m1 --; sp_m2 --; vp1 ++; vp2 ++; vm1 --; vm2 --; } transfer_pixels (val_p1, val_m1, dest1 + row * width, 1, 1, width); transfer_pixels (val_p2, val_m2, dest2 + row * width, 1, 1, width); if (!preview) { progress += width; if ((row % 5) == 0) gimp_progress_update ((gdouble) progress / (gdouble) max_progress); } } /* Compute the ramp value which sets 'pct_black' % of the darkened pixels black */ ramp = compute_ramp (dest1, dest2, width * height, cvals.pct_black); /* Initialize the pixel regions. */ gimp_pixel_rgn_init (&src_rgn, drawable, x1, y1, width, height, FALSE, FALSE); if (preview) { pr = gimp_pixel_rgns_register (1, &src_rgn); preview_buffer = g_new (guchar, width * height * bytes); } else { gimp_pixel_rgn_init (&dest_rgn, drawable, x1, y1, width, height, TRUE, TRUE); pr = gimp_pixel_rgns_register (2, &src_rgn, &dest_rgn); } while (pr) { guchar *src_ptr = src_rgn.data; guchar *dest_ptr; guchar *blur_ptr = dest1 + (src_rgn.y - y1) * width + (src_rgn.x - x1); guchar *avg_ptr = dest2 + (src_rgn.y - y1) * width + (src_rgn.x - x1); gdouble diff; gdouble mult = 0.0; gdouble lightness; if (preview) dest_ptr = preview_buffer + ((src_rgn.y - y1) * width + (src_rgn.x - x1)) * bytes; else dest_ptr = dest_rgn.data; for (row = 0; row < src_rgn.h; row++) { for (col = 0; col < src_rgn.w; col++) { if (avg_ptr[col] != 0) { diff = (gdouble) blur_ptr[col] / (gdouble) avg_ptr[col]; if (diff < cvals.threshold) { if (ramp == 0.0) mult = 0.0; else mult = (ramp - MIN (ramp, (cvals.threshold - diff))) / ramp; } else mult = 1.0; } lightness = CLAMP (blur_ptr[col] * mult, 0, 255); if (bytes < 3) { dest_ptr[col * bytes] = (guchar) lightness; if (has_alpha) dest_ptr[col * bytes + 1] = src_ptr[col * src_rgn.bpp + 1]; } else { /* Convert to HLS, set lightness and convert back */ gint r, g, b; r = src_ptr[col * src_rgn.bpp + 0]; g = src_ptr[col * src_rgn.bpp + 1]; b = src_ptr[col * src_rgn.bpp + 2]; gimp_rgb_to_hsl_int (&r, &g, &b); b = lightness; gimp_hsl_to_rgb_int (&r, &g, &b); dest_ptr[col * bytes + 0] = r; dest_ptr[col * bytes + 1] = g; dest_ptr[col * bytes + 2] = b; if (has_alpha) dest_ptr[col * bytes + 3] = src_ptr[col * src_rgn.bpp + 3]; } } src_ptr += src_rgn.rowstride; if (preview) dest_ptr += width * bytes; else dest_ptr += dest_rgn.rowstride; blur_ptr += width; avg_ptr += width; } if (!preview) { progress += src_rgn.w * src_rgn.h; gimp_progress_update ((gdouble) progress / (gdouble) max_progress); } pr = gimp_pixel_rgns_process (pr); } if (preview) { gimp_preview_draw_buffer (preview, preview_buffer, width * bytes); g_free (preview_buffer); } else { /* merge the shadow, update the drawable */ gimp_drawable_flush (drawable); gimp_drawable_merge_shadow (drawable->drawable_id, TRUE); gimp_drawable_update (drawable->drawable_id, x1, y1, width, height); } /* free up buffers */ g_free (val_p1); g_free (val_p2); g_free (val_m1); g_free (val_m2); g_free (src); g_free (dest1); g_free (dest2); }