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

data/ext/pikl/decrease/wu.h

@@ -0,0 +1,7 @@
+#ifndef _EXTRA_WU_
+#define _EXTRA_WU_
+
+int wuReduce(unsigned char *RGBpic, int numcolors, long picsize,
+			unsigned char *Picture256, unsigned char *QuantizedPalette);
+
+#endif

data/ext/pikl/pikl_affine.c

@@ -0,0 +1,250 @@
+#include "pikl_affine.h"
+
+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 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)
+{
+	int (*sample)(PKLImage pkl, point2 *p, unsigned char *dst);
+	unsigned char *wrk, back[4];
+	int i, j;
+	point2 p;
+	matrix mat;
+	
+	//affine-matrix�̍\�z
+	pkl_matrix(pkl, &mat);
+	
+	//�T���v�����O��ݒ�
+	switch(sampler){
+		case PKL_SAMPLE_NN:
+			sample = pkl_affine_nn;
+			break;
+		default:
+			sample = pkl_affine_bl;
+	}
+	
+	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);
+	
+	//�ό`��T�C�Y��loop
+	for(i=0; i<height; i++){
+		for(j=0; j<width; j++){
+			if(sample(pkl, transform(&mat, j, i, &p), &wrk[(i*width+j)*pkl->channel]))
+				memcpy(&wrk[(i*width+j)*pkl->channel], back, pkl->channel);
+		}
+	}
+	
+	free(pkl->image);
+	pkl->image = wrk;
+	pkl->width = width;
+	pkl->height = height;
+	return(0);
+}
+
+//=============================================================================
+// pkl_affine_nn
+//=============================================================================
+static int pkl_affine_nn(PKLImage pkl, point2 *p, unsigned char *dst)
+{
+	int x, y;
+	
+	x = p->x < 0.0f ? (int)(p->x-0.5f) : (int)(p->x+0.5f);
+	y = p->y < 0.0f ? (int)(p->y-0.5f) : (int)(p->y+0.5f);
+	
+	if(x>=0 && x<pkl->width && y>=0 && y<pkl->height){
+		memcpy(dst, &pkl->image[(y*pkl->width+x)*pkl->channel], pkl->channel);
+		return(0);
+	}
+	return(1);
+}
+
+
+//=============================================================================
+// pkl_affine_bl
+//=============================================================================
+static int pkl_affine_bl(PKLImage pkl, point2 *p, unsigned char *dst)
+{
+	int p0x, p0y, i;
+	double fracx, fracy;
+	double pixel[PKL_CHANNEL];
+	
+	memset(pixel, 0, sizeof(double)*PKL_CHANNEL);
+	p0x = (int)floor(p->x);
+	p0y = (int)floor(p->y);
+	fracx = p->x - p0x;
+	fracy = p->y - p0y;
+	if(p0x<0 || p0x>=pkl->width || p0y<0 || p0y>=pkl->height) return(1);
+	
+	if(p0x+1 < pkl->width){
+		if(p0y+1 < pkl->height){
+			for(i=0; i<pkl->channel; i++){
+				pixel[i] += pkl->image[(p0y*pkl->width+p0x)*pkl->channel+i] * (1-fracx)*(1-fracy);
+				pixel[i] += pkl->image[(p0y*pkl->width+p0x+1)*pkl->channel+i] * fracx*(1-fracy);
+				pixel[i] += pkl->image[((p0y+1)*pkl->width+p0x)*pkl->channel+i] * (1-fracx)*fracy;
+				pixel[i] += pkl->image[((p0y+1)*pkl->width+p0x+1)*pkl->channel+i] * fracx*fracy;
+			}
+		}else{
+			for(i=0; i<pkl->channel; i++){
+				pixel[i] += pkl->image[(p0y*pkl->width+p0x)*pkl->channel+i] * (1-fracx);
+				pixel[i] += pkl->image[(p0y*pkl->width+p0x+1)*pkl->channel+i] * fracx;
+			}
+		}
+	}else{
+		if(p0y+1 < pkl->height){
+			for(i=0; i<pkl->channel; i++){
+				pixel[i] += pkl->image[(p0y*pkl->width+p0x)*pkl->channel+i] * (1-fracy);
+				pixel[i] += pkl->image[((p0y+1)*pkl->width+p0x)*pkl->channel+i] * fracy;
+			}
+		}else{
+			for(i=0; i<pkl->channel; i++)
+				pixel[i] += pkl->image[((p0y+1)*pkl->width+p0x)*pkl->channel+i];
+		}
+	}
+
+	for(i=0; i<pkl->channel; i++)
+		dst[i] = PKL_COLOR_CLIP(pixel[i]);
+	return(0);
+}
+
+//=============================================================================
+// pkl_matrix
+//=============================================================================
+static matrix *pkl_matrix(PKLImage pkl, matrix *mat)
+{
+	matrix mat2;
+	
+	matrix_init(mat);
+	
+	//scale
+	matrix_scale(&mat2, pkl->x_scale, pkl->y_scale);
+	matrix_build(mat, &mat2);
+	
+	//rotate
+	matrix_rotate(&mat2, pkl->angle);
+	matrix_build(mat, &mat2);
+	
+	//translate
+	matrix_translate(&mat2, pkl->x_trns, pkl->y_trns);
+	matrix_build(mat, &mat2);
+	
+	return(mat);
+}
+
+//=============================================================================
+// matrix_init
+//=============================================================================
+static void matrix_init(matrix *mat)
+{
+	mat->a = 1.0;
+	mat->b = 0.0;
+	mat->c = 0.0;
+	mat->d = 1.0;
+	mat->e = 0.0;
+	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
+//=============================================================================
+static void matrix_build(matrix *mat1, matrix *mat2)
+{
+	matrix mat;
+	memcpy(&mat, mat1, sizeof(matrix));
+	
+	mat1->a = mat.a * mat2->a + mat.b * mat2->c;
+	mat1->b = mat.a * mat2->b + mat.b * mat2->d;
+	mat1->c = mat.c * mat2->a + mat.d * mat2->c;
+	mat1->d = mat.c * mat2->b + mat.d * mat2->d;
+	mat1->e = mat.e * mat2->a + mat.f * mat2->c + mat2->e;
+	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_affine.h

@@ -0,0 +1,20 @@
+#ifndef _LIB_PIKL_AFFINE_
+#define _LIB_PIKL_AFFINE_
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+
+#include "pikl.h"
+#include "pikl_private.h"
+
+typedef struct {
+	double x, y;
+} point2;
+
+typedef struct {
+	double a,b,c,d,e,f;
+} matrix;
+
+#endif

data/ext/pikl/pikl_blur.c

@@ -0,0 +1,244 @@
+#include "pikl_blur.h"
+
+static int pkl_raw_blur(PKLImage pkl, int x, int y, double ef, int weight, double angle, double adr);
+
+//=============================================================================
+// pkl_blur
+//=============================================================================
+PKLExport int pkl_blur(PKLImage pkl, int weight)
+{
+	int i, j, p, q, k;
+	int cnt, stock[PKL_CHANNEL];
+	unsigned char *wrk;
+	
+	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++){
+			cnt = 0;
+			memset(stock, 0, sizeof(stock));
+			
+			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(cnt==0) continue;
+			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_gaussblur
+//=============================================================================
+PKLExport int pkl_gaussblur(PKLImage pkl, double weight)
+{
+	int range, i, j, s, t, p;
+	double sg, *gauss, value[PKL_CHANNEL];
+	unsigned char *wrk;
+	
+	if(weight<=0.0) return(1);
+	
+	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));
+	memset(gauss, 0, sizeof(gauss));
+	
+	//gaussian table
+	for(i=0; i<=range; i++)
+		gauss[i] = exp( -1.0*i*i / (2*weight*weight));
+	
+	//horizon(pkl-->wrk)
+	for(i=0; i<pkl->height; i++){
+		for(j=0; j<pkl->width; j++){
+			memset(value, 0, sizeof(double)*PKL_CHANNEL);
+			sg=0;
+			for(s=-range; s<=range; s++){
+				t = j+s<0 ? 0 : j+s>=pkl->width ? pkl->width-1 : j+s;
+				sg += gauss[abs(s)];
+				for(p=0; p<pkl->channel; p++){
+					value[p] += pkl->image[(i*pkl->width+t)*pkl->channel+p] * gauss[abs(s)];
+				}
+			}
+			for(p=0; p<pkl->channel; p++)
+				wrk[(i*pkl->width+j)*pkl->channel+p] = PKL_COLOR_CLIP(value[p]/sg);
+		}
+	}
+	
+	//vertical(wrk-->pkl)
+	for(i=0; i<pkl->height; i++){
+		for(j=0; j<pkl->width; j++){
+			memset(value, 0, sizeof(double)*PKL_CHANNEL);
+			sg=0;
+			for(s=-range; s<=range; s++){
+				t = i+s<0 ? 0 : i+s>=pkl->height ? pkl->height-1 : i+s;
+				sg += gauss[abs(s)];
+				for(p=0; p<pkl->channel; p++){
+					value[p] += wrk[(t*pkl->width+j)*pkl->channel+p] * gauss[abs(s)];
+				}
+			}
+			for(p=0; p<pkl->channel; p++)
+				pkl->image[(i*pkl->width+j)*pkl->channel+p] = PKL_COLOR_CLIP(value[p]/sg);
+		}
+	}
+	
+	free(gauss);
+	free(wrk);
+	return(0);
+}
+
+
+//=============================================================================
+// pkl_rblur(����)
+//=============================================================================
+PKLExport int pkl_rblur(PKLImage pkl, int x, int y, double ef, int weight)
+{
+	return pkl_raw_blur(pkl, x, y, ef, weight, 0.0, 0.0);
+}
+
+//=============================================================================
+// pkl_ablur(��])
+//=============================================================================
+PKLExport int pkl_ablur(PKLImage pkl, int x, int y, double ef, int weight)
+{
+	return pkl_raw_blur(pkl, x, y, ef, weight, 0.0, M_PI/2.0);
+}
+
+//=============================================================================
+// pkl_wblur
+//=============================================================================
+PKLExport int pkl_wblur(PKLImage pkl, int x, int y, double ef, int weight, double angle)
+{
+	return pkl_raw_blur(pkl, x, y, ef, weight, angle, M_PI*angle/180.0);
+}
+
+//=============================================================================
+// pkl_rab_blur(����,��],�����܂��̃R�A)
+//=============================================================================
+static int pkl_raw_blur(PKLImage pkl, int x, int y, double ef, int weight, double angle, double adr)
+{
+	unsigned char *wrk;
+	int i, j, k, t, tx, ty, pat;
+	long color[PKL_CHANNEL], range;
+	double rad, dis, disI, rate, disMAX;
+	double ox, oy, dx, dy, nf;
+
+	if(ef==0.0 || weight==0) return(1);
+
+	wrk = malloc(pkl->width*pkl->height*pkl->channel);
+	if(!wrk) return(1);
+	memset(wrk, 0, pkl->width*pkl->height*pkl->channel);
+
+	nf = weight/2;
+	//ox = (double)(pkl->width)/2.0;
+	//oy = (double)(pkl->height)/2.0;
+	ox = (x<0 || x>=pkl->width) ? (double)(pkl->width)/2.0 : (double)x;			//���S�_�����߂�
+	oy = (y<0 || y>=pkl->height) ? (double)(pkl->height)/2.0 : (double)y;		//���S�_�����߂�
+	dx = (double)pkl->width-ox;
+	dy = (double)pkl->height-oy;
+	disMAX = sqrt(dx*dx+dy*dy);
+
+	for(i=0; i<pkl->height; i++){
+		for(j=0; j<pkl->width; j++){
+			range=0;
+			memset(color, 0, sizeof(color));
+			
+			dx = (double)j-ox;
+			dy = (double)i-oy;
+			//rad = ((dx!=0.0) ? atan(dy/dx) : M_PI/2.0) + (M_PI*angle/180.0);	//�����܂���
+			//rad = ((dx!=0.0) ? atan(dy/dx) : M_PI/2.0);						//���ˏ�
+			//rad = ((dx!=0.0) ? atan(dy/dx) : M_PI/2.0) + (M_PI/2.0);			//��]
+			rad = ((dx!=0.0) ? atan(dy/dx) : M_PI/2.0) + adr;
+			dis = sqrt(dx*dx+dy*dy);
+			rate = (ef*dis/disMAX) / (double)nf;
+
+			for(t=0; t<weight; t++){
+				pat = (t==nf) ? 3 : 1;
+				disI = (double)(t-nf)*rate;
+				tx = (int)(disI * cos(rad)) + j;
+				ty = (int)(disI * sin(rad)) + i;
+				tx = tx<0 ? 0 : tx>=pkl->width ? pkl->width-1 : tx;
+				ty = ty<0 ? 0 : ty>=pkl->height ? pkl->height-1 : ty;
+				for(k=0; k<pkl->channel; k++)
+					color[k] += pkl->image[(ty*pkl->width+tx)*pkl->channel+k] * pat;
+				range += pat;
+			}
+			
+			for(k=0; k<pkl->channel; k++)
+				wrk[(i*pkl->width+j)*pkl->channel+k] = PKL_COLOR_CLIP(color[k]/range);
+		}
+	}
+	
+	free(pkl->image);
+	pkl->image = wrk;
+	return(0);
+}
+
+//=============================================================================
+// pkl_mblur
+//=============================================================================
+PKLExport int pkl_mblur(PKLImage pkl, double angle, int weight)
+{
+	unsigned char *wrk;
+	int i, j, k, t, tx, ty;
+	int *dx, *dy, color[PKL_CHANNEL];
+	double s, c;
+	
+	if(weight < 2) return(0);
+	
+	wrk = malloc(pkl->width*pkl->height*pkl->channel);
+	if(!wrk) return(1);
+	memset(wrk, 0, pkl->width*pkl->height*pkl->channel);
+	
+	//�C�ӊp�x�̃Y���ʃe�[�u�����쐬
+	s = sin((angle+180.0) * M_PI / 180.0);
+	c = cos((angle+180.0) * M_PI / 180.0);
+	
+	dx = malloc(sizeof(int)*(weight+1));
+	dy = malloc(sizeof(int)*(weight+1));
+	memset(dx, 0, sizeof(int)*(weight+1));
+	memset(dy, 0, sizeof(int)*(weight+1));
+	
+	for(i=1; i<=weight; i++){
+		dx[i] = (int)(c * (i+1) + 0.5);
+		dy[i] = (int)(s * (i+1) + 0.5);
+	}
+	
+	for(i=0; i<pkl->height; i++){
+		for(j=0; j<pkl->width; j++){
+			memset(color, 0, sizeof(color));
+			for(t=0; t<=weight; t++){
+				tx = j+dx[t] < 0 ? 0 : j+dx[t]>=pkl->width ? pkl->width-1 : j+dx[t];
+				ty = i+dy[t] < 0 ? 0 : i+dy[t]>=pkl->height ? pkl->height-1 : i+dy[t];
+				
+				for(k=0; k<pkl->channel; k++)
+					color[k] += pkl->image[(ty*pkl->width+tx)*pkl->channel+k];
+			}
+			
+			for(k=0; k<pkl->channel; k++)
+				wrk[(i*pkl->width+j)*pkl->channel+k] = PKL_COLOR_CLIP(color[k]/weight);
+		}
+	}
+	
+	free(dx);
+	free(dy);
+	free(pkl->image);
+	pkl->image = wrk;
+	return(0);
+}
+