pikl 0.2.8 → 0.3.0

data/ext/pikl/pikl_affine.c

@@ -3,55 +3,26 @@
 static int pkl_affine_nn(PKLImage pkl, point2 *p, unsigned char *dst);
 static int pkl_affine_bl(PKLImage pkl, point2 *p, unsigned char *dst);
 static point2 *transform(matrix *mat, int x, int y, point2 *p);
-static matrix *pkl_matrix(PKLImage pkl, matrix *mat);
-
+static matrix *pkl_matrix(PKLImage pkl, matrix *mat, double x_scale, double y_scale, double angle, int x, int y);
 static void matrix_init(matrix *mat);
-static void matrix_scale(matrix *mat, double x_scale, double y_scale);
-static void matrix_translate(matrix *mat, double x_trns, double y_trns);
-static void matrix_rotate(matrix *mat, double angle);
 static void matrix_build(matrix *mat1, matrix *mat2);
 
-//=============================================================================
-// pkl_matrix_scale
-//=============================================================================
-PKLExport void pkl_matrix_scale(PKLImage pkl, double x_scale, double y_scale)
-{
-	pkl->x_scale = x_scale;
-	pkl->y_scale = y_scale;
-}
-
-//=============================================================================
-// pkl_matrix_rotate
-//=============================================================================
-PKLExport void pkl_matrix_rotate(PKLImage pkl, double angle)
-{
-	pkl->angle = angle;
-}
-
-//=============================================================================
-// pkl_matrix_translate
-//=============================================================================
-PKLExport void pkl_matrix_translate(PKLImage pkl, int x, int y)
-{
-	pkl->x_trns = x;
-	pkl->y_trns = y;
-}
-
 //=============================================================================
 // pkl_affine
 //=============================================================================
-PKLExport int pkl_affine(PKLImage pkl, PKL_SAMPLE sampler, int width, int height, int backcolor)
+PKLExport int pkl_affine(PKLImage pkl, PKL_SAMPLE sampler, int width, int height, PKLColor backcolor,
+                                               double x_scale, double y_scale, double angle, int x, int y)
 {
 	int (*sample)(PKLImage pkl, point2 *p, unsigned char *dst);
-	unsigned char *wrk, back[4];
+	unsigned char *wrk, back[PKL_CHANNEL];
 	int i, j;
 	point2 p;
 	matrix mat;
 	
 	//affine-matrix�̍\�z
-	pkl_matrix(pkl, &mat);
+	pkl_matrix(pkl, &mat, x_scale, y_scale, angle, x, y);
 	
-	//�T���v�����O��ݒ�
+	//�T���v�����O���o�C���h
 	switch(sampler){
 		case PKL_SAMPLE_NN:
 			sample = pkl_affine_nn;
@@ -62,11 +33,14 @@ PKLExport int pkl_affine(PKLImage pkl, PKL_SAMPLE sampler, int width, int height
 	
 	wrk = malloc(width * height * pkl->channel);
 	if(!wrk) return(1);
-	memset(wrk, 0, width*height*pkl->channel);
 	
 	//�w�i�F�����
-	for(i=0; i<pkl->channel; i++)
-		back[i] = (backcolor>>((pkl->channel-i)*8) & 0xFF);
+	//for(i=0; i<pkl->channel; i++)
+	//	back[i] = (backcolor>>((pkl->channel-i)*8) & 0xFF);
+	if(backcolor)
+		memcpy(back, backcolor->color, PKL_CHANNEL);
+	else
+		memset(back, 0xff, PKL_CHANNEL);
 	
 	//�ό`��T�C�Y��loop
 	for(i=0; i<height; i++){
@@ -100,7 +74,6 @@ static int pkl_affine_nn(PKLImage pkl, point2 *p, unsigned char *dst)
 	return(1);
 }
 
-
 //=============================================================================
 // pkl_affine_bl
 //=============================================================================
@@ -139,7 +112,7 @@ static int pkl_affine_bl(PKLImage pkl, point2 *p, unsigned char *dst)
 			}
 		}else{
 			for(i=0; i<pkl->channel; i++)
-				pixel[i] += pkl->image[((p0y+1)*pkl->width+p0x)*pkl->channel+i];
+				pixel[i] += pkl->image[(p0y*pkl->width+p0x)*pkl->channel+i];
 		}
 	}
 
@@ -148,25 +121,46 @@ static int pkl_affine_bl(PKLImage pkl, point2 *p, unsigned char *dst)
 	return(0);
 }
 
+//=============================================================================
+// transform
+//=============================================================================
+static point2 *transform(matrix *mat, int x, int y, point2 *p)
+{
+	p->x = mat->a*x + mat->c*y + mat->e;
+	p->y = mat->b*x + mat->d*y + mat->f;
+	return p;
+}
+
 //=============================================================================
 // pkl_matrix
 //=============================================================================
-static matrix *pkl_matrix(PKLImage pkl, matrix *mat)
+static matrix *pkl_matrix(PKLImage pkl, matrix *mat, double x_scale, double y_scale, double angle, int x, int y)
 {
 	matrix mat2;
+	double c, s;
 	
 	matrix_init(mat);
 	
 	//scale
-	matrix_scale(&mat2, pkl->x_scale, pkl->y_scale);
+	matrix_init(&mat2);
+	mat2.a = x_scale;
+	mat2.d = y_scale;
 	matrix_build(mat, &mat2);
 	
 	//rotate
-	matrix_rotate(&mat2, pkl->angle);
+	matrix_init(&mat2);
+	c = cos(angle*3.14/180.0);
+	s = sin(angle*3.14/180.0);
+	mat2.a = c;
+	mat2.b = s;
+	mat2.c = -s;
+	mat2.d = c;
 	matrix_build(mat, &mat2);
 	
 	//translate
-	matrix_translate(&mat2, pkl->x_trns, pkl->y_trns);
+	matrix_init(&mat2);
+	mat2.e = x;
+	mat2.f = y;
 	matrix_build(mat, &mat2);
 	
 	return(mat);
@@ -185,43 +179,6 @@ static void matrix_init(matrix *mat)
 	mat->f = 0.0;
 }
 
-//=============================================================================
-// matrix_init
-//=============================================================================
-static void matrix_scale(matrix *mat, double x_scale, double y_scale)
-{
-	matrix_init(mat);
-	mat->a = x_scale;
-	mat->d = y_scale;
-}
-
-//=============================================================================
-// matrix_translate
-//=============================================================================
-static void matrix_translate(matrix *mat, double x_trns, double y_trns)
-{
-	matrix_init(mat);
-	mat->e = x_trns;
-	mat->f = y_trns;
-}
-
-//=============================================================================
-// matrix_rotate
-//=============================================================================
-static void matrix_rotate(matrix *mat, double angle)
-{
-	double c, s;
-	
-	matrix_init(mat);
-	
-	c = cos(angle*3.14/180.0);
-	s = sin(angle*3.14/180.0);
-	mat->a = c;
-	mat->b = s;
-	mat->c = -s;
-	mat->d = c;
-}
-
 //=============================================================================
 // matrix_init
 //=============================================================================
@@ -238,13 +195,3 @@ static void matrix_build(matrix *mat1, matrix *mat2)
 	mat1->f = mat.e * mat2->b + mat.f * mat2->d + mat2->f;
 }
 
-//=============================================================================
-// transform
-//=============================================================================
-static point2 *transform(matrix *mat, int x, int y, point2 *p)
-{
-	p->x = mat->a*x + mat->c*y + mat->e;
-	p->y = mat->b*x + mat->d*y + mat->f;
-	return p;
-}
-

data/ext/pikl/pikl_blur.c

@@ -13,7 +13,6 @@ PKLExport int pkl_blur(PKLImage pkl, int weight)
 	
 	wrk = malloc(pkl->height * pkl->width * pkl->channel);
 	if(!wrk) return(1);
-	memset(wrk, 0, pkl->height * pkl->width * pkl->channel);
 	
 	for(i=0; i<pkl->height; i++){
 		for(j=0; j<pkl->width; j++){
@@ -22,11 +21,10 @@ PKLExport int pkl_blur(PKLImage pkl, int weight)
 			
 			for(p=-weight; p<=weight; p++){
 				for(q=-weight; q<=weight; 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++;
-					}
+					if(j+q<0 || j+q>=pkl->width || i+p<0 || i+p>=pkl->height) continue;
+					for(k=0; k<pkl->channel; k++)
+						stock[k] += pkl->image[((i+p)*pkl->width+(j+q))*pkl->channel+k];
+					cnt++;
 				}
 			}
 			if(cnt==0) continue;
@@ -53,7 +51,6 @@ PKLExport int pkl_gaussblur(PKLImage pkl, double weight)
 	
 	wrk = malloc(pkl->height * pkl->width * pkl->channel);
 	if(!wrk) return(1);
-	memset(wrk, 0, pkl->height * pkl->width * pkl->channel);
 
 	range = weight * 3;
 	gauss = malloc(sizeof(double)*(range+1));
@@ -102,7 +99,6 @@ PKLExport int pkl_gaussblur(PKLImage pkl, double weight)
 	return(0);
 }
 
-
 //=============================================================================
 // pkl_rblur(����)
 //=============================================================================

data/ext/pikl/pikl_camera.c

@@ -0,0 +1,218 @@
+#include "pikl_camera.h"
+
+//=============================================================================
+// pkl_vignette
+//=============================================================================
+PKLExport int pkl_vignette(PKLImage pkl, PKLColor color, int trans, int radius, int x, int y)
+{
+	double t, t1, tr, r, rr, a, w;
+	unsigned char *p, at[PKL_CHANNEL][PKL_COLOR];
+	int i, j, k, cx, cy;;
+	
+	if(trans<0 || trans>100) return(1);
+	if(!color) return(1);
+
+	t = (double)trans/100.0;
+	t1 = 1.0 - t;
+
+	for(i=0; i<pkl->channel; i++){
+		w = (double)color->color[i]/255.0;
+		for(j=0; j<PKL_COLOR; j++)
+			at[i][j] = PKL_COLOR_CLIP((double)j * (t+t1 * w));
+	}
+
+	cx = (x<0 || x>=pkl->width) ? pkl->width/2 : x;
+	cy = (y<0 || y>=pkl->height) ? pkl->height/2 : y;
+	
+	for(i=0; i<pkl->height; i++){
+		for(j=0; j<pkl->width; j++){
+			r = sqrt((cx-j)*(cx-j) + (cy-i)*(cy-i));
+			p = &pkl->image[(i*pkl->width+j)*pkl->channel];
+			if(r > radius){
+				for(k=0; k<pkl->channel; k++)
+					*(p+k) = at[k][*(p+k)];
+			}else{
+				rr = r/(double)radius;
+				tr = 1.2 - 1.2 * rr * rr;
+				a = 1.0 < tr ? 1.0 : tr;
+				
+				for(k=0; k<pkl->channel; k++)
+					*(p+k) = PKL_COLOR_CLIP((1.0-a) * at[k][*(p+k)] + a * *(p+k));
+			}
+		}
+	}
+	return(0);
+}
+
+//=================================================================================
+// pkl_vaseline
+//=================================================================================
+PKLExport int pkl_vaseline(PKLImage pkl, int radius, int x, int y)
+{
+	int i, j, s, t, k, z, cnt, stock[PKL_CHANNEL], cx, cy;
+	unsigned char *wrk;
+	double r;
+	
+	wrk = malloc(pkl->width*pkl->height*pkl->channel);
+	if(!wrk) return(1);
+	memcpy(wrk, pkl->image, pkl->width*pkl->height*pkl->channel);
+	
+	cx = (x<0 || x>=pkl->width) ? pkl->width/2 : x;
+	cy = (y<0 || y>=pkl->height) ? pkl->height/2 : y;
+	
+	for(i=0; i<pkl->height; i++){
+		for(j=0; j<pkl->width; j++){
+			r = sqrt((j-cx)*(j-cx)+(i-cy)*(i-cy));
+			z = (int)((r-radius)*0.2);
+			z = z>10 ? 10 : z;
+
+			cnt = 0;
+			memset(stock, 0, sizeof(stock));
+			
+			for(s=i-z; s<=i+z; s++){
+				for(t=j-z; t<=j+z; t++){
+					if(s<0 || s>=pkl->height || t<0 || t>=pkl->width) continue;
+					for(k=0; k<pkl->channel; k++)
+						stock[k] += pkl->image[(s*pkl->width+t)*pkl->channel+k];
+					cnt++;
+				}
+			}
+			if(cnt){
+				for(k=0; k<pkl->channel; k++)
+					wrk[(i*pkl->width+j)*pkl->channel+k] = PKL_COLOR_CLIP(stock[k]/cnt);
+			}
+		}
+	}
+	free(pkl->image);
+	pkl->image= wrk;
+	return(0);
+}
+
+//=============================================================================
+// pkl_vv
+//=============================================================================
+PKLExport int pkl_vv(PKLImage pkl, PKLColor color, int trans, int radius, int x, int y)
+{
+	double t, t1, tr, r, rr, a, w;
+	unsigned char at[PKL_CHANNEL][PKL_COLOR], *wrk;
+	int i, j, k, p, q, offset, cnt, stock[PKL_CHANNEL], cx, cy;
+	
+	if(trans<0 || trans>100) return(1);
+	if(!color) return(1);
+
+	wrk = malloc(pkl->width*pkl->height*pkl->channel);
+	if(!wrk) return(1);
+
+	t = (double)trans/100.0;
+	t1 = 1.0 - t;
+
+	for(i=0; i<pkl->channel; i++){
+		w = (double)color->color[i]/255.0;
+		for(j=0; j<PKL_COLOR; j++)
+			at[i][j] = PKL_COLOR_CLIP((double)j * (t+t1 * w));
+	}
+
+	cx = (x<0 || x>=pkl->width) ? pkl->width/2 : x;
+	cy = (y<0 || y>=pkl->height) ? pkl->height/2 : y;
+	
+	for(i=0; i<pkl->height; i++){
+		for(j=0; j<pkl->width; j++){
+			r = sqrt((cx-j)*(cx-j) + (cy-i)*(cy-i));
+			if(r > radius){
+				offset = (int)((r-radius)*0.2);	//0.2��ς��邱�ƂŁA�ڂ�������ς��
+				offset = offset>10 ? 10 : offset;
+				cnt = 0;
+				memset(stock, 0, sizeof(stock));
+				
+				for(p=i-offset; p<=i+offset; p++){
+					for(q=j-offset; q<=j+offset; q++){
+						if(p<0 || p>=pkl->height || q<0 || q>=pkl->width) continue;
+						for(k=0; k<pkl->channel; k++)
+							stock[k] += pkl->image[(p*pkl->width+q)*pkl->channel+k];
+						cnt++;
+					}
+				}
+				
+				if(cnt==0) continue;
+				for(k=0; k<pkl->channel; k++)
+					wrk[(i*pkl->width+j)*pkl->channel+k] = at[k][PKL_COLOR_CLIP(stock[k]/cnt)];
+			}else{
+				rr = r/(double)radius;
+				tr = 1.2 - 1.2 * rr * rr;
+				a = 1.0 < tr ? 1.0 : tr;
+				for(k=0; k<pkl->channel; k++)
+					wrk[(i*pkl->width+j)*pkl->channel+k] = 
+						PKL_COLOR_CLIP((1.0-a) * at[k][pkl->image[(i*pkl->width+j)*pkl->channel+k]] +
+						a * pkl->image[(i*pkl->width+j)*pkl->channel+k]);
+			}
+		}
+	}
+	
+	free(pkl->image);
+	pkl->image=wrk;
+	return(0);
+}
+
+//=============================================================================
+// pkl_film
+//=============================================================================
+PKLExport int pkl_film(PKLImage pkl, PKLColor color, int trans)
+{
+	double t, t1, w;
+	unsigned char at[PKL_CHANNEL][PKL_COLOR];
+	int i, j, k;
+	
+	if(trans<0 || trans>100) return(1);
+	if(!color) return(1);
+
+	t = (double)trans/100.0;
+	t1 = 1.0 - t;
+
+	for(i=0; i<pkl->channel; i++){
+		w = (double)color->color[i]/255.0;
+		for(j=0; j<PKL_COLOR; j++)
+			at[i][j] = PKL_COLOR_CLIP((double)j * (t+t1 * w));
+	}
+	
+	for(i=0; i<pkl->height; i++){
+		for(j=0; j<pkl->width; j++){
+			for(k=0; k<pkl->channel; k++)
+				pkl->image[(i*pkl->width+j)*pkl->channel+k] = at[k][pkl->image[(i*pkl->width+j)*pkl->channel+k]];
+		}
+	}
+	return(0);
+}
+
+////=============================================================================
+//// pkl_spotlight
+////=============================================================================
+//PKLExport int pkl_spotlight(PKLImage pkl, int radius, PKLColor color, int trans)
+//{
+//	int i, j, k;
+//	double rr, r, f, cx, cy, tr;
+//
+//	if(radius < 0) return(1);
+//	
+//	tr = (double)trans/100.0;
+//	rr = radius * radius;
+//	cx = (double)pkl->width/2.0;
+//	cy = (double)pkl->height/2.0;
+//	
+//	for(i=0; i<pkl->height; i++){
+//		for(j=0; j<pkl->width; j++){
+//			r = (j-cx)*(j-cx) + (i-cy)*(i-cy);
+//			f = 1.2 * (1.0 - r / rr);
+//			f = f > 1.0 ? 1.0 : f;
+//			
+//			if(f > 0.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]*tr*f + color->color[k]*(1.0-tr*f));
+//			}else{
+//				memcpy(&pkl->image[(i*pkl->width+j)*pkl->channel], color, pkl->channel);
+//			}
+//		}
+//	}
+//	return(0);
+//}
+//