pikl 0.2.7-x86-mswin32 → 0.2.8-x86-mswin32

data/ext/pikl/pikl_effect4.h

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

data/ext/pikl/pikl_pattern.c

@@ -0,0 +1,611 @@
+#include "pikl_pattern.h"
+
+static int pkl_pattern_draw_line(PKLImage pkl, double *wd, int pw, int ph);
+static int pkl_pattern_draw_average(PKLImage pkl, double *wd, int pw, int ph);
+
+//=============================================================================
+// pkl_pattern_hexagon
+//=============================================================================
+PKLExport int pkl_pattern_hexagon(PKLImage pkl, int pw, int ph, PKL_PAINT_TYPE type)
+{
+	double ww, hh, *wd;
+	int i, result;
+	
+	wd = malloc(sizeof(double)*ph);
+	if(!wd) return(1);
+	
+	ww = (double)pw;
+	hh = (double)ph;
+	
+	/* パターン座標を構築する */
+	for(i=0; i<ph; i++){
+		if((double)i < hh/6.0){
+			wd[i] = ww * (double)i*6.0/hh;
+		}else
+		if((double)i < hh/2.0){
+			wd[i] = ww;
+		}else
+		if((double)i < hh*2.0/3.0){
+			wd[i] = ww*4.0 - ww*(double)i*6.0/hh;
+		}else{
+			wd[i] = 0.0;
+		}
+	}
+
+	/* 塗りタイプ別の処理 */
+	switch(type){
+		case PKL_PAINT_AVE:
+			result = pkl_pattern_draw_average(pkl, wd, pw, ph);
+			break;
+		case PKL_PAINT_LINE:
+		default:
+			result = pkl_pattern_draw_line(pkl, wd, pw, ph);
+	}
+
+	free(wd);
+	return(result);
+}
+
+//=============================================================================
+// pkl_pattern_diamond
+//=============================================================================
+PKLExport int pkl_pattern_diamond(PKLImage pkl, int pw, int ph, PKL_PAINT_TYPE type)
+{
+	double ww, hh, *wd;
+	int i, result;
+	
+	wd = malloc(sizeof(double)*ph);
+	if(!wd) return(1);
+	
+	ww = (double)pw;
+	hh = (double)ph;
+	
+	/* パターン座標を構築する */
+	for(i=0; i<ph; i++){
+		if((double)i < hh/2.0){
+			wd[i] = ww*(double)i*2.0/hh;
+		}else{
+			wd[i] = ww*2.0 - ww*(double)i*2.0/hh;
+		}
+	}
+
+	/* 塗りタイプ別の処理 */
+	switch(type){
+		case PKL_PAINT_AVE:
+			result = pkl_pattern_draw_average(pkl, wd, pw, ph);
+			break;
+		case PKL_PAINT_LINE:
+		default:
+			result = pkl_pattern_draw_line(pkl, wd, pw, ph);
+	}
+
+	free(wd);
+	return(result);
+}
+
+//=============================================================================
+// pkl_pattern_circle
+//=============================================================================
+PKLExport int pkl_pattern_circle(PKLImage pkl, int pw, int ph, PKL_PAINT_TYPE type)
+{
+	double ww, hh, *wd;
+	int i, result;
+	
+	wd = malloc(sizeof(double)*ph);
+	if(!wd) return(1);
+	
+	ww = (double)pw;
+	hh = (double)ph;
+	
+	/* パターン座標を構築する */
+	for(i=0; i<ph; i++){
+		if((double)i < hh/2.0){
+			wd[i] = ww*(double)i*2.0/hh - (ww/8.0)*sin((double)i*4.0/hh*M_PI);
+		}else{
+			wd[i] = ww*2.0 - ww*(double)i*2.0/hh + (ww/8.0)*sin((double)(i-hh/2.0)*4.0/hh*M_PI);
+		}
+	}
+
+	/* 塗りタイプ別の処理 */
+	switch(type){
+		case PKL_PAINT_AVE:
+			result = pkl_pattern_draw_average(pkl, wd, pw, ph);
+			break;
+		case PKL_PAINT_LINE:
+		default:
+			result = pkl_pattern_draw_line(pkl, wd, pw, ph);
+	}
+
+	free(wd);
+	return(result);
+}
+
+//=============================================================================
+// pkl_pattern_brick
+//=============================================================================
+PKLExport int pkl_pattern_brick(PKLImage pkl, int pw, int ph, PKL_PAINT_TYPE type)
+{
+	double ww, hh, *wd;
+	int i, result;
+	
+	wd = malloc(sizeof(double)*ph);
+	if(!wd) return(1);
+	
+	ww = (double)pw;
+	hh = (double)ph;
+	
+	/* パターン座標を構築する */
+	for(i=0; i<ph; i++){
+		if((double)i < hh/2.0){
+			wd[i] = ww;
+		}else{
+			wd[i] = 0.0;
+		}
+	}
+
+	/* 塗りタイプ別の処理 */
+	switch(type){
+		case PKL_PAINT_AVE:
+			result = pkl_pattern_draw_average(pkl, wd, pw, ph);
+			break;
+		case PKL_PAINT_LINE:
+		default:
+			result = pkl_pattern_draw_line(pkl, wd, pw, ph);
+	}
+
+	free(wd);
+	return(result);
+}
+
+//=============================================================================
+// pkl_pattern_draw_line
+//=============================================================================
+static int pkl_pattern_draw_line(PKLImage pkl, double *wd, int pw, int ph)
+{
+	unsigned char clipcolor[PKL_CHANNEL], *p;
+	int i, j, s, idx, k, color[PKL_CHANNEL];
+	double ww, hh, rm;
+	int count, ptn=0;
+
+	if(pw<0 || pw>pkl->width || ph<0 || ph>pkl->height) return(1);
+	
+	ww = (double)pw;
+	hh = (double)ph;
+
+	//x方向に母点分ずつずらしていく
+	for(j=0; j<pkl->width+pw; j+=pw){
+		//パターンの切り替え
+		ptn = !ptn;
+
+		for(i=0; i<pkl->height; i++){
+			memset(color, 0, sizeof(color));
+			count=0;
+			
+			//パターン配列のインデックスを算出
+			//(余剰を算出すれば、パターン配列を順番に処理できるから)
+			idx = i % ph;
+			
+			//パターンを幅=pwの範囲で縦方向に見るので
+			//パターン距離(wd)をpwから引くことで横方向の距離を算出できる
+			//パターンは繰り返しなので、pw++ごとに切り替えればよい
+			rm = ptn ? wd[idx] : ww-wd[idx];
+			
+			//jをパターンの中心として、両側へ広がりのある領域のピクセル平均を取る
+			for(s=j-rm; s<=j+rm; s++){
+				if(s<0 || s>=pkl->width) continue;
+				p = &pkl->image[(i*pkl->width+s)*pkl->channel];
+				for(k=0; k<pkl->channel; k++)
+					color[k] += *p++;
+				count++;
+			}
+			if(count==0) continue;
+			for(k=0; k<pkl->channel; k++)
+				clipcolor[k] = PKL_COLOR_CLIP(color[k]/count);
+
+			//作った色を横方向に適用する
+			for(s=j-rm; s<=j+rm; s++){
+				if(s<0 || s>=pkl->width) continue;
+				memcpy(&pkl->image[(i*pkl->width+s)*pkl->channel], clipcolor, pkl->channel);
+			}
+		}
+	}
+	return(0);
+}
+
+//=============================================================================
+// pkl_pattern_draw_average
+//=============================================================================
+static int pkl_pattern_draw_average(PKLImage pkl, double *wd, int pw, int ph)
+{
+	unsigned char clipcolor[PKL_CHANNEL], *p;
+	int i, j, s, t, k, color[PKL_CHANNEL];
+	int count, ys, idx, ptn=0;
+	double ww, hh, rm;
+	
+	if(pw<0 || pw>pkl->width || ph<0 || ph>pkl->height) return(1);
+	
+	ww = (double)pw;
+	hh = (double)ph;
+
+	for(j=0; j<pkl->width+pw; j+=pw){
+		ptn = !ptn;
+		ys = (ptn) ? 0 : (-ph/2);
+
+		for(i=ys; i<pkl->height; i+=ph){
+			memset(color, 0, sizeof(color));
+			count=0;
+			rm=wd[0];
+			
+			for(t=i; t<i+ph; t++){
+				if(t<0 || t>=pkl->height) continue;
+				
+				idx = t % ph;
+				rm = ptn ? wd[idx] : ww-wd[idx];
+				for(s=j-rm; s<=j+rm; s++){
+					if(s<0 || s>=pkl->width) continue;
+					p = &pkl->image[(t*pkl->width+s)*pkl->channel];
+					for(k=0; k<pkl->channel; k++)
+						color[k] += *p++;
+					count++;
+				}
+			}
+			
+			/* パターン領域内の平均算出 */
+			if(count==0) continue;
+			for(k=0; k<pkl->channel; k++)
+				clipcolor[k] = PKL_COLOR_CLIP(color[k]/count);
+			
+			/* パターン領域を同一色で塗りつぶす */
+			for(t=i; t<i+ph; t++){
+				if(t<0 || t>=pkl->height) continue;
+				idx = t % ph;
+				rm = ptn ? wd[idx] : ww-wd[idx];
+				
+				for(s=j-rm; s<=j+rm; s++){
+					if(s<0 || s>=pkl->width) continue;
+					memcpy(&pkl->image[(t*pkl->width+s)*pkl->channel], clipcolor, pkl->channel);
+				}
+				
+				//境界線
+				//if(j-rm-1>=0)
+				//	memset(&pkl->image[(t*pkl->width+(int)(j-rm-1))*pkl->channel], 0, pkl->channel);
+				//if(j+rm+1<pkl->width)
+				//	memset(&pkl->image[(t*pkl->width+(int)(j+rm+1))*pkl->channel], 0, pkl->channel);
+				//if(t-1>=0)
+				//	memset(&pkl->image[((t-1)*pkl->width+s)*pkl->channel], 0, pkl->channel);
+				//if(t+1<pkl->height)
+				//	memset(&pkl->image[((t+1)*pkl->width+s)*pkl->channel], 0, pkl->channel);
+			}
+		}
+	}
+	return(0);
+}
+
+//=============================================================================
+// voronoi_type1 datatype
+//=============================================================================
+struct VoronoiPoint {
+	int x, y;
+	long color[PKL_CHANNEL];
+	unsigned char ave[PKL_CHANNEL];
+	int count;
+};
+
+//=============================================================================
+// voronoi_type1_query
+//=============================================================================
+static void voronoi_type1_query(PKLImage pkl, struct VoronoiPoint *vptr, int *id, int zone, int xzone, int yzone)
+{
+	struct VoronoiPoint *p;
+	int i, j, k, tx, ty, xx, yy, minIx, minIy;
+	double d, mind;
+	
+	//母点を生成
+	srand48(1);
+	p = vptr;
+	for(i=0; i<yzone; i++){
+		for(j=0; j<xzone; j++){
+			tx = j * zone + lrand48()%zone;
+			ty = i * zone + lrand48()%zone;
+			p->x = tx>=pkl->width ? pkl->width-1 : tx;
+			p->y = ty>=pkl->height ? pkl->height-1 : ty;
+			p++;
+		}
+	}
+	
+	for(i=0; i<pkl->height; i++){
+		yy = i/zone;
+		for(j=0; j<pkl->width; j++){
+			xx = j/zone;
+			mind=10000000;
+			minIx=minIy=0;
+			
+			//カレントピクセルに最も近い母点を探す
+			for(ty=yy-1; ty<=yy+1; ty++){
+				if(ty<0 || ty>yzone-1) continue;
+				for(tx=xx-1; tx<=xx+1; tx++){
+					if(tx<0 || tx>xzone-1) continue;
+					d = (vptr[ty*xzone+tx].x-j)*(vptr[ty*xzone+tx].x-j) +
+						(vptr[ty*xzone+tx].y-i)*(vptr[ty*xzone+tx].y-i);
+					if(d < mind){
+						mind = d;
+						minIx = tx;
+						minIy = ty;
+					}
+				}
+			}
+			
+			for(k=0; k<pkl->channel; k++)
+				vptr[minIy*xzone+minIx].color[k] += pkl->image[(i*pkl->width+j)*pkl->channel+k];
+			vptr[minIy*xzone+minIx].count++;
+
+			//各ピクセルのボロノイIDをセット
+			id[i*pkl->width+j] = minIy*xzone+minIx;
+		}
+	}
+}
+
+//=============================================================================
+// pkl_voronoi_type1
+//=============================================================================
+PKLExport int pkl_voronoi_type1(PKLImage pkl, int zone, int bordercolor, int test)
+{
+	struct VoronoiPoint *vptr, *p;
+	int xzone, yzone, *id;
+	int i, j, k, tx, ty;
+	unsigned char border[PKL_CHANNEL];
+	
+	
+	if(zone < 2) return(1);
+	if(zone>=pkl->width || zone>=pkl->height) return(1);
+	xzone = pkl->width/zone;
+	if((pkl->width%zone) != 0) xzone++;
+	yzone = pkl->height/zone;
+	if((pkl->height%zone) != 0) yzone++;
+
+	for(i=0; i<pkl->channel; i++)
+		border[i] = (bordercolor>>((pkl->channel-i)*8) & 0xFF);
+	
+	//ボロノイ管理データ
+	vptr = malloc(sizeof(struct VoronoiPoint) * xzone*yzone);
+	memset(vptr, 0, sizeof(struct VoronoiPoint) * xzone*yzone);
+	
+	//各座標のボロノイIDを格納するデータ
+	id = malloc(sizeof(int) * pkl->width*pkl->height);
+	
+	//ボロノイ管理データを作る
+	voronoi_type1_query(pkl, vptr, id, zone, xzone, yzone);
+	
+	if(test){
+		//分割シュミレーション(母点を置く)
+		memset(pkl->image, 0xff, pkl->width*pkl->height*pkl->channel);
+		for(i=0; i<xzone*yzone; i++)
+			memcpy(&pkl->image[(vptr[i].y*pkl->width+vptr[i].x)*pkl->channel], border, pkl->channel);
+	}else{
+		//各ボロノイポイントの平均色算出
+		for(ty=0; ty<yzone; ty++){
+			for(tx=0; tx<xzone; tx++){
+				if(vptr[ty*xzone+tx].count == 0) continue;
+				p = &vptr[ty*xzone+tx];
+				for(k=0; k<pkl->channel; k++)
+					p->ave[k] = PKL_COLOR_CLIP(p->color[k]/p->count);
+			}
+		}
+		//色を設定
+		for(i=0; i<pkl->height; i++)
+			for(j=0; j<pkl->width; j++)
+				memcpy(&pkl->image[(i*pkl->width+j)*pkl->channel], vptr[id[i*pkl->width+j]].ave, pkl->channel);
+	}
+	
+	//境界線を引く
+	if(bordercolor!=-1){
+		int currentId, hit=0;
+		for(j=0; j<pkl->height; j++){
+			for(i=0; i<pkl->width; i++){
+				hit=0;
+				currentId = id[j*pkl->width+i];
+				if(i-1>=0         && currentId!=id[j*pkl->width+i-1]) hit++;
+				if(i+1<pkl->width && currentId!=id[j*pkl->width+i+1]) hit++;
+				if(j-1>=0          && currentId!=id[(j-1)*pkl->width+i+1]) hit++;
+				if(j+1<pkl->height && currentId!=id[(j+1)*pkl->width+i+1]) hit++;
+				if(hit)
+					memcpy(&pkl->image[(j*pkl->width+i)*pkl->channel], border, pkl->channel);
+			}
+		}
+	}
+	free(id);
+	free(vptr);
+	return(0);
+}
+
+//=============================================================================
+// voronoi_type2 datatype
+//=============================================================================
+//ボロノイの母点管理用(1つの母点から隣接する母点の個数)
+#define VORONOI_CNT 10	//根拠はない
+
+struct VORONOI {
+	int x, y;				//母点座標
+	int id;					//管理用ID
+	long color[PKL_CHANNEL];	//ターゲット領域の色累積領域
+	int count;				//累積ピクセル数
+	int next[VORONOI_CNT];	//隣接する母点のID
+};
+
+//=============================================================================
+// vcompare
+//=============================================================================
+static int vcompare(const void *a, const void *b)
+{
+	struct VORONOI *t1 = (struct VORONOI *)a;
+	struct VORONOI *t2 = (struct VORONOI *)b;
+	
+	if(t1->y == t2->y)
+		return(t1->x - t2->x);
+	return(t1->y - t2->y);
+}
+
+//=============================================================================
+// voronoi_setid
+//=============================================================================
+static void voronoi_setid(int *ary, int id)
+{
+	int i;
+	
+	for(i=0; i<VORONOI_CNT; i++){
+		if(ary[i] == -1){
+			ary[i] = id;
+			return;
+		}
+	}
+}
+
+//=============================================================================
+// voronoi_type2_query
+//=============================================================================
+static void voronoi_type2_query(PKLImage pkl, struct VORONOI *kp, int *ip, int count)
+{
+	int i, j, k, min_id, pre_id;
+	double d, dx, dy, min_d;
+	
+	//母点をランダムに生成する
+	srand48((long)count);
+	for(i=0; i<count; i++){
+		kp[i].x = lrand48() % pkl->width;
+		kp[i].y = lrand48() % pkl->height;
+		kp[i].id = i;
+	}
+	
+	//生成した母点座標を左上から右下に向かってソートする
+	qsort(kp, count, sizeof(struct VORONOI), vcompare);
+	
+	min_id = 0;  //最初の母点ID
+	pre_id = 0;  //前ピクセルの母点ID
+	
+	//各母点の最近傍の母点を探索する
+	for(j=0; j<pkl->height; j++){
+		for(i=0; i<pkl->width; i++){
+			// 前ピクセルの母点との距離を求める
+			dx = kp[pre_id].x-i;
+			dy = kp[pre_id].y-j;
+			min_d = sqrt(dx*dx+dy*dy);
+			
+			//現在のピクセルの右上により近い母点があるか検索
+			for(k=pre_id-1; k>=0 && (kp[k].y>=j-min_d); k--){
+				if(kp[k].x >= i && kp[k].x <= i+min_d){
+					dx = kp[k].x-i;
+					dy = kp[k].y-j;
+					d = sqrt(dx*dx+dy*dy);
+					if(d<min_d){
+						min_id=k;
+						min_d=d;
+					}
+				}
+			}
+			//現在のピクセルの右下により近い母点があるか検索
+			for(k=pre_id+1; k<count && (kp[k].y<=j+min_d); k++){
+				if(kp[k].x >= i && kp[k].x <= i+min_d){
+					dx = kp[k].x-i;
+					dy = kp[k].y-j;
+					d = sqrt(dx*dx+dy*dy);
+					if(d<min_d){
+						min_id=k;
+						min_d=d;
+					}
+				}
+			}
+			//最も近くにある母点のIDを設定する
+			if(pre_id != min_id){
+				voronoi_setid(kp[pre_id].next, min_id);
+				voronoi_setid(kp[min_id].next, pre_id);
+			}
+			
+			//現在の座標のIDに決定したボロノイ管理IDを設定する
+			ip[j*pkl->width+i] = min_id;
+			pre_id = min_id;
+		}
+	}
+}
+
+//=============================================================================
+// pkl_voronoi_type2
+//=============================================================================
+PKLExport int pkl_voronoi_type2(PKLImage pkl, int count, int bordercolor, int test)
+{
+	struct VORONOI *kp;
+	int i, j, k, *ip;
+	unsigned char border[PKL_CHANNEL];
+
+	//母点数の閾値
+	if(count < 10) return(1);
+	
+	for(i=0; i<pkl->channel; i++)
+		border[i] = (bordercolor>>((pkl->channel-i)*8) & 0xFF);
+	
+	//各座標の母点IDを格納する領域
+	ip = malloc(sizeof(int) * pkl->width * pkl->height);
+	memset(ip, -1, sizeof(int) * pkl->width * pkl->height);
+	
+	//母点管理領域(母点数分用意)
+	kp = malloc(sizeof(struct VORONOI) * count);
+	memset(kp, 0, sizeof(struct VORONOI) * count);
+	for(i=0; i<count; i++)
+		memset(kp[i].next, -1, sizeof(int)*VORONOI_CNT);
+	
+	//ボロノイ管理データを作る
+	voronoi_type2_query(pkl, kp, ip, count);
+	
+	if(test){
+		//分割シュミレーション(母点を置く)
+		memset(pkl->image, 0xff, pkl->width*pkl->height*pkl->channel);
+		for(i=0; i<count; i++)
+			memcpy(&pkl->image[(kp[i].y*pkl->width+kp[i].x)*pkl->channel], border, pkl->channel);
+	}else{
+		//ボロノイ分割されたので、各セルの平均色を算出するためにセルの色を累積する
+		for(j=0; j<pkl->height; j++) {
+			for(i=0; i<pkl->width; i++) {
+				//ipを参照することで、現在の座標がどのIDに所属するかわかる
+				if(ip[j*pkl->width+i] == -1) continue;
+				//IDごとに色を累積する
+				kp[ ip[j*pkl->width+i] ].count++;
+				for(k=0; k<pkl->channel; k++)
+					kp[ ip[j*pkl->width+i] ].color[k] += pkl->image[(j*pkl->width+i)*pkl->channel+k];
+			}
+		}
+		
+		//各セルの平均色を作る
+		for(i=0; i<count; i++){
+			for(k=0; k<pkl->channel; k++){
+				if(kp[i].count!=0)
+					kp[i].color[k] = PKL_COLOR_CLIP(kp[i].color[k]/kp[i].count);
+			}
+		}
+		
+		//色を置く
+		for(j=0; j<pkl->height; j++)
+			for(i=0; i<pkl->width; i++)
+				for(k=0; k<pkl->channel; k++)
+					pkl->image[(j*pkl->width+i)*pkl->channel+k] = kp[ ip[j*pkl->width+i] ].color[k];
+	}
+	
+	//境界線を引く
+	if(bordercolor!=-1){
+		int currentId, hit=0;
+		for(j=0; j<pkl->height; j++){
+			for(i=0; i<pkl->width; i++){
+				hit=0;
+				currentId = ip[j*pkl->width+i];
+				if(i-1>=0         && currentId!=ip[j*pkl->width+i-1]) hit++;
+				if(i+1<pkl->width && currentId!=ip[j*pkl->width+i+1]) hit++;
+				if(j-1>=0          && currentId!=ip[(j-1)*pkl->width+i+1]) hit++;
+				if(j+1<pkl->height && currentId!=ip[(j+1)*pkl->width+i+1]) hit++;
+				if(hit)
+					memcpy(&pkl->image[(j*pkl->width+i)*pkl->channel], border, pkl->channel);
+			}
+		}
+	}
+
+	free(kp);
+	free(ip);
+	return(0);
+}