pikl 0.2.8 → 0.3.0

data/ext/pikl/pikl_effect4.c

@@ -1,495 +0,0 @@
-#include "pikl_effect4.h"
-
-//=============================================================================
-// pkl_edgeposter
-//=============================================================================
-PKLExport int pkl_edgeposter(PKLImage pkl, int level, int up)
-{
-	if(pkl_posterize(pkl, level)) return(1);
-	if(pkl_noisecut(pkl)) return(1);
-	if(pkl_brightness(pkl, up)) return(1);
-	if(pkl_edgepaint(pkl)) return(1);
-	return(0);
-}
-
-//=============================================================================
-// pkl_edgepaint
-//=============================================================================
-PKLExport int pkl_edgepaint(PKLImage pkl)
-{
-	unsigned char *wrk, *p, *q;
-	int i, j, s, t, k, color, clipx, clipy, gray;
-	const int filter[9] = { -1, -1, -1, 
-							-1,  8, -1, 
-							-1, -1, -1};
-	
-	wrk = malloc(pkl->width*pkl->height*pkl->channel);
-	if(!wrk) return(1);
-	memset(wrk, 0, pkl->width*pkl->height*pkl->channel);
-	
-	/* convert grayscale */
-	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);
-	}
-
-	for(i=0; i<pkl->height; i++){
-		for(j=0; j<pkl->width; j++){
-			color=0;
-			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;
-					color += wrk[(clipy*pkl->width+clipx) * pkl->channel] * filter[t+s*3];
-				}
-			}
-			
-			if(color>0){
-				memset(&wrk[(i*pkl->width+j)*pkl->channel], 0, pkl->channel);
-			}else{
-				p = &wrk[(i*pkl->width+j)*pkl->channel];
-				q = &pkl->image[(i*pkl->width+j)*pkl->channel];
-				for(k=0; k<pkl->channel; k++) *p++=*q++;
-			}
-		}
-	}
-
-	free(pkl->image);
-	pkl->image = wrk;
-	return(0);
-}
-
-//=============================================================================
-// 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);
-	
-	srand48(1);
-	for(i=0; i<pkl->height; i+=area){
-		for(j=0; j<pkl->width; j+=area){
-			w = j+area>pkl->width ? pkl->width-j : area;
-			h = i+area>pkl->height ? pkl->height : i+area;
-			
-			//�i�q�̂��炵��
-			//offsetx = rand()%(shift*2+1)-shift;
-			//offsety = rand()%(shift*2+1)-shift;
-			offsetx = lrand48()%(shift*2+1)-shift;
-			offsety = lrand48()%(shift*2+1)-shift;
-			
-			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;
-				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_grid
-//=============================================================================
-PKLExport int pkl_grid(PKLImage pkl, int msx, int msy, int color)
-{
-	unsigned char *p;
-	int i, j, k, mpx, mpy;
-	
-	//��U���U�C�N��
-	if(pkl_mosaic(pkl, msx, msy)) return(1);
-	
-	mpx = (msx<1) ? 1 : (msx>=pkl->width) ? pkl->width-1 : msx;
-	mpy = (msy<1) ? 1 : (msy>=pkl->height) ? pkl->height-1 : msy;
-	
-	for(i=0; i<pkl->height-1; i++){
-		if(i%mpy==0){
-			for(j=0; j<pkl->width; j++){
-				p = &pkl->image[(i*pkl->width+j)*pkl->channel];
-				for(k=0; k<pkl->channel; k++){
-					*p = PKL_COLOR_CLIP(*p+color);
-					p++;
-				}
-			}
-		}
-		for(j=mpx; j<pkl->width; j+=mpx){
-			p = &pkl->image[(i*pkl->width+j)*pkl->channel];
-			for(k=0; k<pkl->channel; k++){
-				*p = PKL_COLOR_CLIP(*p+color);
-				p++;
-			}
-		}
-	}
-	
-	return(0);
-}
-
-//=============================================================================
-// pkl_kuwahara
-//=============================================================================
-PKLExport int pkl_kuwahara(PKLImage pkl, int range)
-{
-	unsigned char *wrk, *p;
-	int i, j, k, count, tr, t, tx, ty, clipx, clipy;
-	int value[4], mincolor, idx, total[PKL_CHANNEL];
-	struct { int sx, sy, ex, ey; } r[4];	//rect
-	unsigned char max_color[PKL_CHANNEL], min_color[PKL_CHANNEL], c;
-	
-	if(range<=1) return(0);
-	
-	wrk = malloc(pkl->width*pkl->height*pkl->channel);
-	if(!wrk) return(1);
-	memset(wrk, 0, pkl->width*pkl->height*pkl->channel);
-
-	//�̈�̃s�N�Z����
-	count = range*range;
-	tr = range-1;
-	
-	for(i=0; i<pkl->height; i++){
-		for(j=0; j<pkl->width; j++){
-			/* �J�����g�s�N�Z���𒆐S��4�‚̗̈�ɕ����� */
-			//����(0)
-			r[0].sx = j-tr;
-			r[0].sy = i-tr;
-			r[0].ex = j;
-			r[0].ey = i;
-			//�E��(1)
-			r[1].sx = j;
-			r[1].sy = i-tr;
-			r[1].ex = j+tr;
-			r[1].ey = i;
-			//�E��(2)
-			r[2].sx = j;
-			r[2].sy = i;
-			r[2].ex = j+tr;
-			r[2].ey = i+tr;
-			//����(3)
-			r[3].sx = j-tr;
-			r[3].sy = i;
-			r[3].ex = j;
-			r[3].ey = i+tr;
-			
-			/* �e�̈�Ŋe�F�̍ő�l�ƍŏ��l�̍���ݐς��� */
-			memset(value, 0, sizeof(value));
-			for(t=0; t<4; t++){
-				memset(max_color, 0x00, PKL_CHANNEL);
-				memset(min_color, 0xff, PKL_CHANNEL);
-				for(ty=r[t].sy; ty<=r[t].ey; ty++){
-					for(tx=r[t].sx; tx<=r[t].ex; tx++){
-						clipx = tx<0 ? 0 : tx>=pkl->width ? pkl->width-1 : tx;
-						clipy = ty<0 ? 0 : ty>=pkl->height ? pkl->height-1 : ty;
-						p = &pkl->image[(ty*pkl->width+tx)*pkl->channel];
-						for(k=0; k<pkl->channel; k++){
-							c = *p++;
-							max_color[k] = (c > max_color[k]) ? c : max_color[k];
-							min_color[k] = (c < min_color[k]) ? c : min_color[k];
-						}
-					}
-				}
-				
-				for(k=0; k<pkl->channel; k++)
-					value[t] += (max_color[k] - min_color[k]);
-			}
-			
-			/* �e�̈�ōł��F�̍������������̈��I������ */
-			mincolor = value[0];
-			idx = 0;
-			for(t=1; t<4; t++){
-				if(value[t]<mincolor){
-					mincolor = value[t];
-					idx = t;
-				}
-			}
-			
-			/* �I�����ꂽ�̈�̐F�̕��ς��s�N�Z���ɓK�p���� */
-			memset(total, 0, sizeof(total));
-			for(ty=r[idx].sy; ty<=r[idx].ey; ty++){
-				for(tx=r[idx].sx; tx<=r[idx].ex; tx++){
-					clipx = tx<0 ? 0 : tx>=pkl->width ? pkl->width-1 : tx;
-					clipy = ty<0 ? 0 : ty>=pkl->height ? pkl->height-1 : ty;
-					p = &pkl->image[(ty*pkl->width+tx)*pkl->channel];
-					for(k=0; k<pkl->channel; k++)
-						total[k] += *p++;
-				}
-			}
-			p =&wrk[(i*pkl->width+j)*pkl->channel];
-			for(k=0; k<pkl->channel; k++)
-				*p++ = PKL_COLOR_CLIP(total[k]/count);
-		}
-	}
-
-	free(pkl->image);
-	pkl->image = wrk;
-	return(0);
-}
-
-//=============================================================================
-// pkl_alphablend
-//=============================================================================
-PKLExport int pkl_alphablend(PKLImage parent, PKLImage child, int xpos, int ypos, int alpha)
-{
-	int tw, th, i, j, k, alp, pp, cp;
-	const int limits=PKL_COLOR-1;
-	
-	if(parent->channel != child->channel) return(1);
-	if(xpos<0 || xpos>=parent->width || ypos<0 || ypos>=parent->height) return(1);
-	alp = PKL_COLOR_CLIP(alpha);
-	
-	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; i<th+ypos; i++){
-		for(j=0; j<tw; j++){
-			pp = (i*parent->width+xpos+j)*parent->channel;
-			cp = ((i-ypos)*child->width+j)*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_alphablend2
-//=============================================================================
-PKLExport int pkl_alphablend2(PKLImage parent, PKLImage child, int xpos, int ypos)
-{
-	int tw, th, i, j, k, pp, cp;
-	double alpha;
-	
-	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; i<th+ypos; i++){
-		for(j=0; j<tw; j++){
-			alpha = sin((i-ypos)*M_PI/child->height) * sin(j*M_PI/child->width);
-			pp = (i*parent->width+xpos+j)*parent->channel;
-			cp = ((i-ypos)*child->width+j)*child->channel;
-			for(k=0; k<parent->channel; k++)
-				parent->image[pp+k] =PKL_COLOR_CLIP(parent->image[pp+k]*(1.0-alpha) + child->image[cp+k]*alpha);
-		}
-		
-	}
-	return(0);
-}
-
-//=============================================================================
-// pkl_shadowframe
-//=============================================================================
-PKLExport int pkl_shadowframe(PKLImage pkl, int margin, int backcolor, int 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);
-	}
-	
-	//�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_edge
-//=============================================================================
-PKLExport int pkl_edge(PKLImage pkl, int threshold)
-{
-	unsigned char *wrk, *p;
-	int i, j, k, color[PKL_CHANNEL], total;
-	int r1, r2, r3;
-	
-	wrk = malloc(pkl->width*pkl->height*pkl->channel);
-	if(!wrk) return(1);
-	memset(wrk, 0xff, pkl->width*pkl->height*pkl->channel);
-	
-	r3 = sqrt((double)pkl->channel);
-
-	for(i=0; i<pkl->height; i++){
-		r1=r2=0;
-		for(j=0; j<pkl->width; j++){
-			//x����
-			if(j+1 < pkl->width){
-				p = &pkl->image[(i*pkl->width+j)*pkl->channel];
-				for(k=0; k<pkl->channel; k++){
-					color[k] = *p - *(p+pkl->channel);
-					color[k] *= color[k];
-					p++;
-				}
-				total=0;
-				for(k=0; k<pkl->channel; k++)
-					total += color[k];
-				r1 = sqrt(total)/r3;
-			}
-			
-			//y����
-			if(i+1 < pkl->height){
-				p = &pkl->image[(i*pkl->width+j)*pkl->channel];
-				for(k=0; k<pkl->channel; k++){
-					color[k] = *p - *(p+pkl->width*pkl->channel);
-					color[k] *= color[k];
-					p++;
-				}
-				total=0;
-				for(k=0; k<pkl->channel; k++)
-					total += color[k];
-				r2 = sqrt(total)/r3;
-			}
-
-			p = &wrk[(i*pkl->width+j)*pkl->channel];
-			if(r1>=threshold || r2>=threshold)
-				for(k=0; k<pkl->channel; k++) *p++=0;
-		}
-	}
-	free(pkl->image);
-	pkl->image = wrk;
-	return(0);
-}
-
-//=============================================================================
-// pkl_dither
-//=============================================================================
-PKLExport int pkl_dither(PKLImage pkl, PKL_DITHER dither)
-{
-	double FloydSteinberg[2][3] = {
-		{       -1,       -1, 7.0/16.0},
-		{ 3.0/16.0, 5.0/16.0, 1.0/16.0} };
-	
-	double Stucci[3][5] = {
-		{      -1,       -1,       -1, 8.0/42.0, 4.0/42.0},
-		{2.0/42.0, 4.0/42.0, 8.0/42.0, 4.0/42.0, 2.0/42.0},
-		{1.0/42.0, 2.0/42.0, 4.0/42.0, 2.0/42.0, 1.0/42.0} };
-
-	double Sierra[3][5] = {
-		{      -1,       -1,       -1, 5.0/32.0, 3.0/32.0},
-		{2.0/32.0, 4.0/32.0, 5.0/32.0, 4.0/32.0, 2.0/32.0},
-		{      -1, 2.0/32.0, 3.0/32.0, 2.0/32.0,       -1} };
-
-	double JaJuNi[3][5] = {
-		{      -1,       -1,       -1, 7.0/48.0, 5.0/48.0},
-		{3.0/48.0, 5.0/48.0, 7.0/48.0, 5.0/48.0, 3.0/48.0},
-		{1.0/48.0, 3.0/48.0, 5.0/48.0, 3.0/48.0, 1.0/48.0} };
-
-	unsigned char *wrk, pix;
-	double *pt, err;
-	int i, j, k, gray, s, t, tx, ty, row, col, xrange;
-	
-	wrk = malloc(pkl->width*pkl->height*pkl->channel);
-	if(!wrk) return(1);
-
-	//�f�B�U�p�^����I��
-	switch(dither){
-		case PKL_DITHER_STUCCI:
-			row = 5;
-			col = 3;
-			pt = &(Stucci[0][0]);
-			break;
-			
-		case PKL_DITHER_SIERRA:
-			row = 5;
-			col = 3;
-			pt = &(Sierra[0][0]);
-			break;
-			
-		case PKL_DITHER_JAJUNI:
-			row = 5;
-			col = 3;
-			pt = &(JaJuNi[0][0]);
-			break;
-			
-		case PKL_DITHER_FLOYDSTEINBERG:
-		default:
-			row = 3;
-			col = 2;
-			pt = &(FloydSteinberg[0][0]);
-	}
-
-	for(i=0; i<pkl->height; i++){
-		for(j=0; j<pkl->width; j++){
-			gray=0;
-			for(k=0; k<pkl->channel; k++)
-				gray += pkl->image[(i*pkl->width+j)*pkl->channel+k];
-			pkl->image[(i*pkl->width+j)*pkl->channel] = PKL_COLOR_CLIP(gray/pkl->channel);
-		}
-	}
-
-	xrange = (row-1)/2;
-
-	for(i=0; i<pkl->height; i++){
-		for(j=0; j<pkl->width; j++){
-			pix = pkl->image[(i*pkl->width+j)*pkl->channel];
-			if(pix>127)
-				memset(&wrk[(i*pkl->width+j)*pkl->channel], 0xff, pkl->channel);
-			else
-				memset(&wrk[(i*pkl->width+j)*pkl->channel], 0x00, pkl->channel);
-			err = pix>127 ? pix-255 : pix;
-
-			for(s=0; s<col; s++){
-				for(t=-xrange; t<=xrange; t++){
-					tx = j+t;
-					ty = i+s;
-					if(tx<0 || tx>=pkl->width || ty>=pkl->height) continue;
-					if (pt[s*row+t+xrange] < 0) continue;
-					
-					pkl->image[(ty*pkl->width+tx)*pkl->channel] =
-						PKL_COLOR_CLIP(pkl->image[(ty*pkl->width+tx)*pkl->channel] + err * pt[s*row+t+xrange]);
-				}
-			}
-		}
-	}
-	
-	free(pkl->image);
-	pkl->image = wrk;
-	return(0);
-}
-