pikl 0.2.8 → 0.3.0

data/ext/pikl/pikl_divide.h

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

data/ext/pikl/pikl_effect.c

@@ -1,203 +1,540 @@
 #include "pikl_effect.h"
 
-//=================================================================================
-// pkl_unsharp
-//=================================================================================
-PKLExport int pkl_unsharp(PKLImage pkl, int threshold, double edge)
+//=============================================================================
+// pkl_invert
+//=============================================================================
+PKLExport int pkl_invert(PKLImage pkl)
 {
-	int i, j, p, q, k;
-	int cnt, value, stock[PKL_CHANNEL];
-	unsigned char *wrk, *s;
-	
-	wrk = malloc(pkl->height * pkl->width * pkl->channel);
+	int i;
+	for(i=0; i<pkl->height*pkl->width*pkl->channel; i++)
+		pkl->image[i] ^= 0xff;
+	return(0);
+}
+
+//=============================================================================
+// pkl_sepia
+//=============================================================================
+PKLExport int pkl_sepia(PKLImage pkl, double red_weight, double green_weight, double blue_weight)
+{
+	unsigned char *wrk;
+	int i, j, color;
+
+	if(pkl->color!=PKL_RGB) return(1);
+
+	wrk = malloc(pkl->width*pkl->height*pkl->channel);
 	if(!wrk) return(1);
-	memset(wrk, 0, pkl->height * pkl->width * pkl->channel);
+	memset(wrk, 0, pkl->width*pkl->height*pkl->channel);
 	
 	for(i=0; i<pkl->height; i++){
 		for(j=0; j<pkl->width; j++){
-			cnt = 0;
-			memset(stock, 0, sizeof(stock));
+			color = ((pkl->image[(i*pkl->width+j)*pkl->channel+0]+
+					  pkl->image[(i*pkl->width+j)*pkl->channel+1]+
+					  pkl->image[(i*pkl->width+j)*pkl->channel+2]) / 3);
 			
-			for(p=-RADIUS; p<=RADIUS; p++){
-				for(q=-RADIUS; q<=RADIUS; q++){
-					if(j+q>=0 && j+q<pkl->width && i+p>=0 && i+p<pkl->height){
-						for(k=0; k<pkl->channel; k++) stock[k] += pkl->image[((i+p)*pkl->width+(j+q))*pkl->channel+k];
-						cnt++;
+			wrk[(i*pkl->width+j)*pkl->channel+0] = PKL_COLOR_CLIP(color*red_weight);
+			wrk[(i*pkl->width+j)*pkl->channel+1] = PKL_COLOR_CLIP(color*green_weight);
+			wrk[(i*pkl->width+j)*pkl->channel+2] = PKL_COLOR_CLIP(color*blue_weight);
+		}
+	}
+
+	free(pkl->image);
+	pkl->image = wrk;
+	return(0);
+}
+
+//=============================================================================
+// pkl_oilpaint
+//=============================================================================
+PKLExport int pkl_oilpaint(PKLImage pkl, int weight)
+{
+	int color[PKL_COLOR], gray;
+	int i, j, k, max, s, t, sx, sy, tx, ty;
+	unsigned char *wrk;
+	
+	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->width*pkl->height*pkl->channel; i+=pkl->channel){
+		gray=0;
+		for(k=0; k<pkl->channel; k++)
+			gray += pkl->image[i+k];
+		wrk[i] = PKL_COLOR_CLIP(gray/pkl->channel);
+	}
+
+	//get histgram
+	memset(color, 0, sizeof(int)*PKL_COLOR);
+	for(i=0; i<pkl->height*pkl->width; i+=pkl->channel) color[wrk[i]]++;
+
+	//���Ӄs�N�Z������ŕp�F��I��
+	for(i=0; i<pkl->height; i++){
+		for(j=0; j<pkl->width; j++){
+			max = 0;
+			tx=j;
+			ty=i;
+			for(s=0; s<weight; s++){
+				for(t=0; t<weight; t++){
+					sx = (t+j >= pkl->width) ? pkl->width-1 : t+j;
+					sy = (s+i >= pkl->height) ? pkl->height-1 : s+i;
+					if(max<color[wrk[(sy*pkl->width+sx)*pkl->channel]]){
+						max = color[wrk[(sy*pkl->width+sx)*pkl->channel]];
+						tx = sx;
+						ty = sy;
 					}
 				}
 			}
-			s = &wrk[(i * pkl->width + j) * pkl->channel];
-			for(k=0; k<pkl->channel; k++)
-				*s++ = stock[k] / cnt;
+			//�I���W�i���̐F��K�p
+			memcpy(&wrk[(i*pkl->width+j)*pkl->channel], &pkl->image[(ty*pkl->width+tx)*pkl->channel], pkl->channel);
 		}
 	}
 	
-	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_COLOR_CLIP(value);
+	free(pkl->image);
+	pkl->image = wrk;
+	return(0);
+}
+
+//=============================================================================
+// pkl_noise
+//=============================================================================
+PKLExport int pkl_noise(PKLImage pkl, int noise)
+{
+	unsigned char *wrk;
+	int i, j, k, sx, sy, nw, nh;
+	
+	wrk = malloc(pkl->width*pkl->height*pkl->channel);
+	if(!wrk) return(1);
+	memset(wrk, 0, pkl->width*pkl->height*pkl->channel);
+
+	#ifdef WIN32
+	srand(1);
+	#else
+	srand48(1);
+	#endif
+	for(i=0; i<pkl->height; i++){
+		for(j=0; j<pkl->width; j++){
+			//nw = rand()%(noise*2+1)-noise;
+			#ifdef WIN32
+			nw = rand()%(noise*2+1)-noise;
+			nh = rand()%(noise*2+1)-noise;
+			#else
+			nw = lrand48()%(noise*2+1)-noise;
+			nh = lrand48()%(noise*2+1)-noise;
+			#endif
+			sx = j+nw<0 ? 0 : j+nw>=pkl->width ? pkl->width-1 : j+nw;
+			sy = i+nh<0 ? 0 : i+nh>=pkl->height ? pkl->height-1 : i+nh;
+			for(k=0; k<pkl->channel; k++)
+				wrk[(i*pkl->width+j)*pkl->channel+k] = pkl->image[(sy*pkl->width+sx)*pkl->channel+k];
+		}
 	}
-	free(wrk);
+
+	free(pkl->image);
+	pkl->image = wrk;
 	return(0);
 }
 
-//=================================================================================
-// pkl_contrast
-//=================================================================================
-PKLExport int pkl_contrast(PKLImage pkl, int rate)
+//=============================================================================
+// pkl_vtr
+//=============================================================================
+PKLExport int pkl_vtr(PKLImage pkl, int colspace, int gst, int cst)
 {
-	unsigned char ct[PKL_COLOR];
-	int value, i;
+	unsigned char *wrk;
+	int i, j, k, t;
+	int h=0, l_det=0;
 
-	if(rate < -127 || rate > 127) return(1);
+	wrk = malloc(pkl->width*pkl->height*pkl->channel);
+	if(!wrk) return(1);
+	memset(wrk, 0, pkl->width*pkl->height*pkl->channel);
 
-	if(rate < 0.0){
-		//�d�݂������̎��͒����I�ɕ��R��
-		for(i=0; i<PKL_COLOR; i++){
-			value = i + (i-127) * rate/127;
-			ct[i] = PKL_COLOR_CLIP(value);
+	for(i=0; i<pkl->height; i++){
+		if(l_det >= colspace){
+			h = !h;
+			l_det=0;
 		}
-	}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_COLOR_CLIP(value);
+		l_det++;
+		
+		for(j=0; j<pkl->width; j++){
+			t = j+gst<0 ? 0 : j+gst>=pkl->width ? pkl->width-1 : j+gst;
+			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] +
+									pkl->image[(i*pkl->width+t)*pkl->channel+k])/2 + (cst-127)*h);
 		}
 	}
 
-	for(i=0; i<pkl->width*pkl->height*pkl->channel; i++)
-		pkl->image[i] = ct[pkl->image[i]];
-
+	free(pkl->image);
+	pkl->image = wrk;
 	return(0);
 }
 
-//=================================================================================
-// pkl_level def=0.0050
-//=================================================================================
-PKLExport int pkl_level(PKLImage pkl, double low, double high, double coeff)
+//=============================================================================
+// pkl_edgepaint
+//=============================================================================
+PKLExport int pkl_edgepaint(PKLImage pkl, int edge)
 {
-	PKL_HISTGRAM hst[PKL_CHANNEL];
-	int i, j, cnt, value;
-
-	if((low  < 0.0 && low  > 100.0) ||
-	   (high < 0.0 && high > 100.0) ||
-	   (coeff< 0.0 && coeff> 2.0)) return(1);
+	unsigned char *wrk;
+	int i, j, s, t, k, color, clipx, clipy, gray;
+	const int filter[9] = { -1, -1, -1, 
+							-1,  8, -1, 
+							-1, -1, -1};
 	
-	memset(&hst, 0, sizeof(hst));
-	for(i=0; i<pkl->height*pkl->width; i++){
-		for(j=0; j<pkl->channel; j++){
-			hst[j].data[ pkl->image[i*pkl->channel+j] ]++;
-		}
+	wrk = malloc(pkl->width*pkl->height);
+	if(!wrk) return(1);
+	
+	/* convert grayscale */
+	for(i=0; i<pkl->width*pkl->height; i++){
+		gray=0;
+		for(k=0; k<pkl->channel; k++)
+			gray += pkl->image[i*pkl->channel+k];
+		wrk[i] = PKL_COLOR_CLIP(gray/pkl->channel);
 	}
 
-	for(i=0; i<pkl->channel; i++){
-		cnt=0;
-		for(j=0; j<PKL_COLOR; j++){
-			cnt += hst[i].data[j];
-			if(cnt > low/100*pkl->height*pkl->width){
-				hst[i].min = j;
-				break;
+	for(i=0; i<pkl->height; i++){
+		for(j=0; j<pkl->width; j++){
+			color=0;
+			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;
+					color += wrk[clipy*pkl->width+clipx] * filter[t+s*3];
+				}
 			}
-		}
-		cnt=0;
-		for(j=PKL_COLOR-1; j>=0; j--){
-			cnt += hst[i].data[j];
-			if(cnt > high/100*pkl->height*pkl->width){
-				hst[i].max = j;
-				break;
+			if(color>0){
+				//memset(&pkl->image[(i*pkl->width+j)*pkl->channel], 0, pkl->channel);
+				for(s=0; s<edge; s++){
+					for(t=0; t<edge; t++){
+						clipx = (j+t)>=pkl->width  ? pkl->width-1  : j+t;
+						clipy = (i+s)>=pkl->height ? pkl->height-1 : i+s;
+						memset(&pkl->image[(clipy*pkl->width+clipx)*pkl->channel], 0, pkl->channel);
+					}
+				}
 			}
 		}
 	}
+	free(wrk);
+	return(0);
+}
 
-	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_COLOR_CLIP(value);
+//=============================================================================
+// pkl_kuwahara
+//=============================================================================
+PKLExport int pkl_kuwahara(PKLImage pkl, int range)
+{
+	unsigned char *wrk, *p;
+	int i, j, k, count, tr, t, tx, ty, clipx, clipy;
+	int value[4], mincolor, idx, total[PKL_CHANNEL];
+	struct { int sx, sy, ex, ey; } r[4];	//rect
+	unsigned char max_color[PKL_CHANNEL], min_color[PKL_CHANNEL], c;
+	
+	if(range<=1) return(0);
+	
+	wrk = malloc(pkl->width*pkl->height*pkl->channel);
+	if(!wrk) return(1);
+	memset(wrk, 0, pkl->width*pkl->height*pkl->channel);
+
+	//�̈�̃s�N�Z����
+	count = range*range;
+	tr = range-1;
+	
+	for(i=0; i<pkl->height; i++){
+		for(j=0; j<pkl->width; j++){
+			/* �J�����g�s�N�Z���𒆐S��4�‚̗̈�ɕ����� */
+			//����(0)
+			r[0].sx = j-tr;
+			r[0].sy = i-tr;
+			r[0].ex = j;
+			r[0].ey = i;
+			//�E��(1)
+			r[1].sx = j;
+			r[1].sy = i-tr;
+			r[1].ex = j+tr;
+			r[1].ey = i;
+			//�E��(2)
+			r[2].sx = j;
+			r[2].sy = i;
+			r[2].ex = j+tr;
+			r[2].ey = i+tr;
+			//����(3)
+			r[3].sx = j-tr;
+			r[3].sy = i;
+			r[3].ex = j;
+			r[3].ey = i+tr;
+			
+			/* �e�̈�Ŋe�F�̍ő�l�ƍŏ��l�̍���ݐς��� */
+			memset(value, 0, sizeof(value));
+			for(t=0; t<4; t++){
+				memset(max_color, 0x00, PKL_CHANNEL);
+				memset(min_color, 0xff, PKL_CHANNEL);
+				for(ty=r[t].sy; ty<=r[t].ey; ty++){
+					for(tx=r[t].sx; tx<=r[t].ex; tx++){
+						clipx = tx<0 ? 0 : tx>=pkl->width ? pkl->width-1 : tx;
+						clipy = ty<0 ? 0 : ty>=pkl->height ? pkl->height-1 : ty;
+						p = &pkl->image[(clipy*pkl->width+clipx)*pkl->channel];
+						for(k=0; k<pkl->channel; k++){
+							c = *p++;
+							max_color[k] = (c > max_color[k]) ? c : max_color[k];
+							min_color[k] = (c < min_color[k]) ? c : min_color[k];
+						}
+					}
+				}
+				
+				for(k=0; k<pkl->channel; k++)
+					value[t] += (max_color[k] - min_color[k]);
+			}
+			
+			/* �e�̈�ōł��F�̍������������̈��I������ */
+			mincolor = value[0];
+			idx = 0;
+			for(t=1; t<4; t++){
+				if(value[t]<mincolor){
+					mincolor = value[t];
+					idx = t;
+				}
+			}
+			
+			/* �I�����ꂽ�̈�̐F�̕��ς��s�N�Z���ɓK�p���� */
+			memset(total, 0, sizeof(total));
+			for(ty=r[idx].sy; ty<=r[idx].ey; ty++){
+				for(tx=r[idx].sx; tx<=r[idx].ex; tx++){
+					clipx = tx<0 ? 0 : tx>=pkl->width ? pkl->width-1 : tx;
+					clipy = ty<0 ? 0 : ty>=pkl->height ? pkl->height-1 : ty;
+					p = &pkl->image[(clipy*pkl->width+clipx)*pkl->channel];
+					for(k=0; k<pkl->channel; k++)
+						total[k] += *p++;
+				}
+			}
+			p =&wrk[(i*pkl->width+j)*pkl->channel];
+			for(k=0; k<pkl->channel; k++)
+				*p++ = PKL_COLOR_CLIP(total[k]/count);
 		}
 	}
 
+	free(pkl->image);
+	pkl->image = wrk;
 	return(0);
 }
 
 //=============================================================================
-// pkl_brightness
+// pkl_edge
 //=============================================================================
-PKLExport int pkl_brightness(PKLImage pkl, int color)
+PKLExport int pkl_edge(PKLImage pkl, int threshold)
 {
-	int i;
-	for(i=0; i<pkl->width*pkl->height*pkl->channel; i++){
-		pkl->image[i] = PKL_COLOR_CLIP(pkl->image[i] + color);
+	unsigned char *wrk, *p;
+	int i, j, k, color[PKL_CHANNEL], total;
+	int r1, r2, r3;
+	
+	wrk = malloc(pkl->width*pkl->height*pkl->channel);
+	if(!wrk) return(1);
+	memset(wrk, 0xff, pkl->width*pkl->height*pkl->channel);
+	
+	r3 = sqrt((double)pkl->channel);
+
+	for(i=0; i<pkl->height; i++){
+		r1=r2=0;
+		for(j=0; j<pkl->width; j++){
+			//x����
+			if(j+1 < pkl->width){
+				p = &pkl->image[(i*pkl->width+j)*pkl->channel];
+				for(k=0; k<pkl->channel; k++){
+					color[k] = *p - *(p+pkl->channel);
+					color[k] *= color[k];
+					p++;
+				}
+				total=0;
+				for(k=0; k<pkl->channel; k++)
+					total += color[k];
+				r1 = sqrt(total)/r3;
+			}
+			
+			//y����
+			if(i+1 < pkl->height){
+				p = &pkl->image[(i*pkl->width+j)*pkl->channel];
+				for(k=0; k<pkl->channel; k++){
+					color[k] = *p - *(p+pkl->width*pkl->channel);
+					color[k] *= color[k];
+					p++;
+				}
+				total=0;
+				for(k=0; k<pkl->channel; k++)
+					total += color[k];
+				r2 = sqrt(total)/r3;
+			}
+
+			p = &wrk[(i*pkl->width+j)*pkl->channel];
+			if(r1>=threshold || r2>=threshold)
+				for(k=0; k<pkl->channel; k++) *p++=0;
+		}
 	}
+	free(pkl->image);
+	pkl->image = wrk;
 	return(0);
 }
 
 //=============================================================================
-// pkl_hls
+// pkl_dither
 //=============================================================================
-PKLExport int pkl_hls(PKLImage pkl, double ym, double sm, double hd)
+PKLExport int pkl_dither(PKLImage pkl, PKL_DITHER dither)
 {
-	int i;
-	double c1, c2;	//�F�M��
-	double y, s, h;	//y=�P�x, s=�ʓx, h=�F��
+	double FloydSteinberg[2][3] = {
+		{       -1,       -1, 7.0/16.0},
+		{ 3.0/16.0, 5.0/16.0, 1.0/16.0} };
 	
-	if(pkl->color != PKL_RGB) return(1);
+	double Stucci[3][5] = {
+		{      -1,       -1,       -1, 8.0/42.0, 4.0/42.0},
+		{2.0/42.0, 4.0/42.0, 8.0/42.0, 4.0/42.0, 2.0/42.0},
+		{1.0/42.0, 2.0/42.0, 4.0/42.0, 2.0/42.0, 1.0/42.0} };
+
+	double Sierra[3][5] = {
+		{      -1,       -1,       -1, 5.0/32.0, 3.0/32.0},
+		{2.0/32.0, 4.0/32.0, 5.0/32.0, 4.0/32.0, 2.0/32.0},
+		{      -1, 2.0/32.0, 3.0/32.0, 2.0/32.0,       -1} };
+
+	double JaJuNi[3][5] = {
+		{      -1,       -1,       -1, 7.0/48.0, 5.0/48.0},
+		{3.0/48.0, 5.0/48.0, 7.0/48.0, 5.0/48.0, 3.0/48.0},
+		{1.0/48.0, 3.0/48.0, 5.0/48.0, 3.0/48.0, 1.0/48.0} };
+
+	unsigned char *wrk, pix;
+	double *pt, err;
+	int i, j, k, gray, s, t, tx, ty, row, col, xrange;
 	
-	for(i=0; i<pkl->width*pkl->height; i++){
-		/* �P�x,�F�M��1,2 */
-		y  = 0.299 * pkl->image[i*pkl->channel]   +
-			 0.587 * pkl->image[i*pkl->channel+1] +
-			 0.114 * pkl->image[i*pkl->channel+2];
-		c1 = pkl->image[i*pkl->channel]   - y;
-		c2 = pkl->image[i*pkl->channel+2] - y;
-		
-		/* �ʓx */
-		s = sqrt(c1*c1 + c2*c2);
-		
-		/* �F�� */
-		if(s < 0.0) h = 0.0;
-		else        h = atan2(c1, c2) * 180.0 / M_PI;
-		
-		/* ������������ */
-		y *= (1 + ym);
-		s *= (1 + sm);
-		h += hd;
-		
-		/* �����l����RGB�ɖ߂� */
-		c1 = s * sin(M_PI * h / 180.0);
-		c2 = s * cos(M_PI * h / 180.0);
+	wrk = malloc(pkl->width*pkl->height*pkl->channel);
+	if(!wrk) return(1);
+
+	//�f�B�U�p�^����I��
+	switch(dither){
+		case PKL_DITHER_STUCCI:
+			row = 5;
+			col = 3;
+			pt = &(Stucci[0][0]);
+			break;
+			
+		case PKL_DITHER_SIERRA:
+			row = 5;
+			col = 3;
+			pt = &(Sierra[0][0]);
+			break;
+			
+		case PKL_DITHER_JAJUNI:
+			row = 5;
+			col = 3;
+			pt = &(JaJuNi[0][0]);
+			break;
+			
+		case PKL_DITHER_FLOYDSTEINBERG:
+		default:
+			row = 3;
+			col = 2;
+			pt = &(FloydSteinberg[0][0]);
+	}
+
+	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];
+			pkl->image[(i*pkl->width+j)*pkl->channel] = 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 = pkl->image[(i*pkl->width+j)*pkl->channel];
+			if(pix>127)
+				memset(&wrk[(i*pkl->width+j)*pkl->channel], 0xff, pkl->channel);
+			else
+				memset(&wrk[(i*pkl->width+j)*pkl->channel], 0x00, pkl->channel);
+			err = pix>127 ? pix-255 : pix;
 
-		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);
+			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;
+					
+					pkl->image[(ty*pkl->width+tx)*pkl->channel] =
+						PKL_COLOR_CLIP(pkl->image[(ty*pkl->width+tx)*pkl->channel] + err * pt[s*row+t+xrange]);
+				}
+			}
+		}
 	}
+	
+	free(pkl->image);
+	pkl->image = wrk;
 	return(0);
 }
 
-//=================================================================================
-// pkl_gamma
-//=================================================================================
-PKLExport int pkl_gamma(PKLImage pkl, double gm)
+//=============================================================================
+// pkl_colordither
+//=============================================================================
+PKLExport int pkl_colordither(PKLImage pkl, int weight)
 {
-	unsigned char gt[PKL_COLOR];
-	int i;
+	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;
 	
-	if(gm < 0.0) return(1);
+	row = 3;
+	col = 2;
+	pt = &(FloydSteinberg[0][0]);
 	
-	for(i=0; i<PKL_COLOR; i++)
-		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]];
+	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(!graypic) 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);
+			}
+			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]);
+				}
+			}
+		}
+	}
+	free(graypic);
+	free(pkl->image);
+	pkl->image = wrk;
 	return(0);
 }
 
 //=============================================================================
-// pkl_noisecut(median filter)
+// pkl_contour
 //=============================================================================
-PKLExport int pkl_noisecut(PKLImage pkl)
+PKLExport int pkl_contour(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;
+	double dd=1.732;
+	int i, j, k, s, ix[4], iy[4], dis[4], max;
+	unsigned char *wrk, p, q;
 
 	wrk = malloc(pkl->width*pkl->height*pkl->channel);
 	if(!wrk) return(1);
@@ -205,31 +542,74 @@ PKLExport int pkl_noisecut(PKLImage pkl)
 
 	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++;
+			ix[0]=j+1; iy[0]=i-1;	//�E��
+			ix[1]=j+1; iy[1]=i;		//�E
+			ix[2]=j+1; iy[2]=i+1;	//�E��
+			ix[3]=j;   iy[3]=i+1;	//��
+
+			for(s=0; s<4; s++){
+				dis[s]=0;
+				if(ix[s]>=0 && ix[s]<pkl->width && iy[s]>=0 && iy[s]<pkl->height){
+					for(k=0; k<pkl->channel; k++){
+						p = pkl->image[(i*pkl->width+j)*pkl->channel+k];
+						q = pkl->image[(iy[s]*pkl->width+ix[s])*pkl->channel+k];
+						dis[s] += ((q-p) * (q-p));
+					}
 				}
 			}
-			//�����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;
+			max=0;
+			for(s=0; s<4; s++)
+				if(dis[s]>max) max=dis[s];
+			
+			for(k=0; k<pkl->channel; k++)
+				wrk[(i*pkl->width+j)*pkl->channel+k] = PKL_COLOR_CLIP(255-sqrt((double)max)/dd);
+		}
+	}
+	
+	free(pkl->image);
+	pkl->image = wrk;
+	return(0);
+}
+
+//=============================================================================
+// pkl_focus
+//=============================================================================
+PKLExport int pkl_focus(PKLImage pkl, PKL_FOCUS type)
+{
+	unsigned char *wrk;
+	int i, j, s, t, k, clipx, clipy, weight=1;
+	int *matrix, color[PKL_CHANNEL];
+
+	//select filter
+	matrix=focus_filter[0].matrix;
+	for(i=0; i<sizeof(focus_filter)/sizeof(struct PKL_FILTER); i++){
+		if(type==focus_filter[i].type){
+			matrix=focus_filter[i].matrix;
+			break;
+		}
+	}
+
+	for(i=0; i<9; i++)
+		weight += matrix[i];
+	
+	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++){
+			memset(color, 0, sizeof(color));
+			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[k] += pkl->image[(clipy*pkl->width+clipx) * pkl->channel + k] * matrix[t+s*3];
 				}
 			}
-			p= &wrk[(i*pkl->width+j)*pkl->channel];
-			for(k=0; k<pkl->channel; k++) *p++=median[k];
+			
+			for(k=0; k<pkl->channel; k++)
+				wrk[(i*pkl->width+j)*pkl->channel+k] = PKL_COLOR_CLIP(color[k]/weight);
 		}
 	}
 
@@ -238,3 +618,55 @@ PKLExport int pkl_noisecut(PKLImage pkl)
 	return(0);
 }
 
+//=============================================================================
+// pkl_emboss
+//=============================================================================
+PKLExport int pkl_emboss(PKLImage pkl, PKL_EMBOSS type)
+{
+	int i, *mask;
+
+	//select filter
+	mask=focus_filter[0].matrix;
+	for(i=0; i<sizeof(emboss_filter)/sizeof(struct PKL_FILTER); i++){
+		if(type==emboss_filter[i].type){
+			mask = emboss_filter[i].matrix;
+			break;
+		}
+	}
+	return pkl_emboss2(pkl, mask, 3, 3, 1.0, 127);
+}
+
+//=============================================================================
+// pkl_emboss2
+//=============================================================================
+PKLExport int pkl_emboss2(PKLImage pkl, int *mask, int row, int col, double factor, int offset)
+{
+	unsigned char *wrk;
+	int i, j, s, t, k, clipx, clipy;
+	int color[PKL_CHANNEL];
+
+	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++){
+			memset(color, 0, sizeof(color));
+			for(s=0; s<col; s++){
+				for(t=0; t<row; 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[k] += pkl->image[(clipy*pkl->width+clipx) * pkl->channel + k] * mask[t+s*row];
+				}
+			}
+			
+			for(k=0; k<pkl->channel; k++)
+				wrk[(i*pkl->width+j)*pkl->channel+k] = PKL_COLOR_CLIP(color[k]/factor + offset);
+		}
+	}
+
+	free(pkl->image);
+	pkl->image = wrk;
+	return(0);
+}