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.
@@ -11,6 +11,21 @@
11
11
  --- PixbufUtils.blur(GdkPixbuf* src, Integer radius)
12
12
 
13
13
 
14
+ --- PixbufUtils.contrast(GdkPixbuf* src, Integer adjust)
15
+
16
+
17
+ --- PixbufUtils.vibrance(GdkPixbuf* src, Integer adjust)
18
+
19
+
20
+ --- PixbufUtils.saturation(GdkPixbuf* src, Integer adjust)
21
+
22
+
23
+ --- PixbufUtils.brightness(GdkPixbuf* src, Integer adjust)
24
+
25
+
26
+ --- PixbufUtils.filter(GdkPixbuf* src, Array filter, double divisor)
27
+
28
+
14
29
  --- PixbufUtils.rotate_90(GdkPixbuf* src, Boolean counter_clockwise)
15
30
 
16
31
 
@@ -59,6 +74,9 @@
59
74
  --- PixbufUtils.mask(GdkPixbuf* src, GdkPixbuf* mask)
60
75
 
61
76
 
77
+ --- PixbufUtils.auto_equalize(GdkPixbuf* src)
78
+
79
+
62
80
  --- PixbufUtils.blend5050(GdkPixbuf* src1, GdkPixbuf* src2)
63
81
 
64
82
 
@@ -0,0 +1,82 @@
1
+ typedef enum {
2
+ ANGLE_0 = 0,
3
+ ANGLE_90 = 90,
4
+ ANGLE_180 = 180,
5
+ ANGLE_270 = 270
6
+ } rotate_angle_t;
7
+
8
+ static GdkPixbuf *
9
+ pixbuf_rotate(GdkPixbuf *src, rotate_angle_t angle)
10
+ {
11
+ GdkPixbuf *dest;
12
+ int has_alpha;
13
+ int s_width, s_height, s_rowstride;
14
+ int d_width, d_height, d_rowstride;
15
+ guchar *s_pix;
16
+ guchar *d_pix;
17
+ guchar *sp;
18
+ guchar *dp;
19
+ int i, j, pix_width;
20
+
21
+ if (!src) return NULL;
22
+
23
+ if (angle == ANGLE_0)
24
+ return gdk_pixbuf_copy(src);
25
+
26
+ s_width = gdk_pixbuf_get_width(src);
27
+ s_height = gdk_pixbuf_get_height(src);
28
+ has_alpha = gdk_pixbuf_get_has_alpha(src);
29
+ s_rowstride = gdk_pixbuf_get_rowstride(src);
30
+ s_pix = gdk_pixbuf_get_pixels(src);
31
+
32
+ switch (angle)
33
+ {
34
+ case ANGLE_90:
35
+ case ANGLE_270:
36
+ d_width = s_height;
37
+ d_height = s_width;
38
+ break;
39
+ default:
40
+ case ANGLE_0:/* Avoid compiler warnings... */
41
+ case ANGLE_180:
42
+ d_width = s_width;
43
+ d_height = s_height;
44
+ break;
45
+ }
46
+
47
+ dest = gdk_pixbuf_new(GDK_COLORSPACE_RGB, has_alpha, 8, d_width, d_height);
48
+ d_rowstride = gdk_pixbuf_get_rowstride(dest);
49
+ d_pix = gdk_pixbuf_get_pixels(dest);
50
+
51
+ pix_width = (has_alpha ? 4 : 3);
52
+
53
+ for (i = 0; i < s_height; i++) {
54
+ sp = s_pix + (i * s_rowstride);
55
+ for (j = 0; j < s_width; j++) {
56
+ switch (angle)
57
+ {
58
+ case ANGLE_180:
59
+ dp = d_pix + ((d_height - i - 1) * d_rowstride) + ((d_width - j - 1) * pix_width);
60
+ break;
61
+ case ANGLE_90:
62
+ dp = d_pix + (j * d_rowstride) + ((d_width - i - 1) * pix_width);
63
+ break;
64
+ case ANGLE_270:
65
+ dp = d_pix + ((d_height - j - 1) * d_rowstride) + (i * pix_width);
66
+ break;
67
+ default:
68
+ case ANGLE_0:/* Avoid compiler warnings... */
69
+ dp = d_pix + (i * d_rowstride) + (j * pix_width);
70
+ break;
71
+ }
72
+
73
+ *(dp++) = *(sp++); /* red */
74
+ *(dp++) = *(sp++); /* green */
75
+ *(dp++) = *(sp++); /* blue */
76
+ if (has_alpha) *(dp) = *(sp++); /* alpha */
77
+ }
78
+ }
79
+
80
+ return dest;
81
+ }
82
+
@@ -0,0 +1,121 @@
1
+ static GdkPixbuf *
2
+ pixbuf_sharpen(GdkPixbuf *src, int strength)
3
+ {
4
+ GdkPixbuf *dest;
5
+ int has_alpha;
6
+ int s_width, s_height, s_rowstride;
7
+ int d_width, d_height, d_rowstride;
8
+ guchar *s_pix;
9
+ guchar *d_pix;
10
+ guchar *sp;
11
+ guchar *dp;
12
+ int pix_width;
13
+ bool row_only = TRUE;
14
+ int a=0, r, g, b, x, y, mul;
15
+ int b_a=0, b_r, b_g, b_b;
16
+
17
+ if (!src) return 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 = s_width;
26
+ d_height = s_height;
27
+
28
+ dest = gdk_pixbuf_copy(src);
29
+ d_rowstride = gdk_pixbuf_get_rowstride(dest);
30
+ d_pix = gdk_pixbuf_get_pixels(dest);
31
+
32
+ pix_width = (has_alpha ? 4 : 3);
33
+
34
+ mul = (row_only ? 3 : 5);
35
+
36
+ for (y = 0; y < (s_height); y++)
37
+ {
38
+ sp = s_pix + (y * s_rowstride) + pix_width;
39
+ dp = d_pix + (y * d_rowstride) + pix_width;
40
+
41
+ for (x = 1; x < (s_width - 1); x++)
42
+ {
43
+
44
+ b_r = ((int)*(sp));
45
+ b_g = ((int)*(sp+1));
46
+ b_b = ((int)*(sp+2));
47
+ if (has_alpha)
48
+ b_a = ((int)*((sp+3)));
49
+
50
+ r = b_r * mul;
51
+ g = b_g * mul;
52
+ b = b_b * mul;
53
+ if (has_alpha)
54
+ a = b_a * mul;
55
+
56
+ r = ((int)*(sp)) * mul;
57
+ g = ((int)*(sp+1)) * mul;
58
+ b = ((int)*(sp+2)) * mul;
59
+ if (has_alpha)
60
+ a = ((int)*((sp+3))) * mul;
61
+
62
+ r -= (int)*(sp - pix_width);
63
+ g -= (int)*(sp - pix_width + 1);
64
+ b -= (int)*(sp - pix_width + 2);
65
+ if (has_alpha)
66
+ a -= (int)*(sp - pix_width + 3);
67
+
68
+ r -= (int)*(sp + pix_width);
69
+ g -= (int)*(sp + pix_width + 1);
70
+ b -= (int)*(sp + pix_width + 2);
71
+ if (has_alpha)
72
+ a -= (int)*(sp + pix_width + 3);
73
+
74
+ if (row_only == 0)
75
+ {
76
+ r -= (int)*(sp - (s_rowstride));
77
+ g -= (int)*(sp + 1 - (s_rowstride));
78
+ b -= (int)*(sp + 2 - (s_rowstride));
79
+ if (has_alpha)
80
+ a -= (int)*(sp + 3 - (s_rowstride));
81
+
82
+ r -= (int)*(sp + (s_rowstride));
83
+ g -= (int)*(sp + 1 + (s_rowstride));
84
+ b -= (int)*(sp + 2 + (s_rowstride));
85
+ if (has_alpha)
86
+ a -= (int)*(sp + 3 + (s_rowstride));
87
+ }
88
+
89
+ r = (r & ((~r) >> 16));
90
+ r = ((r | ((r & 256) - ((r & 256) >> 8))));
91
+ g = (g & ((~g) >> 16));
92
+ g = ((g | ((g & 256) - ((g & 256) >> 8))));
93
+ b = (b & ((~b) >> 16));
94
+ b = ((b | ((b & 256) - ((b & 256) >> 8))));
95
+ a = (a & ((~a) >> 16));
96
+ a = ((a | ((a & 256) - ((a & 256) >> 8))));
97
+
98
+ r = 0xff & (MAX(r,0));
99
+ g = 0xff & (MAX(g,0));
100
+ b = 0xff & (MAX(b,0));
101
+ if (has_alpha)
102
+ a = 0xff & (MAX(a,0));
103
+
104
+ r = ((r * strength) + b_r) / (strength + 1);
105
+ g = ((g * strength) + b_g) / (strength + 1);
106
+ b = ((b * strength) + b_b) / (strength + 1);
107
+ if (has_alpha)
108
+ a = ((a * strength) + b_a) / (strength + 1);
109
+
110
+ *(dp++) = r;
111
+ *(dp++) = g;
112
+ *(dp++) = b;
113
+ if (has_alpha)
114
+ *(dp++) = a;
115
+
116
+ sp += pix_width;
117
+ }
118
+ }
119
+ return dest;
120
+ } // */
121
+
@@ -0,0 +1,52 @@
1
+ static GdkPixbuf *pixbuf_soften_edges(GdkPixbuf *dest, int size)
2
+ {
3
+ int d_has_alpha;
4
+ int d_width, d_height, d_rowstride;
5
+ guchar *d_pix, *dp;
6
+ int i, j, pix_width;
7
+
8
+ g_return_val_if_fail(dest != NULL, NULL);
9
+
10
+ d_width = gdk_pixbuf_get_width(dest);
11
+ d_height = gdk_pixbuf_get_height(dest);
12
+ d_has_alpha = gdk_pixbuf_get_has_alpha(dest);
13
+ d_rowstride = gdk_pixbuf_get_rowstride(dest);
14
+ d_pix = gdk_pixbuf_get_pixels(dest);
15
+
16
+ g_return_val_if_fail(d_has_alpha, NULL);
17
+
18
+ pix_width = (d_has_alpha ? 4 : 3);
19
+
20
+ for (i = 0; i < MIN(size,d_height); i++) {
21
+ dp = d_pix + (i * d_rowstride);
22
+ //pix = (pixel_t)dp;
23
+ for (j = 0; j < d_width; j++) {
24
+ dp[3] = (dp[3] * i) / size; /* alpha */
25
+ dp += pix_width;
26
+ }
27
+
28
+ dp = d_pix + ((d_height - i - 1) * d_rowstride);
29
+ for (j = 0; j < d_width; j++) {
30
+ dp[3] = (dp[3] * i) / size; /* alpha */
31
+ dp += pix_width;
32
+ }
33
+
34
+ }
35
+ for (j = 0; j < d_height; j++) {
36
+ //pix = (pixel_t)GINT_TO_POINTER(GPOINTER_TO_INT(d_pix) + (j * d_rowstride));
37
+ dp = d_pix + ((d_height - i - 1) * d_rowstride);
38
+ for (i = 0; i < MIN(size, d_width); i++) {
39
+ dp[3] = (dp[3] * i) / size; /* alpha */
40
+ dp += pix_width;
41
+ }
42
+
43
+ dp = d_pix + (j * d_rowstride) + (pix_width * d_width);
44
+ for (i = 0; i < MIN(size, d_width); i++) {
45
+ dp[3] = (dp[3] * i) / size; /* alpha */
46
+ dp -= pix_width;
47
+ }
48
+ }
49
+
50
+ return dest;
51
+ }
52
+
@@ -0,0 +1,61 @@
1
+ static gboolean pixbuf_save_tiff(GdkPixbuf *pixbuf, char *filename)
2
+ {
3
+ long row;
4
+ TIFF *tif;
5
+ struct tm *ct;
6
+ time_t t;
7
+ int width,
8
+ height,
9
+ rowstride;
10
+ guchar *pixels;
11
+ short photometric;
12
+ short samplesperpixel;
13
+ short bitspersample;
14
+ static char datetime[40] = "";
15
+ char hostname[256] = "";
16
+
17
+ time(&t);
18
+ ct = localtime(&t);
19
+ sprintf(datetime, "%04i:%02i:%02i %02i:%02i:%02i",
20
+ 1900 + ct->tm_year, ct->tm_mon + 1, ct->tm_mday,
21
+ ct->tm_hour, ct->tm_min, ct->tm_sec);
22
+
23
+ tif = TIFFOpen(filename, "w");
24
+
25
+ width = gdk_pixbuf_get_width(pixbuf);
26
+ height = gdk_pixbuf_get_height(pixbuf);
27
+ samplesperpixel = gdk_pixbuf_get_has_alpha(pixbuf) ? 4 : 3;
28
+ bitspersample = gdk_pixbuf_get_bits_per_sample(pixbuf);
29
+ photometric = PHOTOMETRIC_RGB;
30
+ rowstride = gdk_pixbuf_get_rowstride(pixbuf);
31
+ pixels = gdk_pixbuf_get_pixels(pixbuf);
32
+
33
+
34
+ TIFFSetField(tif, TIFFTAG_IMAGEWIDTH, width);
35
+ TIFFSetField(tif, TIFFTAG_IMAGELENGTH, height);
36
+ TIFFSetField(tif, TIFFTAG_BITSPERSAMPLE, bitspersample);
37
+ TIFFSetField(tif, TIFFTAG_ORIENTATION, ORIENTATION_TOPLEFT);
38
+ TIFFSetField(tif, TIFFTAG_COMPRESSION, COMPRESSION_LZW);
39
+ TIFFSetField(tif, TIFFTAG_PHOTOMETRIC, photometric);
40
+ /*#TIFFSetField(tif, TIFFTAG_DOCUMENTNAME, inf);*/
41
+ TIFFSetField(tif, TIFFTAG_IMAGEDESCRIPTION, "Saved from a Gdk::Pixbuf");
42
+ TIFFSetField(tif, TIFFTAG_SAMPLESPERPIXEL, samplesperpixel);
43
+ TIFFSetField(tif, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG);
44
+ TIFFSetField(tif, TIFFTAG_SOFTWARE, "LiveLink Photo Kiosk 1.0");
45
+ TIFFSetField(tif, TIFFTAG_DATETIME, datetime);
46
+ if(gethostname((char*)&hostname,sizeof(hostname))==0)
47
+ TIFFSetField(tif, TIFFTAG_HOSTCOMPUTER, hostname);
48
+
49
+ for (row = 0; row < height; row++) {
50
+ if (TIFFWriteScanline(tif, (u_char *) pixels, row, 0) < 0) {
51
+ fprintf(stderr, "failed a scanline write (%li)\n", row);
52
+ break;
53
+ }
54
+ pixels = GINT_TO_POINTER(GPOINTER_TO_INT(pixels) + rowstride);
55
+ }
56
+ TIFFFlushData(tif);
57
+ TIFFClose(tif);
58
+
59
+ return TRUE;
60
+ }
61
+
@@ -0,0 +1,66 @@
1
+ static inline unsigned char pu_clamp(int x)
2
+ {
3
+ unsigned char i = (x > 255) ? 255 : (x < 0 ? 0 : x);
4
+ return i;
5
+ }
6
+
7
+ static GdkPixbuf *pixbuf_tint(GdkPixbuf *src, GdkPixbuf *dest, int r, int g, int b, int alpha)
8
+ {
9
+ int s_has_alpha, d_has_alpha;
10
+ int s_width, s_height, s_rowstride;
11
+ int d_width, d_height, d_rowstride;
12
+ guchar *s_pix, *sp;
13
+ guchar *d_pix, *dp;
14
+ int i, j, pix_width, grey;
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
+ s_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_has_alpha = gdk_pixbuf_get_has_alpha(dest);
28
+ d_rowstride = gdk_pixbuf_get_rowstride(dest);
29
+ d_pix = gdk_pixbuf_get_pixels(dest);
30
+
31
+ g_return_val_if_fail(d_width == s_width, NULL);
32
+ g_return_val_if_fail(d_height == s_height, NULL);
33
+ g_return_val_if_fail(d_has_alpha == s_has_alpha, NULL);
34
+
35
+ pix_width = (s_has_alpha ? 4 : 3);
36
+
37
+ for (i = 0; i < s_height; i++) {
38
+ sp = s_pix;
39
+ dp = d_pix;
40
+
41
+ for (j = 0; j < s_width; j++) {
42
+ grey = GO_RGB_TO_GREY(sp[0], sp[1], sp[2]);
43
+
44
+ dp[0] = pu_clamp(pu_clamp(((int)grey + r) * alpha / 255) + pu_clamp((int)sp[0] * (255 - alpha) / 255)); /* red */
45
+
46
+ //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 */
47
+
48
+ dp[1] = pu_clamp(pu_clamp((grey + g) * alpha / 255) + pu_clamp((int)sp[1] * (255 - alpha) / 255)); /* green */
49
+ dp[2] = pu_clamp(pu_clamp((grey + b) * alpha / 255) + pu_clamp((int)sp[2] * (255 - alpha) / 255)); /* blue */
50
+
51
+ if (s_has_alpha)
52
+ {
53
+ dp[3] = sp[3]; /* alpha */
54
+ }
55
+
56
+ dp += pix_width;
57
+ sp += pix_width;
58
+ }
59
+
60
+ d_pix += d_rowstride;
61
+ s_pix += s_rowstride;
62
+ }
63
+
64
+ return dest;
65
+ }
66
+
metadata CHANGED
@@ -1,120 +1,107 @@
1
- --- !ruby/object:Gem::Specification
1
+ --- !ruby/object:Gem::Specification
2
2
  name: pixbufutils
3
- version: !ruby/object:Gem::Version
4
- hash: 25
5
- prerelease:
6
- segments:
7
- - 0
8
- - 0
9
- - 3
10
- version: 0.0.3
3
+ version: !ruby/object:Gem::Version
4
+ version: 0.0.4
11
5
  platform: ruby
12
- authors:
6
+ authors:
13
7
  - Geoff Youngs
14
8
  autorequire:
15
9
  bindir: bin
16
10
  cert_chain: []
17
-
18
- date: 2013-08-14 00:00:00 Z
19
- dependencies:
20
- - !ruby/object:Gem::Dependency
11
+ date: 2015-04-06 00:00:00.000000000 Z
12
+ dependencies:
13
+ - !ruby/object:Gem::Dependency
21
14
  name: rubber-generate
22
- prerelease: false
23
- requirement: &id001 !ruby/object:Gem::Requirement
24
- none: false
25
- requirements:
26
- - - ">="
27
- - !ruby/object:Gem::Version
28
- hash: 61
29
- segments:
30
- - 0
31
- - 0
32
- - 17
15
+ requirement: !ruby/object:Gem::Requirement
16
+ requirements:
17
+ - - '>='
18
+ - !ruby/object:Gem::Version
33
19
  version: 0.0.17
34
20
  type: :runtime
35
- version_requirements: *id001
36
- - !ruby/object:Gem::Dependency
37
- name: glib2
38
21
  prerelease: false
39
- requirement: &id002 !ruby/object:Gem::Requirement
40
- none: false
41
- requirements:
42
- - - ">="
43
- - !ruby/object:Gem::Version
44
- hash: 31
45
- segments:
46
- - 1
47
- - 1
48
- - 6
22
+ version_requirements: !ruby/object:Gem::Requirement
23
+ requirements:
24
+ - - '>='
25
+ - !ruby/object:Gem::Version
26
+ version: 0.0.17
27
+ - !ruby/object:Gem::Dependency
28
+ name: glib2
29
+ requirement: !ruby/object:Gem::Requirement
30
+ requirements:
31
+ - - '>='
32
+ - !ruby/object:Gem::Version
49
33
  version: 1.1.6
50
34
  type: :runtime
51
- version_requirements: *id002
52
- - !ruby/object:Gem::Dependency
53
- name: gdk_pixbuf2
54
35
  prerelease: false
55
- requirement: &id003 !ruby/object:Gem::Requirement
56
- none: false
57
- requirements:
58
- - - ">="
59
- - !ruby/object:Gem::Version
60
- hash: 31
61
- segments:
62
- - 1
63
- - 1
64
- - 6
36
+ version_requirements: !ruby/object:Gem::Requirement
37
+ requirements:
38
+ - - '>='
39
+ - !ruby/object:Gem::Version
40
+ version: 1.1.6
41
+ - !ruby/object:Gem::Dependency
42
+ name: gdk_pixbuf2
43
+ requirement: !ruby/object:Gem::Requirement
44
+ requirements:
45
+ - - '>='
46
+ - !ruby/object:Gem::Version
65
47
  version: 1.1.6
66
48
  type: :runtime
67
- version_requirements: *id003
49
+ prerelease: false
50
+ version_requirements: !ruby/object:Gem::Requirement
51
+ requirements:
52
+ - - '>='
53
+ - !ruby/object:Gem::Version
54
+ version: 1.1.6
68
55
  description: |
69
56
  Misc functions for alpha channel extraction, gamma, tinting, masking, blur etc.
70
-
71
57
  email: git@intersect-uk.co.uk
72
58
  executables: []
73
-
74
- extensions:
59
+ extensions:
75
60
  - ext/pixbufutils/extconf.rb
76
61
  extra_rdoc_files: []
77
-
78
- files:
62
+ files:
63
+ - README.md
64
+ - Rakefile
65
+ - ext/pixbufutils/auto-equalize.h
66
+ - ext/pixbufutils/blend5050.h
67
+ - ext/pixbufutils/blur.h
68
+ - ext/pixbufutils/extconf.rb
69
+ - ext/pixbufutils/extract-alpha.h
70
+ - ext/pixbufutils/filter.h
71
+ - ext/pixbufutils/gamma.h
72
+ - ext/pixbufutils/greyscale.h
73
+ - ext/pixbufutils/histogram.h
74
+ - ext/pixbufutils/mask.h
79
75
  - ext/pixbufutils/pixbufutils.c
80
76
  - ext/pixbufutils/pixbufutils.cr
81
77
  - ext/pixbufutils/pixbufutils.rd
82
- - Rakefile
83
- - README.md
78
+ - ext/pixbufutils/rotate.h
79
+ - ext/pixbufutils/sharpen.h
80
+ - ext/pixbufutils/soften-edges.h
81
+ - ext/pixbufutils/tiff.h
82
+ - ext/pixbufutils/tint.h
84
83
  - lib/pixbufutils.rb
85
- - ext/pixbufutils/extconf.rb
86
84
  homepage: http://github.com/geoffyoungs/pixbufutils
87
85
  licenses: []
88
-
86
+ metadata: {}
89
87
  post_install_message:
90
88
  rdoc_options: []
91
-
92
- require_paths:
89
+ require_paths:
93
90
  - lib
94
- required_ruby_version: !ruby/object:Gem::Requirement
95
- none: false
96
- requirements:
97
- - - ">="
98
- - !ruby/object:Gem::Version
99
- hash: 3
100
- segments:
101
- - 0
102
- version: "0"
103
- required_rubygems_version: !ruby/object:Gem::Requirement
104
- none: false
105
- requirements:
106
- - - ">="
107
- - !ruby/object:Gem::Version
108
- hash: 3
109
- segments:
110
- - 0
111
- version: "0"
91
+ required_ruby_version: !ruby/object:Gem::Requirement
92
+ requirements:
93
+ - - '>='
94
+ - !ruby/object:Gem::Version
95
+ version: '0'
96
+ required_rubygems_version: !ruby/object:Gem::Requirement
97
+ requirements:
98
+ - - '>='
99
+ - !ruby/object:Gem::Version
100
+ version: '0'
112
101
  requirements: []
113
-
114
102
  rubyforge_project:
115
- rubygems_version: 1.8.15
103
+ rubygems_version: 2.2.1
116
104
  signing_key:
117
- specification_version: 3
105
+ specification_version: 4
118
106
  summary: Additional utils for Gdk::Pixbuf
119
107
  test_files: []
120
-