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

data/ext/pikl/pikl_pattern.c

@@ -1,15 +1,27 @@
 #include "pikl_pattern.h"
 
+static int tile_rectangle(PKLImage pkl, int msx, int msy, unsigned char level);
+static int tile_pattern(PKLImage pkl, PKL_TILE_TYPE type, int pw, int ph, unsigned char level);
+static int tile_pattern_draw(PKLImage pkl, double *wd, int pw, int ph, unsigned char level);
+static int tile_brick(PKLImage pkl, int msx, int msy, unsigned char level);
+
+static void pattern_hexagon(int ph, double *wd, double ww, double hh);
+static void pattern_diamond(int ph, double *wd, double ww, double hh);
+static void pattern_circle(int ph, double *wd, double ww, double hh);
+static void pattern_brick(int ph, double *wd, double ww, double hh);
+
 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
+// pkl_pattern
 //=============================================================================
-PKLExport int pkl_pattern_hexagon(PKLImage pkl, int pw, int ph, PKL_PAINT_TYPE type)
+PKLExport int pkl_pattern(PKLImage pkl, int pw, int ph, PKL_PATTERN_TYPE mode, PKL_PAINT_TYPE type)
 {
 	double ww, hh, *wd;
-	int i, result;
+	int result;
+	
+	if(pw<1 || ph<1) return(1);
 	
 	wd = malloc(sizeof(double)*ph);
 	if(!wd) return(1);
@@ -17,21 +29,22 @@ PKLExport int pkl_pattern_hexagon(PKLImage pkl, int pw, int ph, PKL_PAINT_TYPE t
 	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(mode){
+		case PKL_PATTERN_DIAMOND:
+			pattern_diamond(ph, wd, ww, hh);
+			break;
+		case PKL_PATTERN_CIRCLE:
+			pattern_circle(ph, wd, ww, hh);
+			break;
+		case PKL_PATTERN_BRICK:
+			pattern_brick(ph, wd, ww, hh);
+			break;
+		case PKL_PATTERN_HEXAGON:
+		default:
+			pattern_hexagon(ph, wd, ww, hh);
 	}
-
+	
 	/* 塗りタイプ別の処理 */
 	switch(type){
 		case PKL_PAINT_AVE:
@@ -47,20 +60,32 @@ PKLExport int pkl_pattern_hexagon(PKLImage pkl, int pw, int ph, PKL_PAINT_TYPE t
 }
 
 //=============================================================================
-// pkl_pattern_diamond
+// pattern_hexagon
 //=============================================================================
-PKLExport int pkl_pattern_diamond(PKLImage pkl, int pw, int ph, PKL_PAINT_TYPE type)
+void pattern_hexagon(int ph, double *wd, double ww, double hh)
 {
-	double ww, hh, *wd;
-	int i, result;
-	
-	wd = malloc(sizeof(double)*ph);
-	if(!wd) return(1);
-	
-	ww = (double)pw;
-	hh = (double)ph;
-	
-	/* パターン座標を構築する */
+	int i;
+	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;
+		}
+	}
+}
+
+//=============================================================================
+// pattern_diamond
+//=============================================================================
+void pattern_diamond(int ph, double *wd, double ww, double hh)
+{
+	int i;
 	for(i=0; i<ph; i++){
 		if((double)i < hh/2.0){
 			wd[i] = ww*(double)i*2.0/hh;
@@ -68,36 +93,14 @@ PKLExport int pkl_pattern_diamond(PKLImage pkl, int pw, int ph, PKL_PAINT_TYPE t
 			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
+// pattern_circle
 //=============================================================================
-PKLExport int pkl_pattern_circle(PKLImage pkl, int pw, int ph, PKL_PAINT_TYPE type)
+void pattern_circle(int ph, double *wd, double ww, double hh)
 {
-	double ww, hh, *wd;
-	int i, result;
-	
-	wd = malloc(sizeof(double)*ph);
-	if(!wd) return(1);
-	
-	ww = (double)pw;
-	hh = (double)ph;
-	
-	/* パターン座標を構築する */
+	int i;
 	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);
@@ -105,36 +108,14 @@ PKLExport int pkl_pattern_circle(PKLImage pkl, int pw, int ph, PKL_PAINT_TYPE ty
 			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
+// pattern_brick
 //=============================================================================
-PKLExport int pkl_pattern_brick(PKLImage pkl, int pw, int ph, PKL_PAINT_TYPE type)
+void pattern_brick(int ph, double *wd, double ww, double hh)
 {
-	double ww, hh, *wd;
-	int i, result;
-	
-	wd = malloc(sizeof(double)*ph);
-	if(!wd) return(1);
-	
-	ww = (double)pw;
-	hh = (double)ph;
-	
-	/* パターン座標を構築する */
+	int i;
 	for(i=0; i<ph; i++){
 		if((double)i < hh/2.0){
 			wd[i] = ww;
@@ -142,25 +123,12 @@ PKLExport int pkl_pattern_brick(PKLImage pkl, int pw, int ph, PKL_PAINT_TYPE typ
 			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)
+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];
@@ -215,7 +183,7 @@ static int pkl_pattern_draw_line(PKLImage pkl, double *wd, int pw, int ph)
 //=============================================================================
 // pkl_pattern_draw_average
 //=============================================================================
-static int pkl_pattern_draw_average(PKLImage pkl, double *wd, int pw, int ph)
+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];
@@ -282,330 +250,388 @@ static int pkl_pattern_draw_average(PKLImage pkl, double *wd, int pw, int ph)
 }
 
 //=============================================================================
-// voronoi_type1 datatype
+// pkl_tile
 //=============================================================================
-struct VoronoiPoint {
-	int x, y;
-	long color[PKL_CHANNEL];
-	unsigned char ave[PKL_CHANNEL];
-	int count;
-};
+PKLExport int pkl_tile(PKLImage pkl, PKL_TILE_TYPE type, int msx, int msy, unsigned char level)
+{
+	if(msx<=0 || msx>pkl->width || msy<=0 || msy>pkl->height)
+		return(1);
+	
+	switch(type){
+		case PKL_TILE_RECT:
+			return tile_rectangle(pkl, msx, msy, level);
+		case PKL_TILE_HEXAGON:
+		case PKL_TILE_DIAMOND:
+		case PKL_TILE_CIRCLE:
+			return tile_pattern(pkl, type, msx, msy, level);
+		case PKL_TILE_BRICK:
+			return tile_brick(pkl, msx, msy, level);
+	}
+	return(1);
+}
 
 //=============================================================================
-// voronoi_type1_query
+// tile_brick
 //=============================================================================
-static void voronoi_type1_query(PKLImage pkl, struct VoronoiPoint *vptr, int *id, int zone, int xzone, int yzone)
+static int tile_brick(PKLImage pkl, int msx, int msy, unsigned char level)
 {
-	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;
+	unsigned char *wrk, *p;
+	int mpx, mpy;	//モザイクの大きさ
+	int mlx, mly;	//画像の分割数
+	int i, j, k, sx, sy, ex, ey, px, py, count, offset;
+	long color[PKL_CHANNEL];
+
+	wrk = malloc(pkl->width*pkl->height*pkl->channel);
+	if(!wrk) return(1);
+	memset(wrk, 0, pkl->width*pkl->height*pkl->channel);
+
+	mpx = (msx<1) ? 1 : (msx>=pkl->width) ? pkl->width-1 : msx;
+	mpy = (msy<1) ? 1 : (msy>=pkl->height) ? pkl->height-1 : msy;
+	mlx = (pkl->width+mpx-1)/mpx;
+	mly = (pkl->height+mpy-1)/mpy;
+	
+	for(i=0; i<=mly; i++){
+		offset = (i%2) ? 0 : mpx/2;
+		for(j=0; j<=mlx; j++){
+			sx = j*mpx - offset;
+			sx = sx<0 ? 0 : sx;
+			sy = i*mpy;
+			ex = sx+mpx>pkl->width ? pkl->width : sx+mpx;
+			ey = sy+mpy>pkl->height ? pkl->height : sy+mpy;
 			
-			//カレントピクセルに最も近い母点を探す
-			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;
-					}
+			//1セルの総和算出
+			count=0;
+			memset(color, 0, sizeof(color));
+			for(py=sy; py<ey; py++){
+				for(px=sx; px<ex; px++){
+					count++;
+					for(k=0; k<pkl->channel; k++)
+						color[k] += pkl->image[(py*pkl->width+px)*pkl->channel+k];
 				}
 			}
+			if(!count) continue;
 			
+			//セルの平均色を算出して、セル内のピクセルに適用
 			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;
+				color[k] = PKL_COLOR_CLIP(color[k]/count);
+			for(py=sy; py<ey; py++){
+				for(px=sx; px<ex; px++){
+					for(k=0; k<pkl->channel; k++)
+						wrk[(py*pkl->width+px)*pkl->channel+k] = color[k];
+				}
+			}
+			
+			//平均色で塗り終わったら枠線を描く
+			//横方向
+			for(px=sx; px<ex; px++){
+				p = &wrk[(sy*pkl->width+px)*pkl->channel];
+				for(k=0; k<pkl->channel; k++,p++)
+					*p = PKL_MIN(0xff, *p+level);
+				
+				p = &wrk[((ey-1)*pkl->width+px)*pkl->channel];
+				for(k=0; k<pkl->channel; k++,p++)
+					*p = PKL_MAX(0, *p-level);
+			}
+			//縦方向
+			for(py=sy; py<ey; py++){
+				p = &wrk[(py*pkl->width+sx)*pkl->channel];
+				for(k=0; k<pkl->channel; k++,p++)
+					*p = PKL_MIN(0xff, *p+level);
+				
+				p = &wrk[(py*pkl->width+ex-1)*pkl->channel];
+				for(k=0; k<pkl->channel; k++,p++)
+					*p = PKL_MAX(0, *p-level);
+			}
+			
 		}
 	}
+	
+	free(pkl->image);
+	pkl->image = wrk;
+	return(0);
 }
 
 //=============================================================================
-// pkl_voronoi_type1
+// tile_rectangle
 //=============================================================================
-PKLExport int pkl_voronoi_type1(PKLImage pkl, int zone, int bordercolor, int test)
+static int tile_rectangle(PKLImage pkl, int msx, int msy, unsigned char level)
 {
-	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);
-			}
+	unsigned char *p;
+	int i, j, k;
+
+	//モザイク化
+	if(pkl_mosaic(pkl, msx, msy)) return(1);
+
+	//横方向(light)
+	for(i=0; i<pkl->height; i+=msy){
+		for(j=0; j<pkl->width; j++){
+			p = &pkl->image[(i*pkl->width+j)*pkl->channel];
+			for(k=0; k<pkl->channel; k++,p++)
+				*p = PKL_MIN(0xff, *p+level);
 		}
-		//色を設定
-		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);
-			}
+
+	//横方向(dark)
+	for(i=msy-1; i<pkl->height; i+=msy){
+		for(j=0; j<pkl->width; j++){
+			p = &pkl->image[(i*pkl->width+j)*pkl->channel];
+			for(k=0; k<pkl->channel; k++,p++)
+				*p = PKL_MAX(0, *p-level);
 		}
 	}
-	free(id);
-	free(vptr);
-	return(0);
-}
 
-//=============================================================================
-// voronoi_type2 datatype
-//=============================================================================
-//ボロノイの母点管理用(1つの母点から隣接する母点の個数)
-#define VORONOI_CNT 10	//根拠はない
+	//縦方向(light)
+	for(i=0; i<pkl->height; i++){
+		for(j=0; j<pkl->width; j+=msx){
+			p = &pkl->image[(i*pkl->width+j)*pkl->channel];
+			for(k=0; k<pkl->channel; k++,p++)
+				*p = PKL_MIN(0xff, *p+level);
+		}
+	}
+
+	//縦方向(dark)
+	for(i=0; i<pkl->height; i++){
+		for(j=msx-1; j<pkl->width; j+=msx){
+			p = &pkl->image[(i*pkl->width+j)*pkl->channel];
+			for(k=0; k<pkl->channel; k++,p++)
+				*p = PKL_MAX(0, *p-level);
+		}
+	}
 
-struct VORONOI {
-	int x, y;				//母点座標
-	int id;					//管理用ID
-	long color[PKL_CHANNEL];	//ターゲット領域の色累積領域
-	int count;				//累積ピクセル数
-	int next[VORONOI_CNT];	//隣接する母点のID
-};
+	return(0);
+}
 
 //=============================================================================
-// vcompare
+// tile_pattern
 //=============================================================================
-static int vcompare(const void *a, const void *b)
+static int tile_pattern(PKLImage pkl, PKL_TILE_TYPE type, int pw, int ph, unsigned char level)
 {
-	struct VORONOI *t1 = (struct VORONOI *)a;
-	struct VORONOI *t2 = (struct VORONOI *)b;
+	double ww, hh, *wd;
+	int result=1;
+	
+	wd = malloc(sizeof(double)*ph);
+	if(!wd) return(1);
+	
+	ww = (double)pw;
+	hh = (double)ph;
 	
-	if(t1->y == t2->y)
-		return(t1->x - t2->x);
-	return(t1->y - t2->y);
+	/* パターン座標の構築 */
+	switch(type){
+		case PKL_TILE_HEXAGON:
+			pattern_hexagon(ph, wd, ww, hh); break;
+		case PKL_TILE_DIAMOND:
+			pattern_diamond(ph, wd, ww, hh); break;
+		case PKL_TILE_CIRCLE:
+			pattern_circle(ph, wd, ww, hh); break;
+		default:
+			;;
+	}
+	
+	//パターンで塗りつぶしてから枠を描く
+	if(!pkl_pattern_draw_average(pkl, wd, pw, ph))
+		result = tile_pattern_draw(pkl, wd, pw, ph, level);
+	free(wd);
+	return(result);
 }
 
 //=============================================================================
-// voronoi_setid
+// tile_pattern_draw
 //=============================================================================
-static void voronoi_setid(int *ary, int id)
+static int tile_pattern_draw(PKLImage pkl, double *wd, int pw, int ph, unsigned char level)
 {
-	int i;
+	unsigned char *p;
+	int i, j, t, k, pos;
+	int ys, idx, ptn=0;
+	double ww, hh, rm;
 	
-	for(i=0; i<VORONOI_CNT; i++){
-		if(ary[i] == -1){
-			ary[i] = id;
-			return;
+	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){
+			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];
+				
+				//first=light
+				pos = j - rm;
+				if(pos>=0 && pos<pkl->width){
+					p = &pkl->image[(t*pkl->width+pos)*pkl->channel];
+					for(k=0; k<pkl->channel; k++,p++)
+						*p = PKL_MIN(0xff, *p+level);
+				}
+				
+				//last=dark
+				pos = j + rm - 1;
+				if(pos>=0 && pos<pkl->width){
+					p = &pkl->image[(t*pkl->width+pos)*pkl->channel];
+					for(k=0; k<pkl->channel; k++,p++)
+						*p = PKL_MAX(0, *p-level);
+				}
+			}
 		}
 	}
+	return(0);
 }
 
+
 //=============================================================================
-// voronoi_type2_query
+// pkl_mosaic
 //=============================================================================
-static void voronoi_type2_query(PKLImage pkl, struct VORONOI *kp, int *ip, int count)
+PKLExport int pkl_mosaic(PKLImage pkl, int msx, int msy)
 {
-	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);
+	unsigned char *wrk;
+	int mpx, mpy;	//モザイクの大きさ
+	int mlx, mly;	//画像の分割数
+	int i, j, k, sx, sy, ex, ey, px, py, mm;
+	long color[PKL_CHANNEL];
+
+	wrk = malloc(pkl->width*pkl->height*pkl->channel);
+	if(!wrk) return(1);
+	memset(wrk, 0, pkl->width*pkl->height*pkl->channel);
+
+	mpx = (msx<1) ? 1 : (msx>=pkl->width) ? pkl->width-1 : msx;
+	mpy = (msy<1) ? 1 : (msy>=pkl->height) ? pkl->height-1 : msy;
+	mlx = (pkl->width+mpx-1)/mpx;
+	mly = (pkl->height+mpy-1)/mpy;
+	
+	for(i=0; i<=mly; i++){
+		for(j=0; j<=mlx; j++){
+			sx = j*mpx;
+			sy = i*mpy;
+			ex = sx+mpx>pkl->width ? pkl->width : sx+mpx;
+			ey = sy+mpy>pkl->height ? pkl->height : sy+mpy;
 			
-			//現在のピクセルの右上により近い母点があるか検索
-			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;
-					}
+			//1セルの総和算出
+			mm=0;
+			memset(color, 0, sizeof(color));
+			for(py=sy; py<ey; py++){
+				for(px=sx; px<ex; px++){
+					mm++;
+					for(k=0; k<pkl->channel; k++)
+						color[k] += pkl->image[(py*pkl->width+px)*pkl->channel+k];
 				}
 			}
-			//現在のピクセルの右下により近い母点があるか検索
-			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;
-					}
+			if(!mm) continue;
+			
+			//セルの平均色を算出して、セル内のピクセルに適用
+			for(k=0; k<pkl->channel; k++)
+				color[k] = PKL_COLOR_CLIP(color[k]/mm);
+			for(py=sy; py<ey; py++){
+				for(px=sx; px<ex; px++){
+					for(k=0; k<pkl->channel; k++)
+						wrk[(py*pkl->width+px)*pkl->channel+k] = color[k];
 				}
 			}
-			//最も近くにある母点のIDを設定する
-			if(pre_id != min_id){
-				voronoi_setid(kp[pre_id].next, min_id);
-				voronoi_setid(kp[min_id].next, pre_id);
+		}
+	}
+	
+	free(pkl->image);
+	pkl->image = wrk;
+	return(0);
+}
+
+//=============================================================================
+// pkl_pixelate
+//=============================================================================
+PKLExport int pkl_pixelate(PKLImage pkl, int ms)
+{
+	unsigned char *wrk;
+	int mpx, mpy;	//モザイクの大きさ
+	int mlx, mly;	//画像の分割数
+	int i, j, k, sx, sy, ex, ey, px, py, mm;
+	long color[PKL_CHANNEL];
+	int total;
+	unsigned char p;
+
+	wrk = malloc(pkl->width*pkl->height*pkl->channel);
+	if(!wrk) return(1);
+
+	mpx = (ms<1) ? 1 : (ms>=pkl->width) ? pkl->width-1 : ms;
+	mpy = (ms<1) ? 1 : (ms>=pkl->height) ? pkl->height-1 : ms;
+	mlx = (pkl->width+mpx-1)/mpx;
+	mly = (pkl->height+mpy-1)/mpy;
+	
+	for(i=0; i<=mly; i++){
+		for(j=0; j<=mlx; j++){
+			sx = j*mpx;
+			sy = i*mpy;
+			ex = sx+mpx>pkl->width ? pkl->width : sx+mpx;
+			ey = sy+mpy>pkl->height ? pkl->height : sy+mpy;
+			
+			//1セルの総和算出
+			mm=0;
+			memset(color, 0, sizeof(color));
+			for(py=sy; py<ey; py++){
+				for(px=sx; px<ex; px++){
+					mm++;
+					for(k=0; k<pkl->channel; k++)
+						color[k] += pkl->image[(py*pkl->width+px)*pkl->channel+k];
+				}
 			}
+			if(!mm) continue;
 			
-			//現在の座標のIDに決定したボロノイ管理IDを設定する
-			ip[j*pkl->width+i] = min_id;
-			pre_id = min_id;
+			//セルの平均色を算出
+			for(k=0; k<pkl->channel; k++)
+				color[k] = PKL_COLOR_CLIP(color[k]/mm);
+			
+			total=0;
+			for(k=0; k<pkl->channel; k++)
+				total += color[k];
+			total /=pkl->channel;
+			p = total<128 ? 0 : 255;
+			
+			for(py=sy; py<ey; py++){
+				for(px=sx; px<ex; px++){
+					for(k=0; k<pkl->channel; k++)
+						wrk[(py*pkl->width+px)*pkl->channel+k] = p;
+				}
+			}
 		}
 	}
+	
+	free(pkl->image);
+	pkl->image = wrk;
+	return(0);
 }
 
 //=============================================================================
-// pkl_voronoi_type2
+// pkl_grid
 //=============================================================================
-PKLExport int pkl_voronoi_type2(PKLImage pkl, int count, int bordercolor, int test)
+PKLExport int pkl_grid(PKLImage pkl, int msx, int msy, int color)
 {
-	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];
+	unsigned char *p;
+	int i, j, k, mpx, mpy;
+	
+	//一旦モザイク化
+	if(pkl_mosaic(pkl, msx, msy)) return(1);
+	
+	mpx = (msx<1) ? 1 : (msx>=pkl->width) ? pkl->width-1 : msx;
+	mpy = (msy<1) ? 1 : (msy>=pkl->height) ? pkl->height-1 : msy;
+	
+	for(i=0; i<pkl->height-1; i++){
+		if(i%mpy==0){
+			for(j=0; j<pkl->width; j++){
+				p = &pkl->image[(i*pkl->width+j)*pkl->channel];
+				for(k=0; k<pkl->channel; k++){
+					*p = PKL_COLOR_CLIP(*p+color);
+					p++;
+				}
 			}
 		}
-		
-		//各セルの平均色を作る
-		for(i=0; i<count; i++){
+		for(j=mpx; j<pkl->width; j+=mpx){
+			p = &pkl->image[(i*pkl->width+j)*pkl->channel];
 			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);
+				*p = PKL_COLOR_CLIP(*p+color);
+				p++;
 			}
 		}
-		
-		//色を置く
-		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);
 }