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; }