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

data/ext/pikl/pikl_effect3.c

@@ -0,0 +1,266 @@
+#include "pikl_effect3.h"
+
+static unsigned char lighting(unsigned char color, double dx, double dy, double dz,
+                                                    double mil, double env, double *light);
+
+//=============================================================================
+// pkl_illust
+//=============================================================================
+PKLExport int pkl_illust(PKLImage pkl, int edge, int gammaint)
+{
+	int GAP=10;
+	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, rc, gt;
+	int wx[PKL_CHANNEL], wy[PKL_CHANNEL], rate[PKL_CHANNEL];
+	unsigned char *wrk;
+	double gamma;
+	int th1, th2, th3;
+
+	wrk = malloc(pkl->width*pkl->height*pkl->channel);
+	if(!wrk) return(1);
+	memset(wrk, 0, pkl->width*pkl->height*pkl->channel);
+	
+	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(wx, 0, sizeof(wx));
+			memset(wy, 0, sizeof(wy));
+			
+			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);
+					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++)
+				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;
+			
+			rc = PKL_COLOR_CLIP(r1*r2/256);
+			for(k=0; k<pkl->channel; k++)
+				wrk[(i*pkl->width+j)*pkl->channel+k] = rc;
+		}
+	}
+	
+	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++)
+				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(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_mosaic
+//=============================================================================
+PKLExport int pkl_mosaic(PKLImage pkl, int msx, int msy)
+{
+	unsigned char *wrk;
+	int mpx, mpy;	//���U�C�N�̑傫��
+	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;
+			
+			//1�Z���̑��a�Z�o
+			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;
+			
+			//�Z���̕��ϐF���Z�o���āA�Z�����̃s�N�Z���ɓK�p
+			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];
+				}
+			}
+		}
+	}
+	
+	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);
+
+	srand48(1);
+	for(i=0; i<pkl->height; i++){
+		for(j=0; j<pkl->width; j++){
+			//nw = rand()%(noise*2+1)-noise;
+			nw = lrand48()%(noise*2+1)-noise;
+			nh = lrand48()%(noise*2+1)-noise;
+			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(pkl->image);
+	pkl->image = wrk;
+	return(0);
+}
+
+//=============================================================================
+// pkl_vtr
+//=============================================================================
+PKLExport int pkl_vtr(PKLImage pkl, int colspace, int gst, int cst)
+{
+	unsigned char *wrk;
+	int i, j, k, t;
+	int h=0, l_det=0;
+
+	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++){
+		if(l_det >= colspace){
+			h = !h;
+			l_det=0;
+		}
+		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);
+		}
+	}
+
+	free(pkl->image);
+	pkl->image = wrk;
+	return(0);
+}
+

data/ext/pikl/pikl_effect3.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_effect4.c

@@ -0,0 +1,495 @@
+#include "pikl_effect4.h"
+
+//=============================================================================
+// pkl_edgeposter
+//=============================================================================
+PKLExport int pkl_edgeposter(PKLImage pkl, int level, int up)
+{
+	if(pkl_posterize(pkl, level)) return(1);
+	if(pkl_noisecut(pkl)) return(1);
+	if(pkl_brightness(pkl, up)) return(1);
+	if(pkl_edgepaint(pkl)) return(1);
+	return(0);
+}
+
+//=============================================================================
+// pkl_edgepaint
+//=============================================================================
+PKLExport int pkl_edgepaint(PKLImage pkl)
+{
+	unsigned char *wrk, *p, *q;
+	int i, j, s, t, k, color, clipx, clipy, gray;
+	const int filter[9] = { -1, -1, -1, 
+							-1,  8, -1, 
+							-1, -1, -1};
+	
+	wrk = malloc(pkl->width*pkl->height*pkl->channel);
+	if(!wrk) return(1);
+	memset(wrk, 0, pkl->width*pkl->height*pkl->channel);
+	
+	/* convert grayscale */
+	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);
+	}
+
+	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) * pkl->channel] * filter[t+s*3];
+				}
+			}
+			
+			if(color>0){
+				memset(&wrk[(i*pkl->width+j)*pkl->channel], 0, pkl->channel);
+			}else{
+				p = &wrk[(i*pkl->width+j)*pkl->channel];
+				q = &pkl->image[(i*pkl->width+j)*pkl->channel];
+				for(k=0; k<pkl->channel; k++) *p++=*q++;
+			}
+		}
+	}
+
+	free(pkl->image);
+	pkl->image = wrk;
+	return(0);
+}
+
+//=============================================================================
+// pkl_tileslit
+//=============================================================================
+PKLExport int pkl_tileslit(PKLImage pkl, int area, int shift)
+{
+	unsigned char *wrk;
+	int i, j, k, tx, ty;
+	int w, h, offsetx, offsety;
+
+	if(shift==0) return(0);
+	if(area<=1 && (area>pkl->width || area>pkl->height)) return(1);
+
+	wrk = malloc(pkl->width*pkl->height*pkl->channel);
+	if(!wrk) return(1);
+	memset(wrk, 0, pkl->width*pkl->height*pkl->channel);
+	
+	//invert
+	for(i=0; i<pkl->height*pkl->width*pkl->channel; i++)
+		wrk[i] = (pkl->image[i] ^ 0xff);
+	
+	srand48(1);
+	for(i=0; i<pkl->height; i+=area){
+		for(j=0; j<pkl->width; j+=area){
+			w = j+area>pkl->width ? pkl->width-j : area;
+			h = i+area>pkl->height ? pkl->height : i+area;
+			
+			//�i�q�̂��炵��
+			//offsetx = rand()%(shift*2+1)-shift;
+			//offsety = rand()%(shift*2+1)-shift;
+			offsetx = lrand48()%(shift*2+1)-shift;
+			offsety = lrand48()%(shift*2+1)-shift;
+			
+			for(k=i; k<h; k++){
+				tx = j+offsetx<0 ? 0 : j+offsetx>=pkl->width ? pkl->width-1 : j+offsetx;
+				ty = k+offsety<0 ? 0 : k+offsety>=pkl->height ? pkl->height-1 : k+offsety;
+				memcpy(&wrk[(ty*pkl->width+tx)*pkl->channel], &pkl->image[(k*pkl->width+j)*pkl->channel], w*pkl->channel);
+			}
+		}
+	}
+	
+	free(pkl->image);
+	pkl->image = wrk;
+	return(0);
+}
+
+//=============================================================================
+// pkl_grid
+//=============================================================================
+PKLExport int pkl_grid(PKLImage pkl, int msx, int msy, int color)
+{
+	unsigned char *p;
+	int i, j, k, mpx, mpy;
+	
+	//��U���U�C�N��
+	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(j=mpx; j<pkl->width; j+=mpx){
+			p = &pkl->image[(i*pkl->width+j)*pkl->channel];
+			for(k=0; k<pkl->channel; k++){
+				*p = PKL_COLOR_CLIP(*p+color);
+				p++;
+			}
+		}
+	}
+	
+	return(0);
+}
+
+//=============================================================================
+// 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[(ty*pkl->width+tx)*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[(ty*pkl->width+tx)*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_alphablend
+//=============================================================================
+PKLExport int pkl_alphablend(PKLImage parent, PKLImage child, int xpos, int ypos, int alpha)
+{
+	int tw, th, i, j, k, alp, pp, cp;
+	const int limits=PKL_COLOR-1;
+	
+	if(parent->channel != child->channel) return(1);
+	if(xpos<0 || xpos>=parent->width || ypos<0 || ypos>=parent->height) return(1);
+	alp = PKL_COLOR_CLIP(alpha);
+	
+	tw = (xpos+child->width > parent->width) ? parent->width-xpos : child->width;
+	th = (ypos+child->height > parent->height) ? parent->height-ypos : child->height;
+
+	for(i=ypos; i<th+ypos; i++){
+		for(j=0; j<tw; j++){
+			pp = (i*parent->width+xpos+j)*parent->channel;
+			cp = ((i-ypos)*child->width+j)*child->channel;
+			for(k=0; k<parent->channel; k++)
+				parent->image[pp+k] =PKL_COLOR_CLIP((parent->image[pp+k]*alp + child->image[cp+k]*(limits-alp)) / limits);
+		}
+		
+	}
+	
+	return(0);
+}
+
+//=============================================================================
+// pkl_alphablend2
+//=============================================================================
+PKLExport int pkl_alphablend2(PKLImage parent, PKLImage child, int xpos, int ypos)
+{
+	int tw, th, i, j, k, pp, cp;
+	double alpha;
+	
+	if(parent->channel != child->channel) return(1);
+	if(xpos<0 || xpos>=parent->width || ypos<0 || ypos>=parent->height) return(1);
+	
+	tw = (xpos+child->width > parent->width) ? parent->width-xpos : child->width;
+	th = (ypos+child->height > parent->height) ? parent->height-ypos : child->height;
+
+	for(i=ypos; i<th+ypos; i++){
+		for(j=0; j<tw; j++){
+			alpha = sin((i-ypos)*M_PI/child->height) * sin(j*M_PI/child->width);
+			pp = (i*parent->width+xpos+j)*parent->channel;
+			cp = ((i-ypos)*child->width+j)*child->channel;
+			for(k=0; k<parent->channel; k++)
+				parent->image[pp+k] =PKL_COLOR_CLIP(parent->image[pp+k]*(1.0-alpha) + child->image[cp+k]*alpha);
+		}
+		
+	}
+	return(0);
+}
+
+//=============================================================================
+// pkl_shadowframe
+//=============================================================================
+PKLExport int pkl_shadowframe(PKLImage pkl, int margin, int backcolor, int shadowcolor)
+{
+	unsigned char *img, back[PKL_CHANNEL], shadow[PKL_CHANNEL];
+	int i, j, w, h;
+
+	if(margin<=0) return(1);
+
+	w = pkl->width;
+	h = pkl->height;
+	img = pkl->image;
+	pkl->width = w + margin*3;
+	pkl->height = h + margin*3;
+	
+	pkl->image = malloc(pkl->width*pkl->height*pkl->channel);
+	if(!pkl->image) return(1);
+	memset(pkl->image, 0, pkl->width*pkl->height*pkl->channel);
+
+	for(i=0; i<pkl->channel; i++){
+		back[i] = (backcolor>>((pkl->channel-i)*8) & 0xFF);
+		shadow[i] = (shadowcolor>>((pkl->channel-i)*8) & 0xFF);
+	}
+	
+	//�w�i�F�ݒ�
+	for(i=0; i<pkl->width*pkl->height*pkl->channel; i+=pkl->channel)
+		memcpy(&pkl->image[i], back, pkl->channel);
+	
+	//�t���[���ݒ�
+	for(i=margin*2; i<h+margin*2; i++)
+		for(j=margin*2; j<w+margin*2; j++)
+			memcpy(&pkl->image[(i*pkl->width+j)*pkl->channel], shadow, pkl->channel);
+	
+	//shadowframe�����(�P�Ƀu���[)
+	pkl_gaussblur(pkl, 5.0);
+	
+	for(i=margin,j=0; i<h+margin; i++,j++)
+		memcpy(&pkl->image[(i*pkl->width+margin)*pkl->channel], &img[(j*w)*pkl->channel], w*pkl->channel);
+	
+	free(img);
+	return(0);
+}
+
+//=============================================================================
+// pkl_edge
+//=============================================================================
+PKLExport int pkl_edge(PKLImage pkl, int threshold)
+{
+	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_dither
+//=============================================================================
+PKLExport int pkl_dither(PKLImage pkl, PKL_DITHER dither)
+{
+	double FloydSteinberg[2][3] = {
+		{       -1,       -1, 7.0/16.0},
+		{ 3.0/16.0, 5.0/16.0, 1.0/16.0} };
+	
+	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;
+	
+	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;
+
+			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);
+}
+