pikl 0.2.8 → 0.3.0

data/ext/pikl/pikl_pixel.c

@@ -0,0 +1,173 @@
+#include "pikl_pixel.h"
+
+static int check_offset(PKLImage pkl, int x, int y, PKL_COLOR_MODEL target);
+
+//=============================================================================
+// pkl_color_create
+//=============================================================================
+PKLExport PKLColor pkl_color_create(unsigned char a, unsigned char b, unsigned char c, unsigned char d)
+{
+	PKLColor pcolor;
+	
+	pcolor = malloc(sizeof(struct _PKLColor));
+	if(!pcolor) return(NULL);
+	memset(pcolor, 0, sizeof(struct _PKLColor));
+	
+	pcolor->color[0] = a;
+	pcolor->color[1] = b;
+	pcolor->color[2] = c;
+	pcolor->color[3] = d;
+	return(pcolor);
+}
+
+//=============================================================================
+// pkl_color_gray
+//=============================================================================
+PKLExport PKLColor pkl_color_gray(unsigned char gray)
+{
+	return pkl_color_create(gray, 0, 0, 0);
+}
+
+//=============================================================================
+// pkl_color_rgb
+//=============================================================================
+PKLExport PKLColor pkl_color_rgb(unsigned char red, unsigned char green, unsigned char blue)
+{
+	return pkl_color_create(red, green, blue, 0);
+}
+
+//=============================================================================
+// pkl_color_cmyk
+//=============================================================================
+PKLExport PKLColor pkl_color_cmyk(unsigned char c, unsigned char m, unsigned char y, unsigned char k)
+{
+	return pkl_color_create(c, m, y, k);
+}
+
+//=============================================================================
+// pkl_color_close
+//=============================================================================
+PKLExport void pkl_color_close(PKLColor color)
+{
+	if(color) free(color);
+}
+
+//=============================================================================
+// pkl_color_get
+//=============================================================================
+PKLExport unsigned char pkl_get_color(PKLImage pkl, int x, int y, PKL_COLOR_MODEL target)
+{
+	int offset=0;
+	
+	if((offset=check_offset(pkl, x, y, target)) == -1) return(0);
+	return pkl->image[(y*pkl->width+x)*pkl->channel+offset];
+}
+
+//=============================================================================
+// pkl_color_set
+//=============================================================================
+PKLExport int pkl_set_color(PKLImage pkl, int x, int y, PKL_COLOR_MODEL target, unsigned char color)
+{
+	int offset=0;
+
+	if((offset=check_offset(pkl, x, y, target)) == -1) return(1);
+	pkl->image[(y*pkl->width+x)*pkl->channel+offset]=color;
+	return(0);
+}
+
+//=============================================================================
+// check_offset
+//=============================================================================
+static int check_offset(PKLImage pkl, int x, int y, PKL_COLOR_MODEL target)
+{
+	if(x<0 || x>=pkl->width || y<0 || y>=pkl->height) return(-1);
+	
+	switch(pkl->color){
+		case PKL_GRAYSCALE:
+			if(target != PKL_GRAY) return(-1);
+			return(0);
+		case PKL_RGB:
+			switch(target){
+				case PKL_RED:   return(0);
+				case PKL_GREEN: return(1);
+				case PKL_BLUE:  return(2);
+				default:
+					return(-1);
+			}
+			break;
+		case PKL_CMYK:
+			switch(target){
+				case PKL_CYAN:    return(0);
+				case PKL_MAGENTA: return(1);
+				case PKL_YELLOW:  return(2);
+				case PKL_BLACK:   return(3);
+				default:
+					return(-1);
+			}
+			break;
+		case PKL_UNKNOWN:
+		case PKL_BLACKWHITE:
+		case PKL_RGBA:
+		case PKL_YCbCr:
+		case PKL_YCCK:
+		default:
+			return(-1);
+	}
+	return(-1);
+}
+
+//=============================================================================
+// pkl_pixel_get
+//=============================================================================
+PKLExport PKLColor pkl_get_pixel(PKLImage pkl, int x, int y)
+{
+	PKLColor pcolor;
+	
+	if(x<0 || x>=pkl->width || y<0 || y>=pkl->height) return(NULL);
+
+	pcolor = malloc(sizeof(struct _PKLColor));
+	if(!pcolor) return(NULL);
+	memset(pcolor, 0, sizeof(struct _PKLColor));
+	memcpy(pcolor->color, &pkl->image[(y*pkl->width+x)*pkl->channel], pkl->channel);
+	return(pcolor);
+}
+
+//=============================================================================
+// pkl_pixel_set
+//=============================================================================
+PKLExport int pkl_set_pixel(PKLImage pkl, int x, int y, PKLColor color)
+{
+	if(x<0 || x>=pkl->width || y<0 || y>=pkl->height) return(1);
+	memcpy(&pkl->image[(y*pkl->width+x)*pkl->channel], color->color, pkl->channel);
+	return(0);
+}
+
+//=============================================================================
+// pkl_color
+//=============================================================================
+PKLExport unsigned char pkl_color(PKLColor color, PKL_COLOR_MODEL target)
+{
+	int offset;
+	
+	switch(target){
+		case PKL_GRAY:
+		case PKL_RED:
+		case PKL_CYAN:
+			offset=0;
+			break;
+		case PKL_GREEN:
+		case PKL_MAGENTA:
+			offset=1;
+			break;
+		case PKL_BLUE:
+		case PKL_YELLOW:
+			offset=2;
+			break;
+		case PKL_BLACK:
+			offset=3;
+			break;
+		default:
+			return(0);
+	}
+	return color->color[offset];
+}

data/ext/pikl/{pikl_trim.h → pikl_pixel.h}

@@ -1,5 +1,5 @@
-#ifndef _LIB_PIKL_TRIM_
-#define _LIB_PIKL_TRIM_
+#ifndef _LIB_PIKL_PIXEL_
+#define _LIB_PIKL_PIXEL_
 
 #include <stdio.h>
 #include <stdlib.h>

data/ext/pikl/pikl_private.h

@@ -1,7 +1,13 @@
 #ifndef _LIB_PIKL_PRIVATE_
 #define _LIB_PIKL_PRIVATE_
 
+#ifdef DEBUG
+#include "dbg/dbg.h"
+#endif
+
 #define PKL_MINMAX(a,b,i) (((a>=i)?a:((b<=i)?b:i)))
+#define PKL_MIN(a,b) ((a<b)?a:b)
+#define PKL_MAX(a,b) ((a>b)?a:b)
 #define PKL_COLOR_CLIP(v) v<0?0:v>255?255:v
 #define PKL_CHANNEL 4
 #define PKL_COLOR 256
@@ -19,11 +25,12 @@ struct _PKLImage {
 	unsigned char *image;
 	PKL_FORMAT format;
 	int compress;
-	
-	//affine
-	double x_scale, y_scale;
-	double angle;
-	double x_trns, y_trns;
 };
 
+//=============================================================================
+// PKLColor
+//=============================================================================
+struct _PKLColor {
+	unsigned char color[PKL_CHANNEL];
+};
 #endif

data/ext/pikl/pikl_rotate.c

@@ -1,70 +1,428 @@
 #include "pikl_rotate.h"
 
+static int rotate_90(PKLImage pkl, float angle);
+static int rotate_custom(PKLImage pkl, float angle, PKL_SAMPLE sample, PKLColor backcolor);
+static void bsort(int *p);
+
+static int pkl_rotate_nr(PKLImage pkl, PIKL_ROTATE *ri);
+static int pkl_rotate_nn(PKLImage pkl, PIKL_ROTATE *ri);
+static int pkl_rotate_bl(PKLImage pkl, PIKL_ROTATE *ri);
+static int pkl_rotate_bc(PKLImage pkl, PIKL_ROTATE *ri);
+//static int pkl_rotate_pa(PKLImage pkl, float angle, int backcolor);
+
 //=================================================================================
 // pkl_rotate
 //=================================================================================
-PKLExport int pkl_rotate(PKLImage pkl, PKL_ANGLE angle)
+PKLExport int pkl_rotate(PKLImage pkl, float angle, PKL_SAMPLE sample, PKLColor backcolor)
 {
-	unsigned char *wrk;
-	int rsin, rcos;
-	int width, height;
-	int sx, sy, ex, ey;
-	int i, j, x, y;
-
-	switch(angle){
-		case PKL_ANGLE_000:
-			return(0);
-		case PKL_ANGLE_090:
-			rcos   = 0;
-			rsin   = 1;
-			width  = pkl->height;
-			height = pkl->width;
-			sx     = 0;
-			sy     = -(pkl->width-1);
-			ex     = pkl->height-1;
-			ey     = 0;
-			break;
-		case PKL_ANGLE_180:
-			rcos   = -1;
-			rsin   =  0;
-			width  = pkl->width;
-			height = pkl->height;
-			sx     = -(pkl->width-1);
-			sy     = -(pkl->height-1);
-			ex     = 0;
-			ey     = 0;
-			break;
-		case PKL_ANGLE_270:
-			rcos   =  0;
-			rsin   = -1;
-			width  = pkl->height;
-			height = pkl->width;
-			sx     = -(pkl->height-1);
-			sy     = 0;
-			ex     = 0;
-			ey     = pkl->width-1;
-			break;
+	/* 90�x�̔{�p���ǂ����ŏ����𕪂���(�덷����̂���) */
+	if((int)angle%90){
+		return rotate_custom(pkl, angle, sample, backcolor);
+	}else{
+		return rotate_90(pkl, angle);
+	}
+	return(1);
+}
+
+//=============================================================================
+// rotate_90
+//=============================================================================
+static int rotate_90(PKLImage pkl, float angle)
+{
+	PIKL_ROTATE ri;
+	float c, s, rad;
+	
+	rad = -angle*M_PI/180.0;
+	c = cos(rad);
+	s = sin(rad);
+	ri.rcos = (int)c==0 ? 0.0 : (int)c==1 ? 1.0 : -1.0;
+	ri.rsin = (int)s==0 ? 0.0 : (int)s==1 ? 1.0 : -1.0;
+	
+	/*90*/
+	if(ri.rcos==0 && ri.rsin==1){
+		ri.width  = pkl->height;
+		ri.height = pkl->width;
+		ri.sx     = 0;
+		ri.sy     = -(pkl->width-1);
+		ri.ex     = pkl->height-1;
+		ri.ey     = 0;
+	}else
+	/*180*/
+	if(ri.rcos==-1 && ri.rsin==0){
+		ri.width  = pkl->width;
+		ri.height = pkl->height;
+		ri.sx     = -(pkl->width-1);
+		ri.sy     = -(pkl->height-1);
+		ri.ex     = 0;
+		ri.ey     = 0;
+	}else
+	/*270*/
+	if(ri.rcos==0 && ri.rsin==-1){
+		ri.width  = pkl->height;
+		ri.height = pkl->width;
+		ri.sx     = -(pkl->height-1);
+		ri.sy     = 0;
+		ri.ex     = 0;
+		ri.ey     = pkl->width-1;
+	}
+	
+	return pkl_rotate_nr(pkl, &ri);
+}
+
+//=============================================================================
+// rotate_custom
+//=============================================================================
+static int rotate_custom(PKLImage pkl, float angle, PKL_SAMPLE sample, PKLColor backcolor)
+{
+	PIKL_ROTATE ri;
+	float rad;
+	int px[4], py[4], i, x, y;
+	
+	rad = -angle*M_PI/180.0;
+	ri.rcos = cos(rad);
+	ri.rsin = sin(rad);
+	
+	px[0] = 0;
+	py[0] = 0;
+	px[1] = pkl->width;
+	py[1] = 0;
+	px[2] = 0;
+	py[2] = pkl->height;
+	px[3] = pkl->width;
+	py[3] = pkl->height;
+	
+	for(i=0; i<4; i++){
+		x = (int)(cos(-rad)*px[i] - sin(-rad)*py[i]);
+		y = (int)(sin(-rad)*px[i] + cos(-rad)*py[i]);
+		px[i] = x;
+		py[i] = y;
+	}
+	
+	//�����ɕ��т���(qsort���g���ƒx���̂Ńo�u���\�[�g�A���S���Y����)
+	bsort(px);
+	bsort(py);
+	ri.sx = px[0];
+	ri.sy = py[0];
+	ri.ex = px[3];
+	ri.ey = py[3];
+	ri.width = ri.ex - ri.sx;
+	ri.height = ri.ey - ri.sy;
+	
+	//for(i=0; i<pkl->channel; i++)
+	//	ri.back[i] = (backcolor>>((pkl->channel-i)*8) & 0xFF);
+	if(backcolor)
+		memcpy(ri.back, backcolor->color, PKL_CHANNEL);
+	else
+		memset(ri.back, 0xff, PKL_CHANNEL);
+
+	switch(sample){
+		case PKL_SAMPLE_BL:
+			return pkl_rotate_bl(pkl, &ri);
+		case PKL_SAMPLE_BC:
+		case PKL_SAMPLE_PA:
+		case PKL_SAMPLE_LZ:
+			return pkl_rotate_bc(pkl, &ri);
+		case PKL_SAMPLE_NN:
 		default:
-			return(1);
+			return pkl_rotate_nn(pkl, &ri);
 	}
+	return(1);
+}
+
+//=============================================================================
+// bsort
+//=============================================================================
+static void bsort(int *p)
+{
+	int i, j, k, t;
 	
-	wrk = malloc(width * height * pkl->channel);
-	if(!wrk) return(1);
+	k=3;
+	while(k>=0){
+		j=-1;
+		for(i=1; i<=k; i++){
+			if(p[i-1] > p[i]){
+				j = i-1;
+				t=p[j]; p[i-1]=p[i]; p[i]=t;
+			}
+		}
+		k=j;
+	}
+}
 
-	for(i=sy; i<=ey; i++){
-		for(j=sx; j<=ex; j++){
-			x = rcos * j - rsin * i;
-			y = rsin * j + rcos * i;
-			memcpy(&wrk[((i-sy)*width+j-sx)*pkl->channel], &pkl->image[(y*pkl->width+x)*pkl->channel], pkl->channel);
+//=============================================================================
+// pkl_rotate_nr
+//=============================================================================
+static int pkl_rotate_nr(PKLImage pkl, PIKL_ROTATE *ri)
+{
+	unsigned char *wrk;
+	int i, j, px, py;
+	
+	wrk = malloc(ri->width * ri->height * pkl->channel);
+	if(!wrk) return(1);
+	
+	for(i=ri->sy; i<=ri->ey; i++){
+		for(j=ri->sx; j<=ri->ex; j++){
+			px = (int)ri->rcos * j - (int)ri->rsin * i;
+			py = (int)ri->rsin * j + (int)ri->rcos * i;
+			memcpy(&wrk[((i-ri->sy)*ri->width+j-ri->sx)*pkl->channel], &pkl->image[(py*pkl->width+px)*pkl->channel], pkl->channel);
 		}
 	}
 	
 	free(pkl->image);
-	pkl->image  = wrk;
-	pkl->width  = width;
-	pkl->height = height;
+	pkl->image = wrk;
+	pkl->width = ri->width;
+	pkl->height = ri->height;
+	return(0);
+}
+
+//=============================================================================
+// pkl_rotate_nn
+//=============================================================================
+static int pkl_rotate_nn(PKLImage pkl, PIKL_ROTATE *ri)
+{
+	unsigned char *wrk;
+	int i, j, px, py;
+	float x, y;
 	
+	wrk = malloc(ri->width * ri->height * pkl->channel);
+	if(!wrk) return(1);
+	
+	for(i=ri->sy; i<ri->ey; i++){
+		for(j=ri->sx; j<ri->ex; j++){
+			x = ri->rcos * j - ri->rsin * i;
+			y = ri->rsin * j + ri->rcos * i;
+			px = x < 0.0f ? (int)(x-0.5f) : (int)(x+0.5f);
+			py = y < 0.0f ? (int)(y-0.5f) : (int)(y+0.5f);
+			//px = ri->rcos * j - ri->rsin * i;
+			//py = ri->rsin * j + ri->rcos * i;
+			if(px>=0 && px<pkl->width && py>=0 && py<pkl->height){
+				memcpy(&wrk[((i-ri->sy)*ri->width+j-ri->sx)*pkl->channel],
+					&pkl->image[(py*pkl->width+px)*pkl->channel], pkl->channel);
+			}else{
+				memcpy(&wrk[((i-ri->sy)*ri->width+j-ri->sx)*pkl->channel], ri->back, pkl->channel);
+			}
+		}
+	}
+
+	free(pkl->image);
+	pkl->image = wrk;
+	pkl->width = ri->width;
+	pkl->height = ri->height;
 	return(0);
 }
 
+//=============================================================================
+// pkl_rotate_bl
+//	+----+----+
+//	| d0 | d1 |
+//	+----+----+
+//	| d2 | d3 |
+//	+----+----+
+//=============================================================================
+static int pkl_rotate_bl(PKLImage pkl, PIKL_ROTATE *ri)
+{
+	unsigned char *wrk, *d0, *d1, *d2, *d3;
+	int p0x, p0y, i, j, k;
+	double dx, dy, fracx, fracy;
+	double pixel[PKL_CHANNEL];
+	
+	wrk = malloc(ri->width * ri->height * pkl->channel);
+	if(!wrk) return(1);
+
+	for(i=ri->sy; i<ri->ey; i++){
+		for(j=ri->sx; j<ri->ex; j++){
+			dx = ri->rcos*j-ri->rsin*i;
+			dy = ri->rsin*j+ri->rcos*i;
+			p0x = (int)floor(dx);
+			p0y = (int)floor(dy);
+			fracx = dx - p0x;
+			fracy = dy - p0y;
+			//if(p0x<0 || p0x>=pkl->width || p0y<0 || p0y>=pkl->height){
+			if(p0x<-1 || p0x>=pkl->width || p0y<-1 || p0y>=pkl->height){
+				memcpy(&wrk[((i-ri->sy)*ri->width+j-ri->sx)*pkl->channel], ri->back, pkl->channel);
+				continue;
+			}
+			
+			//if((p0x==-1 && p0y==-1) || (p0x+1>=pkl->width && p0y+1>=pkl->height)){
+			if((p0x==-1 && p0y==-1) || (p0x+1>=pkl->width && p0y+1>=pkl->height) ||
+			   (p0x==-1 && p0y+1>=pkl->height) || (p0x+1>=pkl->width && p0y==-1)){
+				//�e���_
+				d0 = &pkl->image[(p0y*pkl->width+p0x)*pkl->channel];
+				d1 = &pkl->image[(p0y*pkl->width+p0x)*pkl->channel];
+				d2 = &pkl->image[(p0y*pkl->width+p0x)*pkl->channel];
+				d3 = &pkl->image[(p0y*pkl->width+p0x)*pkl->channel];
+			}else{
+				if(p0x==-1 && p0y>-1){
+					//���G�b�W
+					d0 = ri->back;
+					d1 = &pkl->image[(p0y*pkl->width+p0x+1)*pkl->channel];
+					d2 = ri->back;
+					d3 = &pkl->image[((p0y+1)*pkl->width+p0x+1)*pkl->channel];
+				}else if(p0x>-1 && p0y==-1){
+					//��G�b�W
+					d0 = ri->back;
+					d1 = ri->back;
+					d2 = &pkl->image[((p0y+1)*pkl->width+p0x)*pkl->channel];
+					d3 = &pkl->image[((p0y+1)*pkl->width+p0x+1)*pkl->channel];
+				}else if(p0x+1<pkl->width && p0y+1>=pkl->height){
+					//���G�b�W
+					d0 = &pkl->image[(p0y*pkl->width+p0x)*pkl->channel];
+					d1 = &pkl->image[(p0y*pkl->width+p0x+1)*pkl->channel];
+					d2 = ri->back;
+					d3 = ri->back;
+				}else if(p0x+1>=pkl->width && p0y+1<pkl->height){
+					//�E�G�b�W
+					d0 = &pkl->image[(p0y*pkl->width+p0x)*pkl->channel];
+					d1 = ri->back;
+					d2 = &pkl->image[((p0y+1)*pkl->width+p0x)*pkl->channel];
+					d3 = ri->back;
+				}else{
+					//�G�b�W�ȊO
+					d0 = &pkl->image[(p0y*pkl->width+p0x)*pkl->channel];
+					d1 = &pkl->image[(p0y*pkl->width+p0x+1)*pkl->channel];
+					d2 = &pkl->image[((p0y+1)*pkl->width+p0x)*pkl->channel];
+					d3 = &pkl->image[((p0y+1)*pkl->width+p0x+1)*pkl->channel];
+				}
+			}
+			
+			memset(pixel, 0, sizeof(double)*PKL_CHANNEL);
+			for(k=0; k<pkl->channel; k++){
+				pixel[k] += d0[k] * (1-fracx)*(1-fracy);
+				pixel[k] += d1[k] * fracx*(1-fracy);
+				pixel[k] += d2[k] * (1-fracx)*fracy;
+				pixel[k] += d3[k] * fracx*fracy;
+			}
+			for(k=0; k<pkl->channel; k++)
+				wrk[((i-ri->sy)*ri->width+j-ri->sx)*pkl->channel+k] = PKL_COLOR_CLIP(pixel[k]);
+		}
+	}
+
+	free(pkl->image);
+	pkl->image = wrk;
+	pkl->width = ri->width;
+	pkl->height = ri->height;
+	return(0);
+}
+
+//=============================================================================
+// pkl_rotate_bc
+//=============================================================================
+static int pkl_rotate_bc(PKLImage pkl, PIKL_ROTATE *ri)
+{
+	unsigned char *wrk;
+	int i, j, k, px, py;
+	float wx, wy, dx, dy, sx, sy;
+	float data[PKL_CHANNEL];
+
+	wrk = malloc(ri->width * ri->height * pkl->channel);
+	if(!wrk) return(1);
+	
+	for(i=ri->sy; i<ri->ey; i++){
+		for(j=ri->sx; j<ri->ex; j++){
+			sx = ri->rcos * j - ri->rsin * i;
+			sy = ri->rsin * j + ri->rcos * i;
+			
+			if(sx<0 || sx>=pkl->width || sy<0 || sy>=pkl->height){
+				memcpy(&wrk[((i-ri->sy)*ri->width+j-ri->sx)*pkl->channel], ri->back, pkl->channel);
+				continue;
+			}
+			
+			memset(&data, 0, sizeof(data));
+			for(py=(int)sy-1; py<=(int)sy+2; py++){
+				for(px=(int)sx-1; px<=(int)sx+2; px++){
+					dx = fabs(sx-px);
+					dy = fabs(sy-py);
+					wx = (dx<1) ? (dx-1)*(dx*dx-dx-1) : -(dx-1)*(dx-2)*(dx-2);
+					wy = (dy<1) ? (dy-1)*(dy*dy-dy-1) : -(dy-1)*(dy-2)*(dy-2);
+					
+					if(px>=0 && px<pkl->width && py>=0 && py<pkl->height){
+						for(k=0; k<pkl->channel; k++)
+							data[k] += pkl->image[(py*pkl->width+px)*pkl->channel+k]*wx*wy;
+					}else{
+						for(k=0; k<pkl->channel; k++)
+							data[k] += ri->back[k]*wx*wy;
+					}
+				}
+			}
+			for(k=0; k<pkl->channel; k++)
+				wrk[((i-ri->sy)*ri->width+j-ri->sx)*pkl->channel+k] = PKL_COLOR_CLIP(data[k]);
+		}
+	}
+
+	free(pkl->image);
+	pkl->image = wrk;
+	pkl->width = ri->width;
+	pkl->height = ri->height;
+	return(0);
+}
 
+////=============================================================================
+//// pkl_rotate_pa
+////=============================================================================
+//static int pkl_rotate_pa(PKLImage pkl, float angle, int backcolor)
+//{
+//	int width, height;
+//	PIKL_RECT rect;
+//	float rad;
+//	unsigned char *wrk, back[PKL_CHANNEL];
+//	int i, j;
+//	double zx, zy, power;
+//	
+//	rad = -angle*M_PI/180;
+//	get_rect(&rect, pkl->width, pkl->height, rad);
+//	width = rect.right - rect.left;
+//	height = rect.bottom - rect.top;
+//
+//	wrk = malloc(width * height * pkl->channel);
+//	if(!wrk) return(1);
+//	memset(wrk, 0, width*height*pkl->channel);
+//	
+//	for(i=0; i<pkl->channel; i++)
+//		back[i] = (backcolor>>((pkl->channel-i)*8) & 0xFF);
+//
+//	zx = (double)pkl->width  / (double)width;
+//	zy = (double)pkl->height / (double)height;
+//	//���_�����������ϒl�Z�o�l
+//	power= zx*zy + (zx*zy * angle*M_PI/180 * angle*M_PI/180);
+//
+//	for(i=rect.top; i<rect.bottom; i++){
+//		for(j=rect.left; j<rect.right; j++){
+//			double w1, w2, h1, h2;
+//			double w1b, w2b, h1b, h2b;
+//			double bi, ixg[PKL_CHANNEL] = {0.0, 0.0, 0.0, 0.0};
+//			int fsx ,fsy, s, t, k;
+//			
+//			w1b = modf(cos(rad)*j    -sin(rad)*i,     &w1);
+//			w2b = modf(cos(rad)*(j+1)-sin(rad)*i, &w2);
+//			h1b = modf(sin(rad)*j    +cos(rad)*i,     &h1);
+//			h2b = modf(sin(rad)*j+cos(rad)*(i+1), &h2);
+//
+//			for(s=(int)w1; s<=(int)w2; s++){
+//				for(t=(int)h1; t<=(int)h2; t++){
+//					bi = 1.0;
+//					if(s == (int)w1) bi*=(1-w1b);
+//					if(s == (int)w2) bi*=(w2b);
+//					if(t == (int)h1) bi*=(1-h1b);
+//					if(t == (int)h2) bi*=(h2b);
+//					fsx = (s < 0) ? 0 : (s > pkl->width -1) ? pkl->width -1 : s;
+//					fsy = (t < 0) ? 0 : (t > pkl->height-1) ? pkl->height-1 : t;
+//					for(k=0; k<pkl->channel; k++)
+//						ixg[k] += pkl->image[(fsy*pkl->width+fsx)*pkl->channel+k] * bi;
+//				}
+//			}
+//			
+//			if((int)w1>=0 && (int)w1<pkl->width && (int)h1>=0 && (int)h1<pkl->height){
+//				for(k=0; k<pkl->channel; k++)
+//					wrk[((i-rect.top)*width+j-rect.left)*pkl->channel+k] = PKL_RGB(ixg[k]/power);
+//			}else{
+//				memcpy(&wrk[((i-rect.top)*width+j-rect.left)*pkl->channel], back, pkl->channel);
+//			}
+//
+//		}
+//	}
+//	free(pkl->image);
+//	pkl->image = wrk;
+//	pkl->width = width;
+//	pkl->height = height;
+//	return(0);
+//}