pikl 0.2.6-x86-mswin32 → 0.2.7-x86-mswin32

data/History.txt

@@ -1,3 +1,7 @@
+== 0.2.7
+
+* Bug Fix parsing extension.
+
 == 0.2.6
 
 * Bug Fix for mswin32 dll.

data/ext/pikl/pikl.h

@@ -1,9 +1,8 @@
-/*! @file
-    @brief  image library "pikl"
-    simple image library
-    @author soe(soezimaster@gmail.com)
-    @date   2008.4
-*/
+/*=============================================================================
+ ImageLibrary 'pikl'
+   author: soe(soezimaster@gmail.com)
+   date: 2008.4
+===============================================================================*/
 #ifndef _LIB_PIKL_
 #define _LIB_PIKL_
 
@@ -18,44 +17,47 @@
 extern "C" {
 #endif
 
-/*! version */
-#define PKL_VERSION "libpikl 0.1"
+#define PKL_VERSION "libpikl 0.3.2"
 
 // PKLImage
 typedef struct _PKLImage * PKLImage;
 
-/*!
-	support format<br>
-	■JPEG:<br>
-		gray, rgb, cmyk<br>
-		* color-typeのYCbCrおよびYCCには読み取りも保存も対応していません。<br>
-	■PNG:<br>
-		gray,gray-alpha,rgb,rgb-alpha,palette<br>
-		* alphaは読取は可能ですが、保存はできません。<br>
-		* paletteはRGBとして扱われます。<br>
-	■BMP(windows bitmap):<br>
-		24bit only
-*/
+//=============================================================================
+// support format & color
+//	JPEG:
+//		gray/rgb/cmyk
+//		* color-typeのYCbCrおよびYCCには読み取りも保存も対応していない
+//
+//	PNG:
+//		gray/gray-alpha/rgb/rgb-alpha/palette
+//		* alphaは読取は可能だが、保存はできない
+//		* paletteはRGBとして扱われる
+//
+//	BMP(windows bitmap):
+//		24bit + non-compress only
+//=============================================================================
 typedef enum {
-	PKL_FORMAT_ERROR,	/*!< error */
-	PKL_FORMAT_JPEG,	/*!< jpeg */
-	PKL_FORMAT_PNG,		/*!< png */
-	PKL_FORMAT_BITMAP	/*!< windows bitmap */
+	PKL_FORMAT_ERROR,	// error
+	PKL_FORMAT_JPEG,	// jpeg
+	PKL_FORMAT_PNG,		// png
+	PKL_FORMAT_BITMAP	// windows bitmap
 } PKL_FORMAT;
 
-/*! color type */
 typedef enum {
-	PKL_UNKNOWN,		/*!< error */
-	PKL_BLACKWHITE,		/*!< non support */
-	PKL_GRAYSCALE,		/*!< gray scale */
-	PKL_RGB,			/*!< 24bit RGB */
-	PKL_RGBA,			/*!< non support */
-	PKL_YCbCr,			/*!< non support */
-	PKL_CMYK,			/*!< CMYK(for jpeg) */
-	PKL_YCCK			/*!< non support */
+	PKL_UNKNOWN,		// error
+	PKL_BLACKWHITE,		// non support
+	PKL_GRAYSCALE,		// gray scale
+	PKL_RGB,			// 24bit RGB
+	PKL_RGBA,			// not support!
+	PKL_YCbCr,			// not support!
+	PKL_CMYK,			// CMYK(for jpeg)
+	PKL_YCCK			// non support
 } PKL_COLOR_SPACE;
 
-/*! right turn angle(for rotate) */
+//=============================================================================
+// 回転角度(右回り)
+//	* pkl_rotateで使用
+//=============================================================================
 typedef enum {
 	PKL_ANGLE_000,
 	PKL_ANGLE_090,
@@ -63,18 +65,18 @@ typedef enum {
 	PKL_ANGLE_270
 } PKL_ANGLE;
 
-/*!
-	sampling pattern(for resize)<br>
-	※全てのサンプリングパターンに拡大縮小対応しています。<br>
-	※但し、pixcel averageで拡大をする場合は、lanczosと品質は同じになります。
-*/
+//=============================================================================
+// サンプリングパターン
+//	* 全てのサンプリングパターンで拡大縮小対応
+//	* 但し、pixcel-averageで拡大をする場合は、lanczosと品質は同じ
+//=============================================================================
 typedef enum {
 	PKL_SAMPLE_ERROR,
-	PKL_SAMPLE_NN,	/*!< nearest neighbor */
-	PKL_SAMPLE_BL,	/*!< bilinear */
-	PKL_SAMPLE_BC,	/*!< bicubic */
-	PKL_SAMPLE_PA,	/*!< pixcel average */
-	PKL_SAMPLE_LZ	/*!< lanczos */
+	PKL_SAMPLE_NN,	// nearest neighbor
+	PKL_SAMPLE_BL,	// bilinear
+	PKL_SAMPLE_BC,	// bicubic
+	PKL_SAMPLE_PA,	// pixcel-average
+	PKL_SAMPLE_LZ	// lanczos
 } PKL_SAMPLE;
 
 //=============================================================================
@@ -109,6 +111,40 @@ PKLExport int pkl_width(PKLImage pkl);
 */
 PKLExport int pkl_height(PKLImage pkl);
 
+
+/*!
+	PNG/JPEG保存時の圧縮率<br>
+	@param pkl [in] PKLImageオブジェクト
+	@param level [in]
+		0(無圧縮) .. 10(最高圧縮)。
+		指定がない場合は、デフォルトレベルが設定されます。
+	@return 成功した場合は0。失敗した場合は真を返します。
+*/
+PKLExport int pkl_compress(PKLImage pkl, int level);
+
+//=============================================================================
+// pkl_save
+//=============================================================================
+/*
+	保存<br>
+	@param pkl [in] PKLImageオブジェクト
+	@param out [in] 保存ファイル名
+	@param format [in] 保存フォーマット(PKL_FORMAT参照)
+	@return 成功した場合は0。失敗した場合は真を返します。
+*/
+PKLExport int pkl_save(PKLImage pkl, const char *out, PKL_FORMAT format);
+
+//=============================================================================
+// pkl_close
+//=============================================================================
+/*!
+	PKLImageオブジェクトの破棄<br>
+	確保していたメモリを全て解放します。用がなくなったら実行するようにしてください。
+	@param pkl [in] PKLImageオブジェクト
+*/
+PKLExport void pkl_close(PKLImage pkl);
+
+
 /*!
 	トリミングします。<br>
 	・パラメータは左上原点です。<br>
@@ -146,6 +182,24 @@ PKLExport int pkl_rotate2(PKLImage pkl, float angle, PKL_SAMPLE sample,
 */
 PKLExport int pkl_resize(PKLImage pkl, int width, int height, PKL_SAMPLE sample);
 
+//=============================================================================
+// affine変換
+//=============================================================================
+//*_scale = 変形率の逆数
+PKLExport void pkl_matrix_scale(PKLImage pkl, double x_scale, double y_scale);
+
+//angle=左回りの回転角度
+PKLExport void pkl_matrix_rotate(PKLImage pkl, double angle);
+
+//正数は上、左方向への移動
+PKLExport void pkl_matrix_translate(PKLImage pkl, int x, int y);
+
+PKLExport int pkl_affine(PKLImage pkl, PKL_SAMPLE sampler, int width, int height, int backcolor);
+//#define pkl_color(a,b,c,d) ((a<<24)+(b<<16)+(c<<8)+d)
+
+//=============================================================================
+// エフェクト(ベーシック)
+//=============================================================================
 /*!
 	アンシャープ処理<br>
 	@param pkl [in] PKLImageオブジェクト
@@ -224,43 +278,358 @@ PKLExport int pkl_brightness(PKLImage pkl, int color);
 */
 PKLExport int pkl_hls(PKLImage pkl, double ym, double sm, double hd);
 
-/*!
-	ガンマ補正<br>
-	@param pkl [in] PKLImageオブジェクト
-	@param gm [in]
-		補正係数(0.0以上の値が指定できます)。
-		1.0より小さい時は暗く、1.0より大きい時は明るく調整されます。
-		1.0を指定した時は調整されません。
-	@return 成功した場合は0。失敗した場合は真を返します。
-*/
+/* ガンマ補正 */
+//		gm: 補正係数(>=0.0)
+//			gm<1.0：暗く調整される
+//			gm=1.0：変化しない
+//			gm>1.0：明るく調整される
 PKLExport int pkl_gamma(PKLImage pkl, double gm);
 
-/*!
-	PNG/JPEG保存時の圧縮率<br>
-	@param pkl [in] PKLImageオブジェクト
-	@param level [in]
-		0(無圧縮) .. 10(最高圧縮)。
-		指定がない場合は、デフォルトレベルが設定されます。
-	@return 成功した場合は0。失敗した場合は真を返します。
-*/
-PKLExport int pkl_compress(PKLImage pkl, int level);
+/* ノイズ除去(median filter) */
+PKLExport int pkl_noisecut(PKLImage pkl);
 
-/*!
-	保存<br>
-	@param pkl [in] PKLImageオブジェクト
-	@param out [in] 保存ファイル名
-	@param format [in] 保存フォーマット(PKL_FORMAT参照)
-	@return 成功した場合は0。失敗した場合は真を返します。
-*/
-PKLExport int pkl_save(PKLImage pkl, const char *out, PKL_FORMAT format);
+//=============================================================================
+// エフェクト２
+//=============================================================================
+/* 反転 */
+PKLExport int pkl_invert(PKLImage pkl);
+
+//エッジ(輪郭)を強調する
+//unsharpは画像全体をシャープにするが、これはエッジ部分のみの強調
+typedef enum {
+	PKL_FOCUS_DETAIL,	//弱い
+	PKL_FOCUS_FOCUS,	//中間
+	PKL_FOCUS_EDGES	//強い
+} PKL_FOCUS;
+PKLExport int pkl_focus(PKLImage pkl, PKL_FOCUS type);
+
+//エンボス
+typedef enum {
+	PKL_EMBOSS_EMBOSS,		//エンボス1
+	PKL_EMBOSS_HEAVY,		//エンボス2
+	PKL_EMBOSS_LIGHT,		//エンボス3
+	PKL_EMBOSS_LAPLACIAN	//輪郭抽出
+} PKL_EMBOSS;
+PKLExport int pkl_emboss(PKLImage pkl, PKL_EMBOSS type);
+
+
+/* 画像の合成 */
+// parentの上にchildを乗せる
+//		parent:		ベース(処理後はこのオブジェクトが更新される)
+//		child:		乗せる画像(このオブジェクトは処理しても不可侵)
+//		xpos,ypos:	childを乗せるparent上の座標.
+//					必ずparent上の座標でなければならない.
+// *parentとchildは同じカラーモードでなければエラーとなる
+PKLExport int pkl_composite(PKLImage parent, PKLImage child, int xpos, int ypos);
+
+/* 画像の合成２ */
+// pkl_composite()に加え、childイメージ上の1色を透明扱いにできる
+//		parent:		ベース(処理後はこのオブジェクトが更新される)
+//		child:		乗せる画像(このオブジェクトは処理しても不可侵)
+//		xpos,ypos:	childを乗せるparent上の座標.
+//					必ずparent上の座標でなければならない.
+//		transcolor:	透明にする色(pkl_colorマクロで生成する)
+// *parentとchildは同じカラーモードでなければエラーとなる
+PKLExport int pkl_composite2(PKLImage parent, PKLImage child, int xpos, int ypos, int transcolor);
+
+/* (安易な)セピア */
+//		red_weight,green_weight,blue_weight:
+//			red,green,blueそれぞれに対しての重み
+//			値が大きいほど、その色が強く出る
+// *RGBのみに対応
+// *セピアっぽくするのであれば、redの重みを1.0として、他の重みを1.0より小さくする
+PKLExport int pkl_sepia(PKLImage pkl, double red_weight, double green_weight, double blue_weight);
+
+/* (安易な)油絵化 */
+// 油絵のようにする
+//		weight:	筆の太さ(というか最頻色走査領域のサイズ)
+//				例えば、3を指定した場合、近傍3x3の領域の最頻色が選択される
+// *weightを大きくしすぎると、処理が重くなる。注意せよ
+PKLExport int pkl_oilpaint(PKLImage pkl, int weight);
+
+
+//=============================================================================
+// Blur(ぼかし)
+//=============================================================================
+/* (安易な)ぼかし */
+//		weight:	平均算出領域のサイズ
+//				例えば、3を指定した場合、近傍3x3の領域の平均色が選択される
+//				値が大きいほど、ぼかし度は強くなる。
+// *weightを大きくしすぎると、処理が重くなる。注意せよ
+PKLExport int pkl_blur(PKLImage pkl, int weight);
+
+/* ガウスぼかし */
+// ガウス関数を使ったぼかし。「画像全体にぼかしが入る」「方向がない」
+//		weight:	ぼかし強調度(>0.0)
+//				値が大きいほど、ぼかし度は強くなる。
+// *weightを大きくしすぎると、処理が重くなる。注意せよ
+PKLExport int pkl_gaussblur(PKLImage pkl, double weight);
+
+/* 放射状ブラー(radiation) */
+//		x,y:	放射の中心座標(画像範囲内にない場合は中心)
+//		ef:		中心からの強調度(>0.0。値が大きいほど、放射度が強くなる)
+//		weight:	ぼかしの強調度(>0)
+// *weightを大きくしすぎると、処理が重くなる。注意せよ
+PKLExport int pkl_rblur(PKLImage pkl, int x, int y, double ef, int weight);
+
+/* 回転ブラー(angle) */
+//		x,y:	放射の中心座標(画像範囲内にない場合は中心)
+//		ef:		中心からの強調度(>0.0。値が大きいほど、放射度が強くなる)
+//		weight:	ぼかしの強調度(>0)
+// *weightを大きくしすぎると、処理が重くなる。注意せよ
+PKLExport int pkl_ablur(PKLImage pkl, int x, int y, double ef, int weight);
+
+/* うずまきブラー(whirlpool) */
+//		x,y:	放射の中心座標(画像範囲内にない場合は中心)
+//		ef:		中心からの強調度(>0.0。値が大きいほど、放射度が強くなる)
+//		weight:	ぼかしの強調度(>0)
+//		angle:	回転角度(0は回転なし)
+// *weightを大きくしすぎると、処理が重くなる。注意せよ
+PKLExport int pkl_wblur(PKLImage pkl, int x, int y, double ef, int weight, double angle);
+
+/* モーションブラー */
+// 任意角度での直線ブラー
+//		angle: ぼかす角度
+//		range: ぼかし強調度
+// *weightを大きくしすぎると、処理が重くなる。注意せよ
+PKLExport int pkl_mblur(PKLImage pkl, double angle, int weight);
+
+
+//**************************************************************************
+// エフェクト３(from 画像処理プログラミング)
+//**************************************************************************
+/* イラスト調 */
+// edge: エッジの重み(0が最もエッジが強い。0..20程度が目安)
+// gammaint: 絵柄のガンマ評価値(0:暗く評価、100:明るく評価。0..100)
+PKLExport int pkl_illust(PKLImage pkl, int edge, int gammaint);
+
+/* エンボス */
+// mil: ハイライト(1..400)
+// env: 環境光(1..100)
+PKLExport int pkl_color_emboss(PKLImage pkl, double mil, double env);
+
+/* モザイク処理 */
+// mx,my:モザイクのピクセルサイズ(それぞれ、幅・高さ)
+//	1以下の時には変化はありません
+//	画像サイズ以上の時には１色の画像になります
+PKLExport int pkl_mosaic(PKLImage pkl, int msx, int msy);
+
+/* ノイズ処理 */
+PKLExport int pkl_noise(PKLImage pkl, int noise);
+
+/* VTR調 */
+//colspace;	//行の間隔
+//gst;	//横方向のブレ
+//cst;	//行の色差分
+PKLExport int pkl_vtr(PKLImage pkl, int colspace, int gst, int cst);
+
+//**************************************************************************
+// エフェクト４(実験シリーズ)
+//**************************************************************************
+/* 輪郭抽出 */
+PKLExport int pkl_edgepaint(PKLImage pkl);
+
+/* ポスタライズ(階調変更)→ブライトネス→ノイズ除去→輪郭抽出 */
+// level:階調数(1-256) *256を何分割するかということ
+// up: ポスタライズにより暗めの画像になってしまうので、ブライトネスで適用する色
+PKLExport int pkl_edgeposter(PKLImage pkl, int level, int up);
+
+
+/* 格子のずらし配置 */
+// area:格子のサイズ
+// shift:格子をずらす範囲
+PKLExport int pkl_tileslit(PKLImage pkl, int area, int shift);
+
+
+/* モザイクグリッド */
+// モザイク化した上でグリッド線を引く
+//	<引数>
+//		msx,msy:	モザイクのピクセルサイズ(それぞれ、幅・高さ)
+//		color:		グリッド線の調整値
+//					グリッド線色は単色ではなく、モザイク領域の色を元に生成する
+//					colorはモザイク色に加算されるだけ。
+//						0の時：モザイクと同色になり表出しない
+//					  255の時：いわゆる白線
+//					 -255の時：いわゆる黒線
+PKLExport int pkl_grid(PKLImage pkl, int msx, int msy, int color);
+
+
+/* kuwahara(from MemoNyanDum) */
+//	kuwaharaオペレータを使った抽象化で油絵のようになる。
+//	pkl_oilpaint()との違いは、エッジがより鮮明であるという点。
+//	<引数>
+//		range: 調整領域(>=2)
+//
+// *rangeを大きくしすぎると、処理が重くなる。注意せよ
+PKLExport int pkl_kuwahara(PKLImage pkl, int range);
+
+/* アルファブレンド */
+//	parentの上にchildをアルファブレンドで乗せる
+//	<引数>
+//		parent: ベース(処理後はこのオブジェクトが更新される)
+//		child: 乗せる画像(このオブジェクトは処理しても不可侵)
+//		xpos,ypos：childを乗せるparent上の座標.
+//		           必ずparent上の座標でなければならない.
+//		alpha: α値(0-255)
+//				alpha=0の時:   childは100%で乗る
+//				alpha=255の時：childは  0%で乗る
+//	<注意>
+//		parentとchildは同じカラーモードでなければエラーとなる
+PKLExport int pkl_alphablend(PKLImage parent, PKLImage child, int xpos, int ypos, int alpha);
+
+//アルファブレンド
+//1との違いは、画像全体に対してアルファを効かせるのでなく
+//画像の縁ほどアルファを強調するという点
+PKLExport int pkl_alphablend2(PKLImage parent, PKLImage child, int xpos, int ypos);
+
+//影付け
+PKLExport int pkl_shadowframe(PKLImage pkl, int margin, int backcolor, int shadowcolor);
+
+//輪郭抽出
+//threshold: 輪郭強調度(値が小さいほど、輪郭判定は荒くなる-->全体が黒くなる)
+PKLExport int pkl_edge(PKLImage pkl, int threshold);
+
+typedef enum {
+	PKL_DITHER_NON,				//pkl_dithercolorではdefaultとなる
+	PKL_DITHER_FLOYDSTEINBERG,	//default
+	PKL_DITHER_STUCCI,
+	PKL_DITHER_SIERRA,
+	PKL_DITHER_JAJUNI
+} PKL_DITHER;
+PKLExport int pkl_dither(PKLImage pkl, PKL_DITHER dither);
+
+//=============================================================================
+// pattern(パターン)
+//=============================================================================
+typedef enum {
+	PKL_PAINT_LINE,	//ライン(パターン内の横方向の平均で塗る)(default)
+	PKL_PAINT_AVE,	//モザイク(パターン内の平均色で塗る)
+} PKL_PAINT_TYPE;
+
+/* 六角形 */
+//	pw,ph:	パターンのサイズ
+//			phのサイズをpwの３倍に設定すると、縦横サイズが同じパターンになる
+//	type:	塗り方式
+PKLExport int pkl_pattern_hexagon(PKLImage pkl, int pw, int ph, PKL_PAINT_TYPE type);
+
+/* ひし形 */
+//	pw,ph:	パターンのサイズ
+//			phのサイズをpwの２倍に設定すると、縦横サイズが同じパターンになる
+//	type:	塗り方式
+//		ex1) pw=10,ph=10にすると横長のパターン
+//		ex2) pw=10,ph=20にすると縦横同じ大きさのパターン
+//		ex3) pw=10,ph=30にすると縦長のパターン
+PKLExport int pkl_pattern_diamond(PKLImage pkl, int pw, int ph, PKL_PAINT_TYPE type);
+
+/* 円 */
+//	pw,ph:	パターンのサイズ
+//			phのサイズをpwの３倍に設定すると、縦横サイズが同じパターンになる
+//	type:	塗り方式
+PKLExport int pkl_pattern_circle(PKLImage pkl, int pw, int ph, PKL_PAINT_TYPE type);
+
+/* レンガ */
+//	pw,ph:	パターンのサイズ
+//			phのサイズをpwの4倍に設定すると、縦横サイズが同じパターンになる
+//	type:	塗り方式
+PKLExport int pkl_pattern_brick(PKLImage pkl, int pw, int ph, PKL_PAINT_TYPE type);
+
+
+/* ボロノイ分割(タイプ1) */
+// zone: ボロノイサイズ(>=2, <w,h)
+// bordercolor: -1の時は境界線を引かない。境界線色はpkl_colorで作る
+// test: 真の時、分割シュミレーション図を出力する
+PKLExport int pkl_voronoi_type1(PKLImage pkl, int zone, int bordercolor, int test);
+
+
+/* ボロノイ分割(タイプ2) */
+//	count: 母点数(>=10)
+//	bordercolor: -1の時は境界線を引かない。境界線色はpkl_colorで作る
+//	test: 真の時、分割シュミレーション図を出力する
+//	
+//	*type1との違いは、母点がよりランダムに配置されるという点
+PKLExport int pkl_voronoi_type2(PKLImage pkl, int count, int bordercolor, int test);
+
+
+//=============================================================================
+// decrease(減色)
+//=============================================================================
+/* メディアンカット */
+//	ncolors:	色数(1..256)
+//	dither:		真の時dither処理する
+// *RGBのみ
+// *設定した色数で保存するには、PNGかBMPにする必要がある(JPEGは非可逆のため)
+PKLExport int pkl_mediancut(PKLImage pkl, int ncolors, int dither);
+
+/* Neural-Net Quantization */
+//	ncolors:	色数(1..256)
+//	sample:		sampling factor(1..30) 1=slowest/best, 30=fastest
+// *設定した色数で保存するには、PNGかBMPにする必要がある(JPEGは非可逆のため)
+// *メディアンカットより質のいい減色ができるが遅い。
+PKLExport int pkl_neuquant(PKLImage pkl, int ncolors, int sample);
+
+/* Xiaolin Wu */
+//	ncolors::色数(1..256)
+// *設定した色数で保存するには、PNGかBMPにする必要がある(JPEGは非可逆のため)
+PKLExport int pkl_wu(PKLImage pkl, int ncolors);
+
+
+/* ポスタライズ(階調変更) */
+// level:階調数(1-256) *256を何分割するかということ
+PKLExport int pkl_posterize(PKLImage pkl, int level);
+
+
+/* 色数削減 */
+// 単純にlevelで指定した下位ビットを削除する。
+// level: 無効にする下位ビット数(0-255)
+PKLExport int pkl_cutcolor(PKLImage pkl, int level);
+
+
+//=============================================================================
+// scrap(スクラップ)
+//	Junkiさんところを参考に作ったものや試行錯誤品
+//=============================================================================
+/* 渦巻き */
+//	factor:	渦巻き度合い(絶対値で1以下の範囲で指定する。0に近いほど、ゆるやかな渦巻きになる)
+// 			* 負数と正数の違いは回転方向
+//	x,y:	渦巻きの中心点(座標が画像内に収まらない場合は、中心となる)
+//	backcolor:背景色
+// * Junkiさんとことの違いは、ピクセル生成時にバイリニアしていないこと。なので、粗い画像になる
+PKLExport int pkl_swirl(PKLImage pkl, double factor, int x, int y, int backcolor);
+
+/* wave */
+//	factor:周期
+//	frequency:振幅
+typedef enum {
+	PKL_WAVE_HORZ,	//横方向のwave
+	PKL_WAVE_VERT,	//縦方向のwave
+	PKL_WAVE_BOTH	//縦横のwave
+} PKL_WAVE;
+PKLExport int pkl_wave(PKLImage pkl, PKL_WAVE mode, double factor, double frequency);
+
+
+/* さほど美しくないドット絵 */
+//	円の描画を自力でやっているので、微妙な仕上がり品。
+//	zone:ドット化する領域の一辺のサイズ(3..10)
+//	color:ドットの色(pkl_colorで作る)
+PKLExport int pkl_dots(PKLImage pkl, int zone, int color);
+
+
+/* フォトフレーム分割 */
+// イメージを分割し、フォトフレームのようにする
+//	backcolor:	背景色
+//	wbs,hbs:	オリジナルイメージの縦横分割数(>0)
+//	margin:		キャンバスのマージン(上下左右の空間)(>0)
+//	frame:		フレームの太さ(>=1)
+PKLExport int pkl_splitframe(PKLImage pkl, int backcolor, int wbs, int hbs, int margin, int frame);
+
+/* カラーディザー */
+//weight: 誤差点に確定しなかった色に対する加算色
+//			+255以上の時は完全な白
+//			-255以下の時は完全な黒
+PKLExport int pkl_colordither(PKLImage pkl, int weight);
+
+PKLExport int pkl_ttt(PKLImage pkl);
 
-/*!
-	PKLImageオブジェクトの破棄<br>
-	確保していたメモリを全て解放します。用がなくなったら実行するようにしてください。
-	@param pkl [in] PKLImageオブジェクト
-	@return 成功した場合は0。失敗した場合は真を返します。
-*/
-PKLExport void pkl_close(PKLImage pkl);
 
 #if defined __cplusplus
 }

data/ext/pikl/pikl_bitmap.c

@@ -111,6 +111,8 @@ int save_bitmap(PKLImage pkl, FILE *image)
 	unsigned char data[BF_SIZE+BI_SIZE], *wrk, stuck;
 	int linesize, i, j;
 	
+	if(pkl->color!=PKL_RGB) return(1);
+	
 	linesize = bmp_width(pkl->width, pkl->channel);
 	
 	data[0] = 'B';

data/ext/pikl/pikl_effect.c

@@ -7,7 +7,7 @@ PKLExport int pkl_unsharp(PKLImage pkl, int threshold, double edge)
 {
 	int i, j, p, q, k;
 	int cnt, value, stock[PKL_CHANNEL];
-	unsigned char *wrk;
+	unsigned char *wrk, *s;
 	
 	wrk = malloc(pkl->height * pkl->width * pkl->channel);
 	if(!wrk) return(1);
@@ -26,15 +26,15 @@ PKLExport int pkl_unsharp(PKLImage pkl, int threshold, double edge)
 					}
 				}
 			}
-			for(k=0; k<pkl->channel; k++){
-				wrk[(i * pkl->width + j) * pkl->channel+k] = stock[k] / cnt;
-			}
+			s = &wrk[(i * pkl->width + j) * pkl->channel];
+			for(k=0; k<pkl->channel; k++)
+				*s++ = stock[k] / cnt;
 		}
 	}
 	
 	for(i=0; i<pkl->height*pkl->width*pkl->channel; i++){
 		value = abs(pkl->image[i]-wrk[i])<threshold ? pkl->image[i] : pkl->image[i]+(pkl->image[i]-wrk[i])*edge;
-		pkl->image[i] = PKL_RGB(value);
+		pkl->image[i] = PKL_COLOR_CLIP(value);
 	}
 	free(wrk);
 	return(0);
@@ -54,17 +54,18 @@ PKLExport int pkl_contrast(PKLImage pkl, int rate)
 		//�d�݂������̎��͒����I�ɕ��R��
 		for(i=0; i<PKL_COLOR; i++){
 			value = i + (i-127) * rate/127;
-			ct[i] = PKL_RGB(value);
+			ct[i] = PKL_COLOR_CLIP(value);
 		}
 	}else{
 		//�d�݂������̎��͎��g��
 		for(i=0; i<PKL_COLOR; i++){
 			value = i - rate*rate/127 * sin(M_PI/2+M_PI*i/255);
-			ct[i] = PKL_RGB(value);
+			ct[i] = PKL_COLOR_CLIP(value);
 		}
 	}
 
-	for(i=0; i<pkl->width*pkl->height*pkl->channel; i++) pkl->image[i] = ct[pkl->image[i]];
+	for(i=0; i<pkl->width*pkl->height*pkl->channel; i++)
+		pkl->image[i] = ct[pkl->image[i]];
 
 	return(0);
 }
@@ -110,7 +111,7 @@ PKLExport int pkl_level(PKLImage pkl, double low, double high, double coeff)
 	for(i=0; i<pkl->width*pkl->height; i++){
 		for(j=0; j<pkl->channel; j++){
 			value = ((coeff * pkl->image[i*pkl->channel+j])-hst[j].min)/(hst[j].max-hst[j].min) * 255;
-			pkl->image[i*pkl->channel+j] = PKL_RGB(value);
+			pkl->image[i*pkl->channel+j] = PKL_COLOR_CLIP(value);
 		}
 	}
 
@@ -124,7 +125,7 @@ PKLExport int pkl_brightness(PKLImage pkl, int color)
 {
 	int i;
 	for(i=0; i<pkl->width*pkl->height*pkl->channel; i++){
-		pkl->image[i] = PKL_RGB(pkl->image[i] + color);
+		pkl->image[i] = PKL_COLOR_CLIP(pkl->image[i] + color);
 	}
 	return(0);
 }
@@ -164,9 +165,9 @@ PKLExport int pkl_hls(PKLImage pkl, double ym, double sm, double hd)
 		c1 = s * sin(M_PI * h / 180.0);
 		c2 = s * cos(M_PI * h / 180.0);
 
-		pkl->image[i*pkl->channel]   = PKL_RGB(c1 + y);
-		pkl->image[i*pkl->channel+1] = PKL_RGB(y - (0.299*c1 + 0.114*c2)/0.587);
-		pkl->image[i*pkl->channel+2] = PKL_RGB(c2 + y);
+		pkl->image[i*pkl->channel]   = PKL_COLOR_CLIP(c1 + y);
+		pkl->image[i*pkl->channel+1] = PKL_COLOR_CLIP(y - (0.299*c1 + 0.114*c2)/0.587);
+		pkl->image[i*pkl->channel+2] = PKL_COLOR_CLIP(c2 + y);
 	}
 	return(0);
 }
@@ -182,10 +183,58 @@ PKLExport int pkl_gamma(PKLImage pkl, double gm)
 	if(gm < 0.0) return(1);
 	
 	for(i=0; i<PKL_COLOR; i++)
-		gt[i] = PKL_RGB(255.0 * pow(i/255.0, 1.0/gm));
+		gt[i] = PKL_COLOR_CLIP(255.0 * pow(i/255.0, 1.0/gm));
 	
 	for(i=0; i<pkl->width*pkl->height*pkl->channel; i++)
 		pkl->image[i] = gt[pkl->image[i]];
 
 	return(0);
 }
+
+//=============================================================================
+// pkl_noisecut(median filter)
+//=============================================================================
+PKLExport int pkl_noisecut(PKLImage pkl)
+{
+	unsigned char *wrk, *p, sort[PKL_CHANNEL][9], median[PKL_CHANNEL];
+	int i, j, tx, ty, k, clipx, clipy, rd, s, t, n;
+
+	wrk = malloc(pkl->width*pkl->height*pkl->channel);
+	if(!wrk) return(1);
+	memset(wrk, 0, pkl->width*pkl->height*pkl->channel);
+
+	for(i=0; i<pkl->height; i++){
+		for(j=0; j<pkl->width; j++){
+			rd=0;
+			for(ty=-1; ty<=1; ty++){
+				for(tx=-1; tx<=1; tx++){
+					clipx = j+tx < 0 ? 0 : j+tx>=pkl->width ? pkl->width-1 : j+tx;
+					clipy = i+ty < 0 ? 0 : i+ty>=pkl->height ? pkl->height-1 : i+ty;
+					p = &pkl->image[(clipy*pkl->width+clipx)*pkl->channel];
+					for(k=0; k<pkl->channel; k++)
+						sort[k][rd] = *p++;
+					rd++;
+				}
+			}
+			//�����l�T��
+			for(k=0; k<pkl->channel; k++){
+				for(s=0; s<5; s++){
+					for(t=1,n=0,median[k]=sort[k][0]; t<9; t++){
+						if(median[k]<sort[k][t]){
+							median[k]=sort[k][t];
+							n=t;
+						}
+					}
+					sort[k][n]=0;
+				}
+			}
+			p= &wrk[(i*pkl->width+j)*pkl->channel];
+			for(k=0; k<pkl->channel; k++) *p++=median[k];
+		}
+	}
+
+	free(pkl->image);
+	pkl->image = wrk;
+	return(0);
+}
+

data/ext/pikl/pikl_io.c

@@ -15,6 +15,8 @@ PKLExport PKLImage pkl_open(const char *in)
 	memset(pkl, 0, sizeof(struct _PKLImage));
 	
 	pkl->compress = -1;
+	pkl->x_scale=1.0;
+	pkl->y_scale=1.0;
 	
 	image = fopen(in, "rb");
 	if(!image) return(NULL);

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);
@@ -66,6 +66,9 @@ int save_png(PKLImage pkl, FILE *image)
 	png_infop   info_ptr;
 	int  i;
 	
+	if(pkl->color!=PKL_RGB &&
+	   pkl->color!=PKL_GRAYSCALE) return(1);
+	
 	png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
 	if(!png_ptr) return(1);
 	
@@ -75,11 +78,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_private.h

@@ -2,7 +2,7 @@
 #define _LIB_PIKL_PRIVATE_
 
 #define PKL_MINMAX(a,b,i) (((a>=i)?a:((b<=i)?b:i)))
-#define PKL_RGB(v) v<0?0:v>255?255:v
+#define PKL_COLOR_CLIP(v) v<0?0:v>255?255:v
 #define PKL_CHANNEL 4
 #define PKL_COLOR 256
 #ifndef M_PI
@@ -19,6 +19,11 @@ struct _PKLImage {
 	unsigned char *image;
 	PKL_FORMAT format;
 	int compress;
+	
+	//affine
+	double x_scale, y_scale;
+	double angle;
+	double x_trns, y_trns;
 };
 
 #endif

data/ext/pikl/pikl_resize.c

@@ -99,7 +99,7 @@ static int resize_bl(PKLImage pkl, int width, int height)
 					sy = ((int)py+wy<0) ? pkl->height+((int)py+wy)%pkl->height-1 : ((int)py+wy)%pkl->height;
 					for(k=0; k<pkl->channel; k++){
 						wrk[(i*width+j)*pkl->channel+k] = 
-							PKL_RGB(wrk[(i*width+j)*pkl->channel+k] + pkl->image[(sy*pkl->width+sx)*pkl->channel+k] * f[wy*2+wx]);
+							PKL_COLOR_CLIP(wrk[(i*width+j)*pkl->channel+k] + pkl->image[(sy*pkl->width+sx)*pkl->channel+k] * f[wy*2+wx]);
 					}
 				}
 			}
@@ -146,7 +146,7 @@ static int resize_bc(PKLImage pkl, int width, int height)
 					for(k=0; k<pkl->channel; k++) data[k]+=pkl->image[(y0*pkl->width+x0)*pkl->channel+k]*wx*wy;
 				}
 			}
-			for(k=0; k<pkl->channel; k++) wrk[(i*width+j)*pkl->channel+k]=PKL_RGB(data[k]);
+			for(k=0; k<pkl->channel; k++) wrk[(i*width+j)*pkl->channel+k]=PKL_COLOR_CLIP(data[k]);
 		}
 	}
 	free(pkl->image);
@@ -198,7 +198,7 @@ static int resize_pa(PKLImage pkl, int width, int height)
 				}
 			}
 			for(k=0; k<pkl->channel; k++)
-				wrk[(i*width+j)*pkl->channel+k] = PKL_RGB(ixg[k]/(zx*zy));
+				wrk[(i*width+j)*pkl->channel+k] = PKL_COLOR_CLIP(ixg[k]/(zx*zy));
 		}
 	}
 	free(pkl->image);

data/ext/pikl/pikl_rotate2.c

@@ -159,7 +159,7 @@ static int pkl_rotate_bl(PKLImage pkl, float angle, unsigned char *backcolor)
 					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_COLOR_CLIP(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{
@@ -226,7 +226,7 @@ static int pkl_rotate_bc(PKLImage pkl, float angle, unsigned char *backcolor)
 			
 			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]);
+					wrk[((i-rect.top)*width+j-rect.left)*pkl->channel+k] = PKL_COLOR_CLIP(data[k]);
 			}else{
 				memcpy(&wrk[((i-rect.top)*width+j-rect.left)*pkl->channel], back, pkl->channel);
 			}

data/lib/pikl/ext.rb

@@ -33,5 +33,9 @@ module Pikl
     extern "int pkl_hls(PKLImage*, double, double, double)"
     extern "int pkl_gamma(PKLImage*, 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/image.rb

@@ -16,6 +16,10 @@ module Pikl
     
     end
     
+    def rawdata
+      @pkl_image
+    end
+    
     def initialize( inpath )
       @pkl_image = Ext.pkl_open(File.expand_path(inpath))
     end
@@ -28,7 +32,7 @@ module Pikl
         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)
+      Ext.pkl_save(@pkl_image, File.expand_path(outpath), EXTENSIONS_FORMATS[format.to_s.downcase] || format.to_i)
       self.close unless(@block)
       @pkl_image
     end
@@ -195,17 +199,50 @@ module Pikl
       self
     end
     
-    # ガンマ補正
-    #   ガンマ補正をします。
-    #   gmは補正係数です。
-    #   gm=0以上の値が指定できます。
-    #   1.0より小さい時は暗く、1.0より大きい時は明るく調整されます。
-    #   1.0を指定した時は調整されません。    
+    # 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
     
+    # 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
+    
+    # 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
+    
+    # mediancut to decrease colors.
+    # _ncolors_ :: num of colors.(1..256)
+    # _dither_ :: dither. true/false
+    def mediancut(ncolors, dither)
+      dither = dither ? 1 : 0
+      Ext.pkl_mediancut(@pkl_image, 4, dither)
+      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
+
     # regular expressions to try for identifying extensions
     def split_extensions(path)
       filename = path.split('/').last

data/lib/pikl/version.rb

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

data/test/test_pikl_image.rb

@@ -194,7 +194,7 @@ class TestPiklImage < Test::Unit::TestCase
       end
     end
 
-    def test_fit_inner
+    def test_fit_inner2
       # vertical-inner
       Pikl::Image.open(SAMPLE_IMAGE) do |img|
         img.fit(20,100)
@@ -363,10 +363,56 @@ class TestPiklImage < Test::Unit::TestCase
       end
     end
     
-    def test_method_chain
+    # mosaic effect
+    # _width_ :: width for mosaic unit.
+    # _height_ :: height for mosaic unit. 
+    def test_mosaic
       Pikl::Image.open(SAMPLE_IMAGE) do |img|
-        img.trim(5,10,:auto,:auto).rotate(90).resize(50,:auto).unshapmask(10,3).contrast(10).level(5,5,1.2).brightness(10).hls(0.1,0.1,355).gamma(1.2).save(SAMPLE_OUTPUT)
+        img.mosaic(3,3)
       end
     end
+    
+    # compose image
+    # _image_ :: another pikl image object.
+    # _xpos_ :: left position of composing image.
+    # _ypos_ :: top position of composing image.
+    # def test_compose
+    #   Pikl::Image.open(SAMPLE_IMAGE) do |img2|
+    #     Pikl::Image.open(SAMPLE_IMAGE) do |img|
+    #       img.compose(img2,3,3)
+    #     end
+    #   end
+    # end
+
+    # # mediancut to decrease colors.
+    # # _ncolors_ :: num of colors.(1..256)
+    # # _dither_ :: dither. true/false
+    # def test_mediancut
+    #   Pikl::Image.open(SAMPLE_IMAGE) do |img|
+    #     img.mediancut(256,true)
+    #   end
+    # 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 test_alphablend
+      Pikl::Image.open(SAMPLE_IMAGE) do |img2|
+        Pikl::Image.open(SAMPLE_IMAGE) do |img|
+          img.alphablend(img2,0,0,200)
+        end
+      end
+    end
+    
+    # def test_method_chain
+    #   Pikl::Image.open(SAMPLE_IMAGE) do |img2|
+    #     Pikl::Image.open(SAMPLE_IMAGE) do |img|
+    #       img.trim(5,10,:auto,:auto).rotate(90).resize(50,:auto).unshapmask(10,3).contrast(10).level(5,5,1.2).brightness(10).hls(0.1,0.1,355).gamma(1.2).mosaic(3,3).mediancut(256,true).compose(img2,10,10).save(SAMPLE_OUTPUT)
+    #     end
+    #   end
+    # end
+    
 
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: pikl
 version: !ruby/object:Gem::Version 
-  version: 0.2.6
+  version: 0.2.7
 platform: x86-mswin32
 authors: 
 - Ryota Maruko
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-08-19 00:00:00 +09:00
+date: 2008-09-27 00:00:00 +09:00
 default_executable: 
 dependencies: []