pikl 0.2.8-x86-mswin32 → 0.3.0-x86-mswin32

data/ext/pikl/{pikl_effect3.h → pikl_camera.h}

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

data/ext/pikl/pikl_composite.c

@@ -0,0 +1,175 @@
+#include "pikl_composite.h"
+
+//=============================================================================
+// pkl_composite
+//=============================================================================
+PKLExport int pkl_composite(PKLImage parent, PKLImage child, int xpos, int ypos, PKLColor transcolor)
+{
+	int tw, th, i, j, px, py, cx, cy;
+	
+	if(parent->channel != child->channel) return(1);
+	if(child->width > parent->width || child->height > parent->height) return(1);
+	if(xpos+child->width<0 || xpos>=parent->width ||
+	   ypos+child->height<0 || ypos>=parent->height) return(0);
+	
+	tw = xpos<0 ? child->width+xpos : (xpos+child->width >= parent->width) ? parent->width-xpos : child->width;
+	th = ypos<0 ? child->height+ypos : (ypos+child->height >= parent->height) ? parent->height-ypos : child->height;
+	px = xpos<0 ? 0 : xpos;
+	py = ypos<0 ? 0 : ypos;
+	cx = xpos<0 ? -xpos : 0;
+	cy = ypos<0 ? -ypos : 0;
+	
+	if(transcolor){
+		//�����F���ݒ肳��Ă��鎞
+		int s, t;
+		for(i=py,j=cy; i<th+py; i++,j++){
+			for(s=px,t=cx; t<cx+tw; s++,t++){
+				if( memcmp(&child->image[(j*child->width+t)*child->channel], transcolor->color, child->channel) ){
+					memcpy(&parent->image[(i*parent->width+s)*parent->channel],
+						   &child->image[(j*child->width+t)*child->channel], child->channel);
+				}
+			}
+		}
+	}else{
+		//�����F���ݒ肳��Ă��Ȃ���
+		for(i=py,j=cy; i<th+py; i++,j++){
+			memcpy(&parent->image[(i*parent->width+px)*parent->channel],
+				   &child->image[(j*child->width+cx)*child->channel], tw*child->channel);
+		}
+	}
+	return(0);
+}
+
+//=============================================================================
+// pkl_alphablend
+//=============================================================================
+PKLExport int pkl_alphablend(PKLImage parent, PKLImage child, int xpos, int ypos, int alpha)
+{
+	int tw, th, i, j, k, pp, cp, px, py, cx, cy, s, t;
+	
+	if(parent->channel != child->channel) return(1);
+	if(child->width > parent->width || child->height > parent->height) return(1);
+	if(xpos+child->width<0 || xpos>=parent->width ||
+	   ypos+child->height<0 || ypos>=parent->height) return(0);
+	
+	tw = xpos<0 ? child->width+xpos : (xpos+child->width >= parent->width) ? parent->width-xpos : child->width;
+	th = ypos<0 ? child->height+ypos : (ypos+child->height >= parent->height) ? parent->height-ypos : child->height;
+	px = xpos<0 ? 0 : xpos;
+	py = ypos<0 ? 0 : ypos;
+	cx = xpos<0 ? -xpos : 0;
+	cy = ypos<0 ? -ypos : 0;
+	
+	if(alpha<0){
+		//child�̎��݂͂̂Ƀ���K�p
+		double alp;
+		
+		for(i=py,j=cy; i<th+py; i++,j++){
+			for(s=px,t=cx; t<cx+tw; s++,t++){
+				alp = sin(j*M_PI/child->height) * sin(t*M_PI/child->width);
+				pp = (i*parent->width+s)*parent->channel;
+				cp = (j*child->width+t)*child->channel;
+				for(k=0; k<parent->channel; k++)
+					parent->image[pp+k] =PKL_COLOR_CLIP(parent->image[pp+k]*(1.0-alp) + child->image[cp+k]*alp);
+			}
+		}
+	}else{
+		//child�S�̂Ƀ���K�p
+		int alp=PKL_COLOR_CLIP(alpha);
+		const int limits=PKL_COLOR-1;
+		
+		for(i=py,j=cy; i<th+py; i++,j++){
+			for(s=px,t=cx; t<cx+tw; s++,t++){
+				pp = (i*parent->width+s)*parent->channel;
+				cp = (j*child->width+t)*child->channel;
+				for(k=0; k<parent->channel; k++)
+					parent->image[pp+k] =PKL_COLOR_CLIP((parent->image[pp+k]*alp + child->image[cp+k]*(limits-alp)) / limits);
+			}
+		}
+	}
+	return(0);
+}
+
+//=============================================================================
+// pkl_shadowframe
+//=============================================================================
+PKLExport int pkl_shadowframe(PKLImage pkl, int margin, PKLColor backcolor, PKLColor shadowcolor)
+{
+	unsigned char *img, back[PKL_CHANNEL], shadow[PKL_CHANNEL];
+	int i, j, w, h;
+
+	if(margin<=0) return(1);
+
+	w = pkl->width;
+	h = pkl->height;
+	img = pkl->image;
+	pkl->width = w + margin*3;
+	pkl->height = h + margin*3;
+	
+	pkl->image = malloc(pkl->width*pkl->height*pkl->channel);
+	if(!pkl->image) return(1);
+	memset(pkl->image, 0, pkl->width*pkl->height*pkl->channel);
+
+	//for(i=0; i<pkl->channel; i++){
+	//	back[i] = (backcolor>>((pkl->channel-i)*8) & 0xFF);
+	//	shadow[i] = (shadowcolor>>((pkl->channel-i)*8) & 0xFF);
+	//}
+	if(backcolor) memcpy(back, backcolor->color, pkl->channel);
+	else          memset(back, 0xff, pkl->channel);
+
+	if(shadowcolor) memcpy(shadow, shadowcolor->color, pkl->channel);
+	else            memset(shadow, 0, pkl->channel);
+	
+	//�w�i�F�ݒ�
+	for(i=0; i<pkl->width*pkl->height*pkl->channel; i+=pkl->channel)
+		memcpy(&pkl->image[i], back, pkl->channel);
+	
+	//�t���[���ݒ�
+	for(i=margin*2; i<h+margin*2; i++)
+		for(j=margin*2; j<w+margin*2; j++)
+			memcpy(&pkl->image[(i*pkl->width+j)*pkl->channel], shadow, pkl->channel);
+	
+	//shadowframe�����(�P�Ƀu���[)
+	pkl_gaussblur(pkl, 5.0);
+	
+	for(i=margin,j=0; i<h+margin; i++,j++)
+		memcpy(&pkl->image[(i*pkl->width+margin)*pkl->channel], &img[(j*w)*pkl->channel], w*pkl->channel);
+	
+	free(img);
+	return(0);
+}
+
+
+//=============================================================================
+// pkl_randomshadow
+//=============================================================================
+PKLExport int pkl_randomshadow(PKLImage canvas, PKLImage pasteimage, int top, int left, int margin, PKLColor shadowcolor)
+{
+	PKLImage shadow;
+	int i, j;
+	unsigned char shcolor[PKL_CHANNEL];
+	
+	if(canvas->color != pasteimage->color) return(1);
+	
+	//�V���h�E�t���[�������
+	shadow = pkl_canvas(pasteimage->width, pasteimage->height, pasteimage->color, NULL);
+	if(!shadow) return(1);
+	
+	//for(i=0; i<shadow->channel; i++)
+	//	shcolor[i] = (shadowcolor>>((shadow->channel-i)*8) & 0xFF);
+	if(shadowcolor) memcpy(shcolor, shadowcolor->color, canvas->channel);
+	else            memset(shcolor, 0, canvas->channel);
+	
+	for(i=0; i<pasteimage->height; i++)
+		for(j=0; j<pasteimage->width; j++)
+			memcpy(&shadow->image[(i*shadow->width+j)*shadow->channel], shcolor, shadow->channel);
+	
+	//�o���オ�����V���h�E�t���[�����L�����o�X�ɓ\��t����
+	pkl_alphablend(canvas, shadow, top+margin, left+margin, -1);
+	pkl_alphablend(canvas, shadow, top+margin, left+margin, -1);
+	pkl_alphablend(canvas, shadow, top+margin, left+margin, -1);
+	pkl_close(shadow);
+	
+	//�I���W�i���C���[�W��\��
+	pkl_composite(canvas, pasteimage, top, left, NULL);
+	return(0);
+}

data/ext/pikl/pikl_composite.h

@@ -0,0 +1,12 @@
+#ifndef _LIB_PIKL_COMPOSITE_
+#define _LIB_PIKL_COMPOSITE_
+
+#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

@@ -1,76 +1,141 @@
 #include "pikl_decrease.h"
 
+static void gray_normal(PKLImage pkl, unsigned char *gray);
+static void gray_median(PKLImage pkl, unsigned char *gray);
+static void gray_average(PKLImage pkl, unsigned char *gray);
+
 //=============================================================================
-// median
+// pkl_gray
 //=============================================================================
-PKLExport int pkl_mediancut(PKLImage pkl, int ncolors, int dither)
+PKLExport int pkl_gray(PKLImage pkl, PKL_GRAYTYPE type)
 {
-	unsigned char QuantizedPalette[256*3], *Picture256;
-	int i, j;
+	unsigned char *gray;
 	
 	if(pkl->color!=PKL_RGB) return(1);
-	if(ncolors<=0 || ncolors>256) return(1);
+	
+	gray = malloc(pkl->height * pkl->width);
+	if(!gray) return(1);
+	
+	switch(type){
+		case PKL_GRAY_NRM:
+			gray_normal(pkl, gray);
+			break;
+		case PKL_GRAY_MED:
+			gray_median(pkl, gray);
+			break;
+		case PKL_GRAY_AVE:
+			gray_average(pkl, gray);
+			break;
+		default:
+			return(1);
+	}
+	
+	free(pkl->image);
+	pkl->image = gray;
+	pkl->channel=1;
+	pkl->color=PKL_GRAYSCALE;
+	return(0);
+}
 
-	Picture256 = malloc(pkl->width*pkl->height);
-	if(!Picture256) return(1);
+//=================================================================================
+// gs_nrm(���d���ϖ@)
+//=================================================================================
+static void gray_normal(PKLImage pkl, unsigned char *gray)
+{
+	int i, j;
+	
+	for(i=0; i<pkl->height; i++){
+		for(j=0; j<pkl->width; j++){
+			gray[i*pkl->width+j] =
+					pkl->image[(i*pkl->width+j)*pkl->channel  ] * 0.298912 +
+					pkl->image[(i*pkl->width+j)*pkl->channel+1] * 0.586611 +
+					pkl->image[(i*pkl->width+j)*pkl->channel+2] * 0.114478;
+		}
+	}
+}
 
-	to_indexed(pkl->image, ncolors, dither, pkl->width, pkl->height, Picture256, QuantizedPalette);
+//=================================================================================
+// gs_med(���Ԓl�@)
+//=================================================================================
+static void gray_median(PKLImage pkl, unsigned char *gray)
+{
+	int i, j;
+	unsigned char mx, mn;
+	
+	for(i=0; i<pkl->height; i++){
+		for(j=0; j<pkl->width; j++){
+			mx = pkl->image[(i*pkl->width+j)*pkl->channel];
+			mx = PKL_MAX(pkl->image[(i*pkl->width+j)*pkl->channel+1], mx);
+			mx = PKL_MAX(pkl->image[(i*pkl->width+j)*pkl->channel+2], mx);
+			
+			mn = pkl->image[(i*pkl->width+j)*pkl->channel];
+			mn = PKL_MAX(pkl->image[(i*pkl->width+j)*pkl->channel+1], mn);
+			mn = PKL_MAX(pkl->image[(i*pkl->width+j)*pkl->channel+2], mn);
+			
+			gray[i*pkl->width+j] = (mx + mn) * 0.5;
+		}
+	}
+}
 
-	for(i=0,j=0; i<pkl->height*pkl->width*3; i+=3,j++)
-		memcpy(&pkl->image[i], &QuantizedPalette[ Picture256[j]*3 ], pkl->channel);
+//=================================================================================
+// gs_ave(�P�����ϖ@)
+//=================================================================================
+static void gray_average(PKLImage pkl, unsigned char *gray)
+{
+	int i, j;
 	
-	free(Picture256);
-	return(0);
+	for(i=0; i<pkl->height; i++){
+		for(j=0; j<pkl->width; j++){
+			gray[i*pkl->width+j] = 
+				(pkl->image[(i*pkl->width+j)*pkl->channel  ] +
+				 pkl->image[(i*pkl->width+j)*pkl->channel+1] +
+				 pkl->image[(i*pkl->width+j)*pkl->channel+2]) / 3;
+		}
+	}
 }
 
 //=============================================================================
-// pkl_neuquant
+// pkl_rgb
 //=============================================================================
-PKLExport int pkl_neuquant(PKLImage pkl, int ncolors, int sample)
+PKLExport int pkl_rgb(PKLImage pkl)
 {
-	unsigned char QuantizedPalette[256*3], *Picture256;
+	unsigned char *rgb, k;
 	int i, j;
 	
-	if(pkl->color!=PKL_RGB) return(1);
-	if(ncolors<=0 || ncolors>256) return(1);
-	if(sample<=0 || sample>30) return(1);
+	if(pkl->color!=PKL_CMYK) 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);
+	rgb = malloc(pkl->height * pkl->width * 3);
+	if(!rgb) return(1);
+	
+	for(i=0; i<pkl->height; i++){
+		for(j=0; j<pkl->width; j++){
+			k = pkl->image[(i*pkl->width+j)*pkl->channel+3];
+			rgb[(i*pkl->width+j)*3  ] = ~(255 - pkl->image[(i*pkl->width+j)*pkl->channel  ] + k);
+			rgb[(i*pkl->width+j)*3+1] = ~(255 - pkl->image[(i*pkl->width+j)*pkl->channel+1] + k);
+			rgb[(i*pkl->width+j)*3+2] = ~(255 - pkl->image[(i*pkl->width+j)*pkl->channel+2] + k);
+		}
+	}
+	
+	free(pkl->image);
+	pkl->image = rgb;
+	pkl->channel=3;
+	pkl->color=PKL_RGB;
 	return(0);
 }
 
 //=============================================================================
-// pkl_wu
+// pkl_2c
 //=============================================================================
-PKLExport int pkl_wu(PKLImage pkl, int ncolors)
+PKLExport int pkl_2c(PKLImage pkl, int threshold)
 {
-	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);
+	if(pkl->color!=PKL_GRAYSCALE) return(1);
+	if(threshold<0 || threshold>255) return(1);
+	
+	for(i=0; i<pkl->height*pkl->width; i++)
+		pkl->image[i] = pkl->image[i]<threshold ? 0 : 255;
 	
-	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);
 }
 

data/ext/pikl/pikl_decrease.h

@@ -9,11 +9,4 @@
 #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_divide.c

@@ -0,0 +1,116 @@
+#include "pikl_divide.h"
+
+//=============================================================================
+// pkl_tileslit
+//=============================================================================
+PKLExport int pkl_tileslit(PKLImage pkl, int area, int shift)
+{
+	unsigned char *wrk;
+	int i, j, k, tx, ty;
+	int w, h, offsetx, offsety;
+
+	if(shift==0) return(0);
+	if(area<=1 || (area>pkl->width || area>pkl->height)) return(1);
+
+	wrk = malloc(pkl->width*pkl->height*pkl->channel);
+	if(!wrk) return(1);
+	memset(wrk, 0, pkl->width*pkl->height*pkl->channel);
+	
+	//invert
+	for(i=0; i<pkl->height*pkl->width*pkl->channel; i++)
+		wrk[i] = (pkl->image[i] ^ 0xff);
+
+	srand(1);
+	for(i=0; i<pkl->height; i+=area){
+		for(j=0; j<pkl->width; j+=area){
+			//�i�q�̂��炵��
+			offsetx = rand()%(shift*2+1)-shift;
+			offsety = rand()%(shift*2+1)-shift;
+			
+			h = i+area>pkl->height ? pkl->height : i+area;
+			for(k=i; k<h; k++){
+				tx = j+offsetx<0 ? 0 : j+offsetx>=pkl->width ? pkl->width-1 : j+offsetx;
+				ty = k+offsety<0 ? 0 : k+offsety>=pkl->height ? pkl->height-1 : k+offsety;
+				w = tx+area > pkl->width ? pkl->width-tx : area;
+				memcpy(&wrk[(ty*pkl->width+tx)*pkl->channel], &pkl->image[(k*pkl->width+j)*pkl->channel], w*pkl->channel);
+			}
+		}
+	}
+
+	free(pkl->image);
+	pkl->image = wrk;
+	return(0);
+}
+
+//=============================================================================
+// pkl_splitframe
+//=============================================================================
+PKLExport int pkl_splitframe(PKLImage pkl, PKLColor backcolor, int wbs, int hbs, int margin, int frame)
+{
+	unsigned char *wrk;
+	int i, j, k, s, t, u, tx, ty;
+	int offsetx, offsety, width, height, fw, fh;
+	int warea, harea;
+	int shift=5;
+
+	if(wbs<=0 || hbs<=0) return(1);
+	if(margin<0) return(1);
+	if(frame<1) return(1);
+
+	//1�‚̕����G���A�̃C���[�W�T�C�Y
+	warea = pkl->width / wbs;
+	harea = pkl->height / hbs;
+	//1�‚̃G���A�̃T�C�Y(�t���[���T�C�Y���܂�)
+	fw = warea + frame*2;
+	fh = harea + frame*2;
+	//�ŏI�I�ȃL�����o�X�̑傫��
+	width = fw * wbs + margin*2;
+	height = fh * hbs + margin*2;
+
+	wrk = malloc(width*height*pkl->channel);
+	if(!wrk) return(1);
+	
+	//�w�i�F�̐ݒ�
+	//for(i=0; i<pkl->channel; i++)
+	//	color[i] = (backcolor>>((pkl->channel-i)*8) & 0xFF);
+	if(backcolor){
+		for(i=0; i<width*height; i++)
+			memcpy(&wrk[i*pkl->channel], backcolor->color, pkl->channel);
+	}else{
+		memset(wrk, 0xff, width*height*pkl->channel);
+	}
+
+	srand(1);
+	for(i=margin,s=0; i<height-margin; i+=fh,s+=harea){
+		for(j=margin,t=0; j<width-margin; j+=fw,t+=warea){
+			offsetx = rand()%(shift*2+1)-shift;
+			offsety = rand()%(shift*2+1)-shift;
+			
+			//�t�H�g�t���[��
+			k = i+offsety<0 ? 0 : i+offsety+fh>height ? height-fh : i+offsety;
+			for(ty=k; ty<k+fh; ty++){
+				tx = j+offsetx<0 ? 0 : j+offsetx+fw>width ? width-fw : j+offsetx;
+				//�w�i�F(��)
+				memset(&wrk[(ty*width+tx)*pkl->channel], 0xFF, fw*pkl->channel);
+				//�V�n�̃t���[��
+				if(ty==k || ty==k+fh-1)
+					memset(&wrk[(ty*width+tx)*pkl->channel], 0x00, fw*pkl->channel);
+				//���E�̃t���[��
+				memset(&wrk[(ty*width+tx)*pkl->channel], 0x00, pkl->channel);
+				memset(&wrk[(ty*width+tx+fw-1)*pkl->channel], 0x00, pkl->channel);
+			}
+			//�C���[�W
+			k = i+offsety<0 ? frame : i+offsety+fh>height ? height-fh+frame : i+offsety+frame;
+			for(ty=k,u=s; ty<k+harea; ty++,u++){
+				tx = j+offsetx<0 ? frame : j+offsetx+fw>width ? width-fw+frame : j+offsetx+frame;
+				memcpy(&wrk[(ty*width+tx)*pkl->channel], &pkl->image[(u*pkl->width+t)*pkl->channel], warea*pkl->channel);
+			}
+		}
+	}
+	
+	free(pkl->image);
+	pkl->image = wrk;
+	pkl->width = width;
+	pkl->height = height;
+	return(0);
+}