gala/lib/Drawing/BufferSurface.vala
José Expósito f74d8fdad5
Granite drawing removals (#1428)
* Drawing: Migrate functions removed from Granite 7

Some drawing utilities used by Gala were removed from Granite 7:
https://github.com/elementary/granite/pull/603

Add them to Gala.

* Drawing: Use drawings functions from Gala instead of Granite
2022-05-22 18:02:45 +00:00

709 lines
25 KiB
Vala

/*
* Copyright 2019 elementary, Inc. (https://elementary.io)
* Copyright 2011-2013 Robert Dyer
* Copyright 2011-2013 Rico Tzschichholz <ricotz@ubuntu.com>
* SPDX-License-Identifier: LGPL-3.0-or-later
*/
using Cairo;
using Posix;
namespace Gala.Drawing {
/**
* A buffer containing an internal Cairo-usable surface and context, designed
* for usage with large, rarely updated draw operations.
*/
public class BufferSurface : GLib.Object {
private Surface _surface;
/**
* The {@link Cairo.Surface} which will store the results of all drawing operations
* made with {@link Gala.Drawing.BufferSurface.context}.
*/
public Surface surface {
get {
if (_surface == null) {
_surface = new ImageSurface (Format.ARGB32, width, height);
}
return _surface;
}
private set { _surface = value; }
}
/**
* The width of the {@link Gala.Drawing.BufferSurface}, in pixels.
*/
public int width { get; private set; }
/**
* The height of the BufferSurface, in pixels.
*/
public int height { get; private set; }
private Context _context;
/**
* The {@link Cairo.Context} for the internal surface. All drawing operations done on this
* {@link Gala.Drawing.BufferSurface} should use this context.
*/
public Cairo.Context context {
get {
if (_context == null) {
_context = new Cairo.Context (surface);
}
return _context;
}
}
/**
* Constructs a new, empty {@link Gala.Drawing.BufferSurface} with the supplied dimensions.
*
* @param width the width of {@link Gala.Drawing.BufferSurface}, in pixels
* @param height the height of the {@link Gala.Drawing.BufferSurface}, in pixels
*/
public BufferSurface (int width, int height) requires (width >= 0 && height >= 0) {
this.width = width;
this.height = height;
}
/**
* Constructs a new, empty {@link Gala.Drawing.BufferSurface} with the supplied dimensions, using
* the supplied {@link Cairo.Surface} as a model.
*
* @param width the width of the new {@link Gala.Drawing.BufferSurface}, in pixels
* @param height the height of the new {@link Gala.Drawing.BufferSurface}, in pixels
* @param model the {@link Cairo.Surface} to use as a model for the internal {@link Cairo.Surface}
*/
public BufferSurface.with_surface (int width, int height, Surface model) requires (model != null) {
this (width, height);
surface = new Surface.similar (model, Content.COLOR_ALPHA, width, height);
}
/**
* Constructs a new, empty {@link Gala.Drawing.BufferSurface} with the supplied dimensions, using
* the supplied {@link Gala.Drawing.BufferSurface} as a model.
*
* @param width the width of the new {@link Gala.Drawing.BufferSurface}, in pixels
* @param height the height of the new {@link Gala.Drawing.BufferSurface}, in pixels
* @param model the {@link Gala.Drawing.BufferSurface} to use as a model for the internal {@link Cairo.Surface}
*/
public BufferSurface.with_buffer_surface (int width, int height, BufferSurface model) requires (model != null) {
this (width, height);
surface = new Surface.similar (model.surface, Content.COLOR_ALPHA, width, height);
}
/**
* Clears the internal {@link Cairo.Surface}, making all pixels fully transparent.
*/
public void clear () {
context.save ();
_context.set_source_rgba (0, 0, 0, 0);
_context.set_operator (Operator.SOURCE);
_context.paint ();
_context.restore ();
}
/**
* Creates a {@link Gdk.Pixbuf} from internal {@link Cairo.Surface}.
*
* @return the {@link Gdk.Pixbuf}
*/
public Gdk.Pixbuf load_to_pixbuf () {
var image_surface = new ImageSurface (Format.ARGB32, width, height);
var cr = new Cairo.Context (image_surface);
cr.set_operator (Operator.SOURCE);
cr.set_source_surface (surface, 0, 0);
cr.paint ();
var width = image_surface.get_width ();
var height = image_surface.get_height ();
var pb = new Gdk.Pixbuf (Gdk.Colorspace.RGB, true, 8, width, height);
pb.fill (0x00000000);
uint8 *data = image_surface.get_data ();
uint8 *pixels = pb.get_pixels ();
var length = width * height;
if (image_surface.get_format () == Format.ARGB32) {
for (var i = 0; i < length; i++) {
// if alpha is 0 set nothing
if (data[3] > 0) {
pixels[0] = (uint8) (data[2] * 255 / data[3]);
pixels[1] = (uint8) (data[1] * 255 / data[3]);
pixels[2] = (uint8) (data[0] * 255 / data[3]);
pixels[3] = data[3];
}
pixels += 4;
data += 4;
}
} else if (image_surface.get_format () == Format.RGB24) {
for (var i = 0; i < length; i++) {
pixels[0] = data[2];
pixels[1] = data[1];
pixels[2] = data[0];
pixels[3] = data[3];
pixels += 4;
data += 4;
}
}
return pb;
}
/**
* Averages all the colors in the internal {@link Cairo.Surface}.
*
* @return the {@link Gala.Drawing.Color} with the averaged color
*/
public Drawing.Color average_color () {
var b_total = 0.0;
var g_total = 0.0;
var r_total = 0.0;
var w = width;
var h = height;
var original = new ImageSurface (Format.ARGB32, w, h);
var cr = new Cairo.Context (original);
cr.set_operator (Operator.SOURCE);
cr.set_source_surface (surface, 0, 0);
cr.paint ();
uint8 *data = original.get_data ();
var length = w * h;
for (var i = 0; i < length; i++) {
uint8 b = data [0];
uint8 g = data [1];
uint8 r = data [2];
uint8 max = (uint8) double.max (r, double.max (g, b));
uint8 min = (uint8) double.min (r, double.min (g, b));
double delta = max - min;
var sat = delta == 0 ? 0.0 : delta / max;
var score = 0.2 + 0.8 * sat;
b_total += b * score;
g_total += g * score;
r_total += r * score;
data += 4;
}
return new Drawing.Color (
r_total / uint8.MAX / length,
g_total / uint8.MAX / length,
b_total / uint8.MAX / length,
1
).set_val (0.8).multiply_sat (1.15);
}
/**
* Performs a blur operation on the internal {@link Cairo.Surface}, using the
* fast-blur algorithm found here [[http://incubator.quasimondo.com/processing/superfastblur.pde]].
*
* @param radius the blur radius
* @param process_count the number of times to perform the operation
*/
public void fast_blur (int radius, int process_count = 1) {
if (radius < 1 || process_count < 1) {
return;
}
var w = width;
var h = height;
var channels = 4;
if (radius > w - 1 || radius > h - 1) {
return;
}
var original = new ImageSurface (Format.ARGB32, w, h);
var cr = new Cairo.Context (original);
cr.set_operator (Operator.SOURCE);
cr.set_source_surface (surface, 0, 0);
cr.paint ();
uint8 *pixels = original.get_data ();
var buffer = new uint8[w * h * channels];
var v_min = new int[int.max (w, h)];
var v_max = new int[int.max (w, h)];
var div = 2 * radius + 1;
var dv = new uint8[256 * div];
for (var i = 0; i < dv.length; i++) {
dv[i] = (uint8) (i / div);
}
while (process_count-- > 0) {
for (var x = 0; x < w; x++) {
v_min[x] = int.min (x + radius + 1, w - 1);
v_max[x] = int.max (x - radius, 0);
}
for (var y = 0; y < h; y++) {
var a_sum = 0, r_sum = 0, g_sum = 0, b_sum = 0;
uint32 cur_pixel = y * w * channels;
a_sum += radius * pixels[cur_pixel + 0];
r_sum += radius * pixels[cur_pixel + 1];
g_sum += radius * pixels[cur_pixel + 2];
b_sum += radius * pixels[cur_pixel + 3];
for (var i = 0; i <= radius; i++) {
a_sum += pixels[cur_pixel + 0];
r_sum += pixels[cur_pixel + 1];
g_sum += pixels[cur_pixel + 2];
b_sum += pixels[cur_pixel + 3];
cur_pixel += channels;
}
cur_pixel = y * w * channels;
for (var x = 0; x < w; x++) {
uint32 p1 = (y * w + v_min[x]) * channels;
uint32 p2 = (y * w + v_max[x]) * channels;
buffer[cur_pixel + 0] = dv[a_sum];
buffer[cur_pixel + 1] = dv[r_sum];
buffer[cur_pixel + 2] = dv[g_sum];
buffer[cur_pixel + 3] = dv[b_sum];
a_sum += pixels[p1 + 0] - pixels[p2 + 0];
r_sum += pixels[p1 + 1] - pixels[p2 + 1];
g_sum += pixels[p1 + 2] - pixels[p2 + 2];
b_sum += pixels[p1 + 3] - pixels[p2 + 3];
cur_pixel += channels;
}
}
for (var y = 0; y < h; y++) {
v_min[y] = int.min (y + radius + 1, h - 1) * w;
v_max[y] = int.max (y - radius, 0) * w;
}
for (var x = 0; x < w; x++) {
var a_sum = 0, r_sum = 0, g_sum = 0, b_sum = 0;
uint32 cur_pixel = x * channels;
a_sum += radius * buffer[cur_pixel + 0];
r_sum += radius * buffer[cur_pixel + 1];
g_sum += radius * buffer[cur_pixel + 2];
b_sum += radius * buffer[cur_pixel + 3];
for (var i = 0; i <= radius; i++) {
a_sum += buffer[cur_pixel + 0];
r_sum += buffer[cur_pixel + 1];
g_sum += buffer[cur_pixel + 2];
b_sum += buffer[cur_pixel + 3];
cur_pixel += w * channels;
}
cur_pixel = x * channels;
for (var y = 0; y < h; y++) {
uint32 p1 = (x + v_min[y]) * channels;
uint32 p2 = (x + v_max[y]) * channels;
pixels[cur_pixel + 0] = dv[a_sum];
pixels[cur_pixel + 1] = dv[r_sum];
pixels[cur_pixel + 2] = dv[g_sum];
pixels[cur_pixel + 3] = dv[b_sum];
a_sum += buffer[p1 + 0] - buffer[p2 + 0];
r_sum += buffer[p1 + 1] - buffer[p2 + 1];
g_sum += buffer[p1 + 2] - buffer[p2 + 2];
b_sum += buffer[p1 + 3] - buffer[p2 + 3];
cur_pixel += w * channels;
}
}
}
original.mark_dirty ();
context.set_operator (Operator.SOURCE);
context.set_source_surface (original, 0, 0);
context.paint ();
context.set_operator (Operator.OVER);
}
const int ALPHA_PRECISION = 16;
const int PARAM_PRECISION = 7;
/**
* Performs a blur operation on the internal {@link Cairo.Surface}, using an
* exponential blurring algorithm. This method is usually the fastest
* and produces good-looking results (though not quite as good as gaussian's).
*
* @param radius the blur radius
*/
public void exponential_blur (int radius) {
if (radius < 1) {
return;
}
var alpha = (int) ((1 << ALPHA_PRECISION) * (1.0 - Math.exp (-2.3 / (radius + 1.0))));
var height = this.height;
var width = this.width;
var original = new ImageSurface (Format.ARGB32, width, height);
var cr = new Cairo.Context (original);
cr.set_operator (Operator.SOURCE);
cr.set_source_surface (surface, 0, 0);
cr.paint ();
uint8 *pixels = original.get_data ();
try {
// Process Rows
var th = new Thread<void*>.try (null, () => {
exponential_blur_rows (pixels, width, height, 0, height / 2, 0, width, alpha);
return null;
});
exponential_blur_rows (pixels, width, height, height / 2, height, 0, width, alpha);
th.join ();
// Process Columns
var th2 = new Thread<void*>.try (null, () => {
exponential_blur_columns (pixels, width, height, 0, width / 2, 0, height, alpha);
return null;
});
exponential_blur_columns (pixels, width, height, width / 2, width, 0, height, alpha);
th2.join ();
} catch (Error err) {
warning (err.message);
}
original.mark_dirty ();
context.set_operator (Operator.SOURCE);
context.set_source_surface (original, 0, 0);
context.paint ();
context.set_operator (Operator.OVER);
}
void exponential_blur_columns (
uint8* pixels,
int width,
int height,
int start_col,
int end_col,
int start_y,
int end_y,
int alpha
) {
for (var column_index = start_col; column_index < end_col; column_index++) {
// blur columns
uint8 *column = pixels + column_index * 4;
var z_alpha = column[0] << PARAM_PRECISION;
var z_red = column[1] << PARAM_PRECISION;
var z_green = column[2] << PARAM_PRECISION;
var z_blue = column[3] << PARAM_PRECISION;
// Top to Bottom
for (var index = width * (start_y + 1); index < (end_y - 1) * width; index += width) {
exponential_blur_inner (&column[index * 4], ref z_alpha, ref z_red, ref z_green, ref z_blue, alpha);
}
// Bottom to Top
for (var index = (end_y - 2) * width; index >= start_y; index -= width) {
exponential_blur_inner (&column[index * 4], ref z_alpha, ref z_red, ref z_green, ref z_blue, alpha);
}
}
}
void exponential_blur_rows (
uint8* pixels,
int width,
int height,
int start_row,
int end_row,
int start_x,
int end_x,
int alpha
) {
for (var row_index = start_row; row_index < end_row; row_index++) {
// Get a pointer to our current row
uint8* row = pixels + row_index * width * 4;
var z_alpha = row[start_x + 0] << PARAM_PRECISION;
var z_red = row[start_x + 1] << PARAM_PRECISION;
var z_green = row[start_x + 2] << PARAM_PRECISION;
var z_blue = row[start_x + 3] << PARAM_PRECISION;
// Left to Right
for (var index = start_x + 1; index < end_x; index++)
exponential_blur_inner (&row[index * 4], ref z_alpha, ref z_red, ref z_green, ref z_blue, alpha);
// Right to Left
for (var index = end_x - 2; index >= start_x; index--)
exponential_blur_inner (&row[index * 4], ref z_alpha, ref z_red, ref z_green, ref z_blue, alpha);
}
}
private static inline void exponential_blur_inner (
uint8* pixel,
ref int z_alpha,
ref int z_red,
ref int z_green,
ref int z_blue,
int alpha
) {
z_alpha += (alpha * ((pixel[0] << PARAM_PRECISION) - z_alpha)) >> ALPHA_PRECISION;
z_red += (alpha * ((pixel[1] << PARAM_PRECISION) - z_red)) >> ALPHA_PRECISION;
z_green += (alpha * ((pixel[2] << PARAM_PRECISION) - z_green)) >> ALPHA_PRECISION;
z_blue += (alpha * ((pixel[3] << PARAM_PRECISION) - z_blue)) >> ALPHA_PRECISION;
pixel[0] = (uint8) (z_alpha >> PARAM_PRECISION);
pixel[1] = (uint8) (z_red >> PARAM_PRECISION);
pixel[2] = (uint8) (z_green >> PARAM_PRECISION);
pixel[3] = (uint8) (z_blue >> PARAM_PRECISION);
}
/**
* Performs a blur operation on the internal {@link Cairo.Surface}, using a
* gaussian blurring algorithm. This method is very slow, albeit producing
* debatably the best-looking results, and in most cases developers should
* use the exponential blurring algorithm instead.
*
* @param radius the blur radius
*/
public void gaussian_blur (int radius) {
var gauss_width = radius * 2 + 1;
var kernel = build_gaussian_kernel (gauss_width);
var width = this.width;
var height = this.height;
var original = new ImageSurface (Format.ARGB32, width, height);
var cr = new Cairo.Context (original);
cr.set_operator (Operator.SOURCE);
cr.set_source_surface (surface, 0, 0);
cr.paint ();
uint8 *src = original.get_data ();
var size = height * original.get_stride ();
var buffer_a = new double[size];
var buffer_b = new double[size];
// Copy image to double[] for faster horizontal pass
for (var i = 0; i < size; i++) {
buffer_a[i] = (double) src[i];
}
// Precompute horizontal shifts
var shiftar = new int[int.max (width, height), gauss_width];
for (var x = 0; x < width; x++)
for (var k = 0; k < gauss_width; k++) {
var shift = k - radius;
if (x + shift <= 0 || x + shift >= width)
shiftar[x, k] = 0;
else
shiftar[x, k] = shift * 4;
}
try {
// Horizontal Pass
var th = new Thread<void*>.try (null, () => {
gaussian_blur_horizontal (
buffer_a,
buffer_b,
kernel,
gauss_width,
width,
height,
0,
height / 2,
shiftar
);
return null;
});
gaussian_blur_horizontal (
buffer_a,
buffer_b,
kernel,
gauss_width,
width,
height,
height / 2,
height,
shiftar
);
th.join ();
// Clear buffer
memset (buffer_a, 0, sizeof (double) * size);
// Precompute vertical shifts
shiftar = new int[int.max (width, height), gauss_width];
for (var y = 0; y < height; y++)
for (var k = 0; k < gauss_width; k++) {
var shift = k - radius;
if (y + shift <= 0 || y + shift >= height)
shiftar[y, k] = 0;
else
shiftar[y, k] = shift * width * 4;
}
// Vertical Pass
var th2 = new Thread<void*>.try (null, () => {
gaussian_blur_vertical (
buffer_b,
buffer_a,
kernel,
gauss_width,
width,
height,
0,
width / 2,
shiftar
);
return null;
});
gaussian_blur_vertical (
buffer_b,
buffer_a,
kernel,
gauss_width,
width,
height,
width / 2,
width,
shiftar
);
th2.join ();
} catch (Error err) {
message (err.message);
}
// Save blurred image to original uint8[]
for (var i = 0; i < size; i++) {
src[i] = (uint8) buffer_a[i];
}
original.mark_dirty ();
context.set_operator (Operator.SOURCE);
context.set_source_surface (original, 0, 0);
context.paint ();
context.set_operator (Operator.OVER);
}
void gaussian_blur_horizontal (
double* src,
double* dest,
double* kernel,
int gauss_width,
int width,
int height,
int start_row,
int end_row,
int[,] shift
) {
uint32 cur_pixel = start_row * width * 4;
for (var y = start_row; y < end_row; y++) {
for (var x = 0; x < width; x++) {
for (var k = 0; k < gauss_width; k++) {
var source = cur_pixel + shift[x, k];
dest[cur_pixel + 0] += src[source + 0] * kernel[k];
dest[cur_pixel + 1] += src[source + 1] * kernel[k];
dest[cur_pixel + 2] += src[source + 2] * kernel[k];
dest[cur_pixel + 3] += src[source + 3] * kernel[k];
}
cur_pixel += 4;
}
}
}
void gaussian_blur_vertical (
double* src,
double* dest,
double* kernel,
int gauss_width,
int width,
int height,
int start_col,
int end_col,
int[,] shift
) {
uint32 cur_pixel = start_col * 4;
for (var y = 0; y < height; y++) {
for (var x = start_col; x < end_col; x++) {
for (var k = 0; k < gauss_width; k++) {
var source = cur_pixel + shift[y, k];
dest[cur_pixel + 0] += src[source + 0] * kernel[k];
dest[cur_pixel + 1] += src[source + 1] * kernel[k];
dest[cur_pixel + 2] += src[source + 2] * kernel[k];
dest[cur_pixel + 3] += src[source + 3] * kernel[k];
}
cur_pixel += 4;
}
cur_pixel += (width - end_col + start_col) * 4;
}
}
static double[] build_gaussian_kernel (int gauss_width) requires (gauss_width % 2 == 1) {
var kernel = new double[gauss_width];
// Maximum value of curve
var sd = 255.0;
// width of curve
var range = gauss_width;
// Average value of curve
var mean = range / sd;
for (var i = 0; i < gauss_width / 2 + 1; i++) {
kernel[gauss_width - i - 1] = kernel[i] = Math.pow (
Math.sin (((i + 1) * (Math.PI / 2) - mean) / range), 2
) * sd;
}
// normalize the values
var gauss_sum = 0.0;
foreach (var d in kernel) {
gauss_sum += d;
}
for (var i = 0; i < kernel.length; i++) {
kernel[i] = kernel[i] / gauss_sum;
}
return kernel;
}
}
}