pixbufutils 0.0.3 → 0.0.4

data/ext/pixbufutils/pixbufutils.rd

@@ -11,6 +11,21 @@
 --- PixbufUtils.blur(GdkPixbuf* src, Integer radius)
 
 
+--- PixbufUtils.contrast(GdkPixbuf* src, Integer adjust)
+
+
+--- PixbufUtils.vibrance(GdkPixbuf* src, Integer adjust)
+
+
+--- PixbufUtils.saturation(GdkPixbuf* src, Integer adjust)
+
+
+--- PixbufUtils.brightness(GdkPixbuf* src, Integer adjust)
+
+
+--- PixbufUtils.filter(GdkPixbuf* src, Array filter, double divisor)
+
+
 --- PixbufUtils.rotate_90(GdkPixbuf* src, Boolean counter_clockwise)
 
 
@@ -59,6 +74,9 @@
 --- PixbufUtils.mask(GdkPixbuf* src, GdkPixbuf* mask)
 
 
+--- PixbufUtils.auto_equalize(GdkPixbuf* src)
+
+
 --- PixbufUtils.blend5050(GdkPixbuf* src1, GdkPixbuf* src2)
 
 

data/ext/pixbufutils/rotate.h

@@ -0,0 +1,82 @@
+typedef enum {
+	ANGLE_0 = 0,
+	ANGLE_90 = 90,
+	ANGLE_180 = 180,
+	ANGLE_270 = 270
+} rotate_angle_t;
+
+static GdkPixbuf *
+pixbuf_rotate(GdkPixbuf *src, rotate_angle_t angle)
+{
+	GdkPixbuf *dest;
+	int        has_alpha;
+	int        s_width, s_height, s_rowstride;
+	int        d_width, d_height, d_rowstride;
+	guchar    *s_pix;
+        guchar    *d_pix;
+	guchar    *sp;
+        guchar    *dp;
+	int        i, j, pix_width;
+
+	if (!src) return NULL;
+
+	if (angle == ANGLE_0)
+		return gdk_pixbuf_copy(src);
+
+	s_width = gdk_pixbuf_get_width(src);
+	s_height = gdk_pixbuf_get_height(src);
+	has_alpha = gdk_pixbuf_get_has_alpha(src);
+	s_rowstride = gdk_pixbuf_get_rowstride(src);
+	s_pix = gdk_pixbuf_get_pixels(src);
+
+	switch (angle)
+	{
+	case ANGLE_90:
+	case ANGLE_270:
+		d_width = s_height;
+		d_height = s_width;
+		break;
+	default:
+	case ANGLE_0:/* Avoid compiler warnings... */
+	case ANGLE_180:
+		d_width = s_width;
+		d_height = s_height;
+		break;
+	}
+
+	dest = gdk_pixbuf_new(GDK_COLORSPACE_RGB, has_alpha, 8, d_width, d_height);
+	d_rowstride = gdk_pixbuf_get_rowstride(dest);
+	d_pix = gdk_pixbuf_get_pixels(dest);
+
+	pix_width = (has_alpha ? 4 : 3);
+
+	for (i = 0; i < s_height; i++) {
+		sp = s_pix + (i * s_rowstride);
+		for (j = 0; j < s_width; j++) {
+			switch (angle)
+			{
+			case ANGLE_180:
+				dp = d_pix + ((d_height - i - 1) * d_rowstride) + ((d_width - j - 1) * pix_width);
+				break;
+			case ANGLE_90:
+				dp = d_pix + (j * d_rowstride) + ((d_width - i - 1) * pix_width);
+				break;
+			case ANGLE_270:
+				dp = d_pix + ((d_height - j - 1) * d_rowstride) + (i * pix_width);
+				break;
+			default:
+			case ANGLE_0:/* Avoid compiler warnings... */
+				dp = d_pix + (i * d_rowstride) + (j * pix_width);
+				break;
+			}
+
+			*(dp++) = *(sp++);	/* red */
+			*(dp++) = *(sp++);	/* green */
+			*(dp++) = *(sp++);	/* blue */
+			if (has_alpha) *(dp) = *(sp++);	/* alpha */
+		}
+	}
+
+	return dest;
+}
+

data/ext/pixbufutils/sharpen.h

@@ -0,0 +1,121 @@
+static GdkPixbuf *
+pixbuf_sharpen(GdkPixbuf *src, int strength)
+{
+	GdkPixbuf *dest;
+	int        has_alpha;
+	int        s_width, s_height, s_rowstride;
+	int        d_width, d_height, d_rowstride;
+	guchar    *s_pix;
+        guchar    *d_pix;
+	guchar    *sp;
+        guchar    *dp;
+	int       pix_width;
+	bool	row_only = TRUE;
+	int        a=0, r, g, b, x, y, mul;
+	int        b_a=0, b_r, b_g, b_b;
+
+	if (!src) return NULL;
+
+	s_width = gdk_pixbuf_get_width(src);
+	s_height = gdk_pixbuf_get_height(src);
+	has_alpha = gdk_pixbuf_get_has_alpha(src);
+	s_rowstride = gdk_pixbuf_get_rowstride(src);
+	s_pix = gdk_pixbuf_get_pixels(src);
+
+	d_width = s_width;
+	d_height = s_height;
+
+	dest = gdk_pixbuf_copy(src);
+	d_rowstride = gdk_pixbuf_get_rowstride(dest);
+	d_pix = gdk_pixbuf_get_pixels(dest);
+
+	pix_width = (has_alpha ? 4 : 3);
+
+ 	mul = (row_only ? 3 : 5);
+
+	for (y = 0; y < (s_height); y++)
+	{
+             sp = s_pix + (y * s_rowstride) + pix_width;
+             dp = d_pix + (y * d_rowstride) + pix_width;
+
+		for (x = 1; x < (s_width - 1); x++)
+		{
+
+			b_r = ((int)*(sp));
+			b_g = ((int)*(sp+1));
+			b_b = ((int)*(sp+2));
+			if (has_alpha)
+				b_a = ((int)*((sp+3)));
+
+			r = b_r * mul;
+			g = b_g * mul;
+			b = b_b * mul;
+			if (has_alpha)
+				a = b_a * mul;
+
+			r = ((int)*(sp)) * mul;
+			g = ((int)*(sp+1)) * mul;
+			b = ((int)*(sp+2)) * mul;
+			if (has_alpha)
+				a = ((int)*((sp+3))) * mul;
+
+ 			r -= (int)*(sp - pix_width);
+			g -= (int)*(sp - pix_width + 1);
+			b -= (int)*(sp - pix_width + 2);
+			if (has_alpha)
+				a -= (int)*(sp - pix_width + 3);
+
+			r -= (int)*(sp + pix_width);
+			g -= (int)*(sp + pix_width + 1);
+			b -= (int)*(sp + pix_width + 2);
+			if (has_alpha)
+				a -= (int)*(sp + pix_width + 3);
+
+			if (row_only == 0)
+			{
+				r -= (int)*(sp - (s_rowstride));
+				g -= (int)*(sp + 1 - (s_rowstride));
+				b -= (int)*(sp + 2 - (s_rowstride));
+				if (has_alpha)
+					a -= (int)*(sp + 3 - (s_rowstride));
+
+				r -= (int)*(sp + (s_rowstride));
+				g -= (int)*(sp + 1 + (s_rowstride));
+				b -= (int)*(sp + 2 + (s_rowstride));
+				if (has_alpha)
+					a -= (int)*(sp + 3 + (s_rowstride));
+			}
+
+			r = (r & ((~r) >> 16));
+			r = ((r | ((r & 256) - ((r & 256) >> 8))));
+			g = (g & ((~g) >> 16));
+			g = ((g | ((g & 256) - ((g & 256) >> 8))));
+			b = (b & ((~b) >> 16));
+			b = ((b | ((b & 256) - ((b & 256) >> 8))));
+			a = (a & ((~a) >> 16));
+			a = ((a | ((a & 256) - ((a & 256) >> 8))));
+
+			r = 0xff & (MAX(r,0));
+			g = 0xff & (MAX(g,0));
+			b = 0xff & (MAX(b,0));
+			if (has_alpha)
+				a = 0xff & (MAX(a,0));
+
+			r = ((r * strength) + b_r) / (strength + 1);
+			g = ((g * strength) + b_g) / (strength + 1);
+			b = ((b * strength) + b_b) / (strength + 1);
+			if (has_alpha)
+				a = ((a * strength) + b_a) / (strength + 1);
+
+			*(dp++) = r;
+			*(dp++) = g;
+			*(dp++) = b;
+			if (has_alpha)
+				*(dp++) = a;
+
+			sp += pix_width;
+		}
+	}
+	return dest;
+} // */
+

data/ext/pixbufutils/soften-edges.h

@@ -0,0 +1,52 @@
+static GdkPixbuf *pixbuf_soften_edges(GdkPixbuf *dest, int size)
+{
+	int        d_has_alpha;
+	int        d_width, d_height, d_rowstride;
+        guchar    *d_pix, *dp;
+	int        i, j, pix_width;
+
+	g_return_val_if_fail(dest != NULL, NULL);
+
+	d_width = gdk_pixbuf_get_width(dest);
+	d_height = gdk_pixbuf_get_height(dest);
+	d_has_alpha = gdk_pixbuf_get_has_alpha(dest);
+	d_rowstride = gdk_pixbuf_get_rowstride(dest);
+	d_pix = gdk_pixbuf_get_pixels(dest);
+
+	g_return_val_if_fail(d_has_alpha, NULL);
+
+	pix_width = (d_has_alpha ? 4 : 3);
+
+	for (i = 0; i < MIN(size,d_height); i++) {
+		dp = d_pix + (i * d_rowstride);
+		//pix = (pixel_t)dp;
+		for (j = 0; j < d_width; j++) {
+			dp[3] = (dp[3] * i) / size; /* alpha */
+			dp += pix_width;
+		}
+
+		dp = d_pix + ((d_height - i - 1) * d_rowstride);
+		for (j = 0; j < d_width; j++) {
+			dp[3] = (dp[3] * i) / size; /* alpha */
+			dp += pix_width;
+		}
+
+	}
+	for (j = 0; j < d_height; j++) {
+		//pix = (pixel_t)GINT_TO_POINTER(GPOINTER_TO_INT(d_pix) + (j * d_rowstride));
+		dp = d_pix + ((d_height - i - 1) * d_rowstride);
+		for (i = 0; i < MIN(size, d_width); i++) {
+			dp[3] = (dp[3] * i) / size; /* alpha */
+			dp += pix_width;
+		}
+
+		dp = d_pix + (j * d_rowstride) + (pix_width * d_width);
+		for (i = 0; i < MIN(size, d_width); i++) {
+			dp[3] = (dp[3] * i) / size; /* alpha */
+			dp -= pix_width;
+		}
+	}
+
+	return dest;
+}
+

data/ext/pixbufutils/tiff.h

@@ -0,0 +1,61 @@
+static gboolean pixbuf_save_tiff(GdkPixbuf *pixbuf, char *filename)
+{
+    long        row;
+    TIFF       *tif;
+    struct tm  *ct;
+    time_t t;
+    int         width,
+                height,
+		rowstride;
+    guchar     *pixels;
+    short       photometric;
+    short       samplesperpixel;
+    short       bitspersample;
+    static char datetime[40] = "";
+    char hostname[256] = "";
+
+    time(&t);
+    ct = localtime(&t);
+    sprintf(datetime, "%04i:%02i:%02i %02i:%02i:%02i",
+	    1900 + ct->tm_year, ct->tm_mon + 1, ct->tm_mday,
+	    ct->tm_hour, ct->tm_min, ct->tm_sec);
+
+    tif = TIFFOpen(filename, "w");
+
+    width = gdk_pixbuf_get_width(pixbuf);
+    height = gdk_pixbuf_get_height(pixbuf);
+    samplesperpixel = gdk_pixbuf_get_has_alpha(pixbuf) ? 4 : 3;
+    bitspersample = gdk_pixbuf_get_bits_per_sample(pixbuf);
+    photometric = PHOTOMETRIC_RGB;
+    rowstride = gdk_pixbuf_get_rowstride(pixbuf);
+    pixels = gdk_pixbuf_get_pixels(pixbuf);
+
+
+    TIFFSetField(tif, TIFFTAG_IMAGEWIDTH, width);
+    TIFFSetField(tif, TIFFTAG_IMAGELENGTH, height);
+    TIFFSetField(tif, TIFFTAG_BITSPERSAMPLE, bitspersample);
+    TIFFSetField(tif, TIFFTAG_ORIENTATION, ORIENTATION_TOPLEFT);
+    TIFFSetField(tif, TIFFTAG_COMPRESSION, COMPRESSION_LZW);
+    TIFFSetField(tif, TIFFTAG_PHOTOMETRIC, photometric);
+    /*#TIFFSetField(tif, TIFFTAG_DOCUMENTNAME, inf);*/
+    TIFFSetField(tif, TIFFTAG_IMAGEDESCRIPTION, "Saved from a Gdk::Pixbuf");
+    TIFFSetField(tif, TIFFTAG_SAMPLESPERPIXEL, samplesperpixel);
+    TIFFSetField(tif, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG);
+    TIFFSetField(tif, TIFFTAG_SOFTWARE, "LiveLink Photo Kiosk 1.0");
+    TIFFSetField(tif, TIFFTAG_DATETIME, datetime);
+    if(gethostname((char*)&hostname,sizeof(hostname))==0)
+    TIFFSetField(tif, TIFFTAG_HOSTCOMPUTER, hostname);
+
+    for (row = 0; row < height; row++) {
+      if (TIFFWriteScanline(tif, (u_char *) pixels, row, 0) < 0) {
+        fprintf(stderr, "failed a scanline write (%li)\n", row);
+        break;
+      }
+      pixels = GINT_TO_POINTER(GPOINTER_TO_INT(pixels) + rowstride);
+    }
+    TIFFFlushData(tif);
+    TIFFClose(tif);
+
+    return TRUE;
+}
+

data/ext/pixbufutils/tint.h

@@ -0,0 +1,66 @@
+static inline unsigned char pu_clamp(int x)
+{
+ 	unsigned char i = (x > 255) ? 255 : (x < 0 ? 0 : x);
+  return i;
+}
+
+static GdkPixbuf *pixbuf_tint(GdkPixbuf *src, GdkPixbuf *dest, int r, int g, int b, int alpha)
+{
+	int        s_has_alpha, d_has_alpha;
+	int        s_width, s_height, s_rowstride;
+	int        d_width, d_height, d_rowstride;
+	guchar    *s_pix, *sp;
+	guchar    *d_pix, *dp;
+	int        i, j, pix_width, grey;
+
+	g_return_val_if_fail(src != NULL, NULL);
+	g_return_val_if_fail(dest != NULL, NULL);
+
+	s_width = gdk_pixbuf_get_width(src);
+	s_height = gdk_pixbuf_get_height(src);
+	s_has_alpha = gdk_pixbuf_get_has_alpha(src);
+	s_rowstride = gdk_pixbuf_get_rowstride(src);
+	s_pix = gdk_pixbuf_get_pixels(src);
+
+	d_width = gdk_pixbuf_get_width(dest);
+	d_height = gdk_pixbuf_get_height(dest);
+	d_has_alpha = gdk_pixbuf_get_has_alpha(dest);
+	d_rowstride = gdk_pixbuf_get_rowstride(dest);
+	d_pix = gdk_pixbuf_get_pixels(dest);
+
+	g_return_val_if_fail(d_width == s_width, NULL);
+	g_return_val_if_fail(d_height == s_height, NULL);
+	g_return_val_if_fail(d_has_alpha == s_has_alpha, NULL);
+
+	pix_width = (s_has_alpha ? 4 : 3);
+
+	for (i = 0; i < s_height; i++) {
+		sp = s_pix;
+		dp = d_pix;
+
+		for (j = 0; j < s_width; j++) {
+			grey = GO_RGB_TO_GREY(sp[0], sp[1], sp[2]);
+
+			dp[0] = pu_clamp(pu_clamp(((int)grey + r) * alpha / 255) + pu_clamp((int)sp[0] * (255 - alpha) / 255));	/* red */
+
+			//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 */
+
+			dp[1] = pu_clamp(pu_clamp((grey + g) * alpha / 255) + pu_clamp((int)sp[1] * (255 - alpha) / 255));	/* green */
+			dp[2] = pu_clamp(pu_clamp((grey + b) * alpha / 255) + pu_clamp((int)sp[2] * (255 - alpha) / 255));	/* blue */
+
+			if (s_has_alpha)
+			{
+				dp[3] = sp[3];	/* alpha */
+			}
+
+			dp += pix_width;
+			sp += pix_width;
+		}
+
+		d_pix += d_rowstride;
+		s_pix += s_rowstride;
+	}
+
+	return dest;
+}
+

metadata

@@ -1,120 +1,107 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: pixbufutils
-version: !ruby/object:Gem::Version 
-  hash: 25
-  prerelease: 
-  segments: 
-  - 0
-  - 0
-  - 3
-  version: 0.0.3
+version: !ruby/object:Gem::Version
+  version: 0.0.4
 platform: ruby
-authors: 
+authors:
 - Geoff Youngs
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2013-08-14 00:00:00 Z
-dependencies: 
-- !ruby/object:Gem::Dependency 
+date: 2015-04-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
   name: rubber-generate
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 61
-        segments: 
-        - 0
-        - 0
-        - 17
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
         version: 0.0.17
   type: :runtime
-  version_requirements: *id001
-- !ruby/object:Gem::Dependency 
-  name: glib2
   prerelease: false
-  requirement: &id002 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 31
-        segments: 
-        - 1
-        - 1
-        - 6
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 0.0.17
+- !ruby/object:Gem::Dependency
+  name: glib2
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
         version: 1.1.6
   type: :runtime
-  version_requirements: *id002
-- !ruby/object:Gem::Dependency 
-  name: gdk_pixbuf2
   prerelease: false
-  requirement: &id003 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 31
-        segments: 
-        - 1
-        - 1
-        - 6
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 1.1.6
+- !ruby/object:Gem::Dependency
+  name: gdk_pixbuf2
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
         version: 1.1.6
   type: :runtime
-  version_requirements: *id003
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 1.1.6
 description: |
   Misc functions for alpha channel extraction, gamma, tinting, masking, blur etc.
-
 email: git@intersect-uk.co.uk
 executables: []
-
-extensions: 
+extensions:
 - ext/pixbufutils/extconf.rb
 extra_rdoc_files: []
-
-files: 
+files:
+- README.md
+- Rakefile
+- ext/pixbufutils/auto-equalize.h
+- ext/pixbufutils/blend5050.h
+- ext/pixbufutils/blur.h
+- ext/pixbufutils/extconf.rb
+- ext/pixbufutils/extract-alpha.h
+- ext/pixbufutils/filter.h
+- ext/pixbufutils/gamma.h
+- ext/pixbufutils/greyscale.h
+- ext/pixbufutils/histogram.h
+- ext/pixbufutils/mask.h
 - ext/pixbufutils/pixbufutils.c
 - ext/pixbufutils/pixbufutils.cr
 - ext/pixbufutils/pixbufutils.rd
-- Rakefile
-- README.md
+- ext/pixbufutils/rotate.h
+- ext/pixbufutils/sharpen.h
+- ext/pixbufutils/soften-edges.h
+- ext/pixbufutils/tiff.h
+- ext/pixbufutils/tint.h
 - lib/pixbufutils.rb
-- ext/pixbufutils/extconf.rb
 homepage: http://github.com/geoffyoungs/pixbufutils
 licenses: []
-
+metadata: {}
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
-  none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
-  none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: 
-rubygems_version: 1.8.15
+rubygems_version: 2.2.1
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Additional utils for Gdk::Pixbuf
 test_files: []
-