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

data/ext/pikl/pikl_rotate.h

@@ -9,4 +9,12 @@
 #include "pikl.h"
 #include "pikl_private.h"
 
+typedef struct {
+	float rcos, rsin;
+	int width, height;
+	int sx, sy;
+	int ex, ey;
+	unsigned char back[PKL_CHANNEL];
+} PIKL_ROTATE;
+
 #endif

data/ext/pikl/pikl_scrap.c

@@ -1,6 +1,7 @@
 #include "pikl_scrap.h"
 
-static void pkl_circle(PKLImage pkl, int x, int y, int radius, unsigned char *color);
+static void circle(PKLImage pkl, int x, int y, int radius, unsigned char *color);
+static unsigned char lighting(unsigned char color, double dx, double dy, double dz, double mil, double env, double *light);
 
 //=============================================================================
 //	�A���`�G�C���A�X�����������~��`��
@@ -8,7 +9,7 @@ static void pkl_circle(PKLImage pkl, int x, int y, int radius, unsigned char *co
 //	radius: ���a
 //	color: �h��F(unsigned char x[pkl->channel]�̗̈�����ƒ|�C���^)
 //=============================================================================
-static void pkl_circle(PKLImage pkl, int x, int y, int radius, unsigned char *color)
+static void circle(PKLImage pkl, int x, int y, int radius, unsigned char *color)
 {
 	unsigned char *p;
 	int sx, sy, ex, ey, tx, ty;
@@ -67,7 +68,7 @@ static void pkl_circle(PKLImage pkl, int x, int y, int radius, unsigned char *co
 //=============================================================================
 // pkl_dots
 //=============================================================================
-PKLExport int pkl_dots(PKLImage pkl, int zone, int color)
+PKLExport int pkl_dots(PKLImage pkl, int zone, PKLColor color)
 {
 	unsigned char *wrk, *bp, *p, dc[PKL_CHANNEL];
 	int i, j, k, t, s, gray, count, stock;
@@ -79,8 +80,12 @@ PKLExport int pkl_dots(PKLImage pkl, int zone, int color)
 	if(!wrk) return(1);
 	memset(wrk, 0xff, pkl->width*pkl->height*pkl->channel);
 	
-	for(i=0; i<pkl->channel; i++)
-		dc[i] = (color>>((pkl->channel-i)*8) & 0xFF);
+	//for(i=0; i<pkl->channel; i++)
+	//	dc[i] = (color>>((pkl->channel-i)*8) & 0xFF);
+	if(color)
+		memcpy(dc, color->color, pkl->channel);
+	else
+		memset(dc, 0, pkl->channel);
 	
 	propc = zone/32.0;
 	
@@ -102,7 +107,7 @@ PKLExport int pkl_dots(PKLImage pkl, int zone, int color)
 				}
 			}
 			if(count)
-				pkl_circle(pkl, j+zone/2, i+zone/2, sqrt(stock/count)*propc, dc);
+				circle(pkl, j+zone/2, i+zone/2, sqrt(stock/count)*propc, dc);
 		}
 	}
 
@@ -113,7 +118,7 @@ PKLExport int pkl_dots(PKLImage pkl, int zone, int color)
 //=============================================================================
 // pkl_swirl
 //=============================================================================
-PKLExport int pkl_swirl(PKLImage pkl, double factor, int x, int y, int backcolor)
+PKLExport int pkl_swirl(PKLImage pkl, double factor, int x, int y, PKLColor backcolor)
 {
 	unsigned char *wrk, color[PKL_CHANNEL], *p, *q;
 	int i, j, k, tx, ty, sx, sy;
@@ -125,9 +130,13 @@ PKLExport int pkl_swirl(PKLImage pkl, double factor, int x, int y, int backcolor
 	if(!wrk) return(1);
 	memset(wrk, 0, pkl->width*pkl->height*pkl->channel);
 	
-	for(i=0; i<pkl->channel; i++)
-		color[i] = (backcolor>>((pkl->channel-i)*8) & 0xFF);
-		
+	//for(i=0; i<pkl->channel; i++)
+	//	color[i] = (backcolor>>((pkl->channel-i)*8) & 0xFF);
+	if(backcolor)
+		memcpy(color, backcolor->color, pkl->channel);
+	else
+		memset(color, 0xff, pkl->channel);
+	
 	for(i=0; i<pkl->width*pkl->height; i++)
 		memcpy(&wrk[i*pkl->channel], color, pkl->channel);
 	
@@ -201,531 +210,302 @@ PKLExport int pkl_wave(PKLImage pkl, PKL_WAVE mode, double factor, double freque
 }
 
 //=============================================================================
-// pkl_splitframe
+// pkl_rgb2hsb(�F��:Hue/�ʓx:Saturation/���x:Brightness)
 //=============================================================================
-PKLExport int pkl_splitframe(PKLImage pkl, int backcolor, int wbs, int hbs, int margin, int frame)
+static float *pkl_rgb2hsb(unsigned char *rgb, float *hsb)
 {
-	unsigned char *wrk, color[PKL_CHANNEL];
-	int i, j, k, s, t, u, tx, ty;
-	int offsetx, offsety, width, height, fw, fh;
-	int warea, harea;
-	int shift=5;
+	#define _max(a,b) (a>b) ? a : b
+	#define _min(a,b) (a>b) ? b : a
+
+	float hue, saturation, brightness;
+	unsigned char color_max, color_min;
+	unsigned char r, g, b;
+	int diff;
+	
+	r = rgb[0];
+	g = rgb[1];
+	b = rgb[2];
+	
+	color_max= _max(_max(r, g), b);
+	color_min= _min(_min(r, g), b);
+	diff= color_max - color_min;
+	
+	hue=0.0;
+	if(diff != 0){
+		if(color_max==r) hue=60*(g-b)/(float)diff;
+		if(color_max==g) hue=60*(b-r)/(float)diff + 120.0;
+		if(color_max==b) hue=60*(r-g)/(float)diff + 240.0;
+	}
+	saturation = color_max!=0 ? diff/(float)color_max : 0.0;
+	brightness = color_max / 255.0;
 
-	if(wbs<=0 || hbs<=0) return(1);
-	if(margin<0) return(1);
-	if(frame<1) return(1);
+	hsb[0] = hue;
+	hsb[1] = saturation;
+	hsb[2] = brightness;
 
-	//1�‚̕����G���A�̃C���[�W�T�C�Y
-	warea = pkl->width / wbs;
-	harea = pkl->height / hbs;
-	//1�‚̃G���A�̃T�C�Y(�t���[���T�C�Y���܂�)
-	fw = warea + frame*2;
-	fh = harea + frame*2;
-	//�ŏI�I�ȃL�����o�X�̑傫��
-	width = fw * wbs + margin*2;
-	height = fh * hbs + margin*2;
+	return(hsb);
+}
 
-	wrk = malloc(width*height*pkl->channel);
-	if(!wrk) return(1);
-	
-	//�w�i�F�̐ݒ�
-	for(i=0; i<pkl->channel; i++)
-		color[i] = (backcolor>>((pkl->channel-i)*8) & 0xFF);
-	for(i=0; i<width*height; i++)
-		memcpy(&wrk[i*pkl->channel], color, pkl->channel);
+//=============================================================================
+// pkl_hsb2rgb
+//=============================================================================
+static unsigned char *pkl_hsb2rgb(float *hsb, unsigned char *rgb)
+{
+	float h, s, b, f;
+	int br, p, q, t, hue;
+
+	h = hsb[0];
+	s = hsb[1];
+	b = hsb[2];
 	
-	srand48(1);
-	for(i=margin,s=0; i<height-margin; i+=fh,s+=harea){
-		for(j=margin,t=0; j<width-margin; j+=fw,t+=warea){
-			offsetx = mrand48()%shift;
-			offsety = mrand48()%shift;
-			
-			//�t�H�g�t���[��
-			k = i+offsety<0 ? 0 : i+offsety+fh>=height ? height-fh : i+offsety;
-			for(ty=k; ty<k+fh; ty++){
-				tx = j+offsetx<0 ? 0 : j+offsetx+fw>=width ? width-fw : j+offsetx;
-				//�w�i�F(��)
-				memset(&wrk[(ty*width+tx)*pkl->channel], 0xFF, fw*pkl->channel);
-				//�V�n�̃t���[��
-				if(ty==k || ty==k+fh-1)
-					memset(&wrk[(ty*width+tx)*pkl->channel], 0x00, fw*pkl->channel);
-				//���E�̃t���[��
-				memset(&wrk[(ty*width+tx)*pkl->channel], 0x00, pkl->channel);
-				memset(&wrk[(ty*width+tx+fw-1)*pkl->channel], 0x00, pkl->channel);
-			}
-			//�C���[�W
-			k = i+offsety<0 ? frame : i+offsety+fh>=height ? height-fh+frame : i+offsety+frame;
-			for(ty=k,u=s; ty<k+harea; ty++,u++){
-				tx = j+offsetx<0 ? frame : j+offsetx+fw>=width ? width-fw+frame : j+offsetx+frame;
-				memcpy(&wrk[(ty*width+tx)*pkl->channel], &pkl->image[(u*pkl->width+t)*pkl->channel], warea*pkl->channel);
-			}
+	h = (h>360.0) ? h-360.0 : (h<0.0) ? h+360.0 : h;
+	s = (s>1.0) ? 1.0 : (s<0.0) ? 0.0 : s;
+	br=(int)(255*b);
+	br = PKL_COLOR_CLIP(br);
+
+	if(s==0.0){
+		rgb[0]=br;
+		rgb[1]=br;
+		rgb[2]=br;
+	}else{
+		hue=(int)(h/60.0);
+		f=h/60.0-hue;
+		
+		p=(int)(br*(1.0-s));
+		p = PKL_COLOR_CLIP(p);
+		
+		q=(int)(br*(1.0-f*s));
+		q = PKL_COLOR_CLIP(q);
+		
+		t=(int)(br*(1.0-(1.0-f)*s));
+		t = PKL_COLOR_CLIP(t);
+		
+		switch(hue){
+			case 1:rgb[0]=q;  rgb[1]=br; rgb[2]=p; break;
+			case 2:rgb[0]=p;  rgb[1]=br; rgb[2]=t; break;
+			case 3:rgb[0]=p;  rgb[1]=q;  rgb[2]=br; break;
+			case 4:rgb[0]=t;  rgb[1]=p;  rgb[2]=br; break;
+			case 5:rgb[0]=br; rgb[1]=p;  rgb[2]=q; break;
+			case 0:
+			default:
+				rgb[0]=br; rgb[1]=t; rgb[2]=p; break;
 		}
 	}
-	
-	free(pkl->image);
-	pkl->image = wrk;
-	pkl->width = width;
-	pkl->height = height;
-	return(0);
+	return(rgb);
 }
 
 //=============================================================================
-// pkl_colordither
+// pkl_sobelpaint
 //=============================================================================
-PKLExport int pkl_colordither(PKLImage pkl, int weight)
+PKLExport int pkl_sobelpaint(PKLImage pkl, int edgeweight, float mix, float saturation, float hue)
 {
-	double FloydSteinberg[2][3] = {
-		{       -1,       -1, 7.0/16.0},
-		{ 3.0/16.0, 5.0/16.0, 1.0/16.0} };
-	unsigned char *wrk, pix, *graypic;
-	double *pt, err;
-	int i, j, k, gray, s, t, tx, ty, row, col, xrange;
-	
-	row = 3;
-	col = 2;
-	pt = &(FloydSteinberg[0][0]);
+	//Sobel Filter
+	double Fx[3][3] = { {-0.25,   0.0,  0.25},
+						{-0.50,   0.0,  0.50},
+						{-0.25,   0.0,  0.25}};
+	double Fy[3][3] = { {-0.25, -0.50, -0.25},
+						{  0.0,   0.0,   0.0},
+						{ 0.25,  0.50,  0.25}};
+	double kg[3] = {0.298912, 0.586611, 0.114478};
+	double dx, dy, dR, dG, dB, weight;
+	int i, j, tx, ty, offset=1;
+	unsigned char *wrk;
+	float hsb[3], bright;
+
+	if(pkl->color != PKL_RGB) return(1);
 	
 	wrk = malloc(pkl->width*pkl->height*pkl->channel);
 	if(!wrk) return(1);
 	memset(wrk, 0xff, pkl->width*pkl->height*pkl->channel);
 
-	graypic = malloc(pkl->width*pkl->height);
-	if(!wrk) return(1);
-
 	for(i=0; i<pkl->height; i++){
 		for(j=0; j<pkl->width; j++){
-			gray=0;
-			for(k=0; k<pkl->channel; k++)
-				gray += pkl->image[(i*pkl->width+j)*pkl->channel+k];
-			graypic[i*pkl->width+j] = PKL_COLOR_CLIP(gray/pkl->channel);
-		}
-	}
-	xrange = (row-1)/2;
-
-	for(i=0; i<pkl->height; i++){
-		for(j=0; j<pkl->width; j++){
-			pix = graypic[i*pkl->width+j];
-			if(pix<127){
-				memcpy(&wrk[(i*pkl->width+j)*pkl->channel], &pkl->image[(i*pkl->width+j)*pkl->channel], pkl->channel);
-			}else{
-				for(k=0; k<pkl->channel; k++)
-					wrk[(i*pkl->width+j)*pkl->channel+k] = PKL_COLOR_CLIP(pkl->image[(i*pkl->width+j)*pkl->channel+k]+weight);
+			if(j-offset<0 || j+offset>=pkl->width || i-offset<0 || i+offset>=pkl->height) continue;
+			
+			dR=dG=dB=0.0;
+			for(ty=-offset; ty<=offset; ty++){
+				for(tx=-offset; tx<=offset; tx++){
+					//if(j+tx<0 || j+tx>=pkl->width || i+ty<0 || i+ty>=pkl->height) continue;
+					weight = Fx[ty+offset][tx+offset];
+					dR += (pkl->image[((i+ty)*pkl->width+j+tx)*pkl->channel+0] * weight);
+					dG += (pkl->image[((i+ty)*pkl->width+j+tx)*pkl->channel+1] * weight);
+					dB += (pkl->image[((i+ty)*pkl->width+j+tx)*pkl->channel+2] * weight);
+				}
 			}
-			err = pix>127 ? pix-255 : pix;
-
-			for(s=0; s<col; s++){
-				for(t=-xrange; t<=xrange; t++){
-					tx = j+t;
-					ty = i+s;
-					if(tx<0 || tx>=pkl->width || ty>=pkl->height) continue;
-					if (pt[s*row+t+xrange] < 0) continue;
-					graypic[ty*pkl->width+tx] = PKL_COLOR_CLIP(graypic[ty*pkl->width+tx] + err * pt[s*row+t+xrange]);
+			dx = kg[0]*dR + kg[1]*dG + kg[2]*dB;
+			
+			dR=dG=dB=0.0;
+			for(ty=-offset; ty<=offset; ty++){
+				for(tx=-offset; tx<=offset; tx++){
+					//if(j+tx<0 || j+tx>=pkl->width || i+ty<0 || i+ty>=pkl->height) continue;
+					weight = Fy[ty+offset][tx+offset];
+					dR += (pkl->image[((i+ty)*pkl->width+j+tx)*pkl->channel+0] * weight);
+					dG += (pkl->image[((i+ty)*pkl->width+j+tx)*pkl->channel+1] * weight);
+					dB += (pkl->image[((i+ty)*pkl->width+j+tx)*pkl->channel+2] * weight);
 				}
 			}
+			dy = kg[0]*dR + kg[1]*dG + kg[2]*dB;
+			
+			//RGB->HSB
+			pkl_rgb2hsb(&pkl->image[(i*pkl->width+j)*pkl->channel], hsb);
+
+			//���x�ɂ̂�sobel��K�p���Č����x�ƍ�������
+			bright = hsb[2];
+			hsb[2] = sqrt(dx*dx+dy*dy) * edgeweight * 0.01;
+			hsb[2] = (hsb[2]>1.0) ? 0.0 : 1.0-hsb[2];
+			hsb[2] = hsb[2]*(1.0-mix) + bright*mix;
+
+			//�ʓx����
+			hsb[1] *= saturation;
+			
+			//�F������
+			hsb[0] += hue;
+			
+			//HSB->RGB
+			pkl_hsb2rgb(hsb, &wrk[(i*pkl->width+j)*pkl->channel]);
 		}
 	}
-	free(graypic);
 	free(pkl->image);
-	pkl->image = wrk;
+	pkl->image=wrk;
 	return(0);
 }
 
-
 //=============================================================================
-// pkl_ttt
+// pkl_illust
 //=============================================================================
-PKLExport int pkl_ttt(PKLImage pkl)
+PKLExport int pkl_illust(PKLImage pkl, int gap, int edge, int gammaint)
 {
+	int sobel1[9] = { 1, 0, -1, 2, 0, -2,  1,  0, -1 };	//sobel filter
+	int sobel2[9] = { 1, 2,  1, 0, 0,  0, -1, -2, -1 };	//sobel filter
+	int i, j, k, s, t, px, py, rp, r1, r2, gt;
+	int wx[PKL_CHANNEL], wy[PKL_CHANNEL], rate[PKL_CHANNEL];
 	unsigned char *wrk;
-	int i, j, s, t, k, clipx, clipy;
-	int color[PKL_CHANNEL];
-
-	int matrix[9] = { 0,  0, -1,
-                      0,  0,  0,
-                      1,  0,  0 };
-
-//	{ PKL_EMBOSS_EMBOSS,    { 0,  0, -1,
-//							  0,  0,  0,
-//							  1,  0,  0 }},
-//	
-//	{ PKL_EMBOSS_LAPLACIAN, {-1, -1, -1,
-//							 -1,  8, -1,
-//							 -1, -1, -1 }},
-//
-//	{ PKL_EMBOSS_HEAVY,     { 2,  0,  0,
-//							  0, -1,  0,
-//							  0,  0, -1 }},
-//	
-//	{ PKL_EMBOSS_LIGHT,     { 0,  0,  0,
-//							  0,  1,  0,
-//							  0,  0, -1 }},
+	double gamma;
+	int th1, th2, th3;
 
-
-	
-	wrk = malloc(pkl->width*pkl->height);
+	wrk = malloc(pkl->width*pkl->height*pkl->channel);
 	if(!wrk) return(1);
-	memset(wrk, 0, pkl->width*pkl->height);
-
+	
+	gamma = 1.0/((double)gammaint/100.0);
+	th1 = (int)(pow(128.0/255.0, gamma)*255.0);
+	th2 = (int)(pow( 96.0/255.0, gamma)*255.0);
+	th3 = (int)(pow( 64.0/255.0, gamma)*255.0);
+	
 	for(i=0; i<pkl->height; i++){
 		for(j=0; j<pkl->width; j++){
-			memset(color, 0, sizeof(color));
+			
+			memset(wx, 0, sizeof(wx));
+			memset(wy, 0, sizeof(wy));
+			
 			for(s=0; s<3; s++){
 				for(t=0; t<3; t++){
-					clipx = (j+t)>=pkl->width  ? pkl->width-1  : j+t;
-					clipy = (i+s)>=pkl->height ? pkl->height-1 : i+s;
-					//for(k=0; k<pkl->channel; k++)
-					color[0] += pkl->image[(clipy*pkl->width+clipx) * pkl->channel + 0] * matrix[t+s*3];
+					px = (j+t-1)<0 ? 0 : (j+t-1)>=pkl->width ? pkl->width-1 : (j+t-1);
+					py = (i+s-1)<0 ? 0 : (i+s-1)>=pkl->height ? pkl->height-1 : (i+s-1);
+					for(k=0; k<pkl->channel; k++){
+						wx[k] += pkl->image[(py*pkl->width+px)*pkl->channel+k] * sobel1[s*3+t];
+						wy[k] += pkl->image[(py*pkl->width+px)*pkl->channel+k] * sobel2[s*3+t];
+					}
 				}
 			}
 			
-			//for(k=0; k<pkl->channel; k++)
-			wrk[i*pkl->width+j] = PKL_COLOR_CLIP(color[0]-127);
+			for(k=0; k<pkl->channel; k++)
+				rate[k] = (int)(sqrt((double)(wx[k]*wx[k]+wy[k]*wy[k]))/8.0);
+			rp = 0;
+			for(k=0; k<pkl->channel; k++)
+				if(rate[k]>rp) rp=rate[k];
+			r1 = (rp<edge) ? 255 : (rp<edge+gap) ? 255-255*(rp-edge)/gap : 0;
+
+			gt = 0;
+			for(k=0; k<pkl->channel; k++)
+				gt += pkl->image[(i*pkl->width+j)*pkl->channel+k];
+			gt /= pkl->channel;
+			r2 = (gt>th1) ? 255 : (gt>th2) ? 128 : (gt>th3) ? 64 : 0;
+			
+			for(k=0; k<pkl->channel; k++)
+				wrk[(i*pkl->width+j)*pkl->channel+k] = PKL_COLOR_CLIP(pkl->image[(i*pkl->width+j)*pkl->channel+k] * r1/256*r2/256);
 		}
 	}
+	
+	free(pkl->image);
+	pkl->image = wrk;
+	return(0);
+}
+
+//=============================================================================
+// pkl_color_emboss
+//=============================================================================
+PKLExport int pkl_color_emboss(PKLImage pkl, double mil, double env)
+{
+	int sobel1[9] = { 1, 0, -1, 2, 0, -2,  1,  0, -1 };	//sobel filter
+	int sobel2[9] = { 1, 2,  1, 0, 0,  0, -1, -2, -1 };	//sobel filter
+	int i, j, k, s, t, wx, wy, gt, px, py;
+	unsigned char *wrk, color[PKL_CHANNEL];
+	double dx, dy, dz, light[3], abl;
+
+	wrk = malloc(pkl->width*pkl->height*pkl->channel);
+	if(!wrk) return(1);
+	memset(wrk, 0, pkl->width*pkl->height*pkl->channel);
+	
+	//�����x�N�g����P�ʃx�N�g���ɕ␳����
+	abl = sqrt(-1.0*-1.0 + -1.0*-1.0 + 1.0*1.0);
+	light[0] = -1.0/abl;
+	light[1] = -1.0/abl;
+	light[2] =  1.0/abl;
 
 	for(i=0; i<pkl->height; i++){
 		for(j=0; j<pkl->width; j++){
+			wx=wy=0;
+			for(s=0; s<3; s++){
+				for(t=0; t<3; t++){
+					px = (j+t-1)<0 ? 0 : (j+t-1)>=pkl->width ? pkl->width-1 : (j+t-1);
+					py = (i+s-1)<0 ? 0 : (i+s-1)>=pkl->height ? pkl->height-1 : (i+s-1);
+					
+					gt=0;
+					for(k=0; k<pkl->channel; k++)
+						gt += pkl->image[(py*pkl->width+px)*pkl->channel+k];
+					gt /= pkl->channel;
+					wx += gt*sobel1[s*3+t];
+					wy += gt*sobel2[s*3+t];
+				}
+			}
+			dx = (double)wx;
+			dy = (double)wy;
+			dz = 16.0;
 			for(k=0; k<pkl->channel; k++)
-				pkl->image[(i*pkl->width+j)*pkl->channel+k] =
-					PKL_COLOR_CLIP((pkl->image[(i*pkl->width+j)*pkl->channel+k] - wrk[i*pkl->width+j]));
+				color[k] = lighting(pkl->image[(py*pkl->width+px)*pkl->channel+k], dx, dy, dz, mil, env, light);
+			memcpy(&wrk[(i*pkl->width+j)*pkl->channel], color, pkl->channel);
 		}
 	}
-
 	
-	free(wrk);
+	free(pkl->image);
+	pkl->image = wrk;
+	
 	return(0);
 }
 
+//=============================================================================
+// �A�e�t��
+// (dx,dy,dz)��@���x�N�g���Ƃ���i�P�ʃx�N�g���łȂ��Ă��悢�j
+//=============================================================================
+static unsigned char lighting(unsigned char color, double dx, double dy, double dz,
+                                                    double mil, double env, double *light)
+{
+	double abl, rz, env2, cosT, cosT2;
+	int res;
+
+	//�@���x�N�g����P�ʃx�N�g���ɕ␳
+	abl = sqrt(dx*dx + dy*dy + dz*dz);
+	cosT = (dx/abl)*light[0] + (dy/abl)*light[1] + (dz/abl)*light[2];
+	rz = 2.0*cosT*(dz/abl) - light[2];
+	cosT2 = (rz>0.0) ? pow(rz, 12.0) : 0.0;
+	cosT  = (cosT<0.0) ? 0.0 : cosT;
+	
+	env2=env*255.0/100.0;
+	res=(int)((cosT*255.0+env2)*(double)color/255.0);
+	
+	if(res>color) res=color;
+	res+=(mil*cosT2);
+	
+	return(PKL_COLOR_CLIP(res));
+}
 
-
-////=============================================================================
-//// pkl_sketch
-////=============================================================================
-//PKLExport int pkl_sketch(PKLImage pkl)
-//{
-//	unsigned char *wrk, ave[PKL_CHANNEL];
-//	int color[PKL_CHANNEL];
-//	int i, j, k, s;
-//	int weight=10;
-//	int sx, sy, dx, dy, x1, x2, y1, y2, xadder;
-//	double t, adder;
-//	
-//	wrk = malloc(pkl->width*pkl->height*pkl->channel);
-//	if(!wrk) return(1);
-//	memset(wrk, 0xff, pkl->width*pkl->height*pkl->channel);
-//	
-//	srand48(1);
-//	for(i=0; i<pkl->height; i+=weight){
-//		for(j=0; j<pkl->width; j+=weight){
-//			
-//			for(k=0; k<weight*2; k++){
-//				//�����_���ȂQ�_�𐶐�
-//				x1 = j + mrand48()%weight;
-//				y1 = i + mrand48()%weight;
-//				x2 = j + mrand48()%weight;
-//				y2 = i + mrand48()%weight;
-//				
-//				sx = x1;
-//				dx = x2;
-//				sy = y1<y2 ? y1 : y2;
-//				dy = y1<y2 ? y2 : y1;
-//				
-//				sx = sx<0 ? 0 : sx>=pkl->width ? pkl->width-1 : sx;
-//				dx = dx<0 ? 0 : dx>=pkl->width ? pkl->width-1 : dx;
-//				sy = sy<0 ? 0 : sy>=pkl->height ? pkl->height-1 : sy;
-//				dy = dy<0 ? 0 : dy>=pkl->height ? pkl->height-1 : dy;
-//				
-//				if(dx-sx != 0)
-//					adder = (double)(dy-sy)/(double)(dx-sx);
-//				else
-//					adder=1.0;
-//				
-//				if(sx<dx){
-//					for(s=sx,t=sy; s<dx; s++,t+=adder){
-//						if(t<pkl->height)
-//							memcpy(&wrk[((int)t*pkl->width+s)*pkl->channel], &pkl->image[((int)t*pkl->width+s)*pkl->channel], pkl->channel);
-//					}
-//				}else{
-//					for(s=sx,t=sy; s>=dx; s--,t-=adder){
-//						if(t>0.0)
-//							memcpy(&wrk[((int)t*pkl->width+s)*pkl->channel], &pkl->image[((int)t*pkl->width+s)*pkl->channel], pkl->channel);
-//					}
-//				}
-//			}
-//		}
-//	}
-//	
-//	free(pkl->image);
-//	pkl->image = wrk;
-//	return(0);
-//}
-
-
-
-
-
-
-
-//    /** �X�g���[�N�̒��� */
-//    int LENGTH = 10; //1..50
-//    /** �u���V�̑傫�� */
-//    int BRUSHSIZE = 8;	//1..50
-//    /** �Z�W����**/
-//    int Gray = 124;	//50..200
-//    /** ���l */
-//    float ALPHA = .8f;	//0.01 .. 1.0
-//
-//    /** �C���[�W�̃\�[�X */
-//    protected AnimatedImage AI;
-//    protected int width;
-//    protected int height;
-//
-//	/** (r, g, b)����P�x���Z�o���� */
-//	public int getLuminance(int r, int g, int b){
-//		return (int)(0.3f*r + 0.59f*g + 0.11f*b);
-//	}
-//
-//    /** �摜�̃t�B���^�����O���s�� */
-//    public void filter(AnimatedImage AI){
-//		this.AI = AI;
-//		width = AI.getWidth();
-//		height = AI.getHeight();
-//
-//		Random rand = new Random(System.currentTimeMillis());
-//
-//		//�o�b�t�@�̏�����
-//		setUpBuffer();
-//
-//		//�z���C�g�m�C�Y
-//		for (int y=0; y<height; y++) {
-//			for (int x=0; x<width; x++) {
-//				int r = AI.getR(x, y);
-//				int g = AI.getG(x, y);
-//				int b = AI.getB(x, y);
-//				int G=getLuminance(r,g,b);
-//				double T = 0.2*(1-G/40);
-//				double P = rand.nextInt()%1.0;
-//				if(P>=T)AI.setRGB(x, y, 255, 255, 255);
-//				else AI.setRGB(x, y, 0, 0, 0);
-//			}
-//		}
-//
-//		//�����_���ɃX�g���[�N��z�u
-//		for (int i = 0; i < height; i++) {
-//		    for(int j = 0; j < width/5; j++){
-//				int x = Math.abs(rand.nextInt()) % width;
-//				int y = i + Math.abs(rand.nextInt()) %  (LENGTH+BRUSHSIZE);
-//				if ( y<0 || y>=height ) continue;
-//			
-//				int r = AI.getR(x, y);
-//				int g = AI.getG(x, y);
-//				int b = AI.getB(x, y);
-//		 
-//				//�u���V�X�g���[�N��`��
-//				drawPenStroke(x, y, r, g, b);
-//		    }
-//		}
-//		return;
-//    }
-//
-//	//* �y���X�g���[�N���P�•`�悷��
-//	protected void drawPenStroke(int x, int y, int r, int g, int b){
-//		// �摜�̋P�x�̌��z�������擾
-//		Point dir = getDirection(x, y);
-//		float vx, vy, l;
-//		vx = -dir.y/255.0f;
-//		vy = dir.x/255.0f;
-//		l = (float)Math.sqrt(vx*vx+vy*vy);
-//		vx /= l;
-//		vy /= l;
-//
-//		//�`��̈���w�肷��
-//		int vxl = (int)(vx * LENGTH);
-//		int vyl = (int)(vy * LENGTH);
-//		int vxb = (int)(vx * BRUSHSIZE / 2);
-//		int vyb = (int)(vy * BRUSHSIZE / 2);
-//		int sx = x - vxl, sy = y - vyl ; //�n�_
-//		int ex = x + vxl, ey = y + vyl; //�I�_
-//
-//		writeLine(sx - vyb, sy + vxb, ex - vyb, ey + vxb);
-//		//�`��̈���w��F�œh��‚Ԃ��B
-//		paintBuffer(r, g, b, ALPHA);
-//	}
-//
-//    //* �P�x�̌��z�������擾����
-//	protected Point getDirection(int x, int y){
-//		int vx, vy;
-//		int[][] pixel = {{0, 0, 0}, {0, 0, 0}, {0, 0, 0}};
-//
-//		for(int i = 0; i < pixel.length; i++){
-//		    int yy = y + i - 1;
-//
-//		    if(yy < 0) continue;
-//		    else if(yy >= height) break;
-//
-//		    for(int j = 0; j < pixel[i].length; j++){
-//				int xx = x + j - 1;
-//
-//				if(xx < 0) continue;
-//				else if(xx >= width) break;
-//
-//				int r = AI.getR(xx, yy);
-//				int g = AI.getG(xx, yy);
-//				int b = AI.getB(xx, yy);
-//
-//				pixel[i][j] = getLuminance(r, g, b);
-//		    }
-//		}
-//
-//		vx = - pixel[0][0] + pixel[0][2] - 2 * pixel[1][0] + 2 * pixel[1][2] - pixel[2][0] + pixel[2][2];
-//		vy = - pixel[0][0] + pixel[2][0] - 2 * pixel[0][1] + 2 * pixel[2][1] - pixel[0][2] + pixel[2][2];
-//
-//		return new Point(vx, vy);
-//	}
-//
-//    //**************************************************************************
-//    //               �ȍ~�A�O���t�B�b�N�X�֘A�̃����o���L�q����
-//    //**************************************************************************
-//
-//    /* �`��̈�𒲂ׂ邽�߂̃o�b�t�@�B
-//     * �`��̈�͓ʂł���Ɖ��肵�Ă���B
-//     * ��{(x, y) | y �� {0, ... height - 1}, buf[y][0] <= x <= buf[y][1]}
-//     * �ŕ\�����̈悪�`��̈�ƂȂ�B
-//     */
-//	protected int[][] buf;
-//
-//    /** �`��̈��y���W�̍ŏ��l */
-//    protected int yMin;
-//
-//    /** �`��̈��y���W�̍ő�l */
-//    protected int yMax;
-//
-//
-//    /**
-//     * buf�̏��������s���B
-//     * �n�߂ɂP�x�����Ăяo�����ƁB
-//     */
-//    protected void setUpBuffer(){
-//		buf = new int[height][2];
-//		yMin = 0;
-//		yMax = height - 1;
-//		clearBuffer();
-//    }
-//
-//	//* buf�̓��e���N���A����B
-//    protected void clearBuffer(){
-//		if(yMin < 0) yMin = 0;
-//		if(yMax >= height) yMax = height - 1;
-//
-//		for(int i = yMin; i <= yMax; i++){
-//		    buf[i][0] = width - 1; //�ŏ��l�̏����l�͍ő�l
-//		    buf[i][1] = 0;         //�ő�l�̏����l�͍ŏ��l
-//		}
-//		yMin = height - 1; //�ŏ��l�̏����l�͍ő�l
-//		yMax = 0;          //�ő�l�̏����l�͍ŏ��l
-//    }
-//
-//    // * buf�ŕ\�����`��̈��F(r, g, b, a)�œh��‚Ԃ��B
-//    protected void paintBuffer(int r, int g, int b, float a){
-//		if(yMin < 0) yMin = 0;
-//		if(yMax >= height) yMax = height - 1;
-//
-//		for(int y = yMin; y <= yMax; y++){
-//		    if(buf[y][0] < 0) buf[y][0] = 0;
-//		    if(buf[y][1] >= width) buf[y][1] = width - 1;
-//
-//		    for(int x = buf[y][0]; x <= buf[y][1]; x++){
-//	              	int G=(int)(0.299*r+0.587*g+0.114*b);    
-//	                if(G>=3*Gray/2)
-//			    		AI.setRGBA(x, y,255, 255, 255, a);
-//	                else if(G>=Gray&&G<3*Gray/2)
-//			    		AI.setRGBA(x, y,170, 170, 170, a);
-//	                else if(G<Gray&&G>Gray/2)
-//						AI.setRGBA(x, y,80, 80, 80, a);
-//	                else
-//						AI.setRGBA(x, y,0, 0, 0, a);
-//		    }
-//		}
-//		clearBuffer();
-//    }
-//
-////     * �_�f�[�^��buf�ɏ������ށB
-////     * yMin, yMax�͍X�V����Ȃ����Ƃɒ��ӁB
-//    protected void writePoint(int x, int y){
-//		if(y < 0 || y >= height) return;
-//		if(x < buf[y][0]) buf[y][0] = x;
-//		if(x > buf[y][1]) buf[y][1] = x;
-//    }
-//
-//
-//    /**
-//     * �����f�[�^��buf�ɏ������ށB
-//     * �u���[���n���̃A���S���Y����p���Ă���B
-//     */
-//    protected void writeLine(int x1, int y1, int x2, int y2){
-//		//yMin, yMax�̍X�V
-//		if(y1 < yMin) yMin = y1;
-//		if(y1 > yMax) yMax = y1;
-//		if(y2 < yMin) yMin = y2;
-//		if(y2 > yMax) yMax = y2;
-//
-//		//dx, dy: X, Y�������̋���
-//		int dx = x2 - x1, dy = y2 - y1;
-//		int sx, sy; //dx, dy�̕�������
-//
-//		if(dx >= 0)
-//		    sx = 1;
-//		else{
-//		    sx = -1; dx = -dx;
-//		}
-//		if(dy >= 0)
-//		    sy = 1;
-//		else{
-//		    sy = -1; dy = -dy;
-//		}
-//
-//		int x = x1, y = y1;
-//		int d, tmp;
-//
-//		if(dx >= dy){
-//		    dy += dy; //dy *= 2
-//		    d = dy - dx;
-//		    tmp = dy - 2 * dx;
-//
-//		    //(x, y)��check
-//		    writePoint(x, y);
-//
-//		    for(int i = 0; i < dx; i++){
-//			if(d > 0){
-//			    y += sy; d += tmp;
-//			}else
-//			    d += dy;
-//
-//			x += sx;
-//
-//					//(x, y)��check
-//			writePoint(x, y);
-//		    }
-//		}else{
-//		    dx += dx; //dx *= 2
-//		    d = dx - dy;
-//		    tmp = dx - 2 * dy;
-//
-//		    //(x, y)��check
-//		    writePoint(x, y);
-//
-//		    for(int i = 0; i < dy; i++){
-//			if(d > 0){
-//			    x += sx; d += tmp;
-//			}else
-//			    d += dx;
-//
-//			y += sy;
-//
-//					//(x, y)��check
-//			writePoint(x, y);
-//		    }
-//		}
-//    }
-//
-//}