pikl 0.2.3 → 0.2.4

data/History.txt

@@ -1,3 +1,6 @@
+== 0.2.4
+* Added flexible rotate.
+
 == 0.2.3
 * Change description.
 

data/Manifest.txt

@@ -22,6 +22,8 @@ ext/pikl/pikl_resize.c
 ext/pikl/pikl_resize.h
 ext/pikl/pikl_rotate.c
 ext/pikl/pikl_rotate.h
+ext/pikl/pikl_rotate2.c
+ext/pikl/pikl_rotate2.h
 ext/pikl/pikl_trim.c
 ext/pikl/pikl_trim.h
 lib/pikl.rb

data/config/hoe.rb

@@ -61,7 +61,7 @@ $hoe = Hoe.new(GEM_NAME, VERS) do |p|
   p.description = DESCRIPTION
   p.summary = DESCRIPTION
   p.url = HOMEPATH
-  p.rubyforge_name = (PACKAGE_PLATFORM =~ /mswin32/) ? "#{GEM_NAME}-mswin32" : GEM_NAME
+  p.rubyforge_name = (PACKAGE_PLATFORM =~ /mswin32/) ? "#{GEM_NAME}-x86-mswin32" : GEM_NAME
   
   p.test_globs = ["test/**/test_*.rb"]
   p.clean_globs |= ['**/.*.sw?', '*.gem', '.config', '**/.DS_Store']  #An array of file patterns to delete on clean.
@@ -70,7 +70,7 @@ $hoe = Hoe.new(GEM_NAME, VERS) do |p|
   p.changes = p.paragraphs_of("History.txt", 0..1).join("\n\n")
   #p.extra_deps = []     # An array of rubygem dependencies [name, version], e.g. [ ['active_support', '>= 1.3.1'] ]
   if PACKAGE_PLATFORM =~ /mswin32/
-    platform = Gem::Platform.new('mswin32')
+    platform = Gem::Platform.respond_to?(:new) ? Gem::Platform.new('mswin32') : Gem::Platform::WIN32
     p.spec_extras[:platform] = platform
   else
     p.spec_extras[:extensions] = ['ext/pikl/extconf.rb']

data/ext/pikl/pikl.h

@@ -131,6 +131,11 @@ PKLExport int pkl_trim(PKLImage pkl, int sx, int sy, int width, int height);
 */
 PKLExport int pkl_rotate(PKLImage pkl, PKL_ANGLE angle);
 
+//#define pkl_color(a,b,c,d) ((a<<24)+(b<<16)+(c<<8)+d)
+//PKLExport int pkl_rotate2(PKLImage pkl, float angle, PKL_SAMPLE sample, int backcolor);
+PKLExport int pkl_rotate2(PKLImage pkl, float angle, PKL_SAMPLE sample,
+								unsigned char a, unsigned char b, unsigned char c, unsigned char d);
+
 /*!
 	拡大・縮小します。<br>
 	@param pkl [in] PKLImageオブジェクト

data/ext/pikl/pikl_png.c

@@ -24,11 +24,11 @@ int load_png(PKLImage pkl, FILE *image)
 		return(1);
 	}
 
-	if( setjmp(png_jmpbuf(png_ptr)) ){
-		png_destroy_info_struct(png_ptr, &info_ptr);
-		png_destroy_read_struct(&png_ptr, &info_ptr, (png_infopp)NULL);
-		return(1);
-	}
+	//if( setjmp(png_jmpbuf(png_ptr)) ){
+	//	png_destroy_info_struct(png_ptr, &info_ptr);
+	//	png_destroy_read_struct(&png_ptr, &info_ptr, (png_infopp)NULL);
+	//	return(1);
+	//}
 
 	png_init_io(png_ptr, image);
 	png_read_info(png_ptr, info_ptr);
@@ -75,11 +75,11 @@ int save_png(PKLImage pkl, FILE *image)
 		return(1);
 	}
 	
-	if( setjmp(png_jmpbuf(png_ptr)) ){
-		png_destroy_info_struct(png_ptr, &info_ptr);
-		png_destroy_write_struct(&png_ptr, &info_ptr);
-		return(1);
-	}
+	//if( setjmp(png_jmpbuf(png_ptr)) ){
+	//	png_destroy_info_struct(png_ptr, &info_ptr);
+	//	png_destroy_write_struct(&png_ptr, &info_ptr);
+	//	return(1);
+	//}
 	
 	png_init_io(png_ptr, image);
 	info_ptr->width  = pkl->width;

data/ext/pikl/pikl_png.h

@@ -4,7 +4,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#include <setjmp.h>
+//#include <setjmp.h>
 #include <png.h>
 
 #include "pikl.h"

data/ext/pikl/pikl_rotate2.c

@@ -0,0 +1,312 @@
+#include "pikl_rotate2.h"
+
+static void get_rect(PIKL_RECT *rect, int w, int h, float rad);
+static int ext_cmp_int(const void *a, const void *b);
+static int pkl_rotate_nn(PKLImage pkl, float angle, unsigned char *backcolor);
+static int pkl_rotate_bl(PKLImage pkl, float angle, unsigned char *backcolor);
+static int pkl_rotate_bc(PKLImage pkl, float angle, unsigned char *backcolor);
+//static int pkl_rotate_pa(PKLImage pkl, float angle, int backcolor);
+//===================================================================
+// pkl_rotate2
+//===================================================================
+PKLExport int pkl_rotate2(PKLImage pkl, float angle, PKL_SAMPLE sample,
+								unsigned char a, unsigned char b, unsigned char c, unsigned char d)
+{
+	unsigned char backcolor[4];
+	
+	backcolor[0] = a;
+	backcolor[1] = b;
+	backcolor[2] = c;
+	backcolor[3] = d;
+	
+	switch(sample){
+		case PKL_SAMPLE_NN:
+			return pkl_rotate_nn(pkl, angle, backcolor);
+		case PKL_SAMPLE_BL:
+			return pkl_rotate_bl(pkl, angle, backcolor);
+		case PKL_SAMPLE_BC:
+		case PKL_SAMPLE_PA:
+		case PKL_SAMPLE_LZ:
+			return pkl_rotate_bc(pkl, angle, backcolor);
+			//return pkl_rotate_pa(pkl, angle, backcolor);
+		default:
+			return(1);
+	}
+	return(1);
+}
+
+//=============================================================================
+// rotate_pos
+//=============================================================================
+static void get_rect(PIKL_RECT *rect, int width, int height, float rad)
+{
+	int nimg_x[4], nimg_y[4];
+	int i, x, y;
+
+	nimg_x[0] = 0;
+	nimg_y[0] = 0;
+	nimg_x[1] = width;
+	nimg_y[1] = 0;
+	nimg_x[2] = 0;
+	nimg_y[2] = height;
+	nimg_x[3] = width;
+	nimg_y[3] = height;
+
+	for(i=0; i<4; i++){
+		x = (int)(cos(-rad)*nimg_x[i] - sin(-rad)*nimg_y[i]);
+		y = (int)(sin(-rad)*nimg_x[i] + cos(-rad)*nimg_y[i]);
+		nimg_x[i] = x;
+		nimg_y[i] = y;
+	}
+	qsort(nimg_x, 4, sizeof(int), ext_cmp_int);
+	qsort(nimg_y, 4, sizeof(int), ext_cmp_int);
+	rect->left   = nimg_x[0];
+	rect->top    = nimg_y[0];
+	rect->right  = nimg_x[3];
+	rect->bottom = nimg_y[3];
+}
+
+//=================================================================================
+// ext_cmp_int
+//=================================================================================
+static int ext_cmp_int(const void *a, const void *b)
+{
+	return *((int *)a) - *((int *)b);
+}
+
+//=============================================================================
+// pkl_rotate_nn
+//=============================================================================
+static int pkl_rotate_nn(PKLImage pkl, float angle, unsigned char *backcolor)
+{
+	int width, height;
+	PIKL_RECT rect;
+	float rad;
+	unsigned char *wrk, back[4];
+	int i, j, px, py;
+	
+	rad = -angle*M_PI/180;
+	get_rect(&rect, pkl->width, pkl->height, rad);
+	width = rect.right - rect.left;
+	height = rect.bottom - rect.top;
+
+	wrk = malloc(width * height * pkl->channel);
+	if(!wrk) return(1);
+	memset(wrk, 0, width*height*pkl->channel);
+	
+	//for(i=0; i<pkl->channel; i++)
+	//	back[i] = (backcolor>>((pkl->channel-i)*8) & 0xFF);
+	memcpy(back, backcolor, pkl->channel);
+
+	for(i=rect.top; i<rect.bottom; i++){
+		for(j=rect.left; j<rect.right; j++){
+			px = (int)(cos(rad) * j - sin(rad) * i);
+			py = (int)(sin(rad) * j + cos(rad) * i);
+			if(px>=0 && px<pkl->width && py>=0 && py<pkl->height){
+				memcpy(&wrk[((i-rect.top)*width+j-rect.left)*pkl->channel],
+					&pkl->image[(py*pkl->width+px)*pkl->channel], pkl->channel);
+			}else{
+				memcpy(&wrk[((i-rect.top)*width+j-rect.left)*pkl->channel], back, pkl->channel);
+			}
+		}
+	}
+
+	free(pkl->image);
+	pkl->image = wrk;
+	pkl->width = width;
+	pkl->height = height;
+	return(0);
+}
+
+//=============================================================================
+// pkl_rotate_bl
+//=============================================================================
+static int pkl_rotate_bl(PKLImage pkl, float angle, unsigned char *backcolor)
+{
+	int width, height;
+	PIKL_RECT rect;
+	float rad;
+	unsigned char *wrk, back[4];
+	int i, j, k, wx, wy, sx, sy;
+	double dx, dy, px, py, f[4];
+	
+	rad = -angle*M_PI/180;
+	get_rect(&rect, pkl->width, pkl->height, rad);
+	width = rect.right - rect.left;
+	height = rect.bottom - rect.top;
+
+	wrk = malloc(width * height * pkl->channel);
+	if(!wrk) return(1);
+	memset(wrk, 0, width*height*pkl->channel);
+	
+	//for(i=0; i<pkl->channel; i++)
+	//	back[i] = (backcolor>>((pkl->channel-i)*8) & 0xFF);
+	memcpy(back, backcolor, pkl->channel);
+	
+	for(i=rect.top; i<rect.bottom; i++){
+		for(j=rect.left; j<rect.right; j++){
+			dx = modf(cos(rad)*j-sin(rad)*i, &px);
+			dy = modf(sin(rad)*j+cos(rad)*i, &py);
+			f[0] = (1.0-dx)*(1.0-dy);
+			f[1] = dx*(1.0-dy);
+			f[2] = (1.0-dx)*dy;
+			f[3] = dx*dy;
+
+			for(wy=0; wy<2; wy++){
+				for(wx=0; wx<2; wx++){
+					sx = ((int)px+wx<0) ? pkl->width +((int)px+wx)%pkl->width -1 : ((int)px+wx)%pkl->width;
+					sy = ((int)py+wy<0) ? pkl->height+((int)py+wy)%pkl->height-1 : ((int)py+wy)%pkl->height;
+					if(px>=0 && px<pkl->width && py>=0 && py<pkl->height){
+						for(k=0; k<pkl->channel; k++){
+							wrk[((i-rect.top)*width+j-rect.left)*pkl->channel+k] = 
+								PKL_RGB(wrk[((i-rect.top)*width+j-rect.left)*pkl->channel+k] +
+										pkl->image[(sy*pkl->width+sx)*pkl->channel+k] * f[wy*2+wx]);
+						}
+					}else{
+						memcpy(&wrk[((i-rect.top)*width+j-rect.left)*pkl->channel], back, pkl->channel);
+					}
+				}
+			}
+		}
+	}
+
+	free(pkl->image);
+	pkl->image = wrk;
+	pkl->width = width;
+	pkl->height = height;
+	return(0);
+}
+
+//=============================================================================
+// pkl_rotate_bc
+//=============================================================================
+static int pkl_rotate_bc(PKLImage pkl, float angle, unsigned char *backcolor)
+{
+	int width, height;
+	PIKL_RECT rect;
+	float rad;
+	unsigned char *wrk, back[4];
+	int i, j, k, px, py, x0, y0;
+	double wx, wy, dx, dy, sx, sy;
+	double data[PKL_CHANNEL];
+
+	rad = -angle*M_PI/180;
+	get_rect(&rect, pkl->width, pkl->height, rad);
+	width = rect.right - rect.left;
+	height = rect.bottom - rect.top;
+
+	wrk = malloc(width * height * pkl->channel);
+	if(!wrk) return(1);
+	memset(wrk, 0, width*height*pkl->channel);
+	
+	//for(i=0; i<pkl->channel; i++)
+	//	back[i] = (backcolor>>((pkl->channel-i)*8) & 0xFF);
+	memcpy(back, backcolor, pkl->channel);
+	
+	for(i=rect.top; i<rect.bottom; i++){
+		for(j=rect.left; j<rect.right; j++){
+			memset(&data, 0, sizeof(data));
+			sx = cos(rad) * j - sin(rad) * i;
+			sy = sin(rad) * j + cos(rad) * i;
+			for(py=(int)sy-1; py<=(int)sy+2; py++){
+				for(px=(int)sx-1; px<=(int)sx+2; px++){
+					dx = fabs(sx-px);
+					dy = fabs(sy-py);
+					wx = (dx<1) ? (dx-1)*(dx*dx-dx-1) : -(dx-1)*(dx-2)*(dx-2);
+					wy = (dy<1) ? (dy-1)*(dy*dy-dy-1) : -(dy-1)*(dy-2)*(dy-2);
+					x0 = (px<0 || px>pkl->width -1) ? sx : px;
+					y0 = (py<0 || py>pkl->height-1) ? sy : py;
+					
+					if(x0>=0 && x0<pkl->width && y0>=0 && y0<pkl->height){
+						for(k=0; k<pkl->channel; k++)
+							data[k] += pkl->image[(y0*pkl->width+x0)*pkl->channel+k]*wx*wy;
+					}
+				}
+			}
+			
+			if(sx>=0 && sx<pkl->width && sy>=0 && sy<pkl->height){
+				for(k=0; k<pkl->channel; k++)
+					wrk[((i-rect.top)*width+j-rect.left)*pkl->channel+k] = PKL_RGB(data[k]);
+			}else{
+				memcpy(&wrk[((i-rect.top)*width+j-rect.left)*pkl->channel], back, pkl->channel);
+			}
+		}
+	}
+
+	free(pkl->image);
+	pkl->image = wrk;
+	pkl->width = width;
+	pkl->height = height;
+	return(0);
+}
+
+////=============================================================================
+//// pkl_rotate_pa
+////=============================================================================
+//static int pkl_rotate_pa(PKLImage pkl, float angle, int backcolor)
+//{
+//	int width, height;
+//	PIKL_RECT rect;
+//	float rad;
+//	unsigned char *wrk, back[4];
+//	int i, j;
+//	double zx, zy, power;
+//	
+//	rad = -angle*M_PI/180;
+//	get_rect(&rect, pkl->width, pkl->height, rad);
+//	width = rect.right - rect.left;
+//	height = rect.bottom - rect.top;
+//
+//	wrk = malloc(width * height * pkl->channel);
+//	if(!wrk) return(1);
+//	memset(wrk, 0, width*height*pkl->channel);
+//	
+//	for(i=0; i<pkl->channel; i++)
+//		back[i] = (backcolor>>((pkl->channel-i)*8) & 0xFF);
+//
+//	zx = (double)pkl->width  / (double)width;
+//	zy = (double)pkl->height / (double)height;
+//	//���_�����������ϒl�Z�o�l
+//	power= zx*zy + (zx*zy * angle*M_PI/180 * angle*M_PI/180);
+//
+//	for(i=rect.top; i<rect.bottom; i++){
+//		for(j=rect.left; j<rect.right; j++){
+//			double w1, w2, h1, h2;
+//			double w1b, w2b, h1b, h2b;
+//			double bi, ixg[PKL_CHANNEL] = {0.0, 0.0, 0.0, 0.0};
+//			int fsx ,fsy, s, t, k;
+//			
+//			w1b = modf(cos(rad)*j    -sin(rad)*i,     &w1);
+//			w2b = modf(cos(rad)*(j+1)-sin(rad)*i, &w2);
+//			h1b = modf(sin(rad)*j    +cos(rad)*i,     &h1);
+//			h2b = modf(sin(rad)*j+cos(rad)*(i+1), &h2);
+//
+//			for(s=(int)w1; s<=(int)w2; s++){
+//				for(t=(int)h1; t<=(int)h2; t++){
+//					bi = 1.0;
+//					if(s == (int)w1) bi*=(1-w1b);
+//					if(s == (int)w2) bi*=(w2b);
+//					if(t == (int)h1) bi*=(1-h1b);
+//					if(t == (int)h2) bi*=(h2b);
+//					fsx = (s < 0) ? 0 : (s > pkl->width -1) ? pkl->width -1 : s;
+//					fsy = (t < 0) ? 0 : (t > pkl->height-1) ? pkl->height-1 : t;
+//					for(k=0; k<pkl->channel; k++)
+//						ixg[k] += pkl->image[(fsy*pkl->width+fsx)*pkl->channel+k] * bi;
+//				}
+//			}
+//			
+//			if((int)w1>=0 && (int)w1<pkl->width && (int)h1>=0 && (int)h1<pkl->height){
+//				for(k=0; k<pkl->channel; k++)
+//					wrk[((i-rect.top)*width+j-rect.left)*pkl->channel+k] = PKL_RGB(ixg[k]/power);
+//			}else{
+//				memcpy(&wrk[((i-rect.top)*width+j-rect.left)*pkl->channel], back, pkl->channel);
+//			}
+//
+//		}
+//	}
+//	free(pkl->image);
+//	pkl->image = wrk;
+//	pkl->width = width;
+//	pkl->height = height;
+//	return(0);
+//}

data/ext/pikl/pikl_rotate2.h

@@ -0,0 +1,19 @@
+#ifndef _LIB_PIKL_ROTATE2_
+#define _LIB_PIKL_ROTATE2_
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+#include "pikl.h"
+#include "pikl_private.h"
+
+typedef struct{
+	int left;
+	int top;
+	int right;
+	int bottom;
+} PIKL_RECT;
+
+#endif
+

data/lib/pikl/ext.rb

@@ -13,6 +13,7 @@ module Pikl
     typealias("PKL_FORMAT", "int")
     typealias("PKL_ANGLE", "int")
     typealias("PKL_SAMPLE", "int")
+    typealias("uchar", "unsigned char")
 
     extern "PKLImage *pkl_open(char*)"
     extern "void pkl_close(PKLImage*)"
@@ -22,7 +23,8 @@ module Pikl
     extern "int pkl_width(PKLImage *)"
     extern "int pkl_height(PKLImage *)"
     extern "int pkl_trim(PKLImage *, int, int, int, int)"
-    extern "int pkl_rotate(PKLImage *, PKL_ANGLE)"
+    extern "int pkl_rotate(PKLImage*, PKL_ANGLE)"
+    extern "int pkl_rotate2(PKLImage*, float, PKL_SAMPLE, uchar, uchar, uchar, uchar)"
     extern "int pkl_resize(PKLImage*, int, int, PKL_SAMPLE)"
     extern "int pkl_unsharp(PKLImage *, int, double)"
     extern "int pkl_contrast(PKLImage *, int)"

data/lib/pikl/image.rb

@@ -70,11 +70,31 @@ module Pikl
       end
     end
 
-    def rotate(angle)
-      validate_rotate(angle)
-      Ext.pkl_rotate(@pkl_image, ROTATE_ANGLE[angle.to_i])
+    def rotate(angle, backcolor = "#FFFFFF", sample = :bilinear)
+
+      if ROTATE_ANGLE.has_key?(angle.to_i)
+        validate_rotate(angle)
+        Ext.pkl_rotate(@pkl_image, ROTATE_ANGLE[angle.to_i])
+      else
+        ci = color_int(backcolor)
+        Ext.pkl_rotate2(@pkl_image, angle.to_f, SAMPLES[sample.to_sym], ci[0], ci[1], ci[2], ci[3])
+      end
       self
     end
+    
+    def color_int(colorstr)
+      validate_color(colorstr)
+      cs = colorstr.gsub(/^#/,"")
+      color = []
+      0.step(6,2) do |i|
+        color << ( cs[i,2].to_s.empty? ? "FF" : cs[i,2] )
+      end
+      color.map!{|c| c.hex}
+    end
+
+    def validate_color(v)
+      error("invalid color parameter. # => #{v}") unless  /^#[a-f|A-F|0-9]+$/ =~ v.to_s
+    end
 
     def resize(width, height, sample = :pixcel_averate)
       validate_auto(width,height)

data/lib/pikl/version.rb

@@ -2,7 +2,7 @@ module Pikl #:nodoc:
   module VERSION #:nodoc:
     MAJOR = 0
     MINOR = 2
-    TINY  = 3
+    TINY  = 4
 
     STRING = [MAJOR, MINOR, TINY].join('.')
   end

data/test/test_pikl_image.rb

@@ -119,7 +119,13 @@ class TestPiklImage < Test::Unit::TestCase
           assert_equal(SAMPLE_IMAGE_H,imgout.width)
           assert_equal(SAMPLE_IMAGE_W,imgout.height)
         end
-    
+
+        img.rotate(285,"#000000")
+        img.save(SAMPLE_OUTPUT)
+        Pikl::Image.open(SAMPLE_OUTPUT) do |imgout|
+          assert_equal(157,imgout.width)
+          assert_equal(185,imgout.height)
+        end
       end
     end
     

metadata

@@ -1,30 +1,35 @@
 --- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.2
+specification_version: 1
 name: pikl
 version: !ruby/object:Gem::Version 
-  version: 0.2.3
+  version: 0.2.4
+date: 2008-06-13 00:00:00 +09:00
+summary: Pikl is an image librarry for JPEG, PNG and Bitmap.Pikl's API is designed to process the image easily with method chain.
+require_paths: 
+- lib
+- ext
+email: 
+- ""
+homepage: http://pikl.rubyforge.org
+rubyforge_project: pikl
+description: Pikl is an image librarry for JPEG, PNG and Bitmap.Pikl's API is designed to process the image easily with method chain.
+autorequire: 
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
 platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
 authors: 
 - Ryota Maruko
-autorequire: 
-bindir: bin
-cert_chain: []
-
-date: 2008-05-24 00:00:00 +09:00
-default_executable: 
-dependencies: []
-
-description: Pikl is an image librarry for JPEG, PNG and Bitmap.Pikl's API is designed to process the image easily with method chain.
-email: 
-- ""
-executables: []
-
-extensions: 
-- ext/pikl/extconf.rb
-extra_rdoc_files: 
-- History.txt
-- License.txt
-- Manifest.txt
-- README.txt
 files: 
 - History.txt
 - License.txt
@@ -50,6 +55,8 @@ files:
 - ext/pikl/pikl_resize.h
 - ext/pikl/pikl_rotate.c
 - ext/pikl/pikl_rotate.h
+- ext/pikl/pikl_rotate2.c
+- ext/pikl/pikl_rotate2.h
 - ext/pikl/pikl_trim.c
 - ext/pikl/pikl_trim.h
 - lib/pikl.rb
@@ -62,34 +69,22 @@ files:
 - test/sample.jpg
 - test/test_helper.rb
 - test/test_pikl_image.rb
-has_rdoc: true
-homepage: http://pikl.rubyforge.org
-post_install_message: 
+test_files: 
+- test/test_helper.rb
+- test/test_pikl_image.rb
 rdoc_options: 
 - --main
 - README.txt
-require_paths: 
-- lib
-- ext
-required_ruby_version: !ruby/object:Gem::Requirement 
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      version: "0"
-  version: 
-required_rubygems_version: !ruby/object:Gem::Requirement 
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      version: "0"
-  version: 
+extra_rdoc_files: 
+- History.txt
+- License.txt
+- Manifest.txt
+- README.txt
+executables: []
+
+extensions: 
+- ext/pikl/extconf.rb
 requirements: []
 
-rubyforge_project: pikl
-rubygems_version: 1.0.1
-signing_key: 
-specification_version: 2
-summary: Pikl is an image librarry for JPEG, PNG and Bitmap.Pikl's API is designed to process the image easily with method chain.
-test_files: 
-- test/test_helper.rb
-- test/test_pikl_image.rb
+dependencies: []
+