pikl 0.2.8 → 0.3.0

data/ext/pikl/decrease/wu.h

@@ -1,7 +0,0 @@
-#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_effect2.c

@@ -1,240 +0,0 @@
-#include "pikl_effect2.h"
-
-//=============================================================================
-// pkl_invert
-//=============================================================================
-PKLExport int pkl_invert(PKLImage pkl)
-{
-	int i;
-	for(i=0; i<pkl->height*pkl->width*pkl->channel; i++)
-		pkl->image[i] ^= 0xff;
-	return(0);
-}
-
-//=============================================================================
-// pkl_composite
-//=============================================================================
-PKLExport int pkl_composite(PKLImage parent, PKLImage child, int xpos, int ypos)
-{
-	int tw, th, i, j;
-	
-	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,j=0; i<th+ypos; i++,j++){
-		memcpy(&parent->image[(i*parent->width+xpos)*parent->channel],
-			   &child->image[j*child->width*child->channel], tw*child->channel);
-	}
-	
-	return(0);
-}
-
-//=============================================================================
-// pkl_composite2
-//=============================================================================
-PKLExport int pkl_composite2(PKLImage parent, PKLImage child, int xpos, int ypos, int transcolor)
-{
-	int tw, th, i, j, s, t, hit;
-	unsigned char trans[PKL_CHANNEL];
-	
-	if(parent->channel != child->channel) return(1);
-	if(xpos<0 || xpos>=parent->width || ypos<0 || ypos>=parent->height) return(1);
-	
-	for(i=0; i<parent->channel; i++)
-		trans[i] = (transcolor>>((parent->channel-i)*8) & 0xFF);
-	
-	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,j=0; i<th+ypos; i++,j++){
-		for(s=0; s<tw; s++){
-			hit = 0;
-			for(t=0; t<child->channel; t++){
-				if(child->image[(j*child->width+s)*child->channel+t] == trans[t]) hit++;
-			}
-			
-			if(hit!=child->channel){
-				memcpy(&parent->image[(i*parent->width+xpos+s)*parent->channel],
-					   &child->image[(j*child->width+s)*child->channel], child->channel);
-			}
-		}
-	}
-	
-	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->width*pkl->height*pkl->channel);
-	
-	for(i=0; i<pkl->height; i++){
-		for(j=0; j<pkl->width; j++){
-			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);
-			
-			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;
-					}
-				}
-			}
-			//�I���W�i���̐F��K�p
-			memcpy(&wrk[(i*pkl->width+j)*pkl->channel], &pkl->image[(ty*pkl->width+tx)*pkl->channel], pkl->channel);
-		}
-	}
-	
-	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];
-				}
-			}
-			
-			for(k=0; k<pkl->channel; k++)
-				wrk[(i*pkl->width+j)*pkl->channel+k] = PKL_COLOR_CLIP(color[k]/weight);
-		}
-	}
-
-	free(pkl->image);
-	pkl->image = wrk;
-	return(0);
-}
-
-//=============================================================================
-// pkl_emboss
-//=============================================================================
-PKLExport int pkl_emboss(PKLImage pkl, PKL_EMBOSS type)
-{
-	unsigned char *wrk;
-	int i, j, s, t, k, clipx, clipy;
-	int *matrix, color[PKL_CHANNEL];
-
-	//select filter
-	matrix=focus_filter[0].matrix;
-	for(i=0; i<sizeof(emboss_filter)/sizeof(struct PKL_FILTER); i++){
-		if(type==emboss_filter[i].type){
-			matrix=emboss_filter[i].matrix;
-			break;
-		}
-	}
-	
-	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];
-				}
-			}
-			
-			for(k=0; k<pkl->channel; k++)
-				wrk[(i*pkl->width+j)*pkl->channel+k] = PKL_COLOR_CLIP(color[k]+127);
-		}
-	}
-
-	free(pkl->image);
-	pkl->image = wrk;
-	return(0);
-}

data/ext/pikl/pikl_effect2.h

@@ -1,55 +0,0 @@
-#ifndef _LIB_PIKL_EFFECT2_
-#define _LIB_PIKL_EFFECT2_
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <math.h>
-
-#include "pikl.h"
-#include "pikl_private.h"
-
-struct PKL_FILTER {
-	int type;
-	int matrix[9];
-};
-
-struct PKL_FILTER emboss_filter[] =
-{
-	{ PKL_EMBOSS_EMBOSS,    { 0,  0, -1,
-							  0,  0,  0,
-							  1,  0,  0 }},
-	
-	{ PKL_EMBOSS_LAPLACIAN, {-1, -1, -1,
-							 -1,  8, -1,
-							 -1, -1, -1 }},
-
-	{ PKL_EMBOSS_HEAVY,     { 2,  0,  0,
-							  0, -1,  0,
-							  0,  0, -1 }},
-	
-	{ PKL_EMBOSS_LIGHT,     { 0,  0,  0,
-							  0,  1,  0,
-							  0,  0, -1 }},
-};
-
-
-struct PKL_FILTER focus_filter[] =
-{
-	{ PKL_FOCUS_DETAIL,    { 0, -1,  0,
-							-1, 10, -1,
-							 0, -1,  0 }},
-
-	{ PKL_FOCUS_EDGES,     {-1, -1, -1,
-							-1,  9, -1,
-							-1, -1, -1 }},
-
-	{ PKL_FOCUS_FOCUS,     {-1,  0, -1,
-							 0,  7,  0,
-							-1,  0, -1 }},
-};
-
-
-
-
-#endif

data/ext/pikl/pikl_effect3.c

@@ -1,266 +0,0 @@
-#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);
-}
-