pikl 0.2.7 → 0.2.8

data/ext/pikl/pikl_blur.h

@@ -0,0 +1,12 @@
+#ifndef _LIB_PIKL_BLUR_
+#define _LIB_PIKL_BLUR_
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+
+#include "pikl.h"
+#include "pikl_private.h"
+
+#endif

data/ext/pikl/pikl_decrease.c

@@ -0,0 +1,126 @@
+#include "pikl_decrease.h"
+
+//=============================================================================
+// median
+//=============================================================================
+PKLExport int pkl_mediancut(PKLImage pkl, int ncolors, int dither)
+{
+	unsigned char QuantizedPalette[256*3], *Picture256;
+	int i, j;
+	
+	if(pkl->color!=PKL_RGB) return(1);
+	if(ncolors<=0 || ncolors>256) return(1);
+
+	Picture256 = malloc(pkl->width*pkl->height);
+	if(!Picture256) return(1);
+
+	to_indexed(pkl->image, ncolors, dither, pkl->width, pkl->height, Picture256, QuantizedPalette);
+
+	for(i=0,j=0; i<pkl->height*pkl->width*3; i+=3,j++)
+		memcpy(&pkl->image[i], &QuantizedPalette[ Picture256[j]*3 ], pkl->channel);
+	
+	free(Picture256);
+	return(0);
+}
+
+//=============================================================================
+// pkl_neuquant
+//=============================================================================
+PKLExport int pkl_neuquant(PKLImage pkl, int ncolors, int sample)
+{
+	unsigned char QuantizedPalette[256*3], *Picture256;
+	int i, j;
+	
+	if(pkl->color!=PKL_RGB) return(1);
+	if(ncolors<=0 || ncolors>256) return(1);
+	if(sample<=0 || sample>30) return(1);
+	
+	Picture256 = malloc(pkl->width*pkl->height);
+
+	neuReduce(pkl->image, ncolors, pkl->width*pkl->height, sample, Picture256, QuantizedPalette);
+
+	for(i=0,j=0; i<pkl->height*pkl->width*3; i+=3,j++)
+		memcpy(&pkl->image[i], &QuantizedPalette[ Picture256[j]*3 ], pkl->channel);
+
+	free(Picture256);
+	return(0);
+}
+
+//=============================================================================
+// pkl_wu
+//=============================================================================
+PKLExport int pkl_wu(PKLImage pkl, int ncolors)
+{
+	unsigned char QuantizedPalette[256*3], *QuantizedPicture;
+	unsigned char *p, *q;
+	int i;
+	
+	if(pkl->color!=PKL_RGB) return(1);
+	if(ncolors<=0 || ncolors>256) return(1);
+	
+	QuantizedPicture = malloc(pkl->width*pkl->height);
+
+	wuReduce(pkl->image, ncolors, pkl->width*pkl->height, QuantizedPicture, QuantizedPalette);
+
+	p = pkl->image;
+	q = QuantizedPicture;
+	for(i=0; i<pkl->height*pkl->width; i++){
+		*p++ = QuantizedPalette[ (*q)*3+0 ];
+		*p++ = QuantizedPalette[ (*q)*3+1 ];
+		*p++ = QuantizedPalette[ (*q)*3+2 ];
+		q++;
+	}
+	free(QuantizedPicture);
+	return(0);
+}
+
+//=============================================================================
+// pkl_posterize
+//=============================================================================
+PKLExport int pkl_posterize(PKLImage pkl, int level)
+{
+	unsigned char *p, color[PKL_COLOR];
+	int i, j, k;
+	double d, n;
+	
+	if(level<1 && level>256) return(1);
+	
+	n = (256.0/(double)level);
+	d = 255.0/(double)((double)level-1.0);
+
+	for(i=0; i<level; i++)
+		for(j=floor(i*n); j<floor((i+1)*n); j++)
+			color[j]= PKL_COLOR_CLIP(d*i);
+	
+	for(i=0; i<pkl->height; i++){
+		for(j=0; j<pkl->width; j++){
+			p = &pkl->image[(i*pkl->width+j)*pkl->channel];
+			for(k=0; k<pkl->channel; k++,p++)
+				*p = color[*p];
+		}
+	}
+	return(0);
+}
+
+//=============================================================================
+// pkl_cutcolor
+//=============================================================================
+PKLExport int pkl_cutcolor(PKLImage pkl, int level)
+{
+	unsigned char *p;
+	int i, j, k;
+	
+	if(level<0 && level>256) return(1);
+	
+	for(i=0; i<pkl->height; i++){
+		for(j=0; j<pkl->width; j++){
+			p = &pkl->image[(i*pkl->width+j)*pkl->channel];
+			for(k=0; k<pkl->channel; k++){
+				*p = (*p & level);
+				p++;
+			}
+		}
+	}
+	return(0);
+}
+

data/ext/pikl/pikl_decrease.h

@@ -0,0 +1,19 @@
+#ifndef _LIB_PIKL_DECREASE_
+#define _LIB_PIKL_DECREASE_
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+
+#include "pikl.h"
+#include "pikl_private.h"
+
+
+#include "decrease/median.h"
+#include "decrease/neuquant.h"
+#include "decrease/wu.h"
+//#include "decrease/dl.h"
+//#include "decrease/ccmap.h"
+
+#endif

data/ext/pikl/pikl_effect2.c

@@ -0,0 +1,240 @@
+#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

@@ -0,0 +1,55 @@
+#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