static void
gimp_smudge_motion (GimpPaintCore *paint_core,
GimpDrawable *drawable,
GimpPaintOptions *paint_options)
{
GimpSmudge *smudge = GIMP_SMUDGE (paint_core);
GimpSmudgeOptions *options = GIMP_SMUDGE_OPTIONS (paint_options);
GimpContext *context = GIMP_CONTEXT (paint_options);
GimpPressureOptions *pressure_options = paint_options->pressure_options;
GimpImage *image;
TempBuf *area;
PixelRegion srcPR, destPR, tempPR;
gdouble rate;
gdouble opacity;
gint x, y, w, h;
image = gimp_item_get_image (GIMP_ITEM (drawable));
if (gimp_drawable_is_indexed (drawable))
return;
opacity = gimp_paint_options_get_fade (paint_options, image,
paint_core->pixel_dist);
if (opacity == 0.0)
return;
/* Get the unclipped brush coordinates */
gimp_smudge_brush_coords (paint_core, &x, &y, &w, &h);
/* Get the paint area (Smudge won't scale!) */
area = gimp_paint_core_get_paint_area (paint_core, drawable, paint_options);
if (! area)
return;
/* srcPR will be the pixels under the current painthit from the drawable */
pixel_region_init (&srcPR, gimp_drawable_get_tiles (drawable),
area->x, area->y, area->width, area->height, FALSE);
/* Enable pressure sensitive rate */
if (pressure_options->rate)
rate = MIN (options->rate / 100.0 * PRESSURE_SCALE *
paint_core->cur_coords.pressure, 1.0);
else
rate = options->rate / 100.0;
/* The tempPR will be the built up buffer (for smudge) */
pixel_region_init_data (&tempPR, smudge->accum_data,
smudge->accumPR.bytes,
smudge->accumPR.rowstride,
area->x - x,
area->y - y,
area->width,
area->height);
/* The dest will be the paint area we got above (= canvas_buf) */
pixel_region_init_temp_buf (&destPR, area,
0, 0, area->width, area->height);
/* Smudge uses the buffer Accum.
* For each successive painthit Accum is built like this
* Accum = rate*Accum + (1-rate)*I.
* where I is the pixels under the current painthit.
* Then the paint area (canvas_buf) is built as
* (Accum,1) (if no alpha),
*/
blend_region (&srcPR, &tempPR, &tempPR, ROUND (rate * 255.0));
/* re-init the tempPR */
pixel_region_init_data (&tempPR, smudge->accum_data,
smudge->accumPR.bytes,
smudge->accumPR.rowstride,
area->x - x,
area->y - y,
area->width,
area->height);
if (! gimp_drawable_has_alpha (drawable))
add_alpha_region (&tempPR, &destPR);
else
copy_region (&tempPR, &destPR);
if (pressure_options->opacity)
opacity *= PRESSURE_SCALE * paint_core->cur_coords.pressure;
gimp_brush_core_replace_canvas (GIMP_BRUSH_CORE (paint_core), drawable,
MIN (opacity, GIMP_OPACITY_OPAQUE),
gimp_context_get_opacity (context),
gimp_paint_options_get_brush_mode (paint_options),
GIMP_PAINT_INCREMENTAL);
}
static void
gimp_convolve_motion (GimpPaintCore *paint_core,
GimpDrawable *drawable,
GimpPaintOptions *paint_options)
{
GimpConvolve *convolve = GIMP_CONVOLVE (paint_core);
GimpBrushCore *brush_core = GIMP_BRUSH_CORE (paint_core);
GimpConvolveOptions *options = GIMP_CONVOLVE_OPTIONS (paint_options);
GimpContext *context = GIMP_CONTEXT (paint_options);
GimpImage *image;
TempBuf *area;
PixelRegion srcPR;
PixelRegion destPR;
PixelRegion tempPR;
guchar *buffer;
gdouble opacity;
gdouble rate;
gint bytes;
image = gimp_item_get_image (GIMP_ITEM (drawable));
if (gimp_drawable_is_indexed (drawable))
return;
opacity = gimp_paint_options_get_fade (paint_options, image,
paint_core->pixel_dist);
if (opacity == 0.0)
return;
area = gimp_paint_core_get_paint_area (paint_core, drawable, paint_options);
if (! area)
return;
rate = options->rate;
rate *= gimp_paint_options_get_dynamic_rate (paint_options,
&paint_core->cur_coords);
gimp_convolve_calculate_matrix (convolve, options->type,
brush_core->brush->mask->width / 2,
brush_core->brush->mask->height / 2,
rate);
/* configure the source pixel region */
pixel_region_init (&srcPR, gimp_drawable_get_tiles (drawable),
area->x, area->y, area->width, area->height, FALSE);
if (gimp_drawable_has_alpha (drawable))
{
bytes = srcPR.bytes;
buffer = g_malloc (area->height * bytes * area->width);
pixel_region_init_data (&tempPR, buffer,
bytes, bytes * area->width,
0, 0, area->width, area->height);
copy_region (&srcPR, &tempPR);
}
else
{
/* note: this particular approach needlessly convolves the totally-
opaque alpha channel. A faster approach would be to keep
tempPR the same number of bytes as srcPR, and extend the
paint_core_replace_canvas API to handle non-alpha images. */
bytes = srcPR.bytes + 1;
buffer = g_malloc (area->height * bytes * area->width);
pixel_region_init_data (&tempPR, buffer,
bytes, bytes * area->width,
0, 0, area->width, area->height);
add_alpha_region (&srcPR, &tempPR);
}
/* Convolve the region */
pixel_region_init_data (&tempPR, buffer,
bytes, bytes * area->width,
0, 0, area->width, area->height);
pixel_region_init_temp_buf (&destPR, area,
0, 0, area->width, area->height);
convolve_region (&tempPR, &destPR,
convolve->matrix, 3, convolve->matrix_divisor,
GIMP_NORMAL_CONVOL, TRUE);
g_free (buffer);
gimp_brush_core_replace_canvas (brush_core, drawable,
MIN (opacity, GIMP_OPACITY_OPAQUE),
gimp_context_get_opacity (context),
gimp_paint_options_get_brush_mode (paint_options),
1.0,
GIMP_PAINT_INCREMENTAL);
}
static gboolean
gimp_perspective_clone_get_source (GimpSourceCore *source_core,
GimpDrawable *drawable,
GimpPaintOptions *paint_options,
GimpPickable *src_pickable,
gint src_offset_x,
gint src_offset_y,
TempBuf *paint_area,
gint *paint_area_offset_x,
gint *paint_area_offset_y,
gint *paint_area_width,
gint *paint_area_height,
PixelRegion *srcPR)
{
GimpPerspectiveClone *clone = GIMP_PERSPECTIVE_CLONE (source_core);
GimpPaintCore *paint_core = GIMP_PAINT_CORE (source_core);
GimpSourceOptions *options = GIMP_SOURCE_OPTIONS (paint_options);
GimpImage *src_image;
GimpImage *image;
GimpImageType src_type;
gint x1d, y1d, x2d, y2d;
gdouble x1s, y1s, x2s, y2s, x3s, y3s, x4s, y4s;
gint xmin, ymin, xmax, ymax;
TileManager *src_tiles;
TileManager *orig_tiles;
PixelRegion origPR;
PixelRegion destPR;
GimpMatrix3 matrix;
gint bytes;
src_image = gimp_pickable_get_image (src_pickable);
image = gimp_item_get_image (GIMP_ITEM (drawable));
src_type = gimp_pickable_get_image_type (src_pickable);
src_tiles = gimp_pickable_get_tiles (src_pickable);
/* Destination coordinates that will be painted */
x1d = paint_area->x;
y1d = paint_area->y;
x2d = paint_area->x + paint_area->width;
y2d = paint_area->y + paint_area->height;
/* Boundary box for source pixels to copy: Convert all the vertex of
* the box to paint in destination area to its correspondent in
* source area bearing in mind perspective
*/
gimp_perspective_clone_get_source_point (clone, x1d, y1d, &x1s, &y1s);
gimp_perspective_clone_get_source_point (clone, x1d, y2d, &x2s, &y2s);
gimp_perspective_clone_get_source_point (clone, x2d, y1d, &x3s, &y3s);
gimp_perspective_clone_get_source_point (clone, x2d, y2d, &x4s, &y4s);
xmin = floor (MIN4 (x1s, x2s, x3s, x4s));
ymin = floor (MIN4 (y1s, y2s, y3s, y4s));
xmax = ceil (MAX4 (x1s, x2s, x3s, x4s));
ymax = ceil (MAX4 (y1s, y2s, y3s, y4s));
xmin = CLAMP (xmin - 1, 0, tile_manager_width (src_tiles));
ymin = CLAMP (ymin - 1, 0, tile_manager_height (src_tiles));
xmax = CLAMP (xmax + 1, 0, tile_manager_width (src_tiles));
ymax = CLAMP (ymax + 1, 0, tile_manager_height (src_tiles));
/* if the source area is completely out of the image */
if (!(xmax - xmin) || !(ymax - ymin))
return FALSE;
/* If the source image is different from the destination,
* then we should copy straight from the source image
* to the canvas.
* Otherwise, we need a call to get_orig_image to make sure
* we get a copy of the unblemished (offset) image
*/
if (( options->sample_merged && (src_image != image)) ||
(! options->sample_merged && (source_core->src_drawable != drawable)))
{
pixel_region_init (&origPR, src_tiles,
xmin, ymin, xmax - xmin, ymax - ymin, FALSE);
}
else
{
TempBuf *orig;
/* get the original image */
if (options->sample_merged)
orig = gimp_paint_core_get_orig_proj (paint_core,
src_pickable,
xmin, ymin, xmax, ymax);
else
orig = gimp_paint_core_get_orig_image (paint_core,
GIMP_DRAWABLE (src_pickable),
xmin, ymin, xmax, ymax);
pixel_region_init_temp_buf (&origPR, orig,
0, 0, xmax - xmin, ymax - ymin);
}
/* copy the original image to a tile manager, adding alpha if needed */
bytes = GIMP_IMAGE_TYPE_BYTES (GIMP_IMAGE_TYPE_WITH_ALPHA (src_type));
orig_tiles = tile_manager_new (xmax - xmin, ymax - ymin, bytes);
tile_manager_set_offsets (orig_tiles, xmin, ymin);
pixel_region_init (&destPR, orig_tiles,
0, 0, xmax - xmin, ymax - ymin,
TRUE);
if (bytes > origPR.bytes)
add_alpha_region (&origPR, &destPR);
else
copy_region (&origPR, &destPR);
clone->src_area = temp_buf_resize (clone->src_area,
tile_manager_bpp (orig_tiles),
0, 0,
x2d - x1d, y2d - y1d);
pixel_region_init_temp_buf (&destPR, clone->src_area,
0, 0,
x2d - x1d, y2d - y1d);
gimp_perspective_clone_get_matrix (clone, &matrix);
gimp_transform_region (src_pickable,
GIMP_CONTEXT (paint_options),
orig_tiles,
&destPR,
x1d, y1d, x2d, y2d,
&matrix,
GIMP_INTERPOLATION_LINEAR, 0, NULL);
tile_manager_unref (orig_tiles);
pixel_region_init_temp_buf (srcPR, clone->src_area,
0, 0, x2d - x1d, y2d - y1d);
return TRUE;
}
