pikl 0.1.0

data/ext/pikl/pikl_resize.h

@@ -0,0 +1,12 @@
+#ifndef _LIB_PIKL_RESIZE_
+#define _LIB_PIKL_RESIZE_
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+
+#include "pikl.h"
+#include "pikl_private.h"
+
+#endif

data/ext/pikl/pikl_rotate.c

@@ -0,0 +1,70 @@
+#include "pikl_rotate.h"
+
+//=================================================================================
+// pkl_rotate
+//=================================================================================
+PKLExport int pkl_rotate(PKLImage pkl, PKL_ANGLE angle)
+{
+	unsigned char *wrk;
+	int rsin, rcos;
+	int width, height;
+	int sx, sy, ex, ey;
+	int i, j, x, y;
+
+	switch(angle){
+		case PKL_ANGLE_000:
+			return(0);
+		case PKL_ANGLE_090:
+			rcos   =  0;
+			rsin   = -1;
+			width  = pkl->height;
+			height = pkl->width;
+			sx     = -(pkl->height-1);
+			sy     = 0;
+			ex     = 0;
+			ey     = pkl->width-1;
+			break;
+		case PKL_ANGLE_180:
+			rcos   = -1;
+			rsin   =  0;
+			width  = pkl->width;
+			height = pkl->height;
+			sx     = -(pkl->width-1);
+			sy     = -(pkl->height-1);
+			ex     = 0;
+			ey     = 0;
+			break;
+		case PKL_ANGLE_270:
+			rcos   = 0;
+			rsin   = 1;
+			width  = pkl->height;
+			height = pkl->width;
+			sx     = 0;
+			sy     = -(pkl->width-1);
+			ex     = pkl->height-1;
+			ey     = 0;
+			break;
+		default:
+			return(1);
+	}
+	
+	wrk = malloc(width * height * pkl->channel);
+	if(!wrk) return(1);
+
+	for(i=sy; i<=ey; i++){
+		for(j=sx; j<=ex; j++){
+			x = rcos * j - rsin * i;
+			y = rsin * j + rcos * i;
+			memcpy(&wrk[((i-sy)*width+j-sx)*pkl->channel], &pkl->image[(y*pkl->width+x)*pkl->channel], pkl->channel);
+		}
+	}
+	
+	free(pkl->image);
+	pkl->image  = wrk;
+	pkl->width  = width;
+	pkl->height = height;
+	
+	return(0);
+}
+
+

data/ext/pikl/pikl_rotate.h

@@ -0,0 +1,12 @@
+#ifndef _LIB_PIKL_ROTATE_
+#define _LIB_PIKL_ROTATE_
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+
+#include "pikl.h"
+#include "pikl_private.h"
+
+#endif

data/ext/pikl/pikl_trim.c

@@ -0,0 +1,28 @@
+#include "pikl_trim.h"
+
+//=================================================================================
+// pkl_trim
+//=================================================================================
+PKLExport int pkl_trim(PKLImage pkl, int sx, int sy, int width, int height)
+{
+	unsigned char *wrk;
+	int p, y;
+	
+	if( sx < 0 || sy < 0 || width <= 0 || height <= 0 ) return(1);
+	if( sx+width  > pkl->width  ) return(1);
+	if( sy+height > pkl->height ) return(1);
+	
+	wrk = malloc(height * width * pkl->channel);
+	if(!wrk) return(1);
+	
+	for(p=0,y=sy; y<sy+height; p++,y++){
+		memcpy(&wrk[p*width*pkl->channel], &pkl->image[(y*pkl->width+sx)*pkl->channel], width*pkl->channel);
+	}
+	
+	free(pkl->image);
+	pkl->image  = wrk;
+	pkl->height = height;
+	pkl->width  = width;
+
+	return(0);
+}

data/ext/pikl/pikl_trim.h

@@ -0,0 +1,11 @@
+#ifndef _LIB_PIKL_TRIM_
+#define _LIB_PIKL_TRIM_
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "pikl.h"
+#include "pikl_private.h"
+
+#endif

data/lib/pikl.rb

@@ -0,0 +1,14 @@
+#--
+# = Pikl - a simple image library.
+# Author::    Ryota Maruko and Keiko Soejima
+# Copyright:: (c) 2008 Ryota Maruko and Keiko Soejima
+# License::   MIT License
+#++
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+module Pikl
+  require "pikl/const"
+  require "pikl/ext"
+  require "pikl/errors"  
+  require "pikl/image"  
+end

data/lib/pikl/const.rb

@@ -0,0 +1,49 @@
+module Pikl
+
+  JPEG   = 1
+  JPG    = JPEG
+  PNG    = 2
+  BITMAP = 3
+  BMP    = BITMAP
+  
+  ANGLE000 = 0
+  ANGLE090 = 1
+  ANGLE180 = 2
+  ANGLE270 = 3
+
+	SAMPLE_NN	= 1  #nearest neighbor
+	SAMPLE_BC	= 2  #bicubic(4points)
+	SAMPLE_BC2 = 3 #bicubic(16points)
+	SAMPLE_PA	= 4  #pixcel average(reduce only)
+	SAMPLE_LZ	= 5  #lanczos
+	
+	SAMPLES = {
+	  :nearest_neighbor => SAMPLE_NN,
+	  :bicubic => SAMPLE_BC,
+	  :bicubic2 => SAMPLE_BC2,
+	  :pixcel_averate => SAMPLE_PA,
+	  :lanczoz => SAMPLE_LZ,
+	}
+  
+  ROTATE_ANGLE = {
+    0   => ANGLE000,
+    90  => ANGLE090,
+    180 => ANGLE180,
+    270 => ANGLE270,      
+    360 => ANGLE000,      
+  }
+
+  
+  EXTENSIONS_FORMATS = {
+    "jpeg" => JPEG,
+    "jpg"  => JPEG,
+    "png"  => PNG,
+    "bmp"  => BITMAP,
+  }
+  
+  EXTENSIONS = EXTENSIONS_FORMATS.keys
+  FORMATS = EXTENSIONS_FORMATS.values.uniq
+  
+  PIX_LIMIT = 6000
+
+end

data/lib/pikl/errors.rb

@@ -0,0 +1,7 @@
+module Pikl
+
+  class ParameterException < Exception; end
+
+  class ImageProcessException < Exception; end
+  
+end

data/lib/pikl/ext.rb

@@ -0,0 +1,32 @@
+module Pikl
+  require "dl/import"
+  require "dl/struct"
+  require "rbconfig"
+  
+  module Ext
+    extend DL::Importable
+    dlload "#{File.dirname(__FILE__)}/pikl.#{RbConfig::CONFIG['DLEXT']}"
+
+    typealias("KKImage", "void")
+    typealias("PKL_FORMAT", "int")
+    typealias("PKL_ANGLE", "int")
+    typealias("PKL_SAMPLE", "int")
+
+    extern "PKLImage *pkl_open(char*)"
+    extern "void pkl_close(PKLImage*)"
+    extern "int pkl_save(PKLImage*, const char *, PKL_FORMAT)"
+    extern "int pkl_compress(PKLImage*, int)"
+    extern "PKL_FORMAT pkl_format(PKLImage *)"
+    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_resize(PKLImage*, int, int, PKL_SAMPLE)"
+    extern "int pkl_unsharp(PKLImage *, int, double)"
+    extern "int pkl_contrast(PKLImage *, int)"
+    extern "int pkl_level(PKLImage *, double, double, double)"
+    extern "int pkl_brightness(PKLImage*, int)"
+    extern "int pkl_hls(PKLImage*, double, double, double)"
+    extern "int pkl_gamma(PKLImage*, double)"
+  end
+end

data/lib/pikl/image.rb

@@ -0,0 +1,219 @@
+module Pikl
+  
+  class Image
+
+    def self.open(inpath, &block)      
+      image = Pikl::Image.new(inpath)
+      image.instance_variable_set(:@block,block)
+      
+      return image unless block_given?
+
+      begin
+        block.call(image)
+      ensure
+        image.close if image
+      end
+    
+    end
+    
+    def initialize( inpath )
+      @pkl_image = Ext.pkl_open(File.expand_path(inpath))
+    end
+
+    def save(outpath, format = nil, compress = nil)
+      raise Pikl::ImageProcessException.new("image already closed.") unless @pkl_image
+      format ||= @format ||= split_extensions(outpath)
+      validate_format(format)
+      if compress
+        validate_compress(compress)
+        Ext.pkl_compress(@pkl_image, compress.to_i)
+      end
+      Ext.pkl_save(@pkl_image, File.expand_path(outpath), EXTENSIONS_FORMATS[format.to_s] || format.to_i)
+      self.close unless(@block)
+    end
+    
+    def close()
+      Ext.pkl_close(@pkl_image) if @pkl_image
+      @pkl_image = nil
+    end
+    
+    def width
+      Ext.pkl_width(@pkl_image) if(@pkl_image)
+    end
+    
+    def height
+      Ext.pkl_height(@pkl_image) if(@pkl_image)
+    end
+    
+    def format
+      Ext.pkl_format(@pkl_image) if(@pkl_image)
+    end
+    
+    def trim(x, y, dist_x, dist_y)
+      validate_trim(x, y, dist_x, dist_y)
+      dist_x = trim_dist(x, self.width, dist_x)
+      dist_y = trim_dist(y, self.height, dist_y)
+            
+      Ext.pkl_trim(@pkl_image, x, y, dist_x, dist_y)
+    end
+    
+    def trim_dist(start, dist_from, dist_to)
+      if dist_to == :auto || dist_to > (dist_from - start)
+        dist_to = dist_from - start
+      elsif dist_to < 0
+        dist_to += (dist_from - start)
+      else
+        dist_to
+      end
+    end
+
+    def rotate(angle)
+      validate_rotate(angle)
+      Ext.pkl_rotate(@pkl_image, ROTATE_ANGLE[angle.to_i])
+    end
+
+    def resize(width, height, sample = :nearest_neighbor)
+      validate_auto(width,height)
+
+      case sample.class.name
+      when 'Symbol', 'String'
+        sample = SAMPLES[sample.to_sym]
+      end
+      
+      width = self.width * height / self.height if(width == :auto)
+      height = self.height * width / self.width if(height == :auto)
+      
+      validate_resize(width, height)
+
+      Ext.pkl_resize(@pkl_image, width, height, sample)
+    end
+
+    # threshold=0-255
+    #  threshold=0の時は変化しません
+    #  threshold=255の時は全ての色にアンシャープ処理が働きます
+    # edge=-10 .. 10
+    # 	edge=0の時は変化しません
+    # 	edge>0の時は値が大きいほど先鋭化されます
+    # 	edge<0の時は値が小さいほどぼやけます
+    # 
+    # 	想定結果が得られる範囲は-10 .. 10程度です。
+    # 	これを超える場合は、品質の保証はありません
+    # 	※画質によりこの通りではありません。-10..10の範囲より小さくなる可能性があります。
+    def unshapmask(threshold, edge)
+      Ext.pkl_unsharp(@pkl_image, threshold.to_i, edge.to_f)
+    end
+
+    # コントラスト調整
+    #  コントラストを強くするということは、白い部分をより白く、
+    #  黒い部分をより黒くするような変換を意味します。
+    #  逆にコントラストを弱くした場合、白い部分と黒い部分の差が無くなり、灰色っぽい画像になります。
+    # <rate>
+    # 	範囲：-127 .. 127
+    # 	rate=0の時は変化しません
+    # 		* rateが0以上の時は周波数によるコントラスト強調がおこなわれます
+    # 		* rateが0未満の時は直線的に平坦化されます
+    def contrast(rate)
+      Ext.pkl_contrast(@pkl_image, rate.to_f)
+    end
+
+    # レベル補正
+    # 	ヒストグラムの平坦化をおこないます。各色の分布に偏りがある画像に有効な場合があります。
+    # 	coeff = 平坦化時の係数です。1が標準です。1より小さい場合は暗く、1より大きい場合は明るくなります(0.0..2.0)
+    # 	low  = 全ピクセル数に対して、切り捨てる暗い色の総数の割合(0-100%)
+    # 	high = 全ピクセル数に対して、切り捨てる明るい色の総数の割合(0-100%)
+    def level(low, high, coeff)
+      Ext.pkl_level(@pkl_image, low.to_f, high.to_f, coeff.to_f)
+    end
+
+    # 明るさ調整
+    # この明るさ調整は各色からcolor値を加算する単純な処理です。
+    # colorに255を指定すれば、ただの白い画像になります
+    # colorに-255を指定すると、ただの黒い画像になります。
+    def brightness(color)
+      Ext.pkl_brightness(@pkl_image, color.to_i)
+    end
+    
+    # 輝度(明るさ)・彩度(鮮やかさ)・色相(色合い)調整
+    #   * 具体的にどういうことかを理解したい場合は、mspaintの「色の編集」を見ると良いでしょう。
+    #   ym(輝度) -1 .. 1(0.1で10%up).0では変化なし
+    #   sm(彩度) -1 .. 1(0.1で10%up).0では変化なし
+    #   hd(色相) 360.0度回転(R=113.2/Ye=173.0/G=225.0/Cy=293.2/B=353.0/Mg=45.0).360の倍数では変化なし
+    def hls(ym, sm ,hd)
+      Ext.pkl_hls(@pkl_image, ym.to_f, sm.to_f, hd.to_f)
+    end
+    
+    # ガンマ補正
+    #   ガンマ補正をします。
+    #   gmは補正係数です。
+    #   gm=0以上の値が指定できます。
+    #   1.0より小さい時は暗く、1.0より大きい時は明るく調整されます。
+    #   1.0を指定した時は調整されません。    
+    def gamma(gm)
+      Ext.pkl_gamma(@pkl_image, gm.to_f)
+    end
+    
+    # regular expressions to try for identifying extensions
+    def split_extensions(path)
+      filename = path.split('/').last
+      (filename =~ %r|.+\.([a-z,A-Z]+)$|) ? $1 : nil
+    end
+
+    def validate_auto(width, height)
+      error("invalid :autoto in the both of width and height.") if(width == :auto && height == :auto)
+    end
+
+    # validate identifying extensions
+    def validate_format(ext)
+      error(ext) unless (ext || EXTENSIONS.include?(ext.to_s.downcase) || FORMATS.include?(ext.to_i))
+    end
+
+    def validate_trim(x, y, dist_x, dist_y)
+      validate_numeric(x, y)
+      
+      validate_pix(dist_x, true)
+      validate_pix(dist_y, true)
+
+      error("left is outside the range.  #{x}") if x > self.width.to_i
+      error("top is outside the range.  #{y}") if y > self.height.to_i
+    end
+
+    def validate_rotate(angle)
+      validate_numeric(angle)
+      error("invalid angle. # => #{angle}") unless ROTATE_ANGLE.has_key?(angle)
+    end
+    
+    def validate_resize(width, height)
+      validate_auto(width, height)
+      validate_pix(width)
+      validate_pix(height)
+    end
+
+    def validate_pix(value, allow_minus = false)
+      return if value == :auto
+      validate_numeric(value)
+      error("value is outside the range.  #{value}") if value == 0
+      error("value is outside the range.  #{value}") if !allow_minus && value < 0
+      error("value is outside the range.  #{value}") if value > PIX_LIMIT
+    end
+
+    def validate_numeric(*args)
+      args = [args] unless args.is_a?(Array)
+      args.each do |v|
+        error("invalid parameter. # => #{v}") unless /^[-\d]+$/ =~ v.to_s
+      end      
+    end
+    
+    def validate_compress(v)
+      error("invalid compress parameter. # => #{v}") unless /^\d+$/ =~ v.to_s
+      error("invalid compress parameter. # => #{v}") unless v.to_i >= 0 && v.to_i <= 10
+    end
+
+    def error(message)
+      #self.close
+      raise Pikl::ParameterException.new(message)
+    end
+  end
+end
+
+
+