pixbufutils 0.0.3 → 0.0.4
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- checksums.yaml +7 -0
- data/Rakefile +1 -1
- data/ext/pixbufutils/auto-equalize.h +102 -0
- data/ext/pixbufutils/blend5050.h +63 -0
- data/ext/pixbufutils/blur.h +358 -0
- data/ext/pixbufutils/extconf.rb +54 -9
- data/ext/pixbufutils/extract-alpha.h +66 -0
- data/ext/pixbufutils/filter.h +376 -0
- data/ext/pixbufutils/gamma.h +49 -0
- data/ext/pixbufutils/greyscale.h +127 -0
- data/ext/pixbufutils/histogram.h +119 -0
- data/ext/pixbufutils/mask.h +74 -0
- data/ext/pixbufutils/pixbufutils.c +289 -1257
- data/ext/pixbufutils/pixbufutils.cr +113 -1180
- data/ext/pixbufutils/pixbufutils.rd +18 -0
- data/ext/pixbufutils/rotate.h +82 -0
- data/ext/pixbufutils/sharpen.h +121 -0
- data/ext/pixbufutils/soften-edges.h +52 -0
- data/ext/pixbufutils/tiff.h +61 -0
- data/ext/pixbufutils/tint.h +66 -0
- metadata +72 -85
|
@@ -0,0 +1,49 @@
|
|
|
1
|
+
static GdkPixbuf *pixbuf_gamma(GdkPixbuf *src, GdkPixbuf *dest, double gamma)
|
|
2
|
+
{
|
|
3
|
+
int has_alpha;
|
|
4
|
+
int s_width, s_height, s_rowstride;
|
|
5
|
+
int d_width, d_height, d_rowstride;
|
|
6
|
+
guchar *s_pix;
|
|
7
|
+
guchar *d_pix;
|
|
8
|
+
guchar *sp;
|
|
9
|
+
guchar *dp;
|
|
10
|
+
int i, j, pix_width;
|
|
11
|
+
double map[256] = {0.0,};
|
|
12
|
+
|
|
13
|
+
for (i=0; i < 256; i++)
|
|
14
|
+
map[i] = 255 * pow((double) i/255, 1.0/gamma);
|
|
15
|
+
|
|
16
|
+
g_return_val_if_fail(src != NULL, NULL);
|
|
17
|
+
g_return_val_if_fail(dest != NULL, NULL);
|
|
18
|
+
|
|
19
|
+
s_width = gdk_pixbuf_get_width(src);
|
|
20
|
+
s_height = gdk_pixbuf_get_height(src);
|
|
21
|
+
has_alpha = gdk_pixbuf_get_has_alpha(src);
|
|
22
|
+
s_rowstride = gdk_pixbuf_get_rowstride(src);
|
|
23
|
+
s_pix = gdk_pixbuf_get_pixels(src);
|
|
24
|
+
|
|
25
|
+
d_width = gdk_pixbuf_get_width(dest);
|
|
26
|
+
d_height = gdk_pixbuf_get_height(dest);
|
|
27
|
+
d_rowstride = gdk_pixbuf_get_rowstride(dest);
|
|
28
|
+
d_pix = gdk_pixbuf_get_pixels(dest);
|
|
29
|
+
|
|
30
|
+
g_return_val_if_fail(d_width == s_width, NULL);
|
|
31
|
+
g_return_val_if_fail(d_height == s_height, NULL);
|
|
32
|
+
g_return_val_if_fail(has_alpha == gdk_pixbuf_get_has_alpha(dest), NULL);
|
|
33
|
+
|
|
34
|
+
pix_width = (has_alpha ? 4 : 3);
|
|
35
|
+
|
|
36
|
+
for (i = 0; i < s_height; i++) {
|
|
37
|
+
sp = s_pix + (i * s_rowstride);
|
|
38
|
+
dp = d_pix + (i * d_rowstride);
|
|
39
|
+
for (j = 0; j < s_width; j++) {
|
|
40
|
+
*(dp++) = map[*(sp++)]; /* red */
|
|
41
|
+
*(dp++) = map[*(sp++)]; /* green */
|
|
42
|
+
*(dp++) = map[*(sp++)]; /* blue */
|
|
43
|
+
if (has_alpha) *(dp++) = map[*(sp++)]; /* alpha */
|
|
44
|
+
}
|
|
45
|
+
}
|
|
46
|
+
|
|
47
|
+
return dest;
|
|
48
|
+
}
|
|
49
|
+
|
|
@@ -0,0 +1,127 @@
|
|
|
1
|
+
|
|
2
|
+
|
|
3
|
+
#define RLUM (0.3086)
|
|
4
|
+
#define GLUM (0.6094)
|
|
5
|
+
#define BLUM (0.0820)
|
|
6
|
+
|
|
7
|
+
// Graphica Obscure
|
|
8
|
+
#define GO_RGB_TO_GREY(r,g,b) ((int)((RLUM * (double)r) + (GLUM * (double)g) + (BLUM * (double)b)))
|
|
9
|
+
|
|
10
|
+
// Gimp Values
|
|
11
|
+
#define GIMP_RGB_TO_GREY(r,g,b) (((77 * r) + (151 * g) + (28 * b)) >> 8)
|
|
12
|
+
|
|
13
|
+
static GdkPixbuf *pixbuf_greyscale(GdkPixbuf *src, GdkPixbuf *dest)
|
|
14
|
+
{
|
|
15
|
+
int s_has_alpha, d_has_alpha;
|
|
16
|
+
int s_width, s_height, s_rowstride;
|
|
17
|
+
int d_width, d_height, d_rowstride;
|
|
18
|
+
guchar *s_pix, *sp;
|
|
19
|
+
guchar *d_pix, *dp;
|
|
20
|
+
int i, j, pix_width, grey;
|
|
21
|
+
|
|
22
|
+
g_return_val_if_fail(src != NULL, NULL);
|
|
23
|
+
g_return_val_if_fail(dest != NULL, NULL);
|
|
24
|
+
|
|
25
|
+
s_width = gdk_pixbuf_get_width(src);
|
|
26
|
+
s_height = gdk_pixbuf_get_height(src);
|
|
27
|
+
s_has_alpha = gdk_pixbuf_get_has_alpha(src);
|
|
28
|
+
s_rowstride = gdk_pixbuf_get_rowstride(src);
|
|
29
|
+
s_pix = gdk_pixbuf_get_pixels(src);
|
|
30
|
+
|
|
31
|
+
d_width = gdk_pixbuf_get_width(dest);
|
|
32
|
+
d_height = gdk_pixbuf_get_height(dest);
|
|
33
|
+
d_has_alpha = gdk_pixbuf_get_has_alpha(dest);
|
|
34
|
+
d_rowstride = gdk_pixbuf_get_rowstride(dest);
|
|
35
|
+
d_pix = gdk_pixbuf_get_pixels(dest);
|
|
36
|
+
|
|
37
|
+
g_return_val_if_fail(d_width == s_width, NULL);
|
|
38
|
+
g_return_val_if_fail(d_height == s_height, NULL);
|
|
39
|
+
g_return_val_if_fail(d_has_alpha == s_has_alpha, NULL);
|
|
40
|
+
|
|
41
|
+
pix_width = (s_has_alpha ? 4 : 3);
|
|
42
|
+
|
|
43
|
+
|
|
44
|
+
for (i = 0; i < s_height; i++) {
|
|
45
|
+
sp = s_pix;
|
|
46
|
+
dp = d_pix;
|
|
47
|
+
|
|
48
|
+
for (j = 0; j < s_width; j++) {
|
|
49
|
+
grey = GIMP_RGB_TO_GREY(sp[0], sp[1], sp[2]);
|
|
50
|
+
|
|
51
|
+
dp[0] = grey; /* red */
|
|
52
|
+
dp[1] = grey; /* green */
|
|
53
|
+
dp[2] = grey; /* blue */
|
|
54
|
+
|
|
55
|
+
if (s_has_alpha)
|
|
56
|
+
{
|
|
57
|
+
dp[3] = sp[3]; /* alpha */
|
|
58
|
+
}
|
|
59
|
+
|
|
60
|
+
dp += pix_width;
|
|
61
|
+
sp += pix_width;
|
|
62
|
+
}
|
|
63
|
+
|
|
64
|
+
d_pix += d_rowstride;
|
|
65
|
+
s_pix += s_rowstride;
|
|
66
|
+
}
|
|
67
|
+
|
|
68
|
+
return dest;
|
|
69
|
+
}
|
|
70
|
+
|
|
71
|
+
static GdkPixbuf *pixbuf_greyscale_go(GdkPixbuf *src, GdkPixbuf *dest)
|
|
72
|
+
{
|
|
73
|
+
int s_has_alpha, d_has_alpha;
|
|
74
|
+
int s_width, s_height, s_rowstride;
|
|
75
|
+
int d_width, d_height, d_rowstride;
|
|
76
|
+
guchar *s_pix, *sp;
|
|
77
|
+
guchar *d_pix, *dp;
|
|
78
|
+
int i, j, pix_width, grey;
|
|
79
|
+
|
|
80
|
+
g_return_val_if_fail(src != NULL, NULL);
|
|
81
|
+
g_return_val_if_fail(dest != NULL, NULL);
|
|
82
|
+
|
|
83
|
+
s_width = gdk_pixbuf_get_width(src);
|
|
84
|
+
s_height = gdk_pixbuf_get_height(src);
|
|
85
|
+
s_has_alpha = gdk_pixbuf_get_has_alpha(src);
|
|
86
|
+
s_rowstride = gdk_pixbuf_get_rowstride(src);
|
|
87
|
+
s_pix = gdk_pixbuf_get_pixels(src);
|
|
88
|
+
|
|
89
|
+
d_width = gdk_pixbuf_get_width(dest);
|
|
90
|
+
d_height = gdk_pixbuf_get_height(dest);
|
|
91
|
+
d_has_alpha = gdk_pixbuf_get_has_alpha(dest);
|
|
92
|
+
d_rowstride = gdk_pixbuf_get_rowstride(dest);
|
|
93
|
+
d_pix = gdk_pixbuf_get_pixels(dest);
|
|
94
|
+
|
|
95
|
+
g_return_val_if_fail(d_width == s_width, NULL);
|
|
96
|
+
g_return_val_if_fail(d_height == s_height, NULL);
|
|
97
|
+
g_return_val_if_fail(d_has_alpha == s_has_alpha, NULL);
|
|
98
|
+
|
|
99
|
+
pix_width = (s_has_alpha ? 4 : 3);
|
|
100
|
+
|
|
101
|
+
for (i = 0; i < s_height; i++) {
|
|
102
|
+
sp = s_pix;
|
|
103
|
+
dp = d_pix;
|
|
104
|
+
|
|
105
|
+
for (j = 0; j < s_width; j++) {
|
|
106
|
+
grey = GO_RGB_TO_GREY(sp[0], sp[1], sp[2]);
|
|
107
|
+
|
|
108
|
+
dp[0] = grey; /* red */
|
|
109
|
+
dp[1] = grey; /* green */
|
|
110
|
+
dp[2] = grey; /* blue */
|
|
111
|
+
|
|
112
|
+
if (s_has_alpha)
|
|
113
|
+
{
|
|
114
|
+
dp[3] = sp[3]; /* alpha */
|
|
115
|
+
}
|
|
116
|
+
|
|
117
|
+
dp += pix_width;
|
|
118
|
+
sp += pix_width;
|
|
119
|
+
}
|
|
120
|
+
|
|
121
|
+
d_pix += d_rowstride;
|
|
122
|
+
s_pix += s_rowstride;
|
|
123
|
+
}
|
|
124
|
+
|
|
125
|
+
return dest;
|
|
126
|
+
}
|
|
127
|
+
|
|
@@ -0,0 +1,119 @@
|
|
|
1
|
+
typedef struct histogram_data {
|
|
2
|
+
int **values;
|
|
3
|
+
int *values_max;
|
|
4
|
+
int n_channels;
|
|
5
|
+
} histogram;
|
|
6
|
+
|
|
7
|
+
enum {
|
|
8
|
+
CHAN_VALUE = 0,
|
|
9
|
+
CHAN_RED,
|
|
10
|
+
CHAN_GREEN,
|
|
11
|
+
CHAN_BLUE,
|
|
12
|
+
CHAN_ALPHA,
|
|
13
|
+
N_CHANNELS
|
|
14
|
+
};
|
|
15
|
+
|
|
16
|
+
|
|
17
|
+
static histogram *
|
|
18
|
+
new_histogram(long width, long height)
|
|
19
|
+
{
|
|
20
|
+
histogram * data = ALLOC(histogram);
|
|
21
|
+
int i;
|
|
22
|
+
|
|
23
|
+
data->values_max = ALLOC_N(int, N_CHANNELS + 1);
|
|
24
|
+
data->values = ALLOC_N(int *, N_CHANNELS + 1);
|
|
25
|
+
|
|
26
|
+
for (i = 0; i < N_CHANNELS; i++) {
|
|
27
|
+
data->values[i] = ALLOC_N(int, 256);
|
|
28
|
+
}
|
|
29
|
+
|
|
30
|
+
return data;
|
|
31
|
+
}
|
|
32
|
+
|
|
33
|
+
static void
|
|
34
|
+
free_histogram(histogram *data)
|
|
35
|
+
{
|
|
36
|
+
int i;
|
|
37
|
+
if (data) {
|
|
38
|
+
for (i = 0; i < N_CHANNELS; i++) {
|
|
39
|
+
free(data->values[i]);
|
|
40
|
+
}
|
|
41
|
+
free(data->values_max);
|
|
42
|
+
free(data);
|
|
43
|
+
}
|
|
44
|
+
}
|
|
45
|
+
|
|
46
|
+
static void
|
|
47
|
+
wipe_histogram(histogram * data)
|
|
48
|
+
{
|
|
49
|
+
int i = 0;
|
|
50
|
+
MEMZERO(data->values_max, int, N_CHANNELS);
|
|
51
|
+
for (i = 0; i < N_CHANNELS; i++) {
|
|
52
|
+
MEMZERO(data->values[i], int, 256);
|
|
53
|
+
}
|
|
54
|
+
data->n_channels = 0;
|
|
55
|
+
}
|
|
56
|
+
|
|
57
|
+
static histogram *
|
|
58
|
+
histogram_from_pixbuf(GdkPixbuf *src)
|
|
59
|
+
{
|
|
60
|
+
int s_has_alpha;
|
|
61
|
+
int s_width, s_height, s_rowstride;
|
|
62
|
+
guchar *s_pix, *sp;
|
|
63
|
+
int i, j, n_channels, r, g, b, a, max;
|
|
64
|
+
int **values, *values_max;
|
|
65
|
+
|
|
66
|
+
histogram * data;
|
|
67
|
+
|
|
68
|
+
g_return_val_if_fail(src != NULL, NULL);
|
|
69
|
+
|
|
70
|
+
s_width = gdk_pixbuf_get_width(src);
|
|
71
|
+
s_height = gdk_pixbuf_get_height(src);
|
|
72
|
+
s_has_alpha = gdk_pixbuf_get_has_alpha(src);
|
|
73
|
+
s_rowstride = gdk_pixbuf_get_rowstride(src);
|
|
74
|
+
s_pix = gdk_pixbuf_get_pixels(src);
|
|
75
|
+
n_channels = s_has_alpha ? 4 : 3;
|
|
76
|
+
|
|
77
|
+
data = new_histogram(s_width, s_height);
|
|
78
|
+
wipe_histogram(data);
|
|
79
|
+
|
|
80
|
+
data->n_channels = n_channels;
|
|
81
|
+
|
|
82
|
+
values = data->values;
|
|
83
|
+
values_max = data->values_max;
|
|
84
|
+
|
|
85
|
+
for (i = 0; i < s_height; i++) {
|
|
86
|
+
sp = s_pix + (i * s_rowstride);
|
|
87
|
+
|
|
88
|
+
for (j = 0; j < s_width; j++) {
|
|
89
|
+
r = *sp++;
|
|
90
|
+
g = *sp++;
|
|
91
|
+
b = *sp++;
|
|
92
|
+
if (s_has_alpha) {
|
|
93
|
+
a = *sp++;
|
|
94
|
+
}
|
|
95
|
+
|
|
96
|
+
max = MAX(MAX(r,g),b);
|
|
97
|
+
|
|
98
|
+
values[CHAN_VALUE][max] += 1;
|
|
99
|
+
values[CHAN_RED][r] += 1;
|
|
100
|
+
values[CHAN_GREEN][g] += 1;
|
|
101
|
+
values[CHAN_BLUE][b] += 1;
|
|
102
|
+
|
|
103
|
+
if (s_has_alpha) {
|
|
104
|
+
values[CHAN_ALPHA][a] += 1;
|
|
105
|
+
}
|
|
106
|
+
|
|
107
|
+
values_max[CHAN_VALUE] = MAX(values_max[CHAN_VALUE], values[CHAN_VALUE][max]);
|
|
108
|
+
values_max[CHAN_RED] = MAX(values_max[CHAN_RED], values[CHAN_RED][r]);
|
|
109
|
+
values_max[CHAN_GREEN] = MAX(values_max[CHAN_GREEN], values[CHAN_GREEN][g]);
|
|
110
|
+
values_max[CHAN_BLUE] = MAX(values_max[CHAN_BLUE], values[CHAN_BLUE][b]);
|
|
111
|
+
if (s_has_alpha) {
|
|
112
|
+
values_max[CHAN_ALPHA] = MAX(values_max[CHAN_ALPHA], values[CHAN_ALPHA][a]);
|
|
113
|
+
}
|
|
114
|
+
}
|
|
115
|
+
}
|
|
116
|
+
|
|
117
|
+
return data;
|
|
118
|
+
}
|
|
119
|
+
|
|
@@ -0,0 +1,74 @@
|
|
|
1
|
+
static GdkPixbuf *pixbuf_mask(GdkPixbuf *src, GdkPixbuf *mask)
|
|
2
|
+
{
|
|
3
|
+
int s_has_alpha, m_has_alpha;
|
|
4
|
+
int s_width, s_height, s_rowstride;
|
|
5
|
+
int d_width, d_height, d_rowstride;
|
|
6
|
+
int m_width, m_height, m_rowstride;
|
|
7
|
+
guchar *s_pix, *sp;
|
|
8
|
+
guchar *d_pix, *dp;
|
|
9
|
+
guchar *m_pix, *mp;
|
|
10
|
+
int i, j, pix_width, alpha, grey;
|
|
11
|
+
pixel_t pix;
|
|
12
|
+
GdkPixbuf *dest;
|
|
13
|
+
|
|
14
|
+
g_return_val_if_fail(src != NULL, NULL);
|
|
15
|
+
|
|
16
|
+
s_width = gdk_pixbuf_get_width(src);
|
|
17
|
+
s_height = gdk_pixbuf_get_height(src);
|
|
18
|
+
s_has_alpha = gdk_pixbuf_get_has_alpha(src);
|
|
19
|
+
s_rowstride = gdk_pixbuf_get_rowstride(src);
|
|
20
|
+
s_pix = gdk_pixbuf_get_pixels(src);
|
|
21
|
+
|
|
22
|
+
g_return_val_if_fail(mask != NULL, NULL);
|
|
23
|
+
|
|
24
|
+
m_width = gdk_pixbuf_get_width(mask);
|
|
25
|
+
m_height = gdk_pixbuf_get_height(mask);
|
|
26
|
+
m_has_alpha = gdk_pixbuf_get_has_alpha(mask);
|
|
27
|
+
m_rowstride = gdk_pixbuf_get_rowstride(mask);
|
|
28
|
+
m_pix = gdk_pixbuf_get_pixels(mask);
|
|
29
|
+
|
|
30
|
+
g_return_val_if_fail(m_width <= s_width, NULL);
|
|
31
|
+
g_return_val_if_fail(m_height <= s_height, NULL);
|
|
32
|
+
|
|
33
|
+
d_width = m_width;
|
|
34
|
+
d_height = m_height;
|
|
35
|
+
dest = gdk_pixbuf_new(GDK_COLORSPACE_RGB, TRUE, 8, d_width, d_height);
|
|
36
|
+
|
|
37
|
+
g_return_val_if_fail(dest != NULL, NULL);
|
|
38
|
+
|
|
39
|
+
d_rowstride = gdk_pixbuf_get_rowstride(dest);
|
|
40
|
+
d_pix = gdk_pixbuf_get_pixels(dest);
|
|
41
|
+
|
|
42
|
+
pix_width = (m_has_alpha ? 4 : 3);
|
|
43
|
+
|
|
44
|
+
|
|
45
|
+
|
|
46
|
+
for (i = 0; i < m_height; i++) {
|
|
47
|
+
sp = s_pix + (i * s_rowstride);
|
|
48
|
+
dp = d_pix + (i * d_rowstride);
|
|
49
|
+
mp = m_pix + (i * m_rowstride);
|
|
50
|
+
|
|
51
|
+
for (j = 0; j < m_width; j++) {
|
|
52
|
+
*(dp++) = *(sp++); /* red */
|
|
53
|
+
*(dp++) = *(sp++); /* green */
|
|
54
|
+
*(dp++) = *(sp++); /* blue */
|
|
55
|
+
|
|
56
|
+
if (s_has_alpha)
|
|
57
|
+
{
|
|
58
|
+
alpha = *(sp++); /* alpha */
|
|
59
|
+
}
|
|
60
|
+
else
|
|
61
|
+
{
|
|
62
|
+
alpha = 0xff;
|
|
63
|
+
}
|
|
64
|
+
|
|
65
|
+
pix = PIXEL(mp, pix_width, j);
|
|
66
|
+
grey = GIMP_RGB_TO_GREY(pix->r, pix->g, pix->b);
|
|
67
|
+
|
|
68
|
+
*(dp++) = sqrt(alpha * (255 - grey)); /* alpha */
|
|
69
|
+
}
|
|
70
|
+
}
|
|
71
|
+
|
|
72
|
+
return dest;
|
|
73
|
+
}
|
|
74
|
+
|
|
@@ -1,9 +1,14 @@
|
|
|
1
1
|
#pragma GCC diagnostic ignored "-Wunused-but-set-variable"
|
|
2
|
-
/* Includes */
|
|
3
|
-
#include <ruby.h>
|
|
4
|
-
#include <stdlib.h>
|
|
5
|
-
#include <stdio.h>
|
|
6
|
-
#include <string.h>
|
|
2
|
+
/* Includes */
|
|
3
|
+
#include <ruby.h>
|
|
4
|
+
#include <stdlib.h>
|
|
5
|
+
#include <stdio.h>
|
|
6
|
+
#include <string.h>
|
|
7
|
+
#if defined GCC
|
|
8
|
+
#define OPTIONAL_ATTR __attribute__((unused))
|
|
9
|
+
#else
|
|
10
|
+
#define OPTIONAL_ATTR
|
|
11
|
+
#endif
|
|
7
12
|
#include "gdk-pixbuf/gdk-pixbuf.h"
|
|
8
13
|
#include "rbglib.h"
|
|
9
14
|
#include "rbgobject.h"
|
|
@@ -20,47 +25,59 @@ typedef int rubber_bool;
|
|
|
20
25
|
|
|
21
26
|
static VALUE mPixbufUtils;
|
|
22
27
|
static VALUE
|
|
23
|
-
PixbufUtils_CLASS_remove_alpha(VALUE self, VALUE __v_src, VALUE __v_col);
|
|
28
|
+
PixbufUtils_CLASS_remove_alpha(VALUE self OPTIONAL_ATTR , VALUE __v_src OPTIONAL_ATTR, VALUE __v_col OPTIONAL_ATTR);
|
|
24
29
|
static VALUE
|
|
25
|
-
PixbufUtils_CLASS_sharpen(VALUE self, VALUE __v_src, VALUE __v_radius);
|
|
30
|
+
PixbufUtils_CLASS_sharpen(VALUE self OPTIONAL_ATTR , VALUE __v_src OPTIONAL_ATTR, VALUE __v_radius OPTIONAL_ATTR);
|
|
26
31
|
static VALUE
|
|
27
32
|
PixbufUtils_CLASS_extract_alpha(int __p_argc, VALUE *__p_argv, VALUE self);
|
|
28
33
|
static VALUE
|
|
29
|
-
PixbufUtils_CLASS_blur(VALUE self, VALUE __v_src, VALUE __v_radius);
|
|
34
|
+
PixbufUtils_CLASS_blur(VALUE self OPTIONAL_ATTR , VALUE __v_src OPTIONAL_ATTR, VALUE __v_radius OPTIONAL_ATTR);
|
|
30
35
|
static VALUE
|
|
31
|
-
|
|
36
|
+
PixbufUtils_CLASS_contrast(VALUE self OPTIONAL_ATTR , VALUE __v_src OPTIONAL_ATTR, VALUE __v_adjust OPTIONAL_ATTR);
|
|
32
37
|
static VALUE
|
|
33
|
-
|
|
38
|
+
PixbufUtils_CLASS_vibrance(VALUE self OPTIONAL_ATTR , VALUE __v_src OPTIONAL_ATTR, VALUE __v_adjust OPTIONAL_ATTR);
|
|
34
39
|
static VALUE
|
|
35
|
-
|
|
40
|
+
PixbufUtils_CLASS_saturation(VALUE self OPTIONAL_ATTR , VALUE __v_src OPTIONAL_ATTR, VALUE __v_adjust OPTIONAL_ATTR);
|
|
36
41
|
static VALUE
|
|
37
|
-
|
|
42
|
+
PixbufUtils_CLASS_brightness(VALUE self OPTIONAL_ATTR , VALUE __v_src OPTIONAL_ATTR, VALUE __v_adjust OPTIONAL_ATTR);
|
|
38
43
|
static VALUE
|
|
39
|
-
|
|
44
|
+
PixbufUtils_CLASS_filter(VALUE self OPTIONAL_ATTR , VALUE __v_src OPTIONAL_ATTR, VALUE filter OPTIONAL_ATTR, VALUE __v_divisor OPTIONAL_ATTR);
|
|
40
45
|
static VALUE
|
|
41
|
-
|
|
46
|
+
PixbufUtils_CLASS_rotate_90(VALUE self OPTIONAL_ATTR , VALUE __v_src OPTIONAL_ATTR, VALUE __v_counter_clockwise OPTIONAL_ATTR);
|
|
42
47
|
static VALUE
|
|
43
|
-
|
|
48
|
+
PixbufUtils_CLASS_rotate_cw(VALUE self OPTIONAL_ATTR , VALUE __v_src OPTIONAL_ATTR);
|
|
44
49
|
static VALUE
|
|
45
|
-
|
|
50
|
+
PixbufUtils_CLASS_rotate_180(VALUE self OPTIONAL_ATTR , VALUE __v_src OPTIONAL_ATTR);
|
|
46
51
|
static VALUE
|
|
47
|
-
|
|
52
|
+
PixbufUtils_CLASS_rotate(VALUE self OPTIONAL_ATTR , VALUE __v_src OPTIONAL_ATTR, VALUE __v_angle OPTIONAL_ATTR);
|
|
48
53
|
static VALUE
|
|
49
|
-
|
|
54
|
+
PixbufUtils_CLASS_rotate_ccw(VALUE self OPTIONAL_ATTR , VALUE __v_src OPTIONAL_ATTR);
|
|
50
55
|
static VALUE
|
|
51
|
-
|
|
56
|
+
PixbufUtils_CLASS_gamma_pling(VALUE self OPTIONAL_ATTR , VALUE __v_src OPTIONAL_ATTR, VALUE __v_level OPTIONAL_ATTR);
|
|
52
57
|
static VALUE
|
|
53
|
-
|
|
58
|
+
PixbufUtils_CLASS_soften_edges_pling(VALUE self OPTIONAL_ATTR , VALUE __v_src OPTIONAL_ATTR, VALUE __v_size OPTIONAL_ATTR);
|
|
54
59
|
static VALUE
|
|
55
|
-
|
|
60
|
+
PixbufUtils_CLASS_gamma(VALUE self OPTIONAL_ATTR , VALUE __v_src OPTIONAL_ATTR, VALUE __v_level OPTIONAL_ATTR);
|
|
61
|
+
static VALUE
|
|
62
|
+
PixbufUtils_CLASS_greyscale_pling(VALUE self OPTIONAL_ATTR , VALUE __v_src OPTIONAL_ATTR);
|
|
63
|
+
static VALUE
|
|
64
|
+
PixbufUtils_CLASS_to_tiff(VALUE self OPTIONAL_ATTR , VALUE __v_src OPTIONAL_ATTR, VALUE __v_filename OPTIONAL_ATTR);
|
|
65
|
+
static VALUE
|
|
66
|
+
PixbufUtils_CLASS_greyscale(VALUE self OPTIONAL_ATTR , VALUE __v_src OPTIONAL_ATTR);
|
|
67
|
+
static VALUE
|
|
68
|
+
PixbufUtils_CLASS_greyscale_go_pling(VALUE self OPTIONAL_ATTR , VALUE __v_src OPTIONAL_ATTR);
|
|
69
|
+
static VALUE
|
|
70
|
+
PixbufUtils_CLASS_greyscale_go(VALUE self OPTIONAL_ATTR , VALUE __v_src OPTIONAL_ATTR);
|
|
56
71
|
static VALUE
|
|
57
72
|
PixbufUtils_CLASS_tint(int __p_argc, VALUE *__p_argv, VALUE self);
|
|
58
73
|
static VALUE
|
|
59
|
-
PixbufUtils_CLASS_perspect_v(VALUE self, VALUE __v_src, VALUE __v_top_x1, VALUE __v_top_x2, VALUE __v_bot_x1, VALUE __v_bot_x2);
|
|
74
|
+
PixbufUtils_CLASS_perspect_v(VALUE self OPTIONAL_ATTR , VALUE __v_src OPTIONAL_ATTR, VALUE __v_top_x1 OPTIONAL_ATTR, VALUE __v_top_x2 OPTIONAL_ATTR, VALUE __v_bot_x1 OPTIONAL_ATTR, VALUE __v_bot_x2 OPTIONAL_ATTR);
|
|
75
|
+
static VALUE
|
|
76
|
+
PixbufUtils_CLASS_mask(VALUE self OPTIONAL_ATTR , VALUE __v_src OPTIONAL_ATTR, VALUE __v_mask OPTIONAL_ATTR);
|
|
60
77
|
static VALUE
|
|
61
|
-
|
|
78
|
+
PixbufUtils_CLASS_auto_equalize(VALUE self OPTIONAL_ATTR , VALUE __v_src OPTIONAL_ATTR);
|
|
62
79
|
static VALUE
|
|
63
|
-
PixbufUtils_CLASS_blend5050(VALUE self, VALUE __v_src1, VALUE __v_src2);
|
|
80
|
+
PixbufUtils_CLASS_blend5050(VALUE self OPTIONAL_ATTR , VALUE __v_src1 OPTIONAL_ATTR, VALUE __v_src2 OPTIONAL_ATTR);
|
|
64
81
|
static VALUE
|
|
65
82
|
PixbufUtils_CLASS_mask_area(int __p_argc, VALUE *__p_argv, VALUE self);
|
|
66
83
|
static VALUE
|
|
@@ -73,1144 +90,39 @@ PixbufUtils_CLASS_draw_scaled_clip(int __p_argc, VALUE *__p_argv, VALUE self);
|
|
|
73
90
|
/* Inline C code */
|
|
74
91
|
|
|
75
92
|
|
|
76
|
-
extern void Init_pixbufutils(void);
|
|
77
|
-
|
|
78
|
-
#ifndef IGNORE
|
|
79
|
-
#define IGNORE(x) x=x
|
|
80
|
-
#endif
|
|
81
|
-
|
|
82
|
-
static GdkPixbuf *pixbuf_extract_alpha(GdkPixbuf *src, int cutoff, int force_2bit)
|
|
83
|
-
{
|
|
84
|
-
int s_has_alpha, d_has_alpha;
|
|
85
|
-
int s_width, s_height, s_rowstride;
|
|
86
|
-
int d_width, d_height, d_rowstride;
|
|
87
|
-
GdkPixbuf *dest;
|
|
88
|
-
guchar *s_pix, *sp;
|
|
89
|
-
guchar *d_pix, *dp;
|
|
90
|
-
int i, j, pix_width, grey;
|
|
91
|
-
|
|
92
|
-
g_return_val_if_fail(src != NULL, NULL);
|
|
93
|
-
|
|
94
|
-
s_width = gdk_pixbuf_get_width(src);
|
|
95
|
-
s_height = gdk_pixbuf_get_height(src);
|
|
96
|
-
s_has_alpha = gdk_pixbuf_get_has_alpha(src);
|
|
97
|
-
s_rowstride = gdk_pixbuf_get_rowstride(src);
|
|
98
|
-
s_pix = gdk_pixbuf_get_pixels(src);
|
|
99
|
-
g_return_val_if_fail(s_has_alpha, NULL);
|
|
100
|
-
|
|
101
|
-
dest = gdk_pixbuf_new(GDK_COLORSPACE_RGB, FALSE, 8, s_width, s_height);
|
|
102
|
-
|
|
103
|
-
g_return_val_if_fail(dest != NULL, NULL);
|
|
104
|
-
|
|
105
|
-
d_rowstride = gdk_pixbuf_get_rowstride(dest);
|
|
106
|
-
d_pix = gdk_pixbuf_get_pixels(dest);
|
|
107
|
-
|
|
108
|
-
d_width = gdk_pixbuf_get_width(dest);
|
|
109
|
-
d_height = gdk_pixbuf_get_height(dest);
|
|
110
|
-
d_has_alpha = gdk_pixbuf_get_has_alpha(dest);
|
|
111
|
-
d_rowstride = gdk_pixbuf_get_rowstride(dest);
|
|
112
|
-
d_pix = gdk_pixbuf_get_pixels(dest);
|
|
113
|
-
|
|
114
|
-
g_return_val_if_fail(d_width == s_width, NULL);
|
|
115
|
-
g_return_val_if_fail(d_height == s_height, NULL);
|
|
116
|
-
|
|
117
|
-
pix_width = (s_has_alpha ? 4 : 3);
|
|
118
|
-
|
|
119
|
-
for (i = 0; i < s_height; i++) {
|
|
120
|
-
sp = s_pix;
|
|
121
|
-
dp = d_pix;
|
|
122
|
-
|
|
123
|
-
for (j = 0; j < s_width; j++) {
|
|
124
|
-
grey = sp[3];
|
|
125
|
-
|
|
126
|
-
if (grey < cutoff)
|
|
127
|
-
grey = 0;
|
|
128
|
-
|
|
129
|
-
if (force_2bit)
|
|
130
|
-
grey = (grey >= cutoff ? 255 : 0);
|
|
131
|
-
|
|
132
|
-
dp[0] = grey; /* red */
|
|
133
|
-
dp[1] = grey; /* green */
|
|
134
|
-
dp[2] = grey; /* blue */
|
|
135
|
-
|
|
136
|
-
dp += 3;
|
|
137
|
-
sp += 4;
|
|
138
|
-
}
|
|
139
|
-
|
|
140
|
-
d_pix += d_rowstride;
|
|
141
|
-
s_pix += s_rowstride;
|
|
142
|
-
}
|
|
143
|
-
|
|
144
|
-
return dest;
|
|
145
|
-
}
|
|
146
|
-
|
|
147
|
-
|
|
148
|
-
typedef enum {
|
|
149
|
-
ANGLE_0 = 0,
|
|
150
|
-
ANGLE_90 = 90,
|
|
151
|
-
ANGLE_180 = 180,
|
|
152
|
-
ANGLE_270 = 270
|
|
153
|
-
} rotate_angle_t;
|
|
154
|
-
|
|
155
|
-
static GdkPixbuf *
|
|
156
|
-
pixbuf_blur(GdkPixbuf *src, gint radius)
|
|
157
|
-
{
|
|
158
|
-
/* Pixels and Rowstride To Perform Blur On */
|
|
159
|
-
guchar *pixels;
|
|
160
|
-
GdkPixbuf *pixbuf;
|
|
161
|
-
gint rowstride, width, height;
|
|
162
|
-
|
|
163
|
-
pixbuf = gdk_pixbuf_copy(src);
|
|
164
|
-
|
|
165
|
-
/* Get Pixels and Rowstride Of Image Buffer */
|
|
166
|
-
if (pixbuf)
|
|
167
|
-
{
|
|
168
|
-
pixels = gdk_pixbuf_get_pixels (pixbuf);
|
|
169
|
-
rowstride = gdk_pixbuf_get_rowstride (pixbuf);
|
|
170
|
-
width = gdk_pixbuf_get_width(pixbuf);
|
|
171
|
-
height = gdk_pixbuf_get_height(pixbuf);
|
|
172
|
-
/*printf("%i, %i, %i, %i\n", rowstride, width, height, rowstride/width);*/
|
|
173
|
-
}
|
|
174
|
-
else
|
|
175
|
-
{
|
|
176
|
-
return NULL;
|
|
177
|
-
}
|
|
178
|
-
if (radius > 1)
|
|
179
|
-
{
|
|
180
|
-
/* Some Important Consts */
|
|
181
|
-
gint bytes = rowstride/width;
|
|
182
|
-
gboolean alpha = (bytes == 4);
|
|
183
|
-
|
|
184
|
-
gint div = radius+radius+1;
|
|
185
|
-
gint divsum = ((div+1)>>1)*((div+1)>>1);
|
|
186
|
-
gint dv[256*divsum]; /* Table of Const RGBA Values */
|
|
187
|
-
|
|
188
|
-
/* Some Important Variables */
|
|
189
|
-
guchar stack[div][bytes];
|
|
190
|
-
gint stackpointer;
|
|
191
|
-
gint stackstart;
|
|
192
|
-
gint vmin[MAX(width,height)];
|
|
193
|
-
guchar *sir;
|
|
194
|
-
gint rbs;
|
|
195
|
-
|
|
196
|
-
gint current = 0;
|
|
197
|
-
|
|
198
|
-
/* RGBA Sums
|
|
199
|
-
0 - Sum of Incoming pixels(the radius pixels above the Center/to left of Center)
|
|
200
|
-
1 - Sum of Outgoing pixels(the Center and the radius pixels below the Center/to right of Center)
|
|
201
|
-
2 - Sum of All pixels within radius
|
|
202
|
-
*/
|
|
203
|
-
gint rgba_sums[3][bytes];
|
|
204
|
-
|
|
205
|
-
/* RGBA Values */
|
|
206
|
-
guchar rgba[bytes][width*height];
|
|
207
|
-
|
|
208
|
-
/* Temp Indexes/Counters */
|
|
209
|
-
gint x, y, i, p, yp, yi=0, yw=0;
|
|
210
|
-
|
|
211
|
-
for (i=0; i<256*divsum; i++)
|
|
212
|
-
{
|
|
213
|
-
dv[i] = (i/divsum);
|
|
214
|
-
}
|
|
215
|
-
|
|
216
|
-
for (y=0; y < height; y++)
|
|
217
|
-
{
|
|
218
|
-
/* initialize sums to zero */
|
|
219
|
-
for (i = 0; i<bytes; i++)
|
|
220
|
-
{
|
|
221
|
-
rgba_sums[0][i] = 0;
|
|
222
|
-
rgba_sums[1][i] = 0;
|
|
223
|
-
rgba_sums[2][i] = 0;
|
|
224
|
-
}
|
|
225
|
-
|
|
226
|
-
/* Calculate Initial Sums For radius */
|
|
227
|
-
for(i=-radius; i<=radius; i++)
|
|
228
|
-
{
|
|
229
|
-
current = (yi + MIN(width - 1, MAX(i,0)))*bytes;
|
|
230
|
-
|
|
231
|
-
sir = stack[i+radius];
|
|
232
|
-
|
|
233
|
-
sir[0] = pixels[current + 0];
|
|
234
|
-
sir[1] = pixels[current + 1];
|
|
235
|
-
sir[2] = pixels[current + 2];
|
|
236
|
-
sir[3] = pixels[current + 3];
|
|
237
|
-
|
|
238
|
-
rbs = (radius + 1) - abs(i);
|
|
239
|
-
|
|
240
|
-
rgba_sums[2][0] += sir[0]*rbs;
|
|
241
|
-
rgba_sums[2][1] += sir[1]*rbs;
|
|
242
|
-
rgba_sums[2][2] += sir[2]*rbs;
|
|
243
|
-
if (alpha)
|
|
244
|
-
{
|
|
245
|
-
rgba_sums[2][3] += sir[3]*rbs;
|
|
246
|
-
}
|
|
247
|
-
|
|
248
|
-
if (i>0)
|
|
249
|
-
{
|
|
250
|
-
rgba_sums[0][0] += sir[0];
|
|
251
|
-
rgba_sums[0][1] += sir[1];
|
|
252
|
-
rgba_sums[0][2] += sir[2];
|
|
253
|
-
if (alpha)
|
|
254
|
-
{
|
|
255
|
-
rgba_sums[0][3] += sir[3];
|
|
256
|
-
}
|
|
257
|
-
}
|
|
258
|
-
else
|
|
259
|
-
{
|
|
260
|
-
rgba_sums[1][0] += sir[0];
|
|
261
|
-
rgba_sums[1][1] += sir[1];
|
|
262
|
-
rgba_sums[1][2] += sir[2];
|
|
263
|
-
if (alpha)
|
|
264
|
-
{
|
|
265
|
-
rgba_sums[1][3] += sir[3];
|
|
266
|
-
}
|
|
267
|
-
}
|
|
268
|
-
}
|
|
269
|
-
|
|
270
|
-
stackpointer = radius;
|
|
271
|
-
|
|
272
|
-
for (x=0; x<width; x++)
|
|
273
|
-
{
|
|
274
|
-
rgba[0][yi] = dv[rgba_sums[2][0]];
|
|
275
|
-
rgba[1][yi] = dv[rgba_sums[2][1]];
|
|
276
|
-
rgba[2][yi] = dv[rgba_sums[2][2]];
|
|
277
|
-
if (alpha)
|
|
278
|
-
{
|
|
279
|
-
rgba[3][yi] = dv[rgba_sums[2][3]];
|
|
280
|
-
}
|
|
281
|
-
|
|
282
|
-
rgba_sums[2][0] -= rgba_sums[1][0];
|
|
283
|
-
rgba_sums[2][1] -= rgba_sums[1][1];
|
|
284
|
-
rgba_sums[2][2] -= rgba_sums[1][2];
|
|
285
|
-
if (alpha)
|
|
286
|
-
{
|
|
287
|
-
rgba_sums[2][3] -= rgba_sums[1][3];
|
|
288
|
-
}
|
|
289
|
-
|
|
290
|
-
stackstart = stackpointer - radius + div;
|
|
291
|
-
sir = stack[stackstart%div];
|
|
292
|
-
|
|
293
|
-
rgba_sums[1][0] -= sir[0];
|
|
294
|
-
rgba_sums[1][1] -= sir[1];
|
|
295
|
-
rgba_sums[1][2] -= sir[2];
|
|
296
|
-
if (alpha)
|
|
297
|
-
{
|
|
298
|
-
rgba_sums[1][3] -= sir[3];
|
|
299
|
-
}
|
|
300
|
-
|
|
301
|
-
if(y==0)
|
|
302
|
-
{
|
|
303
|
-
vmin[x] = MIN(x + radius + 1, width - 1);
|
|
304
|
-
}
|
|
305
|
-
|
|
306
|
-
current = (yw + vmin[x])*bytes;
|
|
307
|
-
|
|
308
|
-
sir[0] = pixels[current + 0];
|
|
309
|
-
sir[1] = pixels[current + 1];
|
|
310
|
-
sir[2] = pixels[current + 2];
|
|
311
|
-
if (alpha)
|
|
312
|
-
{
|
|
313
|
-
sir[3] = pixels[current + 3];
|
|
314
|
-
}
|
|
315
|
-
|
|
316
|
-
rgba_sums[0][0] += sir[0];
|
|
317
|
-
rgba_sums[0][1] += sir[1];
|
|
318
|
-
rgba_sums[0][2] += sir[2];
|
|
319
|
-
if (alpha)
|
|
320
|
-
{
|
|
321
|
-
rgba_sums[0][3] += sir[3];
|
|
322
|
-
}
|
|
323
|
-
|
|
324
|
-
rgba_sums[2][0] += rgba_sums[0][0];
|
|
325
|
-
rgba_sums[2][1] += rgba_sums[0][1];
|
|
326
|
-
rgba_sums[2][2] += rgba_sums[0][2];
|
|
327
|
-
if (alpha)
|
|
328
|
-
{
|
|
329
|
-
rgba_sums[2][3] += rgba_sums[0][3];
|
|
330
|
-
}
|
|
331
|
-
|
|
332
|
-
stackpointer=(stackpointer+1)%div;
|
|
333
|
-
sir=stack[(stackpointer)%div];
|
|
334
|
-
|
|
335
|
-
rgba_sums[1][0] += sir[0];
|
|
336
|
-
rgba_sums[1][1] += sir[1];
|
|
337
|
-
rgba_sums[1][2] += sir[2];
|
|
338
|
-
if (alpha)
|
|
339
|
-
{
|
|
340
|
-
rgba_sums[1][3] += sir[3];
|
|
341
|
-
}
|
|
342
|
-
|
|
343
|
-
rgba_sums[0][0] -= sir[0];
|
|
344
|
-
rgba_sums[0][1] -= sir[1];
|
|
345
|
-
rgba_sums[0][2] -= sir[2];
|
|
346
|
-
if (alpha)
|
|
347
|
-
{
|
|
348
|
-
rgba_sums[0][3] -= sir[3];
|
|
349
|
-
}
|
|
350
|
-
|
|
351
|
-
yi++;
|
|
352
|
-
}
|
|
353
|
-
|
|
354
|
-
yw += width;
|
|
355
|
-
}
|
|
356
|
-
|
|
357
|
-
for (x=0; x<width; x++)
|
|
358
|
-
{
|
|
359
|
-
yp=-radius*width;
|
|
360
|
-
|
|
361
|
-
/* initialize sums to zero */
|
|
362
|
-
for (i = 0; i<bytes; i++)
|
|
363
|
-
{
|
|
364
|
-
rgba_sums[0][i] = 0;
|
|
365
|
-
rgba_sums[1][i] = 0;
|
|
366
|
-
rgba_sums[2][i] = 0;
|
|
367
|
-
}
|
|
368
|
-
|
|
369
|
-
/* Calculate Initial Sums For radius */
|
|
370
|
-
for(i=-radius; i<=radius; i++)
|
|
371
|
-
{
|
|
372
|
-
yi = MAX(0,yp) + x;
|
|
373
|
-
|
|
374
|
-
sir = stack[i+radius];
|
|
375
|
-
|
|
376
|
-
sir[0] = rgba[0][yi];
|
|
377
|
-
sir[1] = rgba[1][yi];
|
|
378
|
-
sir[2] = rgba[2][yi];
|
|
379
|
-
if (alpha)
|
|
380
|
-
{
|
|
381
|
-
sir[3] = rgba[3][yi];
|
|
382
|
-
}
|
|
383
|
-
|
|
384
|
-
rbs = (radius + 1) - abs(i);
|
|
385
|
-
|
|
386
|
-
rgba_sums[2][0] += rgba[0][yi]*rbs;
|
|
387
|
-
rgba_sums[2][1] += rgba[1][yi]*rbs;
|
|
388
|
-
rgba_sums[2][2] += rgba[2][yi]*rbs;
|
|
389
|
-
if (alpha)
|
|
390
|
-
{
|
|
391
|
-
rgba_sums[2][3] += rgba[3][yi]*rbs;
|
|
392
|
-
}
|
|
393
|
-
|
|
394
|
-
if (i>0)
|
|
395
|
-
{
|
|
396
|
-
rgba_sums[0][0] += sir[0];
|
|
397
|
-
rgba_sums[0][1] += sir[1];
|
|
398
|
-
rgba_sums[0][2] += sir[2];
|
|
399
|
-
if (alpha)
|
|
400
|
-
{
|
|
401
|
-
rgba_sums[0][3] += sir[3];
|
|
402
|
-
}
|
|
403
|
-
}
|
|
404
|
-
else
|
|
405
|
-
{
|
|
406
|
-
rgba_sums[1][0] += sir[0];
|
|
407
|
-
rgba_sums[1][1] += sir[1];
|
|
408
|
-
rgba_sums[1][2] += sir[2];
|
|
409
|
-
if (alpha)
|
|
410
|
-
{
|
|
411
|
-
rgba_sums[1][3] += sir[3];
|
|
412
|
-
}
|
|
413
|
-
}
|
|
414
|
-
|
|
415
|
-
if(i < height - 1)
|
|
416
|
-
{
|
|
417
|
-
yp += width;
|
|
418
|
-
}
|
|
419
|
-
}
|
|
420
|
-
|
|
421
|
-
yi = x;
|
|
422
|
-
stackpointer = radius;
|
|
423
|
-
|
|
424
|
-
for (y=0; y<height; y++)
|
|
425
|
-
{
|
|
426
|
-
current = (yi)*bytes;
|
|
427
|
-
|
|
428
|
-
pixels[current + 0] = dv[rgba_sums[2][0]];
|
|
429
|
-
pixels[current + 1] = dv[rgba_sums[2][1]];
|
|
430
|
-
pixels[current + 2] = dv[rgba_sums[2][2]];
|
|
431
|
-
if (alpha)
|
|
432
|
-
{
|
|
433
|
-
pixels[current + 3] = dv[rgba_sums[2][3]];
|
|
434
|
-
}
|
|
435
|
-
|
|
436
|
-
rgba_sums[2][0] -= rgba_sums[1][0];
|
|
437
|
-
rgba_sums[2][1] -= rgba_sums[1][1];
|
|
438
|
-
rgba_sums[2][2] -= rgba_sums[1][2];
|
|
439
|
-
if (alpha)
|
|
440
|
-
{
|
|
441
|
-
rgba_sums[2][3] -= rgba_sums[1][3];
|
|
442
|
-
}
|
|
443
|
-
|
|
444
|
-
stackstart = stackpointer - radius + div;
|
|
445
|
-
sir = stack[stackstart%div];
|
|
446
|
-
|
|
447
|
-
rgba_sums[1][0] -= sir[0];
|
|
448
|
-
rgba_sums[1][1] -= sir[1];
|
|
449
|
-
rgba_sums[1][2] -= sir[2];
|
|
450
|
-
if (alpha)
|
|
451
|
-
{
|
|
452
|
-
rgba_sums[1][3] -= sir[3];
|
|
453
|
-
}
|
|
454
|
-
|
|
455
|
-
if (x == 0)
|
|
456
|
-
{
|
|
457
|
-
vmin[y] = MIN(y + (radius + 1), height - 1)*width;
|
|
458
|
-
}
|
|
459
|
-
|
|
460
|
-
p = x + vmin[y];
|
|
461
|
-
|
|
462
|
-
sir[0] = rgba[0][p];
|
|
463
|
-
sir[1] = rgba[1][p];
|
|
464
|
-
sir[2] = rgba[2][p];
|
|
465
|
-
if (alpha)
|
|
466
|
-
{
|
|
467
|
-
sir[3] = rgba[3][p];
|
|
468
|
-
}
|
|
469
|
-
|
|
470
|
-
rgba_sums[0][0] += sir[0];
|
|
471
|
-
rgba_sums[0][1] += sir[1];
|
|
472
|
-
rgba_sums[0][2] += sir[2];
|
|
473
|
-
if (alpha)
|
|
474
|
-
{
|
|
475
|
-
rgba_sums[0][3] += sir[3];
|
|
476
|
-
}
|
|
477
|
-
|
|
478
|
-
rgba_sums[2][0] += rgba_sums[0][0];
|
|
479
|
-
rgba_sums[2][1] += rgba_sums[0][1];
|
|
480
|
-
rgba_sums[2][2] += rgba_sums[0][2];
|
|
481
|
-
if (alpha)
|
|
482
|
-
{
|
|
483
|
-
rgba_sums[2][3] += rgba_sums[0][3];
|
|
484
|
-
}
|
|
485
|
-
|
|
486
|
-
stackpointer = (stackpointer+1)%div;
|
|
487
|
-
sir = stack[stackpointer];
|
|
488
|
-
|
|
489
|
-
rgba_sums[1][0] += sir[0];
|
|
490
|
-
rgba_sums[1][1] += sir[1];
|
|
491
|
-
rgba_sums[1][2] += sir[2];
|
|
492
|
-
if (alpha)
|
|
493
|
-
{
|
|
494
|
-
rgba_sums[1][3] += sir[3];
|
|
495
|
-
}
|
|
496
|
-
|
|
497
|
-
rgba_sums[0][0] -= sir[0];
|
|
498
|
-
rgba_sums[0][1] -= sir[1];
|
|
499
|
-
rgba_sums[0][2] -= sir[2];
|
|
500
|
-
if (alpha)
|
|
501
|
-
{
|
|
502
|
-
rgba_sums[0][3] -= sir[3];
|
|
503
|
-
}
|
|
504
|
-
|
|
505
|
-
yi += width;
|
|
506
|
-
}
|
|
507
|
-
}
|
|
508
|
-
}
|
|
509
|
-
|
|
510
|
-
return pixbuf;
|
|
511
|
-
}
|
|
512
|
-
|
|
513
|
-
static GdkPixbuf *
|
|
514
|
-
pixbuf_sharpen(GdkPixbuf *src, int strength)
|
|
515
|
-
{
|
|
516
|
-
GdkPixbuf *dest;
|
|
517
|
-
int has_alpha;
|
|
518
|
-
int s_width, s_height, s_rowstride;
|
|
519
|
-
int d_width, d_height, d_rowstride;
|
|
520
|
-
guchar *s_pix;
|
|
521
|
-
guchar *d_pix;
|
|
522
|
-
guchar *sp;
|
|
523
|
-
guchar *dp;
|
|
524
|
-
int pix_width;
|
|
525
|
-
bool row_only = TRUE;
|
|
526
|
-
int a=0, r, g, b, x, y, mul;
|
|
527
|
-
int b_a=0, b_r, b_g, b_b;
|
|
528
|
-
|
|
529
|
-
if (!src) return NULL;
|
|
530
|
-
|
|
531
|
-
s_width = gdk_pixbuf_get_width(src);
|
|
532
|
-
s_height = gdk_pixbuf_get_height(src);
|
|
533
|
-
has_alpha = gdk_pixbuf_get_has_alpha(src);
|
|
534
|
-
s_rowstride = gdk_pixbuf_get_rowstride(src);
|
|
535
|
-
s_pix = gdk_pixbuf_get_pixels(src);
|
|
536
|
-
|
|
537
|
-
d_width = s_width;
|
|
538
|
-
d_height = s_height;
|
|
539
|
-
|
|
540
|
-
dest = gdk_pixbuf_copy(src);
|
|
541
|
-
d_rowstride = gdk_pixbuf_get_rowstride(dest);
|
|
542
|
-
d_pix = gdk_pixbuf_get_pixels(dest);
|
|
543
|
-
|
|
544
|
-
pix_width = (has_alpha ? 4 : 3);
|
|
545
|
-
|
|
546
|
-
mul = (row_only ? 3 : 5);
|
|
547
|
-
|
|
548
|
-
for (y = 0; y < (s_height); y++)
|
|
549
|
-
{
|
|
550
|
-
sp = s_pix + (y * s_rowstride) + pix_width;
|
|
551
|
-
dp = d_pix + (y * d_rowstride) + pix_width;
|
|
552
|
-
|
|
553
|
-
for (x = 1; x < (s_width - 1); x++)
|
|
554
|
-
{
|
|
555
|
-
|
|
556
|
-
b_r = ((int)*(sp));
|
|
557
|
-
b_g = ((int)*(sp+1));
|
|
558
|
-
b_b = ((int)*(sp+2));
|
|
559
|
-
if (has_alpha)
|
|
560
|
-
b_a = ((int)*((sp+3)));
|
|
561
|
-
|
|
562
|
-
r = b_r * mul;
|
|
563
|
-
g = b_g * mul;
|
|
564
|
-
b = b_b * mul;
|
|
565
|
-
if (has_alpha)
|
|
566
|
-
a = b_a * mul;
|
|
567
|
-
|
|
568
|
-
r = ((int)*(sp)) * mul;
|
|
569
|
-
g = ((int)*(sp+1)) * mul;
|
|
570
|
-
b = ((int)*(sp+2)) * mul;
|
|
571
|
-
if (has_alpha)
|
|
572
|
-
a = ((int)*((sp+3))) * mul;
|
|
573
|
-
|
|
574
|
-
r -= (int)*(sp - pix_width);
|
|
575
|
-
g -= (int)*(sp - pix_width + 1);
|
|
576
|
-
b -= (int)*(sp - pix_width + 2);
|
|
577
|
-
if (has_alpha)
|
|
578
|
-
a -= (int)*(sp - pix_width + 3);
|
|
579
|
-
|
|
580
|
-
r -= (int)*(sp + pix_width);
|
|
581
|
-
g -= (int)*(sp + pix_width + 1);
|
|
582
|
-
b -= (int)*(sp + pix_width + 2);
|
|
583
|
-
if (has_alpha)
|
|
584
|
-
a -= (int)*(sp + pix_width + 3);
|
|
585
|
-
|
|
586
|
-
if (row_only == 0)
|
|
587
|
-
{
|
|
588
|
-
r -= (int)*(sp - (s_rowstride));
|
|
589
|
-
g -= (int)*(sp + 1 - (s_rowstride));
|
|
590
|
-
b -= (int)*(sp + 2 - (s_rowstride));
|
|
591
|
-
if (has_alpha)
|
|
592
|
-
a -= (int)*(sp + 3 - (s_rowstride));
|
|
593
|
-
|
|
594
|
-
r -= (int)*(sp + (s_rowstride));
|
|
595
|
-
g -= (int)*(sp + 1 + (s_rowstride));
|
|
596
|
-
b -= (int)*(sp + 2 + (s_rowstride));
|
|
597
|
-
if (has_alpha)
|
|
598
|
-
a -= (int)*(sp + 3 + (s_rowstride));
|
|
599
|
-
}
|
|
600
|
-
|
|
601
|
-
r = (r & ((~r) >> 16));
|
|
602
|
-
r = ((r | ((r & 256) - ((r & 256) >> 8))));
|
|
603
|
-
g = (g & ((~g) >> 16));
|
|
604
|
-
g = ((g | ((g & 256) - ((g & 256) >> 8))));
|
|
605
|
-
b = (b & ((~b) >> 16));
|
|
606
|
-
b = ((b | ((b & 256) - ((b & 256) >> 8))));
|
|
607
|
-
a = (a & ((~a) >> 16));
|
|
608
|
-
a = ((a | ((a & 256) - ((a & 256) >> 8))));
|
|
609
|
-
|
|
610
|
-
r = 0xff & (MAX(r,0));
|
|
611
|
-
g = 0xff & (MAX(g,0));
|
|
612
|
-
b = 0xff & (MAX(b,0));
|
|
613
|
-
if (has_alpha)
|
|
614
|
-
a = 0xff & (MAX(a,0));
|
|
615
|
-
|
|
616
|
-
r = ((r * strength) + b_r) / (strength + 1);
|
|
617
|
-
g = ((g * strength) + b_g) / (strength + 1);
|
|
618
|
-
b = ((b * strength) + b_b) / (strength + 1);
|
|
619
|
-
if (has_alpha)
|
|
620
|
-
a = ((a * strength) + b_a) / (strength + 1);
|
|
621
|
-
|
|
622
|
-
*(dp++) = r;
|
|
623
|
-
*(dp++) = g;
|
|
624
|
-
*(dp++) = b;
|
|
625
|
-
if (has_alpha)
|
|
626
|
-
*(dp++) = a;
|
|
627
|
-
|
|
628
|
-
sp += pix_width;
|
|
629
|
-
}
|
|
630
|
-
}
|
|
631
|
-
return dest;
|
|
632
|
-
} // */
|
|
633
|
-
|
|
634
|
-
static GdkPixbuf *
|
|
635
|
-
pixbuf_rotate(GdkPixbuf *src, rotate_angle_t angle)
|
|
636
|
-
{
|
|
637
|
-
GdkPixbuf *dest;
|
|
638
|
-
int has_alpha;
|
|
639
|
-
int s_width, s_height, s_rowstride;
|
|
640
|
-
int d_width, d_height, d_rowstride;
|
|
641
|
-
guchar *s_pix;
|
|
642
|
-
guchar *d_pix;
|
|
643
|
-
guchar *sp;
|
|
644
|
-
guchar *dp;
|
|
645
|
-
int i, j, pix_width;
|
|
646
|
-
|
|
647
|
-
if (!src) return NULL;
|
|
648
|
-
|
|
649
|
-
if (angle == ANGLE_0)
|
|
650
|
-
return gdk_pixbuf_copy(src);
|
|
651
|
-
|
|
652
|
-
s_width = gdk_pixbuf_get_width(src);
|
|
653
|
-
s_height = gdk_pixbuf_get_height(src);
|
|
654
|
-
has_alpha = gdk_pixbuf_get_has_alpha(src);
|
|
655
|
-
s_rowstride = gdk_pixbuf_get_rowstride(src);
|
|
656
|
-
s_pix = gdk_pixbuf_get_pixels(src);
|
|
657
|
-
|
|
658
|
-
switch (angle)
|
|
659
|
-
{
|
|
660
|
-
case ANGLE_90:
|
|
661
|
-
case ANGLE_270:
|
|
662
|
-
d_width = s_height;
|
|
663
|
-
d_height = s_width;
|
|
664
|
-
break;
|
|
665
|
-
default:
|
|
666
|
-
case ANGLE_0:/* Avoid compiler warnings... */
|
|
667
|
-
case ANGLE_180:
|
|
668
|
-
d_width = s_width;
|
|
669
|
-
d_height = s_height;
|
|
670
|
-
break;
|
|
671
|
-
}
|
|
672
|
-
|
|
673
|
-
dest = gdk_pixbuf_new(GDK_COLORSPACE_RGB, has_alpha, 8, d_width, d_height);
|
|
674
|
-
d_rowstride = gdk_pixbuf_get_rowstride(dest);
|
|
675
|
-
d_pix = gdk_pixbuf_get_pixels(dest);
|
|
676
|
-
|
|
677
|
-
pix_width = (has_alpha ? 4 : 3);
|
|
678
|
-
|
|
679
|
-
for (i = 0; i < s_height; i++) {
|
|
680
|
-
sp = s_pix + (i * s_rowstride);
|
|
681
|
-
for (j = 0; j < s_width; j++) {
|
|
682
|
-
switch (angle)
|
|
683
|
-
{
|
|
684
|
-
case ANGLE_180:
|
|
685
|
-
dp = d_pix + ((d_height - i - 1) * d_rowstride) + ((d_width - j - 1) * pix_width);
|
|
686
|
-
break;
|
|
687
|
-
case ANGLE_90:
|
|
688
|
-
dp = d_pix + (j * d_rowstride) + ((d_width - i - 1) * pix_width);
|
|
689
|
-
break;
|
|
690
|
-
case ANGLE_270:
|
|
691
|
-
dp = d_pix + ((d_height - j - 1) * d_rowstride) + (i * pix_width);
|
|
692
|
-
break;
|
|
693
|
-
default:
|
|
694
|
-
case ANGLE_0:/* Avoid compiler warnings... */
|
|
695
|
-
dp = d_pix + (i * d_rowstride) + (j * pix_width);
|
|
696
|
-
break;
|
|
697
|
-
}
|
|
698
|
-
|
|
699
|
-
*(dp++) = *(sp++); /* red */
|
|
700
|
-
*(dp++) = *(sp++); /* green */
|
|
701
|
-
*(dp++) = *(sp++); /* blue */
|
|
702
|
-
if (has_alpha) *(dp) = *(sp++); /* alpha */
|
|
703
|
-
}
|
|
704
|
-
}
|
|
705
|
-
|
|
706
|
-
return dest;
|
|
707
|
-
}
|
|
708
|
-
|
|
709
|
-
#include <unistd.h>
|
|
710
|
-
|
|
711
|
-
static gboolean pixbuf_save_tiff(GdkPixbuf *pixbuf, char *filename)
|
|
712
|
-
{
|
|
713
|
-
long row;
|
|
714
|
-
TIFF *tif;
|
|
715
|
-
struct tm *ct;
|
|
716
|
-
time_t t;
|
|
717
|
-
int width,
|
|
718
|
-
height,
|
|
719
|
-
rowstride;
|
|
720
|
-
guchar *pixels;
|
|
721
|
-
short photometric;
|
|
722
|
-
short samplesperpixel;
|
|
723
|
-
short bitspersample;
|
|
724
|
-
static char datetime[40] = "";
|
|
725
|
-
char hostname[256] = "";
|
|
726
|
-
|
|
727
|
-
time(&t);
|
|
728
|
-
ct = localtime(&t);
|
|
729
|
-
sprintf(datetime, "%04i:%02i:%02i %02i:%02i:%02i",
|
|
730
|
-
1900 + ct->tm_year, ct->tm_mon + 1, ct->tm_mday,
|
|
731
|
-
ct->tm_hour, ct->tm_min, ct->tm_sec);
|
|
732
|
-
|
|
733
|
-
tif = TIFFOpen(filename, "w");
|
|
734
|
-
|
|
735
|
-
width = gdk_pixbuf_get_width(pixbuf);
|
|
736
|
-
height = gdk_pixbuf_get_height(pixbuf);
|
|
737
|
-
samplesperpixel = gdk_pixbuf_get_has_alpha(pixbuf) ? 4 : 3;
|
|
738
|
-
bitspersample = gdk_pixbuf_get_bits_per_sample(pixbuf);
|
|
739
|
-
photometric = PHOTOMETRIC_RGB;
|
|
740
|
-
rowstride = gdk_pixbuf_get_rowstride(pixbuf);
|
|
741
|
-
pixels = gdk_pixbuf_get_pixels(pixbuf);
|
|
742
|
-
|
|
743
|
-
|
|
744
|
-
TIFFSetField(tif, TIFFTAG_IMAGEWIDTH, width);
|
|
745
|
-
TIFFSetField(tif, TIFFTAG_IMAGELENGTH, height);
|
|
746
|
-
TIFFSetField(tif, TIFFTAG_BITSPERSAMPLE, bitspersample);
|
|
747
|
-
TIFFSetField(tif, TIFFTAG_ORIENTATION, ORIENTATION_TOPLEFT);
|
|
748
|
-
TIFFSetField(tif, TIFFTAG_COMPRESSION, COMPRESSION_LZW);
|
|
749
|
-
TIFFSetField(tif, TIFFTAG_PHOTOMETRIC, photometric);
|
|
750
|
-
/*#TIFFSetField(tif, TIFFTAG_DOCUMENTNAME, inf);*/
|
|
751
|
-
TIFFSetField(tif, TIFFTAG_IMAGEDESCRIPTION, "Saved from a Gdk::Pixbuf");
|
|
752
|
-
TIFFSetField(tif, TIFFTAG_SAMPLESPERPIXEL, samplesperpixel);
|
|
753
|
-
TIFFSetField(tif, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG);
|
|
754
|
-
TIFFSetField(tif, TIFFTAG_SOFTWARE, "LiveLink Photo Kiosk 1.0");
|
|
755
|
-
TIFFSetField(tif, TIFFTAG_DATETIME, datetime);
|
|
756
|
-
if(gethostname((char*)&hostname,sizeof(hostname))==0)
|
|
757
|
-
TIFFSetField(tif, TIFFTAG_HOSTCOMPUTER, hostname);
|
|
758
|
-
|
|
759
|
-
for (row = 0; row < height; row++) {
|
|
760
|
-
if (TIFFWriteScanline(tif, (u_char *) pixels, row, 0) < 0) {
|
|
761
|
-
fprintf(stderr, "failed a scanline write (%li)\n", row);
|
|
762
|
-
break;
|
|
763
|
-
}
|
|
764
|
-
pixels = GINT_TO_POINTER(GPOINTER_TO_INT(pixels) + rowstride);
|
|
765
|
-
}
|
|
766
|
-
TIFFFlushData(tif);
|
|
767
|
-
TIFFClose(tif);
|
|
768
|
-
|
|
769
|
-
return TRUE;
|
|
770
|
-
}
|
|
771
|
-
|
|
772
|
-
#include <math.h>
|
|
773
|
-
|
|
774
|
-
static GdkPixbuf *pixbuf_gamma(GdkPixbuf *src, GdkPixbuf *dest, double gamma)
|
|
775
|
-
{
|
|
776
|
-
int has_alpha;
|
|
777
|
-
int s_width, s_height, s_rowstride;
|
|
778
|
-
int d_width, d_height, d_rowstride;
|
|
779
|
-
guchar *s_pix;
|
|
780
|
-
guchar *d_pix;
|
|
781
|
-
guchar *sp;
|
|
782
|
-
guchar *dp;
|
|
783
|
-
int i, j, pix_width;
|
|
784
|
-
double map[256] = {0.0,};
|
|
785
|
-
|
|
786
|
-
for (i=0; i < 256; i++)
|
|
787
|
-
map[i] = 255 * pow((double) i/255, 1.0/gamma);
|
|
788
|
-
|
|
789
|
-
g_return_val_if_fail(src != NULL, NULL);
|
|
790
|
-
g_return_val_if_fail(dest != NULL, NULL);
|
|
791
|
-
|
|
792
|
-
s_width = gdk_pixbuf_get_width(src);
|
|
793
|
-
s_height = gdk_pixbuf_get_height(src);
|
|
794
|
-
has_alpha = gdk_pixbuf_get_has_alpha(src);
|
|
795
|
-
s_rowstride = gdk_pixbuf_get_rowstride(src);
|
|
796
|
-
s_pix = gdk_pixbuf_get_pixels(src);
|
|
797
|
-
|
|
798
|
-
d_width = gdk_pixbuf_get_width(dest);
|
|
799
|
-
d_height = gdk_pixbuf_get_height(dest);
|
|
800
|
-
d_rowstride = gdk_pixbuf_get_rowstride(dest);
|
|
801
|
-
d_pix = gdk_pixbuf_get_pixels(dest);
|
|
802
|
-
|
|
803
|
-
g_return_val_if_fail(d_width == s_width, NULL);
|
|
804
|
-
g_return_val_if_fail(d_height == s_height, NULL);
|
|
805
|
-
g_return_val_if_fail(has_alpha == gdk_pixbuf_get_has_alpha(dest), NULL);
|
|
806
|
-
|
|
807
|
-
pix_width = (has_alpha ? 4 : 3);
|
|
808
|
-
|
|
809
|
-
for (i = 0; i < s_height; i++) {
|
|
810
|
-
sp = s_pix + (i * s_rowstride);
|
|
811
|
-
dp = d_pix + (i * d_rowstride);
|
|
812
|
-
for (j = 0; j < s_width; j++) {
|
|
813
|
-
*(dp++) = map[*(sp++)]; /* red */
|
|
814
|
-
*(dp++) = map[*(sp++)]; /* green */
|
|
815
|
-
*(dp++) = map[*(sp++)]; /* blue */
|
|
816
|
-
if (has_alpha) *(dp++) = map[*(sp++)]; /* alpha */
|
|
817
|
-
}
|
|
818
|
-
}
|
|
819
|
-
|
|
820
|
-
return dest;
|
|
821
|
-
}
|
|
822
|
-
|
|
823
93
|
#define PIXEL(row, channels, x) ((pixel_t)(row + (channels * x)))
|
|
824
94
|
|
|
825
95
|
typedef struct {
|
|
826
96
|
unsigned char r,g,b,a;
|
|
827
97
|
} * pixel_t;
|
|
828
98
|
|
|
829
|
-
|
|
830
|
-
#define GLUM (0.6094)
|
|
831
|
-
#define BLUM (0.0820)
|
|
832
|
-
|
|
833
|
-
// Graphica Obscure
|
|
834
|
-
#define GO_RGB_TO_GREY(r,g,b) ((int)((RLUM * (double)r) + (GLUM * (double)g) + (BLUM * (double)b)))
|
|
835
|
-
|
|
836
|
-
// Gimp Values
|
|
837
|
-
#define GIMP_RGB_TO_GREY(r,g,b) (((77 * r) + (151 * g) + (28 * b)) >> 8)
|
|
838
|
-
|
|
839
|
-
static GdkPixbuf *pixbuf_mask(GdkPixbuf *src, GdkPixbuf *mask)
|
|
840
|
-
{
|
|
841
|
-
int s_has_alpha, m_has_alpha;
|
|
842
|
-
int s_width, s_height, s_rowstride;
|
|
843
|
-
int d_width, d_height, d_rowstride;
|
|
844
|
-
int m_width, m_height, m_rowstride;
|
|
845
|
-
guchar *s_pix, *sp;
|
|
846
|
-
guchar *d_pix, *dp;
|
|
847
|
-
guchar *m_pix, *mp;
|
|
848
|
-
int i, j, pix_width, alpha, grey;
|
|
849
|
-
pixel_t pix;
|
|
850
|
-
GdkPixbuf *dest;
|
|
851
|
-
|
|
852
|
-
g_return_val_if_fail(src != NULL, NULL);
|
|
853
|
-
|
|
854
|
-
s_width = gdk_pixbuf_get_width(src);
|
|
855
|
-
s_height = gdk_pixbuf_get_height(src);
|
|
856
|
-
s_has_alpha = gdk_pixbuf_get_has_alpha(src);
|
|
857
|
-
s_rowstride = gdk_pixbuf_get_rowstride(src);
|
|
858
|
-
s_pix = gdk_pixbuf_get_pixels(src);
|
|
859
|
-
|
|
860
|
-
g_return_val_if_fail(mask != NULL, NULL);
|
|
861
|
-
|
|
862
|
-
m_width = gdk_pixbuf_get_width(mask);
|
|
863
|
-
m_height = gdk_pixbuf_get_height(mask);
|
|
864
|
-
m_has_alpha = gdk_pixbuf_get_has_alpha(mask);
|
|
865
|
-
m_rowstride = gdk_pixbuf_get_rowstride(mask);
|
|
866
|
-
m_pix = gdk_pixbuf_get_pixels(mask);
|
|
867
|
-
|
|
868
|
-
g_return_val_if_fail(m_width <= s_width, NULL);
|
|
869
|
-
g_return_val_if_fail(m_height <= s_height, NULL);
|
|
870
|
-
|
|
871
|
-
d_width = m_width;
|
|
872
|
-
d_height = m_height;
|
|
873
|
-
dest = gdk_pixbuf_new(GDK_COLORSPACE_RGB, TRUE, 8, d_width, d_height);
|
|
874
|
-
|
|
875
|
-
g_return_val_if_fail(dest != NULL, NULL);
|
|
876
|
-
|
|
877
|
-
d_rowstride = gdk_pixbuf_get_rowstride(dest);
|
|
878
|
-
d_pix = gdk_pixbuf_get_pixels(dest);
|
|
879
|
-
|
|
880
|
-
pix_width = (m_has_alpha ? 4 : 3);
|
|
881
|
-
|
|
882
|
-
|
|
883
|
-
|
|
884
|
-
for (i = 0; i < m_height; i++) {
|
|
885
|
-
sp = s_pix + (i * s_rowstride);
|
|
886
|
-
dp = d_pix + (i * d_rowstride);
|
|
887
|
-
mp = m_pix + (i * m_rowstride);
|
|
888
|
-
|
|
889
|
-
for (j = 0; j < m_width; j++) {
|
|
890
|
-
*(dp++) = *(sp++); /* red */
|
|
891
|
-
*(dp++) = *(sp++); /* green */
|
|
892
|
-
*(dp++) = *(sp++); /* blue */
|
|
893
|
-
|
|
894
|
-
if (s_has_alpha)
|
|
895
|
-
{
|
|
896
|
-
alpha = *(sp++); /* alpha */
|
|
897
|
-
}
|
|
898
|
-
else
|
|
899
|
-
{
|
|
900
|
-
alpha = 0xff;
|
|
901
|
-
}
|
|
902
|
-
|
|
903
|
-
pix = PIXEL(mp, pix_width, j);
|
|
904
|
-
grey = GIMP_RGB_TO_GREY(pix->r, pix->g, pix->b);
|
|
905
|
-
|
|
906
|
-
*(dp++) = sqrt(alpha * (255 - grey)); /* alpha */
|
|
907
|
-
}
|
|
908
|
-
}
|
|
909
|
-
|
|
910
|
-
return dest;
|
|
911
|
-
}
|
|
912
|
-
|
|
913
|
-
static GdkPixbuf *pixbuf_blend5050(GdkPixbuf *src1, GdkPixbuf *src2)
|
|
914
|
-
{
|
|
915
|
-
int s1_has_alpha, s2_has_alpha;
|
|
916
|
-
int s1_width, s1_height, s1_rowstride;
|
|
917
|
-
int d_width, d_height, d_rowstride;
|
|
918
|
-
int s2_width, s2_height, s2_rowstride;
|
|
919
|
-
guchar *s1_pix, *sp;
|
|
920
|
-
guchar *d_pix, *dp;
|
|
921
|
-
guchar *s2_pix, *mp;
|
|
922
|
-
int i, j;
|
|
923
|
-
GdkPixbuf *dest;
|
|
924
|
-
|
|
925
|
-
g_return_val_if_fail(src1 != NULL, NULL);
|
|
926
|
-
|
|
927
|
-
s1_width = gdk_pixbuf_get_width(src1);
|
|
928
|
-
s1_height = gdk_pixbuf_get_height(src1);
|
|
929
|
-
s1_has_alpha = gdk_pixbuf_get_has_alpha(src1);
|
|
930
|
-
s1_rowstride = gdk_pixbuf_get_rowstride(src1);
|
|
931
|
-
s1_pix = gdk_pixbuf_get_pixels(src1);
|
|
932
|
-
|
|
933
|
-
g_return_val_if_fail(src2 != NULL, NULL);
|
|
934
|
-
|
|
935
|
-
s2_width = gdk_pixbuf_get_width(src2);
|
|
936
|
-
s2_height = gdk_pixbuf_get_height(src2);
|
|
937
|
-
s2_has_alpha = gdk_pixbuf_get_has_alpha(src2);
|
|
938
|
-
s2_rowstride = gdk_pixbuf_get_rowstride(src2);
|
|
939
|
-
s2_pix = gdk_pixbuf_get_pixels(src2);
|
|
940
|
-
|
|
941
|
-
g_return_val_if_fail(s2_width == s1_width, NULL);
|
|
942
|
-
g_return_val_if_fail(s2_height == s1_height, NULL);
|
|
943
|
-
g_return_val_if_fail(s2_has_alpha == s1_has_alpha, NULL);
|
|
944
|
-
|
|
945
|
-
d_width = s2_width;
|
|
946
|
-
d_height = s2_height;
|
|
947
|
-
|
|
948
|
-
dest = gdk_pixbuf_new(GDK_COLORSPACE_RGB, TRUE, 8, d_width, d_height);
|
|
949
|
-
|
|
950
|
-
g_return_val_if_fail(dest != NULL, NULL);
|
|
951
|
-
|
|
952
|
-
d_rowstride = gdk_pixbuf_get_rowstride(dest);
|
|
953
|
-
d_pix = gdk_pixbuf_get_pixels(dest);
|
|
954
|
-
|
|
955
|
-
for (i = 0; i < s2_height; i++) {
|
|
956
|
-
sp = s1_pix + (i * s1_rowstride);
|
|
957
|
-
mp = s2_pix + (i * s2_rowstride);
|
|
958
|
-
dp = d_pix + (i * d_rowstride);
|
|
959
|
-
|
|
960
|
-
for (j = 0; j < s2_width; j++) {
|
|
961
|
-
*(dp++) = ((*(sp++)) >> 1) + ((*(mp++)) >> 1); /* red */
|
|
962
|
-
*(dp++) = ((*(sp++)) >> 1) + ((*(mp++)) >> 1); /* green */
|
|
963
|
-
*(dp++) = ((*(sp++)) >> 1) + ((*(mp++)) >> 1); /* blue */
|
|
964
|
-
|
|
965
|
-
if (s1_has_alpha)
|
|
966
|
-
*(dp++) = ((*(sp++)) >> 1) + ((*(mp++)) >> 1); /* alpha */
|
|
967
|
-
else
|
|
968
|
-
*(dp++) = 0xff; /* alpha */
|
|
969
|
-
|
|
970
|
-
}
|
|
971
|
-
}
|
|
972
|
-
|
|
973
|
-
return dest;
|
|
974
|
-
}
|
|
975
|
-
|
|
976
|
-
|
|
977
|
-
static GdkPixbuf *pixbuf_greyscale(GdkPixbuf *src, GdkPixbuf *dest)
|
|
978
|
-
{
|
|
979
|
-
int s_has_alpha, d_has_alpha;
|
|
980
|
-
int s_width, s_height, s_rowstride;
|
|
981
|
-
int d_width, d_height, d_rowstride;
|
|
982
|
-
guchar *s_pix, *sp;
|
|
983
|
-
guchar *d_pix, *dp;
|
|
984
|
-
int i, j, pix_width, grey;
|
|
985
|
-
|
|
986
|
-
g_return_val_if_fail(src != NULL, NULL);
|
|
987
|
-
g_return_val_if_fail(dest != NULL, NULL);
|
|
988
|
-
|
|
989
|
-
s_width = gdk_pixbuf_get_width(src);
|
|
990
|
-
s_height = gdk_pixbuf_get_height(src);
|
|
991
|
-
s_has_alpha = gdk_pixbuf_get_has_alpha(src);
|
|
992
|
-
s_rowstride = gdk_pixbuf_get_rowstride(src);
|
|
993
|
-
s_pix = gdk_pixbuf_get_pixels(src);
|
|
994
|
-
|
|
995
|
-
d_width = gdk_pixbuf_get_width(dest);
|
|
996
|
-
d_height = gdk_pixbuf_get_height(dest);
|
|
997
|
-
d_has_alpha = gdk_pixbuf_get_has_alpha(dest);
|
|
998
|
-
d_rowstride = gdk_pixbuf_get_rowstride(dest);
|
|
999
|
-
d_pix = gdk_pixbuf_get_pixels(dest);
|
|
1000
|
-
|
|
1001
|
-
g_return_val_if_fail(d_width == s_width, NULL);
|
|
1002
|
-
g_return_val_if_fail(d_height == s_height, NULL);
|
|
1003
|
-
g_return_val_if_fail(d_has_alpha == s_has_alpha, NULL);
|
|
1004
|
-
|
|
1005
|
-
pix_width = (s_has_alpha ? 4 : 3);
|
|
1006
|
-
|
|
1007
|
-
|
|
1008
|
-
for (i = 0; i < s_height; i++) {
|
|
1009
|
-
sp = s_pix;
|
|
1010
|
-
dp = d_pix;
|
|
1011
|
-
|
|
1012
|
-
for (j = 0; j < s_width; j++) {
|
|
1013
|
-
grey = GIMP_RGB_TO_GREY(sp[0], sp[1], sp[2]);
|
|
1014
|
-
|
|
1015
|
-
dp[0] = grey; /* red */
|
|
1016
|
-
dp[1] = grey; /* green */
|
|
1017
|
-
dp[2] = grey; /* blue */
|
|
1018
|
-
|
|
1019
|
-
if (s_has_alpha)
|
|
1020
|
-
{
|
|
1021
|
-
dp[3] = sp[3]; /* alpha */
|
|
1022
|
-
}
|
|
1023
|
-
|
|
1024
|
-
dp += pix_width;
|
|
1025
|
-
sp += pix_width;
|
|
1026
|
-
}
|
|
1027
|
-
|
|
1028
|
-
d_pix += d_rowstride;
|
|
1029
|
-
s_pix += s_rowstride;
|
|
1030
|
-
}
|
|
1031
|
-
|
|
1032
|
-
return dest;
|
|
1033
|
-
}
|
|
1034
|
-
|
|
1035
|
-
static GdkPixbuf *pixbuf_greyscale_go(GdkPixbuf *src, GdkPixbuf *dest)
|
|
1036
|
-
{
|
|
1037
|
-
int s_has_alpha, d_has_alpha;
|
|
1038
|
-
int s_width, s_height, s_rowstride;
|
|
1039
|
-
int d_width, d_height, d_rowstride;
|
|
1040
|
-
guchar *s_pix, *sp;
|
|
1041
|
-
guchar *d_pix, *dp;
|
|
1042
|
-
int i, j, pix_width, grey;
|
|
1043
|
-
|
|
1044
|
-
g_return_val_if_fail(src != NULL, NULL);
|
|
1045
|
-
g_return_val_if_fail(dest != NULL, NULL);
|
|
1046
|
-
|
|
1047
|
-
s_width = gdk_pixbuf_get_width(src);
|
|
1048
|
-
s_height = gdk_pixbuf_get_height(src);
|
|
1049
|
-
s_has_alpha = gdk_pixbuf_get_has_alpha(src);
|
|
1050
|
-
s_rowstride = gdk_pixbuf_get_rowstride(src);
|
|
1051
|
-
s_pix = gdk_pixbuf_get_pixels(src);
|
|
1052
|
-
|
|
1053
|
-
d_width = gdk_pixbuf_get_width(dest);
|
|
1054
|
-
d_height = gdk_pixbuf_get_height(dest);
|
|
1055
|
-
d_has_alpha = gdk_pixbuf_get_has_alpha(dest);
|
|
1056
|
-
d_rowstride = gdk_pixbuf_get_rowstride(dest);
|
|
1057
|
-
d_pix = gdk_pixbuf_get_pixels(dest);
|
|
1058
|
-
|
|
1059
|
-
g_return_val_if_fail(d_width == s_width, NULL);
|
|
1060
|
-
g_return_val_if_fail(d_height == s_height, NULL);
|
|
1061
|
-
g_return_val_if_fail(d_has_alpha == s_has_alpha, NULL);
|
|
1062
|
-
|
|
1063
|
-
pix_width = (s_has_alpha ? 4 : 3);
|
|
1064
|
-
|
|
1065
|
-
for (i = 0; i < s_height; i++) {
|
|
1066
|
-
sp = s_pix;
|
|
1067
|
-
dp = d_pix;
|
|
1068
|
-
|
|
1069
|
-
for (j = 0; j < s_width; j++) {
|
|
1070
|
-
grey = GO_RGB_TO_GREY(sp[0], sp[1], sp[2]);
|
|
1071
|
-
|
|
1072
|
-
dp[0] = grey; /* red */
|
|
1073
|
-
dp[1] = grey; /* green */
|
|
1074
|
-
dp[2] = grey; /* blue */
|
|
1075
|
-
|
|
1076
|
-
if (s_has_alpha)
|
|
1077
|
-
{
|
|
1078
|
-
dp[3] = sp[3]; /* alpha */
|
|
1079
|
-
}
|
|
1080
|
-
|
|
1081
|
-
dp += pix_width;
|
|
1082
|
-
sp += pix_width;
|
|
1083
|
-
}
|
|
1084
|
-
|
|
1085
|
-
d_pix += d_rowstride;
|
|
1086
|
-
s_pix += s_rowstride;
|
|
1087
|
-
}
|
|
1088
|
-
|
|
1089
|
-
return dest;
|
|
1090
|
-
}
|
|
1091
|
-
|
|
1092
|
-
static inline unsigned char pu_clamp(int x)
|
|
1093
|
-
{
|
|
1094
|
-
unsigned char i = (x > 255) ? 255 : (x < 0 ? 0 : x);
|
|
1095
|
-
return i;
|
|
1096
|
-
}
|
|
1097
|
-
|
|
1098
|
-
static GdkPixbuf *pixbuf_tint(GdkPixbuf *src, GdkPixbuf *dest, int r, int g, int b, int alpha)
|
|
1099
|
-
{
|
|
1100
|
-
int s_has_alpha, d_has_alpha;
|
|
1101
|
-
int s_width, s_height, s_rowstride;
|
|
1102
|
-
int d_width, d_height, d_rowstride;
|
|
1103
|
-
guchar *s_pix, *sp;
|
|
1104
|
-
guchar *d_pix, *dp;
|
|
1105
|
-
int i, j, pix_width, grey;
|
|
1106
|
-
|
|
1107
|
-
g_return_val_if_fail(src != NULL, NULL);
|
|
1108
|
-
g_return_val_if_fail(dest != NULL, NULL);
|
|
1109
|
-
|
|
1110
|
-
s_width = gdk_pixbuf_get_width(src);
|
|
1111
|
-
s_height = gdk_pixbuf_get_height(src);
|
|
1112
|
-
s_has_alpha = gdk_pixbuf_get_has_alpha(src);
|
|
1113
|
-
s_rowstride = gdk_pixbuf_get_rowstride(src);
|
|
1114
|
-
s_pix = gdk_pixbuf_get_pixels(src);
|
|
1115
|
-
|
|
1116
|
-
d_width = gdk_pixbuf_get_width(dest);
|
|
1117
|
-
d_height = gdk_pixbuf_get_height(dest);
|
|
1118
|
-
d_has_alpha = gdk_pixbuf_get_has_alpha(dest);
|
|
1119
|
-
d_rowstride = gdk_pixbuf_get_rowstride(dest);
|
|
1120
|
-
d_pix = gdk_pixbuf_get_pixels(dest);
|
|
1121
|
-
|
|
1122
|
-
g_return_val_if_fail(d_width == s_width, NULL);
|
|
1123
|
-
g_return_val_if_fail(d_height == s_height, NULL);
|
|
1124
|
-
g_return_val_if_fail(d_has_alpha == s_has_alpha, NULL);
|
|
1125
|
-
|
|
1126
|
-
pix_width = (s_has_alpha ? 4 : 3);
|
|
1127
|
-
|
|
1128
|
-
for (i = 0; i < s_height; i++) {
|
|
1129
|
-
sp = s_pix;
|
|
1130
|
-
dp = d_pix;
|
|
1131
|
-
|
|
1132
|
-
for (j = 0; j < s_width; j++) {
|
|
1133
|
-
grey = GO_RGB_TO_GREY(sp[0], sp[1], sp[2]);
|
|
1134
|
-
|
|
1135
|
-
dp[0] = pu_clamp(pu_clamp(((int)grey + r) * alpha / 255) + pu_clamp((int)sp[0] * (255 - alpha) / 255)); /* red */
|
|
1136
|
-
|
|
1137
|
-
//fprintf(stderr, "alpha=%i, r=%i, grey=%i -> %i + %i = %i\n", alpha, r, grey, pu_clamp(((int)grey + r) * alpha / 255), pu_clamp((int)sp[0] * (255 - alpha) / 255), dp[0]); /* red */
|
|
1138
|
-
|
|
1139
|
-
dp[1] = pu_clamp(pu_clamp((grey + g) * alpha / 255) + pu_clamp((int)sp[1] * (255 - alpha) / 255)); /* green */
|
|
1140
|
-
dp[2] = pu_clamp(pu_clamp((grey + b) * alpha / 255) + pu_clamp((int)sp[2] * (255 - alpha) / 255)); /* blue */
|
|
1141
|
-
|
|
1142
|
-
if (s_has_alpha)
|
|
1143
|
-
{
|
|
1144
|
-
dp[3] = sp[3]; /* alpha */
|
|
1145
|
-
}
|
|
1146
|
-
|
|
1147
|
-
dp += pix_width;
|
|
1148
|
-
sp += pix_width;
|
|
1149
|
-
}
|
|
1150
|
-
|
|
1151
|
-
d_pix += d_rowstride;
|
|
1152
|
-
s_pix += s_rowstride;
|
|
1153
|
-
}
|
|
1154
|
-
|
|
1155
|
-
return dest;
|
|
1156
|
-
}
|
|
1157
|
-
|
|
1158
|
-
static GdkPixbuf *pixbuf_soften_edges(GdkPixbuf *dest, int size)
|
|
1159
|
-
{
|
|
1160
|
-
int d_has_alpha;
|
|
1161
|
-
int d_width, d_height, d_rowstride;
|
|
1162
|
-
guchar *d_pix, *dp;
|
|
1163
|
-
int i, j, pix_width;
|
|
1164
|
-
|
|
1165
|
-
g_return_val_if_fail(dest != NULL, NULL);
|
|
1166
|
-
|
|
1167
|
-
d_width = gdk_pixbuf_get_width(dest);
|
|
1168
|
-
d_height = gdk_pixbuf_get_height(dest);
|
|
1169
|
-
d_has_alpha = gdk_pixbuf_get_has_alpha(dest);
|
|
1170
|
-
d_rowstride = gdk_pixbuf_get_rowstride(dest);
|
|
1171
|
-
d_pix = gdk_pixbuf_get_pixels(dest);
|
|
1172
|
-
|
|
1173
|
-
g_return_val_if_fail(d_has_alpha, NULL);
|
|
1174
|
-
|
|
1175
|
-
pix_width = (d_has_alpha ? 4 : 3);
|
|
99
|
+
extern void Init_pixbufutils(void);
|
|
1176
100
|
|
|
1177
|
-
|
|
1178
|
-
|
|
1179
|
-
|
|
1180
|
-
for (j = 0; j < d_width; j++) {
|
|
1181
|
-
dp[3] = (dp[3] * i) / size; /* alpha */
|
|
1182
|
-
dp += pix_width;
|
|
1183
|
-
}
|
|
1184
|
-
|
|
1185
|
-
dp = d_pix + ((d_height - i - 1) * d_rowstride);
|
|
1186
|
-
for (j = 0; j < d_width; j++) {
|
|
1187
|
-
dp[3] = (dp[3] * i) / size; /* alpha */
|
|
1188
|
-
dp += pix_width;
|
|
1189
|
-
}
|
|
1190
|
-
|
|
1191
|
-
}
|
|
1192
|
-
for (j = 0; j < d_height; j++) {
|
|
1193
|
-
//pix = (pixel_t)GINT_TO_POINTER(GPOINTER_TO_INT(d_pix) + (j * d_rowstride));
|
|
1194
|
-
dp = d_pix + ((d_height - i - 1) * d_rowstride);
|
|
1195
|
-
for (i = 0; i < MIN(size, d_width); i++) {
|
|
1196
|
-
dp[3] = (dp[3] * i) / size; /* alpha */
|
|
1197
|
-
dp += pix_width;
|
|
1198
|
-
}
|
|
1199
|
-
|
|
1200
|
-
dp = d_pix + (j * d_rowstride) + (pix_width * d_width);
|
|
1201
|
-
for (i = 0; i < MIN(size, d_width); i++) {
|
|
1202
|
-
dp[3] = (dp[3] * i) / size; /* alpha */
|
|
1203
|
-
dp -= pix_width;
|
|
1204
|
-
}
|
|
1205
|
-
}
|
|
101
|
+
#ifndef IGNORE
|
|
102
|
+
#define IGNORE(x) x=x
|
|
103
|
+
#endif
|
|
1206
104
|
|
|
1207
|
-
|
|
1208
|
-
|
|
105
|
+
#include <unistd.h>
|
|
106
|
+
#include <math.h>
|
|
1209
107
|
|
|
108
|
+
#include "extract-alpha.h"
|
|
109
|
+
#include "blur.h"
|
|
110
|
+
#include "sharpen.h"
|
|
111
|
+
#include "greyscale.h"
|
|
112
|
+
#include "rotate.h"
|
|
113
|
+
#include "tiff.h"
|
|
114
|
+
#include "gamma.h"
|
|
115
|
+
#include "mask.h"
|
|
116
|
+
#include "blend5050.h"
|
|
117
|
+
#include "tint.h"
|
|
118
|
+
#include "soften-edges.h"
|
|
119
|
+
#include "histogram.h"
|
|
120
|
+
#include "auto-equalize.h"
|
|
121
|
+
#include "filter.h"
|
|
1210
122
|
|
|
1211
123
|
|
|
1212
124
|
/*
|
|
1213
|
-
GdkPixbuf *pixbuf_op(GdkPixbuf *src, GdkPixbuf *dest,
|
|
125
|
+
GdkPixbuf *pixbuf_op(GdkPixbuf *src, GdkPixbuf *dest,
|
|
1214
126
|
*/
|
|
1215
127
|
|
|
1216
128
|
static GdkPixbuf *pixbuf_perspect_v(GdkPixbuf *src, int top_x1, int top_x2, int bot_x1, int bot_x2)
|
|
@@ -1230,65 +142,65 @@ static GdkPixbuf *pixbuf_perspect_v(GdkPixbuf *src, int top_x1, int top_x2, int
|
|
|
1230
142
|
double row_offset2, row_end2;
|
|
1231
143
|
double left_theta, right_theta;
|
|
1232
144
|
pixel_t spx[3];
|
|
1233
|
-
double ex;
|
|
1234
|
-
|
|
145
|
+
double ex;
|
|
146
|
+
|
|
1235
147
|
s_width = gdk_pixbuf_get_width(src);
|
|
1236
148
|
s_height = gdk_pixbuf_get_height(src);
|
|
1237
149
|
has_alpha = gdk_pixbuf_get_has_alpha(src);
|
|
1238
150
|
s_rowstride = gdk_pixbuf_get_rowstride(src);
|
|
1239
151
|
s_pix = gdk_pixbuf_get_pixels(src);
|
|
1240
|
-
|
|
1241
|
-
|
|
152
|
+
|
|
153
|
+
|
|
1242
154
|
g_return_val_if_fail((top_x2 - top_x1) <= s_width, NULL);
|
|
1243
155
|
g_return_val_if_fail((bot_x2 - bot_x1) <= s_width, NULL);
|
|
1244
|
-
|
|
156
|
+
|
|
1245
157
|
d_width = s_width;
|
|
1246
158
|
d_height = s_height;
|
|
1247
159
|
dest = gdk_pixbuf_new(GDK_COLORSPACE_RGB, TRUE, 8, d_width, d_height);
|
|
1248
160
|
d_rowstride = gdk_pixbuf_get_rowstride(dest);
|
|
1249
161
|
d_pix = gdk_pixbuf_get_pixels(dest);
|
|
1250
|
-
|
|
162
|
+
|
|
1251
163
|
// Shortcut ... should be harmless?
|
|
1252
164
|
// We should really only touch info
|
|
1253
165
|
// Within the range d_pix + (d_rowstride * y) + ((has_alpha ? 4 : 3) * x)
|
|
1254
166
|
bzero(d_pix, (d_rowstride * d_height));
|
|
1255
|
-
|
|
167
|
+
|
|
1256
168
|
top_width = top_x2 - top_x1;
|
|
1257
169
|
bot_width = bot_x2 - bot_x1;
|
|
1258
|
-
|
|
170
|
+
|
|
1259
171
|
min_x = MIN(top_x1, bot_x1);
|
|
1260
172
|
max_x = MAX(top_x2, bot_x2);
|
|
1261
|
-
|
|
173
|
+
|
|
1262
174
|
s_channels = has_alpha ? 4 : 3;
|
|
1263
175
|
channels = 4;
|
|
1264
|
-
|
|
176
|
+
|
|
1265
177
|
left_theta = ((double)(min_x == bot_x1 ? top_x1 : bot_x1) - min_x) / (double)d_height;
|
|
1266
178
|
right_theta = ((double)max_x - ((max_x == bot_x2) ? top_x2 : bot_x2)) / (double)d_height;
|
|
1267
|
-
|
|
1268
|
-
|
|
179
|
+
|
|
180
|
+
|
|
1269
181
|
for (y = 0; y < d_height; y++) {
|
|
1270
182
|
sp = s_pix + (y * s_rowstride);
|
|
1271
|
-
|
|
183
|
+
|
|
1272
184
|
row_offset = min_x;
|
|
1273
185
|
row_end = max_x;
|
|
1274
|
-
|
|
186
|
+
|
|
1275
187
|
row_offset2 = min_x;
|
|
1276
188
|
row_end2 = max_x;
|
|
1277
|
-
|
|
189
|
+
|
|
1278
190
|
row_offset += (left_theta * ((min_x == bot_x1) ? (d_height - y - 1) : y));
|
|
1279
191
|
row_end -= (right_theta * ((max_x == bot_x2) ? (d_height - y - 1) : y));
|
|
1280
|
-
|
|
192
|
+
|
|
1281
193
|
row_offset2 += (left_theta * ((min_x == bot_x1) ? (d_height - y) : y+1));
|
|
1282
194
|
row_end2 -= (right_theta * ((max_x == bot_x2) ? (d_height - y) : y+1));
|
|
1283
|
-
|
|
195
|
+
|
|
1284
196
|
row_width = ceil(row_end) - floor(row_offset);
|
|
1285
|
-
|
|
197
|
+
|
|
1286
198
|
dp = d_pix + (y * d_rowstride) + ((int)floor(row_offset) * channels);
|
|
1287
|
-
|
|
199
|
+
|
|
1288
200
|
for (x = (int)floor(row_offset); x < (int)ceil(row_end); x++)
|
|
1289
201
|
{
|
|
1290
202
|
ex = x - floor(row_offset);
|
|
1291
|
-
|
|
203
|
+
|
|
1292
204
|
if ((x < ceil(row_offset)))
|
|
1293
205
|
{
|
|
1294
206
|
alpha = ((int) ((double)255 * (ceil(row_offset) - row_offset)));
|
|
@@ -1303,11 +215,11 @@ static GdkPixbuf *pixbuf_perspect_v(GdkPixbuf *src, int top_x1, int top_x2, int
|
|
|
1303
215
|
{
|
|
1304
216
|
alpha = 0xff;
|
|
1305
217
|
}
|
|
1306
|
-
|
|
218
|
+
|
|
1307
219
|
spx[0] = PIXEL(sp, s_channels, (int)floor(((ex - 1) * (double)s_width) / (double)row_width));
|
|
1308
220
|
spx[1] = PIXEL(sp, s_channels, (int)floor((ex * (double)s_width) / (double)row_width));
|
|
1309
221
|
spx[2] = PIXEL(sp, s_channels, (int)floor(((ex + 1) * (double)s_width) / (double)row_width));
|
|
1310
|
-
|
|
222
|
+
|
|
1311
223
|
*(dp++) = ((spx[1]->r * 14) + ((spx[0]->r + spx[2]->r))) >> 4; /* red */
|
|
1312
224
|
*(dp++) = ((spx[1]->g * 14) + ((spx[0]->g + spx[2]->g))) >> 4; /* green */
|
|
1313
225
|
*(dp++) = ((spx[1]->b * 14) + ((spx[0]->b + spx[2]->b))) >> 4; /* blue */
|
|
@@ -1316,9 +228,9 @@ static GdkPixbuf *pixbuf_perspect_v(GdkPixbuf *src, int top_x1, int top_x2, int
|
|
|
1316
228
|
else
|
|
1317
229
|
*(dp++) = alpha; /* alpha */
|
|
1318
230
|
}
|
|
1319
|
-
|
|
231
|
+
|
|
1320
232
|
}
|
|
1321
|
-
|
|
233
|
+
|
|
1322
234
|
return dest;
|
|
1323
235
|
}
|
|
1324
236
|
|
|
@@ -1330,27 +242,27 @@ static VALUE pixbuf_mask_area(GdkPixbuf *mask, double cutoff)
|
|
|
1330
242
|
guchar *m_pix, *mp;
|
|
1331
243
|
long int y, x;
|
|
1332
244
|
long pix_width;
|
|
1333
|
-
volatile
|
|
245
|
+
volatile
|
|
1334
246
|
double grey;
|
|
1335
|
-
|
|
247
|
+
|
|
1336
248
|
g_return_val_if_fail(mask != NULL, Qnil);
|
|
1337
|
-
|
|
249
|
+
|
|
1338
250
|
m_width = gdk_pixbuf_get_width(mask);
|
|
1339
251
|
m_height = gdk_pixbuf_get_height(mask);
|
|
1340
252
|
m_has_alpha = gdk_pixbuf_get_has_alpha(mask);
|
|
1341
253
|
m_rowstride = gdk_pixbuf_get_rowstride(mask);
|
|
1342
254
|
m_pix = gdk_pixbuf_get_pixels(mask);
|
|
1343
|
-
|
|
255
|
+
|
|
1344
256
|
pix_width = (m_has_alpha ? 4 : 3);
|
|
1345
257
|
|
|
1346
|
-
|
|
258
|
+
|
|
1347
259
|
x1 = m_width;
|
|
1348
260
|
y1 = m_height;
|
|
1349
|
-
|
|
261
|
+
|
|
1350
262
|
for (y = 0; y < m_height; y++)
|
|
1351
263
|
{
|
|
1352
264
|
mp = m_pix;
|
|
1353
|
-
for (x = 0; x < m_width; x++)
|
|
265
|
+
for (x = 0; x < m_width; x++)
|
|
1354
266
|
{
|
|
1355
267
|
grey = GIMP_RGB_TO_GREY(mp[0], mp[1], mp[2]);
|
|
1356
268
|
if (grey < cutoff)// ie. darker than cutoff
|
|
@@ -1365,7 +277,7 @@ static VALUE pixbuf_mask_area(GdkPixbuf *mask, double cutoff)
|
|
|
1365
277
|
x0 = MIN(x0, x);
|
|
1366
278
|
x1 = MAX(x1, x);
|
|
1367
279
|
}
|
|
1368
|
-
|
|
280
|
+
|
|
1369
281
|
if (y0 == 0)
|
|
1370
282
|
{
|
|
1371
283
|
y0 = MAX(y0, y);
|
|
@@ -1377,39 +289,39 @@ static VALUE pixbuf_mask_area(GdkPixbuf *mask, double cutoff)
|
|
|
1377
289
|
y1 = MAX(y1, y);
|
|
1378
290
|
}
|
|
1379
291
|
}
|
|
1380
|
-
|
|
292
|
+
|
|
1381
293
|
mp += pix_width;
|
|
1382
294
|
}
|
|
1383
295
|
m_pix += m_rowstride;
|
|
1384
296
|
}
|
|
1385
|
-
|
|
297
|
+
|
|
1386
298
|
return rb_ary_new3(4, INT2NUM(x0), INT2NUM(y0), INT2NUM(x1), INT2NUM(y1));
|
|
1387
299
|
}
|
|
1388
300
|
|
|
1389
|
-
static inline VALUE
|
|
301
|
+
static inline VALUE
|
|
1390
302
|
unref_pixbuf(GdkPixbuf *pixbuf)
|
|
1391
303
|
{
|
|
1392
304
|
volatile VALUE pb = Qnil;
|
|
1393
|
-
|
|
305
|
+
|
|
1394
306
|
pb = GOBJ2RVAL(pixbuf);
|
|
1395
|
-
|
|
307
|
+
|
|
1396
308
|
g_object_unref(pixbuf);
|
|
1397
|
-
|
|
309
|
+
|
|
1398
310
|
return pb;
|
|
1399
311
|
}
|
|
1400
312
|
|
|
1401
313
|
|
|
1402
314
|
/* Code */
|
|
1403
315
|
static VALUE
|
|
1404
|
-
PixbufUtils_CLASS_remove_alpha(VALUE self, VALUE __v_src, VALUE __v_col)
|
|
316
|
+
PixbufUtils_CLASS_remove_alpha(VALUE self OPTIONAL_ATTR , VALUE __v_src OPTIONAL_ATTR, VALUE __v_col OPTIONAL_ATTR)
|
|
1405
317
|
{
|
|
1406
|
-
VALUE __p_retval = Qnil;
|
|
318
|
+
VALUE __p_retval OPTIONAL_ATTR = Qnil;
|
|
1407
319
|
GdkPixbuf * src; GdkPixbuf * __orig_src;
|
|
1408
320
|
GdkColor * col; GdkColor * __orig_col;
|
|
1409
321
|
__orig_src = src = GDK_PIXBUF(RVAL2GOBJ(__v_src));
|
|
1410
322
|
__orig_col = col = RVAL2BOXED(__v_col, GDK_TYPE_COLOR);
|
|
1411
323
|
|
|
1412
|
-
#line
|
|
324
|
+
#line 259 "/home/geoff/Projects/pixbufutils/ext/pixbufutils/pixbufutils.cr"
|
|
1413
325
|
|
|
1414
326
|
do {
|
|
1415
327
|
GdkPixbuf * dest ;
|
|
@@ -1433,15 +345,15 @@ out:
|
|
|
1433
345
|
}
|
|
1434
346
|
|
|
1435
347
|
static VALUE
|
|
1436
|
-
PixbufUtils_CLASS_sharpen(VALUE self, VALUE __v_src, VALUE __v_radius)
|
|
348
|
+
PixbufUtils_CLASS_sharpen(VALUE self OPTIONAL_ATTR , VALUE __v_src OPTIONAL_ATTR, VALUE __v_radius OPTIONAL_ATTR)
|
|
1437
349
|
{
|
|
1438
|
-
VALUE __p_retval = Qnil;
|
|
350
|
+
VALUE __p_retval OPTIONAL_ATTR = Qnil;
|
|
1439
351
|
GdkPixbuf * src; GdkPixbuf * __orig_src;
|
|
1440
352
|
int radius; int __orig_radius;
|
|
1441
353
|
__orig_src = src = GDK_PIXBUF(RVAL2GOBJ(__v_src));
|
|
1442
354
|
__orig_radius = radius = NUM2INT(__v_radius);
|
|
1443
355
|
|
|
1444
|
-
#line
|
|
356
|
+
#line 280 "/home/geoff/Projects/pixbufutils/ext/pixbufutils/pixbufutils.cr"
|
|
1445
357
|
IGNORE(self);
|
|
1446
358
|
do { __p_retval = unref_pixbuf((pixbuf_sharpen(src, radius))); goto out; } while(0);
|
|
1447
359
|
out:
|
|
@@ -1452,7 +364,7 @@ out:
|
|
|
1452
364
|
static VALUE
|
|
1453
365
|
PixbufUtils_CLASS_extract_alpha(int __p_argc, VALUE *__p_argv, VALUE self)
|
|
1454
366
|
{
|
|
1455
|
-
VALUE __p_retval = Qnil;
|
|
367
|
+
VALUE __p_retval OPTIONAL_ATTR = Qnil;
|
|
1456
368
|
VALUE __v_src = Qnil;
|
|
1457
369
|
GdkPixbuf * src; GdkPixbuf * __orig_src;
|
|
1458
370
|
VALUE __v_cutoff = Qnil;
|
|
@@ -1477,7 +389,7 @@ PixbufUtils_CLASS_extract_alpha(int __p_argc, VALUE *__p_argv, VALUE self)
|
|
|
1477
389
|
force_2bit = FALSE;
|
|
1478
390
|
|
|
1479
391
|
|
|
1480
|
-
#line
|
|
392
|
+
#line 284 "/home/geoff/Projects/pixbufutils/ext/pixbufutils/pixbufutils.cr"
|
|
1481
393
|
IGNORE(self);
|
|
1482
394
|
do { __p_retval = unref_pixbuf((pixbuf_extract_alpha(src, cutoff, force_2bit))); goto out; } while(0);
|
|
1483
395
|
out:
|
|
@@ -1486,15 +398,15 @@ out:
|
|
|
1486
398
|
}
|
|
1487
399
|
|
|
1488
400
|
static VALUE
|
|
1489
|
-
PixbufUtils_CLASS_blur(VALUE self, VALUE __v_src, VALUE __v_radius)
|
|
401
|
+
PixbufUtils_CLASS_blur(VALUE self OPTIONAL_ATTR , VALUE __v_src OPTIONAL_ATTR, VALUE __v_radius OPTIONAL_ATTR)
|
|
1490
402
|
{
|
|
1491
|
-
VALUE __p_retval = Qnil;
|
|
403
|
+
VALUE __p_retval OPTIONAL_ATTR = Qnil;
|
|
1492
404
|
GdkPixbuf * src; GdkPixbuf * __orig_src;
|
|
1493
405
|
int radius; int __orig_radius;
|
|
1494
406
|
__orig_src = src = GDK_PIXBUF(RVAL2GOBJ(__v_src));
|
|
1495
407
|
__orig_radius = radius = NUM2INT(__v_radius);
|
|
1496
408
|
|
|
1497
|
-
#line
|
|
409
|
+
#line 288 "/home/geoff/Projects/pixbufutils/ext/pixbufutils/pixbufutils.cr"
|
|
1498
410
|
IGNORE(self);
|
|
1499
411
|
do { __p_retval = unref_pixbuf((pixbuf_blur(gdk_pixbuf_copy(src), radius))); goto out; } while(0);
|
|
1500
412
|
out:
|
|
@@ -1503,15 +415,114 @@ out:
|
|
|
1503
415
|
}
|
|
1504
416
|
|
|
1505
417
|
static VALUE
|
|
1506
|
-
|
|
418
|
+
PixbufUtils_CLASS_contrast(VALUE self OPTIONAL_ATTR , VALUE __v_src OPTIONAL_ATTR, VALUE __v_adjust OPTIONAL_ATTR)
|
|
419
|
+
{
|
|
420
|
+
VALUE __p_retval OPTIONAL_ATTR = Qnil;
|
|
421
|
+
GdkPixbuf * src; GdkPixbuf * __orig_src;
|
|
422
|
+
int adjust; int __orig_adjust;
|
|
423
|
+
__orig_src = src = GDK_PIXBUF(RVAL2GOBJ(__v_src));
|
|
424
|
+
__orig_adjust = adjust = NUM2INT(__v_adjust);
|
|
425
|
+
|
|
426
|
+
#line 292 "/home/geoff/Projects/pixbufutils/ext/pixbufutils/pixbufutils.cr"
|
|
427
|
+
IGNORE(self);
|
|
428
|
+
do { __p_retval = unref_pixbuf((pixbuf_adjust_contrast(src, gdk_pixbuf_copy(src), adjust))); goto out; } while(0);
|
|
429
|
+
out:
|
|
430
|
+
;
|
|
431
|
+
return __p_retval;
|
|
432
|
+
}
|
|
433
|
+
|
|
434
|
+
static VALUE
|
|
435
|
+
PixbufUtils_CLASS_vibrance(VALUE self OPTIONAL_ATTR , VALUE __v_src OPTIONAL_ATTR, VALUE __v_adjust OPTIONAL_ATTR)
|
|
1507
436
|
{
|
|
1508
|
-
VALUE __p_retval = Qnil;
|
|
437
|
+
VALUE __p_retval OPTIONAL_ATTR = Qnil;
|
|
438
|
+
GdkPixbuf * src; GdkPixbuf * __orig_src;
|
|
439
|
+
int adjust; int __orig_adjust;
|
|
440
|
+
__orig_src = src = GDK_PIXBUF(RVAL2GOBJ(__v_src));
|
|
441
|
+
__orig_adjust = adjust = NUM2INT(__v_adjust);
|
|
442
|
+
|
|
443
|
+
#line 296 "/home/geoff/Projects/pixbufutils/ext/pixbufutils/pixbufutils.cr"
|
|
444
|
+
IGNORE(self);
|
|
445
|
+
do { __p_retval = unref_pixbuf((pixbuf_adjust_vibrance(src, gdk_pixbuf_copy(src), adjust))); goto out; } while(0);
|
|
446
|
+
out:
|
|
447
|
+
;
|
|
448
|
+
return __p_retval;
|
|
449
|
+
}
|
|
450
|
+
|
|
451
|
+
static VALUE
|
|
452
|
+
PixbufUtils_CLASS_saturation(VALUE self OPTIONAL_ATTR , VALUE __v_src OPTIONAL_ATTR, VALUE __v_adjust OPTIONAL_ATTR)
|
|
453
|
+
{
|
|
454
|
+
VALUE __p_retval OPTIONAL_ATTR = Qnil;
|
|
455
|
+
GdkPixbuf * src; GdkPixbuf * __orig_src;
|
|
456
|
+
int adjust; int __orig_adjust;
|
|
457
|
+
__orig_src = src = GDK_PIXBUF(RVAL2GOBJ(__v_src));
|
|
458
|
+
__orig_adjust = adjust = NUM2INT(__v_adjust);
|
|
459
|
+
|
|
460
|
+
#line 300 "/home/geoff/Projects/pixbufutils/ext/pixbufutils/pixbufutils.cr"
|
|
461
|
+
IGNORE(self);
|
|
462
|
+
do { __p_retval = unref_pixbuf((pixbuf_adjust_saturation(src, gdk_pixbuf_copy(src), adjust))); goto out; } while(0);
|
|
463
|
+
out:
|
|
464
|
+
;
|
|
465
|
+
return __p_retval;
|
|
466
|
+
}
|
|
467
|
+
|
|
468
|
+
static VALUE
|
|
469
|
+
PixbufUtils_CLASS_brightness(VALUE self OPTIONAL_ATTR , VALUE __v_src OPTIONAL_ATTR, VALUE __v_adjust OPTIONAL_ATTR)
|
|
470
|
+
{
|
|
471
|
+
VALUE __p_retval OPTIONAL_ATTR = Qnil;
|
|
472
|
+
GdkPixbuf * src; GdkPixbuf * __orig_src;
|
|
473
|
+
int adjust; int __orig_adjust;
|
|
474
|
+
__orig_src = src = GDK_PIXBUF(RVAL2GOBJ(__v_src));
|
|
475
|
+
__orig_adjust = adjust = NUM2INT(__v_adjust);
|
|
476
|
+
|
|
477
|
+
#line 304 "/home/geoff/Projects/pixbufutils/ext/pixbufutils/pixbufutils.cr"
|
|
478
|
+
IGNORE(self);
|
|
479
|
+
do { __p_retval = unref_pixbuf((pixbuf_adjust_brightness(src, gdk_pixbuf_copy(src), adjust))); goto out; } while(0);
|
|
480
|
+
out:
|
|
481
|
+
;
|
|
482
|
+
return __p_retval;
|
|
483
|
+
}
|
|
484
|
+
|
|
485
|
+
static VALUE
|
|
486
|
+
PixbufUtils_CLASS_filter(VALUE self OPTIONAL_ATTR , VALUE __v_src OPTIONAL_ATTR, VALUE filter OPTIONAL_ATTR, VALUE __v_divisor OPTIONAL_ATTR)
|
|
487
|
+
{
|
|
488
|
+
VALUE __p_retval OPTIONAL_ATTR = Qnil;
|
|
489
|
+
GdkPixbuf * src; GdkPixbuf * __orig_src;
|
|
490
|
+
double divisor; double __orig_divisor;
|
|
491
|
+
__orig_src = src = GDK_PIXBUF(RVAL2GOBJ(__v_src));
|
|
492
|
+
Check_Type(filter, T_ARRAY);
|
|
493
|
+
__orig_divisor = divisor = NUM2DBL(__v_divisor);
|
|
494
|
+
|
|
495
|
+
#line 308 "/home/geoff/Projects/pixbufutils/ext/pixbufutils/pixbufutils.cr"
|
|
496
|
+
|
|
497
|
+
do {
|
|
498
|
+
int matrix_size = RARRAY_LEN(filter), len, i;
|
|
499
|
+
double * matrix ;
|
|
500
|
+
IGNORE(self);
|
|
501
|
+
len = (int) sqrt((double)matrix_size);
|
|
502
|
+
if ((len * len) != matrix_size) { rb_raise(rb_eArgError, "Invalid matrix size - sqrt(%i)*sqrt(%i) != %i", matrix_size, matrix_size, matrix_size);
|
|
503
|
+
} matrix = ALLOCA_N(double, matrix_size);
|
|
504
|
+
for (i = 0;
|
|
505
|
+
i < matrix_size;
|
|
506
|
+
i ++) { matrix[i] = NUM2DBL(RARRAY_PTR(filter)[i]);
|
|
507
|
+
} do { __p_retval = unref_pixbuf((pixbuf_convolution_matrix(src, gdk_pixbuf_copy(src), len, matrix, divisor))); goto out; } while(0);
|
|
508
|
+
|
|
509
|
+
} while(0);
|
|
510
|
+
|
|
511
|
+
out:
|
|
512
|
+
;
|
|
513
|
+
return __p_retval;
|
|
514
|
+
}
|
|
515
|
+
|
|
516
|
+
static VALUE
|
|
517
|
+
PixbufUtils_CLASS_rotate_90(VALUE self OPTIONAL_ATTR , VALUE __v_src OPTIONAL_ATTR, VALUE __v_counter_clockwise OPTIONAL_ATTR)
|
|
518
|
+
{
|
|
519
|
+
VALUE __p_retval OPTIONAL_ATTR = Qnil;
|
|
1509
520
|
GdkPixbuf * src; GdkPixbuf * __orig_src;
|
|
1510
521
|
bool counter_clockwise; bool __orig_counter_clockwise;
|
|
1511
522
|
__orig_src = src = GDK_PIXBUF(RVAL2GOBJ(__v_src));
|
|
1512
523
|
__orig_counter_clockwise = counter_clockwise = RTEST(__v_counter_clockwise);
|
|
1513
524
|
|
|
1514
|
-
#line
|
|
525
|
+
#line 326 "/home/geoff/Projects/pixbufutils/ext/pixbufutils/pixbufutils.cr"
|
|
1515
526
|
IGNORE(self);
|
|
1516
527
|
do { __p_retval = unref_pixbuf((pixbuf_rotate(src, counter_clockwise ? ANGLE_270 : ANGLE_90))); goto out; } while(0);
|
|
1517
528
|
out:
|
|
@@ -1520,13 +531,13 @@ out:
|
|
|
1520
531
|
}
|
|
1521
532
|
|
|
1522
533
|
static VALUE
|
|
1523
|
-
PixbufUtils_CLASS_rotate_cw(VALUE self, VALUE __v_src)
|
|
534
|
+
PixbufUtils_CLASS_rotate_cw(VALUE self OPTIONAL_ATTR , VALUE __v_src OPTIONAL_ATTR)
|
|
1524
535
|
{
|
|
1525
|
-
VALUE __p_retval = Qnil;
|
|
536
|
+
VALUE __p_retval OPTIONAL_ATTR = Qnil;
|
|
1526
537
|
GdkPixbuf * src; GdkPixbuf * __orig_src;
|
|
1527
538
|
__orig_src = src = GDK_PIXBUF(RVAL2GOBJ(__v_src));
|
|
1528
539
|
|
|
1529
|
-
#line
|
|
540
|
+
#line 330 "/home/geoff/Projects/pixbufutils/ext/pixbufutils/pixbufutils.cr"
|
|
1530
541
|
IGNORE(self);
|
|
1531
542
|
do { __p_retval = unref_pixbuf((pixbuf_rotate(src, ANGLE_90))); goto out; } while(0);
|
|
1532
543
|
out:
|
|
@@ -1535,13 +546,13 @@ out:
|
|
|
1535
546
|
}
|
|
1536
547
|
|
|
1537
548
|
static VALUE
|
|
1538
|
-
PixbufUtils_CLASS_rotate_180(VALUE self, VALUE __v_src)
|
|
549
|
+
PixbufUtils_CLASS_rotate_180(VALUE self OPTIONAL_ATTR , VALUE __v_src OPTIONAL_ATTR)
|
|
1539
550
|
{
|
|
1540
|
-
VALUE __p_retval = Qnil;
|
|
551
|
+
VALUE __p_retval OPTIONAL_ATTR = Qnil;
|
|
1541
552
|
GdkPixbuf * src; GdkPixbuf * __orig_src;
|
|
1542
553
|
__orig_src = src = GDK_PIXBUF(RVAL2GOBJ(__v_src));
|
|
1543
554
|
|
|
1544
|
-
#line
|
|
555
|
+
#line 334 "/home/geoff/Projects/pixbufutils/ext/pixbufutils/pixbufutils.cr"
|
|
1545
556
|
IGNORE(self);
|
|
1546
557
|
do { __p_retval = unref_pixbuf((pixbuf_rotate(src, ANGLE_180))); goto out; } while(0);
|
|
1547
558
|
out:
|
|
@@ -1550,15 +561,15 @@ out:
|
|
|
1550
561
|
}
|
|
1551
562
|
|
|
1552
563
|
static VALUE
|
|
1553
|
-
PixbufUtils_CLASS_rotate(VALUE self, VALUE __v_src, VALUE __v_angle)
|
|
564
|
+
PixbufUtils_CLASS_rotate(VALUE self OPTIONAL_ATTR , VALUE __v_src OPTIONAL_ATTR, VALUE __v_angle OPTIONAL_ATTR)
|
|
1554
565
|
{
|
|
1555
|
-
VALUE __p_retval = Qnil;
|
|
566
|
+
VALUE __p_retval OPTIONAL_ATTR = Qnil;
|
|
1556
567
|
GdkPixbuf * src; GdkPixbuf * __orig_src;
|
|
1557
568
|
int angle; int __orig_angle;
|
|
1558
569
|
__orig_src = src = GDK_PIXBUF(RVAL2GOBJ(__v_src));
|
|
1559
570
|
__orig_angle = angle = NUM2INT(__v_angle);
|
|
1560
571
|
|
|
1561
|
-
#line
|
|
572
|
+
#line 338 "/home/geoff/Projects/pixbufutils/ext/pixbufutils/pixbufutils.cr"
|
|
1562
573
|
IGNORE(self);
|
|
1563
574
|
g_assert(angle == 0 || angle == 90 || angle == 180 || angle == 270);
|
|
1564
575
|
do { __p_retval = unref_pixbuf((pixbuf_rotate(src, (rotate_angle_t)angle))); goto out; } while(0);
|
|
@@ -1568,13 +579,13 @@ out:
|
|
|
1568
579
|
}
|
|
1569
580
|
|
|
1570
581
|
static VALUE
|
|
1571
|
-
PixbufUtils_CLASS_rotate_ccw(VALUE self, VALUE __v_src)
|
|
582
|
+
PixbufUtils_CLASS_rotate_ccw(VALUE self OPTIONAL_ATTR , VALUE __v_src OPTIONAL_ATTR)
|
|
1572
583
|
{
|
|
1573
|
-
VALUE __p_retval = Qnil;
|
|
584
|
+
VALUE __p_retval OPTIONAL_ATTR = Qnil;
|
|
1574
585
|
GdkPixbuf * src; GdkPixbuf * __orig_src;
|
|
1575
586
|
__orig_src = src = GDK_PIXBUF(RVAL2GOBJ(__v_src));
|
|
1576
587
|
|
|
1577
|
-
#line
|
|
588
|
+
#line 343 "/home/geoff/Projects/pixbufutils/ext/pixbufutils/pixbufutils.cr"
|
|
1578
589
|
IGNORE(self);
|
|
1579
590
|
do { __p_retval = unref_pixbuf((pixbuf_rotate(src, ANGLE_270))); goto out; } while(0);
|
|
1580
591
|
out:
|
|
@@ -1583,15 +594,15 @@ out:
|
|
|
1583
594
|
}
|
|
1584
595
|
|
|
1585
596
|
static VALUE
|
|
1586
|
-
PixbufUtils_CLASS_gamma_pling(VALUE self, VALUE __v_src, VALUE __v_level)
|
|
597
|
+
PixbufUtils_CLASS_gamma_pling(VALUE self OPTIONAL_ATTR , VALUE __v_src OPTIONAL_ATTR, VALUE __v_level OPTIONAL_ATTR)
|
|
1587
598
|
{
|
|
1588
|
-
VALUE __p_retval = Qnil;
|
|
599
|
+
VALUE __p_retval OPTIONAL_ATTR = Qnil;
|
|
1589
600
|
GdkPixbuf * src; GdkPixbuf * __orig_src;
|
|
1590
601
|
double level; double __orig_level;
|
|
1591
602
|
__orig_src = src = GDK_PIXBUF(RVAL2GOBJ(__v_src));
|
|
1592
603
|
__orig_level = level = NUM2DBL(__v_level);
|
|
1593
604
|
|
|
1594
|
-
#line
|
|
605
|
+
#line 347 "/home/geoff/Projects/pixbufutils/ext/pixbufutils/pixbufutils.cr"
|
|
1595
606
|
IGNORE(self);
|
|
1596
607
|
do { __p_retval = GOBJ2RVAL(pixbuf_gamma(src, src, level)); goto out; } while(0);
|
|
1597
608
|
out:
|
|
@@ -1600,15 +611,15 @@ out:
|
|
|
1600
611
|
}
|
|
1601
612
|
|
|
1602
613
|
static VALUE
|
|
1603
|
-
PixbufUtils_CLASS_soften_edges_pling(VALUE self, VALUE __v_src, VALUE __v_size)
|
|
614
|
+
PixbufUtils_CLASS_soften_edges_pling(VALUE self OPTIONAL_ATTR , VALUE __v_src OPTIONAL_ATTR, VALUE __v_size OPTIONAL_ATTR)
|
|
1604
615
|
{
|
|
1605
|
-
VALUE __p_retval = Qnil;
|
|
616
|
+
VALUE __p_retval OPTIONAL_ATTR = Qnil;
|
|
1606
617
|
GdkPixbuf * src; GdkPixbuf * __orig_src;
|
|
1607
618
|
int size; int __orig_size;
|
|
1608
619
|
__orig_src = src = GDK_PIXBUF(RVAL2GOBJ(__v_src));
|
|
1609
620
|
__orig_size = size = NUM2INT(__v_size);
|
|
1610
621
|
|
|
1611
|
-
#line
|
|
622
|
+
#line 351 "/home/geoff/Projects/pixbufutils/ext/pixbufutils/pixbufutils.cr"
|
|
1612
623
|
IGNORE(self);
|
|
1613
624
|
do { __p_retval = GOBJ2RVAL(pixbuf_soften_edges(src, size)); goto out; } while(0);
|
|
1614
625
|
out:
|
|
@@ -1617,15 +628,15 @@ out:
|
|
|
1617
628
|
}
|
|
1618
629
|
|
|
1619
630
|
static VALUE
|
|
1620
|
-
PixbufUtils_CLASS_gamma(VALUE self, VALUE __v_src, VALUE __v_level)
|
|
631
|
+
PixbufUtils_CLASS_gamma(VALUE self OPTIONAL_ATTR , VALUE __v_src OPTIONAL_ATTR, VALUE __v_level OPTIONAL_ATTR)
|
|
1621
632
|
{
|
|
1622
|
-
VALUE __p_retval = Qnil;
|
|
633
|
+
VALUE __p_retval OPTIONAL_ATTR = Qnil;
|
|
1623
634
|
GdkPixbuf * src; GdkPixbuf * __orig_src;
|
|
1624
635
|
double level; double __orig_level;
|
|
1625
636
|
__orig_src = src = GDK_PIXBUF(RVAL2GOBJ(__v_src));
|
|
1626
637
|
__orig_level = level = NUM2DBL(__v_level);
|
|
1627
638
|
|
|
1628
|
-
#line
|
|
639
|
+
#line 355 "/home/geoff/Projects/pixbufutils/ext/pixbufutils/pixbufutils.cr"
|
|
1629
640
|
IGNORE(self);
|
|
1630
641
|
do { __p_retval = unref_pixbuf((pixbuf_gamma(src, gdk_pixbuf_copy(src), level))); goto out; } while(0);
|
|
1631
642
|
out:
|
|
@@ -1634,13 +645,13 @@ out:
|
|
|
1634
645
|
}
|
|
1635
646
|
|
|
1636
647
|
static VALUE
|
|
1637
|
-
PixbufUtils_CLASS_greyscale_pling(VALUE self, VALUE __v_src)
|
|
648
|
+
PixbufUtils_CLASS_greyscale_pling(VALUE self OPTIONAL_ATTR , VALUE __v_src OPTIONAL_ATTR)
|
|
1638
649
|
{
|
|
1639
|
-
VALUE __p_retval = Qnil;
|
|
650
|
+
VALUE __p_retval OPTIONAL_ATTR = Qnil;
|
|
1640
651
|
GdkPixbuf * src; GdkPixbuf * __orig_src;
|
|
1641
652
|
__orig_src = src = GDK_PIXBUF(RVAL2GOBJ(__v_src));
|
|
1642
653
|
|
|
1643
|
-
#line
|
|
654
|
+
#line 359 "/home/geoff/Projects/pixbufutils/ext/pixbufutils/pixbufutils.cr"
|
|
1644
655
|
IGNORE(self);
|
|
1645
656
|
do { __p_retval = GOBJ2RVAL(pixbuf_greyscale(src, src)); goto out; } while(0);
|
|
1646
657
|
out:
|
|
@@ -1649,15 +660,15 @@ out:
|
|
|
1649
660
|
}
|
|
1650
661
|
|
|
1651
662
|
static VALUE
|
|
1652
|
-
PixbufUtils_CLASS_to_tiff(VALUE self, VALUE __v_src, VALUE __v_filename)
|
|
663
|
+
PixbufUtils_CLASS_to_tiff(VALUE self OPTIONAL_ATTR , VALUE __v_src OPTIONAL_ATTR, VALUE __v_filename OPTIONAL_ATTR)
|
|
1653
664
|
{
|
|
1654
|
-
VALUE __p_retval = Qnil;
|
|
665
|
+
VALUE __p_retval OPTIONAL_ATTR = Qnil;
|
|
1655
666
|
GdkPixbuf * src; GdkPixbuf * __orig_src;
|
|
1656
667
|
char * filename; char * __orig_filename;
|
|
1657
668
|
__orig_src = src = GDK_PIXBUF(RVAL2GOBJ(__v_src));
|
|
1658
669
|
__orig_filename = filename = ( NIL_P(__v_filename) ? NULL : StringValuePtr(__v_filename) );
|
|
1659
670
|
|
|
1660
|
-
#line
|
|
671
|
+
#line 363 "/home/geoff/Projects/pixbufutils/ext/pixbufutils/pixbufutils.cr"
|
|
1661
672
|
IGNORE(self);
|
|
1662
673
|
do { __p_retval = ((pixbuf_save_tiff(src, filename)) ? Qtrue : Qfalse); goto out; } while(0);
|
|
1663
674
|
out:
|
|
@@ -1666,13 +677,13 @@ out:
|
|
|
1666
677
|
}
|
|
1667
678
|
|
|
1668
679
|
static VALUE
|
|
1669
|
-
PixbufUtils_CLASS_greyscale(VALUE self, VALUE __v_src)
|
|
680
|
+
PixbufUtils_CLASS_greyscale(VALUE self OPTIONAL_ATTR , VALUE __v_src OPTIONAL_ATTR)
|
|
1670
681
|
{
|
|
1671
|
-
VALUE __p_retval = Qnil;
|
|
682
|
+
VALUE __p_retval OPTIONAL_ATTR = Qnil;
|
|
1672
683
|
GdkPixbuf * src; GdkPixbuf * __orig_src;
|
|
1673
684
|
__orig_src = src = GDK_PIXBUF(RVAL2GOBJ(__v_src));
|
|
1674
685
|
|
|
1675
|
-
#line
|
|
686
|
+
#line 367 "/home/geoff/Projects/pixbufutils/ext/pixbufutils/pixbufutils.cr"
|
|
1676
687
|
IGNORE(self);
|
|
1677
688
|
do { __p_retval = unref_pixbuf((pixbuf_greyscale(src, gdk_pixbuf_copy(src)))); goto out; } while(0);
|
|
1678
689
|
out:
|
|
@@ -1681,13 +692,13 @@ out:
|
|
|
1681
692
|
}
|
|
1682
693
|
|
|
1683
694
|
static VALUE
|
|
1684
|
-
PixbufUtils_CLASS_greyscale_go_pling(VALUE self, VALUE __v_src)
|
|
695
|
+
PixbufUtils_CLASS_greyscale_go_pling(VALUE self OPTIONAL_ATTR , VALUE __v_src OPTIONAL_ATTR)
|
|
1685
696
|
{
|
|
1686
|
-
VALUE __p_retval = Qnil;
|
|
697
|
+
VALUE __p_retval OPTIONAL_ATTR = Qnil;
|
|
1687
698
|
GdkPixbuf * src; GdkPixbuf * __orig_src;
|
|
1688
699
|
__orig_src = src = GDK_PIXBUF(RVAL2GOBJ(__v_src));
|
|
1689
700
|
|
|
1690
|
-
#line
|
|
701
|
+
#line 371 "/home/geoff/Projects/pixbufutils/ext/pixbufutils/pixbufutils.cr"
|
|
1691
702
|
IGNORE(self);
|
|
1692
703
|
do { __p_retval = GOBJ2RVAL(pixbuf_greyscale_go(src, src)); goto out; } while(0);
|
|
1693
704
|
out:
|
|
@@ -1696,13 +707,13 @@ out:
|
|
|
1696
707
|
}
|
|
1697
708
|
|
|
1698
709
|
static VALUE
|
|
1699
|
-
PixbufUtils_CLASS_greyscale_go(VALUE self, VALUE __v_src)
|
|
710
|
+
PixbufUtils_CLASS_greyscale_go(VALUE self OPTIONAL_ATTR , VALUE __v_src OPTIONAL_ATTR)
|
|
1700
711
|
{
|
|
1701
|
-
VALUE __p_retval = Qnil;
|
|
712
|
+
VALUE __p_retval OPTIONAL_ATTR = Qnil;
|
|
1702
713
|
GdkPixbuf * src; GdkPixbuf * __orig_src;
|
|
1703
714
|
__orig_src = src = GDK_PIXBUF(RVAL2GOBJ(__v_src));
|
|
1704
715
|
|
|
1705
|
-
#line
|
|
716
|
+
#line 375 "/home/geoff/Projects/pixbufutils/ext/pixbufutils/pixbufutils.cr"
|
|
1706
717
|
IGNORE(self);
|
|
1707
718
|
do { __p_retval = unref_pixbuf((pixbuf_greyscale_go(src, gdk_pixbuf_copy(src)))); goto out; } while(0);
|
|
1708
719
|
out:
|
|
@@ -1713,7 +724,7 @@ out:
|
|
|
1713
724
|
static VALUE
|
|
1714
725
|
PixbufUtils_CLASS_tint(int __p_argc, VALUE *__p_argv, VALUE self)
|
|
1715
726
|
{
|
|
1716
|
-
VALUE __p_retval = Qnil;
|
|
727
|
+
VALUE __p_retval OPTIONAL_ATTR = Qnil;
|
|
1717
728
|
VALUE __v_src = Qnil;
|
|
1718
729
|
GdkPixbuf * src; GdkPixbuf * __orig_src;
|
|
1719
730
|
VALUE __v_r = Qnil;
|
|
@@ -1743,7 +754,7 @@ PixbufUtils_CLASS_tint(int __p_argc, VALUE *__p_argv, VALUE self)
|
|
|
1743
754
|
alpha = 255;
|
|
1744
755
|
|
|
1745
756
|
|
|
1746
|
-
#line
|
|
757
|
+
#line 379 "/home/geoff/Projects/pixbufutils/ext/pixbufutils/pixbufutils.cr"
|
|
1747
758
|
IGNORE(self);
|
|
1748
759
|
do { __p_retval = unref_pixbuf((pixbuf_tint(src, gdk_pixbuf_copy(src), r, g, b, alpha))); goto out; } while(0);
|
|
1749
760
|
out:
|
|
@@ -1752,9 +763,9 @@ out:
|
|
|
1752
763
|
}
|
|
1753
764
|
|
|
1754
765
|
static VALUE
|
|
1755
|
-
PixbufUtils_CLASS_perspect_v(VALUE self, VALUE __v_src, VALUE __v_top_x1, VALUE __v_top_x2, VALUE __v_bot_x1, VALUE __v_bot_x2)
|
|
766
|
+
PixbufUtils_CLASS_perspect_v(VALUE self OPTIONAL_ATTR , VALUE __v_src OPTIONAL_ATTR, VALUE __v_top_x1 OPTIONAL_ATTR, VALUE __v_top_x2 OPTIONAL_ATTR, VALUE __v_bot_x1 OPTIONAL_ATTR, VALUE __v_bot_x2 OPTIONAL_ATTR)
|
|
1756
767
|
{
|
|
1757
|
-
VALUE __p_retval = Qnil;
|
|
768
|
+
VALUE __p_retval OPTIONAL_ATTR = Qnil;
|
|
1758
769
|
GdkPixbuf * src; GdkPixbuf * __orig_src;
|
|
1759
770
|
int top_x1; int __orig_top_x1;
|
|
1760
771
|
int top_x2; int __orig_top_x2;
|
|
@@ -1766,7 +777,7 @@ PixbufUtils_CLASS_perspect_v(VALUE self, VALUE __v_src, VALUE __v_top_x1, VALUE
|
|
|
1766
777
|
__orig_bot_x1 = bot_x1 = NUM2INT(__v_bot_x1);
|
|
1767
778
|
__orig_bot_x2 = bot_x2 = NUM2INT(__v_bot_x2);
|
|
1768
779
|
|
|
1769
|
-
#line
|
|
780
|
+
#line 383 "/home/geoff/Projects/pixbufutils/ext/pixbufutils/pixbufutils.cr"
|
|
1770
781
|
IGNORE(self);
|
|
1771
782
|
do { __p_retval = unref_pixbuf((pixbuf_perspect_v(src, top_x1, top_x2, bot_x1, bot_x2))); goto out; } while(0);
|
|
1772
783
|
out:
|
|
@@ -1775,15 +786,15 @@ out:
|
|
|
1775
786
|
}
|
|
1776
787
|
|
|
1777
788
|
static VALUE
|
|
1778
|
-
PixbufUtils_CLASS_mask(VALUE self, VALUE __v_src, VALUE __v_mask)
|
|
789
|
+
PixbufUtils_CLASS_mask(VALUE self OPTIONAL_ATTR , VALUE __v_src OPTIONAL_ATTR, VALUE __v_mask OPTIONAL_ATTR)
|
|
1779
790
|
{
|
|
1780
|
-
VALUE __p_retval = Qnil;
|
|
791
|
+
VALUE __p_retval OPTIONAL_ATTR = Qnil;
|
|
1781
792
|
GdkPixbuf * src; GdkPixbuf * __orig_src;
|
|
1782
793
|
GdkPixbuf * mask; GdkPixbuf * __orig_mask;
|
|
1783
794
|
__orig_src = src = GDK_PIXBUF(RVAL2GOBJ(__v_src));
|
|
1784
795
|
__orig_mask = mask = GDK_PIXBUF(RVAL2GOBJ(__v_mask));
|
|
1785
796
|
|
|
1786
|
-
#line
|
|
797
|
+
#line 387 "/home/geoff/Projects/pixbufutils/ext/pixbufutils/pixbufutils.cr"
|
|
1787
798
|
IGNORE(self);
|
|
1788
799
|
do { __p_retval = unref_pixbuf((pixbuf_mask(src, mask))); goto out; } while(0);
|
|
1789
800
|
out:
|
|
@@ -1793,15 +804,30 @@ out:
|
|
|
1793
804
|
}
|
|
1794
805
|
|
|
1795
806
|
static VALUE
|
|
1796
|
-
|
|
807
|
+
PixbufUtils_CLASS_auto_equalize(VALUE self OPTIONAL_ATTR , VALUE __v_src OPTIONAL_ATTR)
|
|
808
|
+
{
|
|
809
|
+
VALUE __p_retval OPTIONAL_ATTR = Qnil;
|
|
810
|
+
GdkPixbuf * src; GdkPixbuf * __orig_src;
|
|
811
|
+
__orig_src = src = GDK_PIXBUF(RVAL2GOBJ(__v_src));
|
|
812
|
+
|
|
813
|
+
#line 391 "/home/geoff/Projects/pixbufutils/ext/pixbufutils/pixbufutils.cr"
|
|
814
|
+
IGNORE(self);
|
|
815
|
+
do { __p_retval = unref_pixbuf((auto_equalize(src, gdk_pixbuf_copy(src)))); goto out; } while(0);
|
|
816
|
+
out:
|
|
817
|
+
;
|
|
818
|
+
return __p_retval;
|
|
819
|
+
}
|
|
820
|
+
|
|
821
|
+
static VALUE
|
|
822
|
+
PixbufUtils_CLASS_blend5050(VALUE self OPTIONAL_ATTR , VALUE __v_src1 OPTIONAL_ATTR, VALUE __v_src2 OPTIONAL_ATTR)
|
|
1797
823
|
{
|
|
1798
|
-
VALUE __p_retval = Qnil;
|
|
824
|
+
VALUE __p_retval OPTIONAL_ATTR = Qnil;
|
|
1799
825
|
GdkPixbuf * src1; GdkPixbuf * __orig_src1;
|
|
1800
826
|
GdkPixbuf * src2; GdkPixbuf * __orig_src2;
|
|
1801
827
|
__orig_src1 = src1 = GDK_PIXBUF(RVAL2GOBJ(__v_src1));
|
|
1802
828
|
__orig_src2 = src2 = GDK_PIXBUF(RVAL2GOBJ(__v_src2));
|
|
1803
829
|
|
|
1804
|
-
#line
|
|
830
|
+
#line 395 "/home/geoff/Projects/pixbufutils/ext/pixbufutils/pixbufutils.cr"
|
|
1805
831
|
IGNORE(self);
|
|
1806
832
|
do { __p_retval = unref_pixbuf((pixbuf_blend5050(src1, src2))); goto out; } while(0);
|
|
1807
833
|
out:
|
|
@@ -1813,7 +839,7 @@ out:
|
|
|
1813
839
|
static VALUE
|
|
1814
840
|
PixbufUtils_CLASS_mask_area(int __p_argc, VALUE *__p_argv, VALUE self)
|
|
1815
841
|
{
|
|
1816
|
-
VALUE __p_retval = Qnil;
|
|
842
|
+
VALUE __p_retval OPTIONAL_ATTR = Qnil;
|
|
1817
843
|
VALUE __v_mask = Qnil;
|
|
1818
844
|
GdkPixbuf * mask; GdkPixbuf * __orig_mask;
|
|
1819
845
|
VALUE __v_cutoff = Qnil;
|
|
@@ -1831,7 +857,7 @@ PixbufUtils_CLASS_mask_area(int __p_argc, VALUE *__p_argv, VALUE self)
|
|
|
1831
857
|
cutoff = 127;
|
|
1832
858
|
|
|
1833
859
|
|
|
1834
|
-
#line
|
|
860
|
+
#line 399 "/home/geoff/Projects/pixbufutils/ext/pixbufutils/pixbufutils.cr"
|
|
1835
861
|
IGNORE(self);
|
|
1836
862
|
do { __p_retval = pixbuf_mask_area(mask, cutoff); goto out; } while(0);
|
|
1837
863
|
out:
|
|
@@ -1842,7 +868,7 @@ out:
|
|
|
1842
868
|
static VALUE
|
|
1843
869
|
PixbufUtils_CLASS_scale_max(int __p_argc, VALUE *__p_argv, VALUE self)
|
|
1844
870
|
{
|
|
1845
|
-
VALUE __p_retval = Qnil;
|
|
871
|
+
VALUE __p_retval OPTIONAL_ATTR = Qnil;
|
|
1846
872
|
VALUE __v_src = Qnil;
|
|
1847
873
|
GdkPixbuf * src; GdkPixbuf * __orig_src;
|
|
1848
874
|
VALUE __v_max = Qnil;
|
|
@@ -1864,7 +890,7 @@ PixbufUtils_CLASS_scale_max(int __p_argc, VALUE *__p_argv, VALUE self)
|
|
|
1864
890
|
interp = GDK_INTERP_BILINEAR;
|
|
1865
891
|
|
|
1866
892
|
|
|
1867
|
-
#line
|
|
893
|
+
#line 403 "/home/geoff/Projects/pixbufutils/ext/pixbufutils/pixbufutils.cr"
|
|
1868
894
|
|
|
1869
895
|
do {
|
|
1870
896
|
gulong width, height, largest;
|
|
@@ -1888,7 +914,7 @@ out:
|
|
|
1888
914
|
static VALUE
|
|
1889
915
|
PixbufUtils_CLASS_draw_scaled(int __p_argc, VALUE *__p_argv, VALUE self)
|
|
1890
916
|
{
|
|
1891
|
-
VALUE __p_retval = Qnil;
|
|
917
|
+
VALUE __p_retval OPTIONAL_ATTR = Qnil;
|
|
1892
918
|
VALUE __v_drawable = Qnil;
|
|
1893
919
|
GdkDrawable * drawable; GdkDrawable * __orig_drawable;
|
|
1894
920
|
VALUE __v_src = Qnil;
|
|
@@ -1926,7 +952,7 @@ PixbufUtils_CLASS_draw_scaled(int __p_argc, VALUE *__p_argv, VALUE self)
|
|
|
1926
952
|
interp = GDK_INTERP_BILINEAR;
|
|
1927
953
|
|
|
1928
954
|
|
|
1929
|
-
#line
|
|
955
|
+
#line 421 "/home/geoff/Projects/pixbufutils/ext/pixbufutils/pixbufutils.cr"
|
|
1930
956
|
|
|
1931
957
|
do {
|
|
1932
958
|
GdkPixbuf * tmp ;
|
|
@@ -1952,7 +978,7 @@ out:
|
|
|
1952
978
|
static VALUE
|
|
1953
979
|
PixbufUtils_CLASS_draw_scaled_clip(int __p_argc, VALUE *__p_argv, VALUE self)
|
|
1954
980
|
{
|
|
1955
|
-
VALUE __p_retval = Qnil;
|
|
981
|
+
VALUE __p_retval OPTIONAL_ATTR = Qnil;
|
|
1956
982
|
VALUE __v_drawable = Qnil;
|
|
1957
983
|
GdkDrawable * drawable; GdkDrawable * __orig_drawable;
|
|
1958
984
|
VALUE __v_src = Qnil;
|
|
@@ -1994,7 +1020,7 @@ PixbufUtils_CLASS_draw_scaled_clip(int __p_argc, VALUE *__p_argv, VALUE self)
|
|
|
1994
1020
|
interp = GDK_INTERP_BILINEAR;
|
|
1995
1021
|
|
|
1996
1022
|
|
|
1997
|
-
#line
|
|
1023
|
+
#line 457 "/home/geoff/Projects/pixbufutils/ext/pixbufutils/pixbufutils.cr"
|
|
1998
1024
|
|
|
1999
1025
|
do {
|
|
2000
1026
|
GdkPixbuf * tmp ;
|
|
@@ -2031,6 +1057,11 @@ Init_pixbufutils(void)
|
|
|
2031
1057
|
rb_define_singleton_method(mPixbufUtils, "sharpen", PixbufUtils_CLASS_sharpen, 2);
|
|
2032
1058
|
rb_define_singleton_method(mPixbufUtils, "extract_alpha", PixbufUtils_CLASS_extract_alpha, -1);
|
|
2033
1059
|
rb_define_singleton_method(mPixbufUtils, "blur", PixbufUtils_CLASS_blur, 2);
|
|
1060
|
+
rb_define_singleton_method(mPixbufUtils, "contrast", PixbufUtils_CLASS_contrast, 2);
|
|
1061
|
+
rb_define_singleton_method(mPixbufUtils, "vibrance", PixbufUtils_CLASS_vibrance, 2);
|
|
1062
|
+
rb_define_singleton_method(mPixbufUtils, "saturation", PixbufUtils_CLASS_saturation, 2);
|
|
1063
|
+
rb_define_singleton_method(mPixbufUtils, "brightness", PixbufUtils_CLASS_brightness, 2);
|
|
1064
|
+
rb_define_singleton_method(mPixbufUtils, "filter", PixbufUtils_CLASS_filter, 3);
|
|
2034
1065
|
rb_define_singleton_method(mPixbufUtils, "rotate_90", PixbufUtils_CLASS_rotate_90, 2);
|
|
2035
1066
|
rb_define_singleton_method(mPixbufUtils, "rotate_cw", PixbufUtils_CLASS_rotate_cw, 1);
|
|
2036
1067
|
rb_define_singleton_method(mPixbufUtils, "rotate_180", PixbufUtils_CLASS_rotate_180, 1);
|
|
@@ -2047,6 +1078,7 @@ Init_pixbufutils(void)
|
|
|
2047
1078
|
rb_define_singleton_method(mPixbufUtils, "tint", PixbufUtils_CLASS_tint, -1);
|
|
2048
1079
|
rb_define_singleton_method(mPixbufUtils, "perspect_v", PixbufUtils_CLASS_perspect_v, 5);
|
|
2049
1080
|
rb_define_singleton_method(mPixbufUtils, "mask", PixbufUtils_CLASS_mask, 2);
|
|
1081
|
+
rb_define_singleton_method(mPixbufUtils, "auto_equalize", PixbufUtils_CLASS_auto_equalize, 1);
|
|
2050
1082
|
rb_define_singleton_method(mPixbufUtils, "blend5050", PixbufUtils_CLASS_blend5050, 2);
|
|
2051
1083
|
rb_define_singleton_method(mPixbufUtils, "mask_area", PixbufUtils_CLASS_mask_area, -1);
|
|
2052
1084
|
rb_define_singleton_method(mPixbufUtils, "scale_max", PixbufUtils_CLASS_scale_max, -1);
|