cairo_surface_t *
_cairo_image_surface_scale (cairo_surface_t *image,
int scaled_width,
int scaled_height,
scale_filter_t filter,
GthAsyncTask *task)
{
int src_width;
int src_height;
cairo_surface_t *scaled;
cairo_surface_metadata_t *metadata;
resize_filter_t *resize_filter;
ScaleReal x_factor;
ScaleReal y_factor;
cairo_surface_t *tmp;
src_width = cairo_image_surface_get_width (image);
src_height = cairo_image_surface_get_height (image);
if ((src_width == scaled_width) && (src_height == scaled_height))
return _cairo_image_surface_copy (image);
scaled = _cairo_image_surface_create (CAIRO_FORMAT_ARGB32,
scaled_width,
scaled_height);
_cairo_image_surface_copy_metadata (image, scaled);
metadata = _cairo_image_surface_get_metadata (scaled);
if (metadata->original_width <= 0) {
metadata->original_width = src_width;
metadata->original_height = src_height;
}
if (scaled == NULL)
return NULL;
if (g_once_init_enter (&coefficients_initialization)) {
initialize_coefficients (1.0, 0.0);
g_once_init_leave (&coefficients_initialization, 1);
}
resize_filter = resize_filter_create (task);
resize_filter_set_type (resize_filter, filter);
resize_filter->total_lines = scaled_width + scaled_height;
resize_filter->processed_lines = 0;
x_factor = (ScaleReal) scaled_width / src_width;
y_factor = (ScaleReal) scaled_height / src_height;
tmp = _cairo_image_surface_create (CAIRO_FORMAT_ARGB32,
src_height,
scaled_width);
horizontal_scale_transpose (image, tmp, x_factor, resize_filter);
horizontal_scale_transpose (tmp, scaled, y_factor, resize_filter);
resize_filter_destroy (resize_filter);
cairo_surface_destroy (tmp);
return scaled;
}
static gboolean
apply_cb (gpointer user_data)
{
GthFileToolSharpen *self = user_data;
GthImageViewer *preview;
if (self->priv->apply_event != 0) {
g_source_remove (self->priv->apply_event);
self->priv->apply_event = 0;
}
preview = GTH_IMAGE_VIEWER (self->priv->preview);
if (self->priv->show_preview) {
SharpenData *sharpen_data;
int x, y, w ,h;
cairo_surface_t *preview_surface;
cairo_t *cr;
sharpen_data = sharpen_data_new (self);
x = MAX (gtk_adjustment_get_value (preview->hadj), 0);
y = MAX (gtk_adjustment_get_value (preview->vadj), 0);
w = MIN (gtk_adjustment_get_page_size (preview->hadj), cairo_image_surface_get_width (self->priv->source));
h = MIN (gtk_adjustment_get_page_size (preview->vadj), cairo_image_surface_get_height (self->priv->source));
if ((w < 0) || (h < 0))
return FALSE;
cairo_surface_destroy (self->priv->destination);
self->priv->destination = _cairo_image_surface_copy (self->priv->source);
/* FIXME: use a cairo sub-surface when cairo 1.10 will be requiered */
preview_surface = _cairo_image_surface_copy_subsurface (self->priv->destination, x, y, w, h);
_cairo_image_surface_sharpen (preview_surface,
sharpen_data->radius,
sharpen_data->amount,
sharpen_data->threshold);
cr = cairo_create (self->priv->destination);
cairo_set_source_surface (cr, preview_surface, x, y);
cairo_rectangle (cr, x, y, w, h);
cairo_fill (cr);
cairo_destroy (cr);
gth_image_viewer_set_surface (preview, self->priv->destination, -1, -1);
cairo_surface_destroy (preview_surface);
sharpen_data_free (sharpen_data);
}
else
gth_image_viewer_set_surface (preview, self->priv->source, -1, -1);
return FALSE;
}
static gpointer
sharpen_exec (GthAsyncTask *task,
gpointer user_data)
{
SharpenData *sharpen_data = user_data;
sharpen_data->destination = _cairo_image_surface_copy (sharpen_data->source);
/* FIXME: set progress info and allow cancellation */
_cairo_image_surface_sharpen (sharpen_data->destination,
sharpen_data->radius,
sharpen_data->amount,
sharpen_data->threshold);
return NULL;
}
cairo_surface_t *
_cairo_image_surface_scale_squared (cairo_surface_t *image,
int size,
scale_filter_t quality,
GthAsyncTask *task)
{
int width, height;
int scaled_width, scaled_height;
cairo_surface_t *scaled;
cairo_surface_t *squared;
width = cairo_image_surface_get_width (image);
height = cairo_image_surface_get_height (image);
if ((width < size) && (height < size))
return _cairo_image_surface_copy (image);
if (width > height) {
scaled_height = size;
scaled_width = (int) (((double) width / height) * scaled_height);
}
else {
scaled_width = size;
scaled_height = (int) (((double) height / width) * scaled_width);
}
if ((scaled_width != width) || (scaled_height != height))
scaled = _cairo_image_surface_scale (image, scaled_width, scaled_height, quality, task);
else
scaled = cairo_surface_reference (image);
if ((scaled_width == size) && (scaled_height == size))
return scaled;
squared = _cairo_image_surface_copy_subsurface (scaled,
(scaled_width - size) / 2,
(scaled_height - size) / 2,
size,
size);
cairo_surface_destroy (scaled);
return squared;
}
static cairo_surface_t*
rotate (cairo_surface_t *image,
double angle,
gboolean high_quality,
guchar r0,
guchar g0,
guchar b0,
guchar a0,
GthAsyncTask *task)
{
cairo_surface_t *image_with_background;
cairo_surface_t *rotated;
double angle_rad;
double cos_angle, sin_angle;
double src_width, src_height;
int new_width, new_height;
int src_rowstride, new_rowstride;
int xi, yi;
double x, y;
double x2, y2;
int x2min, y2min;
int x2max, y2max;
double fx, fy;
guchar *p_src, *p_new;
guchar *p_src2, *p_new2;
guchar r00, r01, r10, r11;
guchar g00, g01, g10, g11;
guchar b00, b01, b10, b11;
guchar a00, a01, a10, a11;
double half_new_width;
double half_new_height;
double half_src_width;
double half_src_height;
int tmp;
guchar r, g, b, a;
guint32 pixel;
angle = CLAMP (angle, -90.0, 90.0);
angle_rad = angle / 180.0 * G_PI;
cos_angle = cos (angle_rad);
sin_angle = sin (angle_rad);
src_width = cairo_image_surface_get_width (image);
src_height = cairo_image_surface_get_height (image);
new_width = GDOUBLE_ROUND_TO_INT ( cos_angle * src_width + fabs(sin_angle) * src_height);
new_height = GDOUBLE_ROUND_TO_INT (fabs (sin_angle) * src_width + cos_angle * src_height);
if (a0 == 0xff) {
/* pre-multiply the background color */
image_with_background = _cairo_image_surface_copy (image);
p_src = _cairo_image_surface_flush_and_get_data (image);
p_new = _cairo_image_surface_flush_and_get_data (image_with_background);
src_rowstride = cairo_image_surface_get_stride (image);
new_rowstride = cairo_image_surface_get_stride (image_with_background);
cairo_surface_flush (image_with_background);
for (yi = 0; yi < src_height; yi++) {
p_src2 = p_src;
p_new2 = p_new;
for (xi = 0; xi < src_width; xi++) {
a = p_src2[CAIRO_ALPHA];
r = p_src2[CAIRO_RED] + _cairo_multiply_alpha (r0, 0xff - a);
g = p_src2[CAIRO_GREEN] + _cairo_multiply_alpha (g0, 0xff - a);
b = p_src2[CAIRO_BLUE] + _cairo_multiply_alpha (b0, 0xff - a);
pixel = CAIRO_RGBA_TO_UINT32 (r, g, b, 0xff);
memcpy (p_new2, &pixel, sizeof (guint32));
p_new2 += 4;
p_src2 += 4;
}
p_src += src_rowstride;
p_new += new_rowstride;
}
cairo_surface_mark_dirty (image_with_background);
}
else
image_with_background = cairo_surface_reference (image);
/* create the rotated image */
rotated = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, new_width, new_height);
p_src = _cairo_image_surface_flush_and_get_data (image_with_background);
p_new = _cairo_image_surface_flush_and_get_data (rotated);
src_rowstride = cairo_image_surface_get_stride (image_with_background);
new_rowstride = cairo_image_surface_get_stride (rotated);
/*
* bilinear interpolation
* fx
* v00------------v01
* | | |
* fy |--------v |
* | |
* | |
* | |
* v10------------v11
*/
#define INTERPOLATE(v, v00, v01, v10, v11, fx, fy) \
tmp = (1.0 - (fy)) * \
((1.0 - (fx)) * (v00) + (fx) * (v01)) \
+ \
(fy) * \
((1.0 - (fx)) * (v10) + (fx) * (v11)); \
v = CLAMP (tmp, 0, 255);
#define GET_VALUES(r, g, b, a, x, y) \
if (x >= 0 && x < src_width && y >= 0 && y < src_height) { \
p_src2 = p_src + src_rowstride * y + 4 * x; \
r = p_src2[CAIRO_RED]; \
g = p_src2[CAIRO_GREEN]; \
b = p_src2[CAIRO_BLUE]; \
a = p_src2[CAIRO_ALPHA]; \
} \
else { \
r = r0; \
g = g0; \
b = b0; \
a = a0; \
}
half_new_width = new_width / 2.0;
half_new_height = new_height / 2.0;
half_src_width = src_width / 2.0;
half_src_height = src_height / 2.0;
cairo_surface_flush (rotated);
y = - half_new_height;
for (yi = 0; yi < new_height; yi++) {
if (task != NULL) {
gboolean cancelled;
double progress;
gth_async_task_get_data (task, NULL, &cancelled, NULL);
if (cancelled)
goto out;
progress = (double) yi / new_height;
gth_async_task_set_data (task, NULL, NULL, &progress);
}
p_new2 = p_new;
x = - half_new_width;
for (xi = 0; xi < new_width; xi++) {
x2 = cos_angle * x - sin_angle * y + half_src_width;
y2 = sin_angle * x + cos_angle * y + half_src_height;
if (high_quality) {
/* Bilinear interpolation. */
x2min = (int) x2;
y2min = (int) y2;
x2max = x2min + 1;
y2max = y2min + 1;
GET_VALUES (r00, g00, b00, a00, x2min, y2min);
GET_VALUES (r01, g01, b01, a01, x2max, y2min);
GET_VALUES (r10, g10, b10, a10, x2min, y2max);
GET_VALUES (r11, g11, b11, a11, x2max, y2max);
fx = x2 - x2min;
fy = y2 - y2min;
INTERPOLATE (r, r00, r01, r10, r11, fx, fy);
INTERPOLATE (g, g00, g01, g10, g11, fx, fy);
INTERPOLATE (b, b00, b01, b10, b11, fx, fy);
INTERPOLATE (a, a00, a01, a10, a11, fx, fy);
pixel = CAIRO_RGBA_TO_UINT32 (r, g, b, a);
memcpy (p_new2, &pixel, sizeof (guint32));
}
else {
/* Nearest neighbor */
x2min = GDOUBLE_ROUND_TO_INT (x2);
y2min = GDOUBLE_ROUND_TO_INT (y2);
GET_VALUES (p_new2[CAIRO_RED],
p_new2[CAIRO_GREEN],
p_new2[CAIRO_BLUE],
p_new2[CAIRO_ALPHA],
x2min,
y2min);
}
p_new2 += 4;
x += 1.0;
}
p_new += new_rowstride;
y += 1.0;
}
out:
cairo_surface_mark_dirty (rotated);
cairo_surface_destroy (image_with_background);
#undef INTERPOLATE
#undef GET_VALUES
return rotated;
}
