pikl 0.2.8-x86-mswin32 → 0.3.0-x86-mswin32

data/ext/pikl/pikl_voronoi.h

@@ -0,0 +1,37 @@
+#ifndef _LIB_PIKL_VORONOI_
+#define _LIB_PIKL_VORONOI_
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+
+#include "pikl.h"
+#include "pikl_private.h"
+
+
+//=============================================================================
+// voronoi_zone datatype
+//=============================================================================
+struct VoronoiPoint {
+	int x, y;
+	long color[PKL_CHANNEL];
+	unsigned char ave[PKL_CHANNEL];
+	int count;
+};
+
+//=============================================================================
+// voronoi_count datatype
+//=============================================================================
+//�{���m�C�̕�_�Ǘ��p(1�‚̕�_����אڂ����_�̌�)
+#define VORONOI_CNT 10	//�����͂Ȃ�
+
+struct VORONOI {
+	int x, y;				//��_���W
+	int id;					//�Ǘ��pID
+	long color[PKL_CHANNEL];	//�^�[�Q�b�g�̈�̐F�ݐϗ̈�
+	int count;				//�ݐσs�N�Z����
+	int next[VORONOI_CNT];	//�אڂ����_��ID
+};
+
+#endif

data/lib/pikl.rb

@@ -9,6 +9,8 @@ $:.unshift(File.dirname(__FILE__)) unless
 module Pikl
   require "pikl/const"
   require "pikl/ext"
-  require "pikl/errors"  
-  require "pikl/image"  
+  require "pikl/errors"
+  require "pikl/image"
+  require "pikl/color"
+  require "pikl/filter"
 end

data/lib/pikl/color.rb

@@ -0,0 +1,47 @@
+module Pikl
+  
+  class Color
+    
+    def initialize(a,b,c,d)
+      validate_color(a)
+      validate_color(b)
+      validate_color(c)
+      validate_color(d)
+      @color = Pikl::Ext.pkl_color_create(a,b,c,d)
+    end
+
+    def Color.gray(g)
+      new(g,0,0,0)
+    end
+
+    def Color.rgb(r, g, b)
+      new(r,g,b,0)
+    end
+
+    def Color.cmyk(c,m,y,k)
+      new(c,m,y,k)
+    end
+    
+    #attr_accessor :color
+    def rawdata
+      @color
+    end
+    
+    def getcolor(colormodel)
+      error("invalid colormodel parameter. # => #{colormodel}") unless COLORMODEL.include?(colormodel)
+      Ext.pkl_color(@color, COLORMODEL[colormodel])
+    end
+
+    def close
+      Ext.pkl_color_close(@color)
+      @color=nil
+    end
+    
+    def validate_color(v)
+      error("invalid color parameter. # => #{v}") unless /^\d+$/ =~ v.to_s
+      error("invalid color parameter. # => #{v}") unless v.to_i >= 0 && v.to_i <= 255
+    end
+    
+  end
+end
+

data/lib/pikl/const.rb

@@ -11,33 +11,32 @@ module Pikl
   ANGLE180 = 2
   ANGLE270 = 3
 
-	SAMPLE_NN	= 1  #nearest neighbor
-	SAMPLE_BL	= 2  #bilinear
-	SAMPLE_BC = 3  #bicubic
-	SAMPLE_PA	= 4  #pixcel average(reduce only)
-	SAMPLE_LZ	= 5  #lanczos
-
-	SAMPLES = {
-	  :nearest_neighbor => SAMPLE_NN,
-	  :bilinear => SAMPLE_BL,
-	  :bicubic => SAMPLE_BC,
-	  :pixcel_averate => SAMPLE_PA,
-	  :lanczos => SAMPLE_LZ,
-	  :nn => SAMPLE_NN,
-	  :bl => SAMPLE_BL,
-	  :bc => SAMPLE_BC,
-	  :pa => SAMPLE_PA,
-	  :lz => SAMPLE_LZ,
-	}
+  SAMPLE_NN	= 1  #nearest neighbor
+  SAMPLE_BL	= 2  #bilinear
+  SAMPLE_BC = 3  #bicubic
+  SAMPLE_PA	= 4  #pixcel average(reduce only)
+  SAMPLE_LZ	= 5  #lanczos
+
+  SAMPLES = {
+    :nearest_neighbor => SAMPLE_NN,
+    :bilinear => SAMPLE_BL,
+    :bicubic => SAMPLE_BC,
+    :pixcel_averate => SAMPLE_PA,
+    :lanczos => SAMPLE_LZ,
+    :nn => SAMPLE_NN,
+    :bl => SAMPLE_BL,
+    :bc => SAMPLE_BC,
+    :pa => SAMPLE_PA,
+    :lz => SAMPLE_LZ,
+  }
   
   ROTATE_ANGLE = {
     0   => ANGLE000,
     90  => ANGLE090,
     180 => ANGLE180,
-    270 => ANGLE270,      
-    360 => ANGLE000,      
+    270 => ANGLE270,
+    360 => ANGLE000,
   }
-
   
   EXTENSIONS_FORMATS = {
     "jpeg" => JPEG,
@@ -51,4 +50,89 @@ module Pikl
   
   PIX_LIMIT = 6000
 
-end
+
+##----soezimaster add.
+  # dummy image ... umm
+  DEFAULT_IMAGE = ''
+
+  # COLORSPACE
+  COLORSPACE = {
+    :GRAY => 2,
+    :RGB  => 3,
+    :CMYK => 6
+  }
+
+  # COLORMODEL
+  COLORMODEL = {
+    :gray    => 0,
+    :red     => 1,
+    :green   => 2,
+    :blue    => 3,
+    :cyan    => 4,
+    :magenta => 5,
+    :yellow  => 6,
+    :black   => 7
+  }
+
+  # dither-type
+  DITHER = {
+    :non => 0,
+    :floydsteinberg => 1,
+    :stucci => 2,
+    :sierra => 3,
+    :jajuni => 4
+  }
+
+  # focus-type
+  FOCUS = {
+    :detail => 0,
+    :focus  => 1,
+    :edges  => 2
+  }
+
+  # emboss-type
+  EMBOSS = {
+    :emboss    => 0,
+    :heavy     => 1,
+    :light     => 2,
+    :laplacian => 3
+  }
+
+  # gray-type
+  GRAY = {
+    :nrm => 0,
+    :med => 1,
+    :ave => 2
+  }
+
+  # wave-type
+  WAVE = {
+    :horz => 0,
+    :vert => 1,
+    :both => 2
+  }
+
+  # pattern-type
+  PATTERN = {
+    :p_hexagon => 0,
+    :p_diamond => 1,
+    :p_circle  => 2,
+    :p_brick   => 3
+  }
+
+  # paint-type
+  PAINT = {
+    :line => 0,
+    :ave  => 1
+  }
+
+  # tile-type
+  TILE = {
+    :t_rect    => 0,
+    :t_hexagon => 1,
+    :t_diamond => 2,
+    :t_circle  => 3,
+    :t_brick   => 4
+  }
+
+end

data/lib/pikl/ext.rb

@@ -9,33 +9,140 @@ module Pikl
     dlext = (RbConfig::CONFIG["host_os"] == 'mswin32') ? 'dll' : RbConfig::CONFIG['DLEXT']
     dlload "#{File.dirname(__FILE__)}/pikl.#{dlext}"
 
-    typealias("KKImage", "void")
+    typealias("FILE", "void")
+    typealias("PKLImage", "void")
+    typealias("PKLColor", "void")
     typealias("PKL_FORMAT", "int")
     typealias("PKL_ANGLE", "int")
     typealias("PKL_SAMPLE", "int")
     typealias("uchar", "unsigned char")
+    typealias("PKL_COLOR_SPACE", "int")
+    typealias("PKL_PATTERN_TYPE", "int")
+    typealias("PKL_PAINT_TYPE", "int")
+    typealias("PKL_DITHER", "int")
+    typealias("PKL_WAVE", "int")
+    typealias("PKL_FOCUS", "int")
+    typealias("PKL_EMBOSS", "int")
+    typealias("PKL_COLOR_MODEL", "int")
+    typealias("PKL_TILE_TYPE", "int")
+    typealias("PKL_GRAYTYPE", "int")
 
+## utility
+    extern "PKLColor *pkl_color_gray(uchar)"
+    extern "PKLColor *pkl_color_rgb(uchar, uchar, uchar)"
+    extern "PKLColor *pkl_color_cmyk(uchar, uchar, uchar, uchar)"
+    extern "PKLColor *pkl_color_create(uchar, uchar, uchar, uchar)"
+    extern "void pkl_color_close(PKLColor*)"
+    extern "uchar pkl_get_color(PKLImage*, int, int, PKL_COLOR_MODEL)"
+    extern "int pkl_set_color(PKLImage*, int, int, PKL_COLOR_MODEL, uchar)"
+    extern "PKLColor *pkl_get_pixel(PKLImage*, int, int)"
+    extern "int pkl_set_pixel(PKLImage*, int, int, PKLColor*)"
+    extern "uchar pkl_color(PKLColor*, PKL_COLOR_MODEL)"
+
+## basic method
     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 "PKLImage *pkl_canvas(int, int, PKL_COLOR_SPACE, PKLColor*)"
+    extern "PKLImage *pkl_fdopen(FILE*)"
+    extern "int pkl_output(PKLImage*, FILE*, PKL_FORMAT)"
+    extern "PKLImage *pkl_dup(PKLImage*)"
+
+## information
     extern "PKL_FORMAT pkl_format(PKLImage *)"
     extern "int pkl_width(PKLImage *)"
     extern "int pkl_height(PKLImage *)"
+    extern "int pkl_count(PKLImage *)"
+    extern "PKL_COLOR_SPACE pkl_colorspace(PKLImage*)"
+
+## basic operation
     extern "int pkl_trim(PKLImage *, int, int, int, int)"
-    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_rotate(PKLImage*, float, PKL_SAMPLE, PKLColor*)"
+    extern "int pkl_affine(PKLImage*, PKL_SAMPLE, int, int, PKLColor*, double, double, double, int, int)"
+
+## enhance
     extern "int pkl_unsharp(PKLImage *, int, double)"
-    extern "int pkl_contrast(PKLImage *, int)"
+    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)"
+    extern "int pkl_noisecut(PKLImage*)"
+
+## blur
+    extern "int pkl_blur(PKLImage*, int)"
+    extern "int pkl_gaussblur(PKLImage*, double)"
+    extern "int pkl_rblur(PKLImage*, int, int, double, int)"
+    extern "int pkl_ablur(PKLImage*, int, int, double, int)"
+    extern "int pkl_wblur(PKLImage*, int, int, double, int, double)"
+    extern "int pkl_mblur(PKLImage*, double, int)"
+
+## pattern
+    extern "int pkl_pattern(PKLImage*, int, int, PKL_PATTERN_TYPE, PKL_PAINT_TYPE)"
+    extern "int pkl_mosaic(PKLImage*, int, int)"
+    extern "int pkl_pixelate(PKLImage*, int)"
+    extern "int pkl_grid(PKLImage*, int, int, int)"
+    extern "int pkl_tile(PKLImage*, PKL_TILE_TYPE, int, int, uchar)"
+
+## voronoi
+    extern "int pkl_voronoi_zone(PKLImage*, int, PKLColor*, int)"
+    extern "int pkl_voronoi_count(PKLImage*, int, PKLColor*, int)"
+
+## decrease
+    extern "int pkl_posterize(PKLImage*, int)"
+    extern "int pkl_cutcolor(PKLImage*, int)"
+    extern "int pkl_rgb(PKLImage*)"
+    extern "int pkl_gray(PKLImage*, PKL_GRAYTYPE)"
+    extern "int pkl_2c(PKLImage*, int)"
+
+## divide
+    extern "int pkl_tileslit(PKLImage*, int, int)"
+    extern "int pkl_splitframe(PKLImage*, PKLColor*, int, int, int, int)"
+
+## composite
+    extern "int pkl_composite(PKLImage*, PKLImage*, int, int, PKLColor*)"
+    extern "int pkl_alphablend(PKLImage*, PKLImage*, int, int, int)"
+    extern "int pkl_shadowframe(PKLImage*, int, PKLColor*, PKLColor*)"
+    extern "int pkl_randomshadow(PKLImage*, PKLImage*, int, int, int, PKLColor*)"
+
+## basic effect
+    extern "int pkl_invert(PKLImage*)"
+    extern "int pkl_sepia(PKLImage*, double, double, double)"
+    extern "int pkl_oilpaint(PKLImage*, int)"
+    extern "int pkl_kuwahara(PKLImage*, int)"
+    extern "int pkl_noise(PKLImage*, int)"
+    extern "int pkl_vtr(PKLImage*, int, int, int)"
+    extern "int pkl_dither(PKLImage*, PKL_DITHER)"
+    extern "int pkl_edgepaint(PKLImage*, int)"
+    extern "int pkl_edge(PKLImage*, int)"
+    extern "int pkl_contour(PKLImage*)"
+    extern "int pkl_focus(PKLImage*, PKL_FOCUS)"
+    extern "int pkl_emboss(PKLImage*, PKL_EMBOSS)"
+    extern "int pkl_emboss2(PKLImage*, int *, int, int, double, int)"
+
+## camera
+    extern "int pkl_vignette(PKLImage*, PKLColor*, int, int, int, int)"
+    extern "int pkl_vaseline(PKLImage*, int, int, int)"
+    extern "int pkl_film(PKLImage*, PKLColor*, int)"
+    extern "int pkl_vv(PKLImage*, PKLColor*, int, int, int, int)"
+
+## special
+    extern "int pkl_edgeposter(PKLImage*, int, double, double, double, int)"
+    extern "int pkl_crayon(PKLImage*, double, int, int, int)"
+    extern "int pkl_rinkaku(PKLImage*, double)"
+    extern "int pkl_hydrangea(PKLImage*, int, double, double, double, double, double)"
+    extern "int pkl_alphaedge(PKLImage*, int, double, double, double, int, int)"
+
+## scrap
+    extern "int pkl_swirl(PKLImage*, double, int, int, PKLColor*)"
+    extern "int pkl_wave(PKLImage*, PKL_WAVE, double, double)"
+    extern "int pkl_dots(PKLImage*, int, PKLColor*)"
+    extern "int pkl_colordither(PKLImage*, int)"
+    extern "int pkl_sobelpaint(PKLImage*, int, float, float, float)"
+    extern "int pkl_illust(PKLImage*, int, int, int)"
+    extern "int pkl_color_emboss(PKLImage*, double, double)"
 
-    extern "int pkl_mosaic(PKLImage *, int, int)"
-    extern "int pkl_composite(PKLImage *, PKLImage *, int, int)"
-    extern "int pkl_mediancut(PKLImage *, int, int)"
-    extern "int pkl_alphablend(PKLImage *, PKLImage *, int, int, int)"
   end
 end

data/lib/pikl/filter.rb

@@ -0,0 +1,371 @@
+module Pikl
+  
+  class Image
+  
+    # unshapmask
+    def unshapmask(threshold, edge)
+      error("invalid parameter. # => #{threshold}") if threshold.to_i<0 || threshold.to_i>255
+      error("invalid parameter. # => #{edge}") if edge.to_f<-10.0 || edge.to_f>10.0
+      Ext.pkl_unsharp(@pkl_image, threshold.to_i, edge.to_f)
+      self
+    end
+
+    # コントラスト調整
+    def contrast(rate)
+      error("invalid parameter. # => #{rate}") if rate<-127 || rate>127
+      Ext.pkl_contrast(@pkl_image, rate.to_i)
+      self
+    end
+
+    # レベル補正
+    def level(low, high, coeff)
+      Ext.pkl_level(@pkl_image, low.to_f, high.to_f, coeff.to_f)
+      self
+    end
+
+    # 明るさ調整
+    def brightness(color)
+      Ext.pkl_brightness(@pkl_image, color.to_i)
+      self
+    end
+    
+    # 輝度(明るさ)・彩度(鮮やかさ)・色相(色合い)調整
+    def hls(ym, sm ,hd)
+      error("invalid parameter. # => #{ym}") if ym.to_f<-1.0 || ym.to_f>1.0
+      error("invalid parameter. # => #{sm}") if sm.to_f<-1.0 || sm.to_f>1.0
+      Ext.pkl_hls(@pkl_image, ym.to_f, sm.to_f, hd.to_f)
+      self
+    end
+    
+    # gamma correction
+    # _gm_ :: compensating rate.
+    # gm must be >= 0 and image is neutral if gm value is 1.0.
+    def gamma(gm)
+      Ext.pkl_gamma(@pkl_image, gm.to_f)
+      self
+    end
+    
+    # compose image
+    # _image_ :: another pikl image object.
+    # _xpos_ :: left position of composing image.
+    # _ypos_ :: top position of composing image.
+    def compose(image, xpos, ypos)
+      Ext.pkl_composite(@pkl_image, image.rawdata, xpos, ypos)
+      self
+    end
+    
+    # alphablend
+    # _image_ :: another pikl image object.
+    # _xpos_ :: left position of blend image.
+    # _ypos_ :: top position of blend image.
+    # _alpha_ :: alpha: α-value(0-255). 255 is complete transparent.
+    def alphablend(image, xpos, ypos, alpha)
+      Ext.pkl_alphablend(@pkl_image, image.rawdata, xpos, ypos, alpha);
+      self
+    end
+    
+    # mosaic effect
+    # _width_ :: width for mosaic unit.
+    # _height_ :: height for mosaic unit. 
+    def mosaic(width, height)
+      Ext.pkl_mosaic(@pkl_image, width, height)
+      self
+    end
+    
+    # 反転
+    def invert
+      Ext.pkl_invert(@pkl_image) if(@pkl_image)
+    end
+    
+    # 手書き風
+    def alphaedge(level=8, low=1.5, high=1.5, coeff=1.0, threshold=50, alpha=80)
+      error("invalid parameter. # => #{level}") if level<1 || level>256
+      error("invalid parameter. # => #{threshold}") if threshold<0 || threshold>80
+      error("invalid parameter. # => #{alpha}") if alpha<0 || alpha>=256
+      Ext.pkl_alphaedge(@pkl_image, level.to_i, low.to_f, high.to_f, coeff.to_f, threshold.to_i, alpha.to_i)
+    end
+    
+    # クレヨン風
+    def crayon(factor=15.0, bv1=3, bv2=2, alpha=80)
+      error("invalid parameter. # => #{factor}") if factor.to_f<5.0 || factor.to_f>80.0
+      error("invalid parameter. # => #{alpha}") if alpha<0 || alpha>=256
+      Ext.pkl_crayon(@pkl_image, factor.to_f, bv1.to_i, bv2.to_i, alpha.to_i)
+    end
+  
+    # ポスター風
+    def edgeposter(level=4, low=1.5, high=1.5, coeff=1.0, edge=1)
+      error("invalid parameter. # => #{level}") if level<2 || level>8
+      error("invalid parameter. # => #{edge}") if edge<0 || edge>5
+      Ext.pkl_edgeposter(@pkl_image, level.to_i, low.to_f, high.to_f, coeff.to_f, edge.to_i)
+    end
+  
+    # あじさい風
+    def hydrangea(zone=10, low=1.5, high=1.5, coeff=1.0, mil=50, env=70)
+      error("invalid parameter. # => #{mil}") if mil.to_f<1 || mil.to_f>400
+      error("invalid parameter. # => #{env}") if env.to_f<1 || env.to_f>100
+      Ext.pkl_hydrangea(@pkl_image, zone.to_i, low.to_f, high.to_f, coeff.to_f, mil.to_f, env.to_f)
+    end
+
+    # 凝った輪郭
+    def rinkaku(factor=30.0)
+      Ext.pkl_rinkaku(@pkl_image, factor.to_f)
+    end
+
+    # voronoi-zone
+    def voronoi_zone(zone, color=nil, edge=false)
+      _color = nil
+      unless color.nil?
+        _color=color.rawdata if color.class.name == 'Pikl::Color'
+      end
+      _edge = edge ? 1 : 0
+      Ext.pkl_voronoi_zone(@pkl_image, zone.to_i, _color, _edge)
+    end
+
+    # voronoi-count
+    def voronoi_count(count, color=nil, edge=false)
+      _color = nil
+      unless color.nil?
+        _color=color.rawdata if color.class.name == 'Pikl::Color'
+      end
+      _edge = edge ? 1 : 0
+      Pikl::Ext.pkl_voronoi_count(@pkl_image, count.to_i, _color, _edge)
+    end
+
+    # sepia
+    def sepia(red_weight, green_weight, blue_weight)
+      error("invalid parameter. # => #{red_weight}") if red_weight.to_f<0.0 || red_weight.to_f>1.0
+      error("invalid parameter. # => #{green_weight}") if green_weight.to_f<0.0 || green_weight.to_f>1.0
+      error("invalid parameter. # => #{blue_weight}") if blue_weight.to_f<0.0 || blue_weight.to_f>1.0
+      Ext.pkl_sepia(@pkl_image, red_weight.to_f, green_weight.to_f, blue_weight.to_f)
+    end
+
+    # oilpaint
+    def oilpaint(weight=3)
+      error("invalid parameter. # => #{weight}") if weight.to_i<2 || weight.to_i>6
+      Ext.pkl_oilpaint(@pkl_image, weight.to_i)
+    end
+
+    # kuwahara
+    def kuwahara(weight=3)
+      error("invalid parameter. # => #{weight}") if weight.to_i<2 || weight.to_i>5
+      Ext.pkl_kuwahara(@pkl_image, weight.to_i)
+    end
+    
+    # blot
+    def blot(level=3)
+      Ext.pkl_noise(@pkl_image, level.to_i)
+    end
+
+    # vtr
+    def vtr(colspace=3, gst=10, cst=10)
+      Ext.pkl_vtr(@pkl_image, colspace.to_i, gst.to_i, cst.to_i)
+    end
+
+    # dither
+    def dither(type=:floydsteinberg)
+      error("invalid parameter. # => #{type}") unless DITHER.include?(type)
+      Ext.pkl_dither(@pkl_image, DITHER[type])
+    end
+
+    # edgepaint
+    def edgepaint(edge=1)
+      Ext.pkl_edgepaint(@pkl_image, edge.to_i)
+    end
+
+    # edge
+    #   threshold=0..30
+    def edge(threshold=15)
+      Ext.pkl_edge(@pkl_image, threshold.to_i)
+    end
+
+    def contour
+      Ext.pkl_contour(@pkl_image)
+    end
+
+    def focus(type=:detail)
+      error("invalid parameter. # => #{type}") unless FOCUS.include?(type)
+      Ext.pkl_focus(@pkl_image, FOCUS[type])
+    end
+
+    def emboss(type=:light)
+      error("invalid parameter. # => #{type}") unless EMBOSS.include?(type)
+      Ext.pkl_emboss(@pkl_image, EMBOSS[type])
+    end
+
+    def emboss2(mask, w, h, factor=1.0, offset=0)
+      error("invalid parameter. # => #{mask}") unless mask.class.name == 'Array'
+      error("invalid parameter. # => #{mask} or #{w} or #{h}") unless mask.length == w.to_i*h.to_i
+      Ext.pkl_emboss2(@pkl_image, mask, w.to_i, h.to_i, factor.to_f, offset.to_i)
+    end
+
+    def noisecut
+      Ext.pkl_noisecut(@pkl_image)
+    end
+
+    def blur(weight)
+      Ext.pkl_blur(@pkl_image, weight.to_i)
+    end
+    
+    def gaussblur(weight)
+      Ext.pkl_gaussblur(@pkl_image, weight.to_f)
+    end
+    
+    def rblur(x=-1, y=-1, ef=30.0, weight=5)
+      Ext.pkl_rblur(@pkl_image, x.to_i, y.to_i, ef.to_f, weight.to_i)
+    end
+    
+    def ablur(x=-1, y=-1, ef=30.0, weight=5)
+      Ext.pkl_ablur(@pkl_image, x.to_i, y.to_i, ef.to_f, weight.to_i)
+    end
+    
+    def wblur(x=-1, y=-1, ef=30.0, weight=5, angle=45.0)
+      Ext.pkl_wblur(@pkl_image, x.to_i, y.to_i, ef.to_f, weight.to_i, angle.to_f)
+    end
+    
+    def mblur(angle, weight)
+      Ext.pkl_mblur(@pkl_image, angle.to_f, weight.to_i)
+    end
+
+    def shadowframe(margin, backcolor=nil, shadowcolor=nil)
+      _backcolor = nil
+      unless backcolor.nil?
+        _backcolor = backcolor.rawdata if backcolor.class.name == 'Pikl::Color'
+      end
+    
+      _shadowcolor = nil
+      unless shadowcolor.nil?
+        _shadowcolor = shadowcolor.rawdata if shadowcolor.class.name == 'Pikl::Color'
+      end
+      
+      Ext.pkl_shadowframe(@pkl_image, margin.to_i, _backcolor, _shadowcolor)
+    end
+  
+  
+    def randomshadow(child, x, y, margin, shadowcolor=nil)
+      error("invalid parameter. # => #{child}") unless child.class.name == 'Pikl::Image'
+      _shadowcolor = nil
+      unless shadowcolor.nil?
+        _shadowcolor = shadowcolor.rawdata if shadowcolor.class.name == 'Pikl::Color'
+      end
+      Pikl::Ext.pkl_randomshadow(@pkl_image, child.rawdata, x.to_i, y.to_i, margin.to_i, _shadowcolor)
+    end
+
+    def pixelate(ms)
+      Ext.pkl_pixelate(@pkl_image, ms.to_i)
+    end
+
+    def grid(msx, msy, color)
+      Ext.pkl_grid(@pkl_image, msx.to_i, msy.to_i, color.to_i)
+    end
+  
+    def posterize(level)
+      error("invalid parameter. # => #{level}") unless level>1 && level<256
+      Ext.pkl_posterize(@pkl_image, level.to_i)
+    end
+  
+    def cutcolor(level)
+      Ext.pkl_cutcolor(@pkl_image, level)
+    end
+    
+    # cmyk-model only
+    def rgb
+      Ext.pkl_rgb(@pkl_image)
+    end
+    
+    def gray(type=:nrm)
+      error("invalid parameter. # => #{type}") unless GRAY.include?(type)
+      Ext.pkl_gray(@pkl_image, GRAY[type])
+    end
+  
+    def blackwhite(level=127)
+      Ext.pkl_2c(@pkl_image, level.to_i)
+    end
+
+    def tileslit(area, shift)
+      Ext.pkl_tileslit(@pkl_image, area.to_i, shift.to_i)
+    end
+
+    def splitframe(backcolor, wbs, hbs, margin, frame)
+      error("invalid parameter. # => #{backcolor}") unless backcolor != nil
+      error("invalid parameter. # => #{backcolor}") unless backcolor.class.name == 'Pikl::Color'
+      Ext.pkl_splitframe(@pkl_image, backcolor.rawdata, wbs.to_i, hbs.to_i, margin.to_i, frame.to_i)
+    end
+    
+    def vignette(color, trans, radius, x=-1, y=-1)
+      error("invalid parameter. # => #{color}") unless color != nil
+      error("invalid parameter. # => #{color}") unless color.class.name == 'Pikl::Color'
+      Ext.pkl_vignette(@pkl_image, color.rawdata, trans.to_i, radius.to_i, x.to_i, y.to_i)
+    end
+
+    def vaseline(radius, x=-1, y=-1)
+      Ext.pkl_vaseline(@pkl_image, radius.to_i, x.to_i, y.to_i)
+    end
+
+    def vv(color, trans, radius, x=-1, y=-1)
+      error("invalid parameter. # => #{color}") unless color != nil
+      error("invalid parameter. # => #{color}") unless color.class.name == 'Pikl::Color'
+      Ext.pkl_vv(@pkl_image, color.rawdata, trans.to_i, radius.to_i, x.to_i, y.to_i)
+    end
+
+    def film(color, trans)
+      error("invalid parameter. # => #{color}") unless color != nil
+      error("invalid parameter. # => #{color}") unless color.class.name == 'Pikl::Color'
+      Ext.pkl_film(@pkl_image, color.rawdata, trans.to_i)
+    end
+  
+    def swirl(factor, x, y, color)
+      error("invalid parameter. # => #{color}") unless color != nil
+      error("invalid parameter. # => #{color}") unless color.class.name == 'Pikl::Color'
+      Ext.pkl_swirl(@pkl_image, factor.to_f, x.to_i, y.to_i, color.rawdata)
+    end
+
+    def wave(factor, frequency, type=:both)
+      error("invalid parameter. # => #{type}") unless WAVE.include?(type)
+      Ext.pkl_wave(@pkl_image, WAVE[type], factor.to_f, frequency.to_f)
+    end
+  
+    def dots(zone, color)
+      error("invalid parameter. # => #{color}") unless color != nil
+      error("invalid parameter. # => #{color}") unless color.class.name == 'Pikl::Color'
+      Ext.pkl_dots(@pkl_image, zone, color.rawdata)
+    end
+
+    def colordither(weight)
+      Ext.pkl_colordither(@pkl_image, weight.to_i)
+    end
+  
+    def fantasy(edgeweight, mix, saturation, hue)
+      Ext.pkl_sobelpaint(@pkl_image, edgeweight.to_i, mix.to_f, saturation.to_f, hue.to_f)
+    end
+    
+    def illust(gap, edge, gammaint)
+      Ext.pkl_illust(@pkl_image, gap.to_i, edge.to_i, gammaint.to_i)
+    end
+  
+    def color_emboss(mil, env)
+      Ext.pkl_color_emboss(@pkl_image, mil.to_f, env.to_f)
+    end
+
+    def pattern(width, height, pattern=:p_hexagon, paint=:ave)
+      error("invalid parameter. # => #{pattern}") unless PATTERN.include?(pattern)
+      error("invalid parameter. # => #{paint}") unless PAINT.include?(paint)
+      Ext.pkl_pattern(@pkl_image, width.to_i, height.to_i, PATTERN[pattern], PAINT[paint])
+    end
+
+    def tile(msx, msy, level, type=:t_rect)
+      error("invalid parameter. # => #{type}") unless TILE.include?(type)
+      Ext.pkl_tile(@pkl_image, TILE[type], msx.to_i, msy.to_i, level.to_i)
+    end
+
+    def affine(width, height, color, xscale, yscale, angle, x, y, sample=:bilinear)
+      error("invalid parameter. # => #{type}") unless SAMPLES.include?(sample)
+      error("invalid parameter. # => #{color}") unless color != nil
+      error("invalid parameter. # => #{color}") unless color.class.name == 'Pikl::Color'
+      Ext.pkl_affine(@pkl_image, SAMPLES[sample], width.to_i, height.to_i, color.rawdata, xscale.to_f, yscale.to_f, angle.to_f, x.to_i, y.to_i)
+    end
+
+  end
+end
+
+
+