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

data/ext/pikl/pikl_effect.h

@@ -9,12 +9,38 @@
 #include "pikl.h"
 #include "pikl_private.h"
 
-//unsharp target pixel
-#define RADIUS 1
+struct PKL_FILTER {
+	int type;
+	int matrix[9];
+};
 
-typedef struct {
-	int max, min;
-	long data[PKL_COLOR];
-} PKL_HISTGRAM;
+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_enhance.c

@@ -0,0 +1,274 @@
+#include "pikl_enhance.h"
+
+//=================================================================================
+// pkl_unsharp
+//=================================================================================
+PKLExport int pkl_unsharp(PKLImage pkl, int threshold, double edge)
+{
+	int i, j, p, q, k;
+	int cnt, value, stock[PKL_CHANNEL];
+	unsigned char *wrk, *s;
+	
+	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=-RADIUS; p<=RADIUS; p++){
+				for(q=-RADIUS; q<=RADIUS; 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++;
+					}
+				}
+			}
+			s = &wrk[(i * pkl->width + j) * pkl->channel];
+			for(k=0; k<pkl->channel; k++)
+				*s++ = stock[k] / cnt;
+		}
+	}
+	
+	for(i=0; i<pkl->height*pkl->width*pkl->channel; i++){
+		value = abs(pkl->image[i]-wrk[i])<threshold ? pkl->image[i] : pkl->image[i]+(pkl->image[i]-wrk[i])*edge;
+		pkl->image[i] = PKL_COLOR_CLIP(value);
+	}
+	free(wrk);
+	return(0);
+}
+
+//=================================================================================
+// pkl_contrast
+//=================================================================================
+PKLExport int pkl_contrast(PKLImage pkl, int rate)
+{
+	unsigned char ct[PKL_COLOR];
+	int value, i;
+
+	if(rate < -127 || rate > 127) return(1);
+
+	if(rate < 0.0){
+		//�d�݂������̎��͒����I�ɕ��R��
+		for(i=0; i<PKL_COLOR; i++){
+			value = i + (i-127) * rate/127;
+			ct[i] = PKL_COLOR_CLIP(value);
+		}
+	}else{
+		//�d�݂������̎��͎��g��
+		for(i=0; i<PKL_COLOR; i++){
+			value = i - rate*rate/127 * sin(M_PI/2+M_PI*i/255);
+			ct[i] = PKL_COLOR_CLIP(value);
+		}
+	}
+
+	for(i=0; i<pkl->width*pkl->height*pkl->channel; i++)
+		pkl->image[i] = ct[pkl->image[i]];
+
+	return(0);
+}
+
+//=================================================================================
+// pkl_level def=0.0050
+//=================================================================================
+PKLExport int pkl_level(PKLImage pkl, double low, double high, double coeff)
+{
+	PKL_HISTGRAM hst[PKL_CHANNEL];
+	int i, j, cnt, value;
+	double lt, ht;
+	
+	if((low  < 0.0 && low  > 100.0) ||
+	   (high < 0.0 && high > 100.0) ||
+	   (coeff< 0.0 && coeff> 2.0)) return(1);
+	
+	memset(&hst, 0, sizeof(hst));
+	for(i=0; i<pkl->height*pkl->width; i++){
+		for(j=0; j<pkl->channel; j++){
+			hst[j].data[ pkl->image[i*pkl->channel+j] ]++;
+		}
+	}
+
+	lt = (low / 100.0) * pkl->height * pkl->width;
+	ht = (high / 100.0) * pkl->height * pkl->width;
+	
+	for(i=0; i<pkl->channel; i++){
+		cnt=0;
+		for(j=0; j<PKL_COLOR; j++){
+			cnt += hst[i].data[j];
+			if(cnt > lt){
+				hst[i].min = j;
+				break;
+			}
+		}
+		cnt=0;
+		for(j=PKL_COLOR-1; j>=0; j--){
+			cnt += hst[i].data[j];
+			if(cnt > ht){
+				hst[i].max = j;
+				break;
+			}
+		}
+	}
+
+	//�q�X�g�O��������e�[�u���𐶐�
+	for(i=0; i<pkl->channel; i++){
+		for(j=0; j<PKL_COLOR; j++){
+			value = ((coeff * j)-hst[i].min) / (hst[i].max-hst[i].min+1) * 255;
+			hst[i].data[j] = PKL_COLOR_CLIP(value);
+		}
+	}
+
+	for(i=0; i<pkl->width*pkl->height; i++)
+		for(j=0; j<pkl->channel; j++)
+			pkl->image[i*pkl->channel+j] = hst[j].data[pkl->image[i*pkl->channel+j]];
+
+	return(0);
+}
+
+//=============================================================================
+// pkl_brightness
+//=============================================================================
+PKLExport int pkl_brightness(PKLImage pkl, int color)
+{
+	int i;
+	for(i=0; i<pkl->width*pkl->height*pkl->channel; i++)
+		pkl->image[i] = PKL_COLOR_CLIP(pkl->image[i] + color);
+	return(0);
+}
+
+//=============================================================================
+// pkl_hls
+//=============================================================================
+PKLExport int pkl_hls(PKLImage pkl, double ym, double sm, double hd)
+{
+	int i;
+	double c1, c2;	//�F�M��
+	double y, s, h;	//y=�P�x, s=�ʓx, h=�F��
+	
+	if(pkl->color != PKL_RGB) return(1);
+	
+	for(i=0; i<pkl->width*pkl->height; i++){
+		/* �P�x,�F�M��1,2 */
+		y  = 0.299 * pkl->image[i*pkl->channel]   +
+			 0.587 * pkl->image[i*pkl->channel+1] +
+			 0.114 * pkl->image[i*pkl->channel+2];
+		c1 = pkl->image[i*pkl->channel]   - y;
+		c2 = pkl->image[i*pkl->channel+2] - y;
+		
+		/* �ʓx */
+		s = sqrt(c1*c1 + c2*c2);
+		
+		/* �F�� */
+		if(s < 0.0) h = 0.0;
+		else        h = atan2(c1, c2) * 180.0 / M_PI;
+		
+		/* ������������ */
+		y *= (1 + ym);
+		s *= (1 + sm);
+		h += hd;
+		
+		/* �����l����RGB�ɖ߂� */
+		c1 = s * sin(M_PI * h / 180.0);
+		c2 = s * cos(M_PI * h / 180.0);
+
+		pkl->image[i*pkl->channel]   = PKL_COLOR_CLIP(c1 + y);
+		pkl->image[i*pkl->channel+1] = PKL_COLOR_CLIP(y - (0.299*c1 + 0.114*c2)/0.587);
+		pkl->image[i*pkl->channel+2] = PKL_COLOR_CLIP(c2 + y);
+	}
+	return(0);
+}
+
+//=================================================================================
+// pkl_gamma
+//=================================================================================
+PKLExport int pkl_gamma(PKLImage pkl, double gm)
+{
+	unsigned char gt[PKL_COLOR];
+	int i;
+	
+	if(gm < 0.0) return(1);
+	
+	for(i=0; i<PKL_COLOR; i++)
+		gt[i] = PKL_COLOR_CLIP(255.0 * pow(i/255.0, 1.0/gm));
+	
+	for(i=0; i<pkl->width*pkl->height*pkl->channel; i++)
+		pkl->image[i] = gt[pkl->image[i]];
+
+	return(0);
+}
+
+//=============================================================================
+// pkl_noisecut(median filter)
+//=============================================================================
+PKLExport int pkl_noisecut(PKLImage pkl)
+{
+	unsigned char *wrk, *p, sort[PKL_CHANNEL][9], median[PKL_CHANNEL];
+	int i, j, tx, ty, k, clipx, clipy, rd, s, t, n;
+
+	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++){
+			rd=0;
+			for(ty=-1; ty<=1; ty++){
+				for(tx=-1; tx<=1; tx++){
+					clipx = j+tx < 0 ? 0 : j+tx>=pkl->width ? pkl->width-1 : j+tx;
+					clipy = i+ty < 0 ? 0 : i+ty>=pkl->height ? pkl->height-1 : i+ty;
+					p = &pkl->image[(clipy*pkl->width+clipx)*pkl->channel];
+					for(k=0; k<pkl->channel; k++)
+						sort[k][rd] = *p++;
+					rd++;
+				}
+			}
+			//�����l�T��
+			for(k=0; k<pkl->channel; k++){
+				for(s=0; s<5; s++){
+					for(t=1,n=0,median[k]=sort[k][0]; t<9; t++){
+						if(median[k]<sort[k][t]){
+							median[k]=sort[k][t];
+							n=t;
+						}
+					}
+					sort[k][n]=0;
+				}
+			}
+			p= &wrk[(i*pkl->width+j)*pkl->channel];
+			for(k=0; k<pkl->channel; k++) *p++=median[k];
+		}
+	}
+
+	free(pkl->image);
+	pkl->image = wrk;
+	return(0);
+}
+
+//=================================================================================
+// pkl_trim
+//=================================================================================
+PKLExport int pkl_trim(PKLImage pkl, int sx, int sy, int width, int height)
+{
+	unsigned char *wrk;
+	int p, y;
+	
+	if( sx < 0 || sy < 0 || width <= 0 || height <= 0 ) return(1);
+	if( sx+width  > pkl->width  ) return(1);
+	if( sy+height > pkl->height ) return(1);
+	
+	wrk = malloc(height * width * pkl->channel);
+	if(!wrk) return(1);
+	
+	for(p=0,y=sy; y<sy+height; p++,y++){
+		memcpy(&wrk[p*width*pkl->channel], &pkl->image[(y*pkl->width+sx)*pkl->channel], width*pkl->channel);
+	}
+	
+	free(pkl->image);
+	pkl->image  = wrk;
+	pkl->height = height;
+	pkl->width  = width;
+
+	return(0);
+}

data/ext/pikl/pikl_enhance.h

@@ -0,0 +1,20 @@
+#ifndef _LIB_PIKL_ENHANCE_
+#define _LIB_PIKL_ENHANCE_
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+
+#include "pikl.h"
+#include "pikl_private.h"
+
+//unsharp target pixel
+#define RADIUS 1
+
+typedef struct {
+	int max, min;
+	long data[PKL_COLOR];
+} PKL_HISTGRAM;
+
+#endif

data/ext/pikl/pikl_io.c

@@ -1,48 +1,114 @@
 #include "pikl_io.h"
 
 static int format_type(PKLImage pkl, FILE *image);
+
 //=============================================================================
-// pkl_open
+// pkl_canvas
 //=============================================================================
-PKLExport PKLImage pkl_open(const char *in)
+PKLExport PKLImage pkl_canvas(int width, int height, PKL_COLOR_SPACE color, PKLColor backcolor)
 {
 	PKLImage pkl;
-	FILE *image;
-	int result=0;
+	PKL_COLOR_SPACE colorspace;
+	int channel, i;
+	unsigned char back[PKL_CHANNEL];
+	
+	switch(color){
+		case PKL_GRAYSCALE:
+			colorspace = PKL_GRAYSCALE;
+			channel = 1;
+			break;
+		case PKL_RGB:
+			colorspace = PKL_RGB;
+			channel = 3;
+			break;
+		case PKL_CMYK:
+			colorspace = PKL_CMYK;
+			channel = 4;
+			break;
+		default:
+			return(NULL);
+	}
 	
 	pkl = malloc( sizeof(struct _PKLImage) );
 	if(!pkl) return(NULL);
 	memset(pkl, 0, sizeof(struct _PKLImage));
 	
+	pkl->image = malloc(width*height*channel);
+	if(!pkl->image){
+		free(pkl);
+		return(NULL);
+	}
+	
+	pkl->width = width;
+	pkl->height = height;
+	pkl->color = colorspace;
+	pkl->channel = channel;
+	pkl->format = PKL_FORMAT_ERROR;
 	pkl->compress = -1;
-	pkl->x_scale=1.0;
-	pkl->y_scale=1.0;
+	
+	//for(i=0; i<pkl->channel; i++)
+	//	back[i] = (backcolor>>((pkl->channel-i)*8) & 0xFF);
+	if(backcolor)
+		memcpy(back, backcolor->color, PKL_CHANNEL);
+	else
+		memset(back, 0xff, PKL_CHANNEL);
+	
+	for(i=0; i<pkl->width*pkl->height*pkl->channel; i+=pkl->channel)
+		memcpy(&pkl->image[i], back, pkl->channel);
+	return(pkl);
+}
+
+//=============================================================================
+// pkl_open
+//=============================================================================
+PKLExport PKLImage pkl_open(const char *in)
+{
+	FILE *image;
+	PKLImage pkl;
 	
 	image = fopen(in, "rb");
 	if(!image) return(NULL);
 	
-	format_type(pkl, image);
+	pkl = pkl_fdopen(image);
+	
+	fclose(image);
+	return(pkl);
+}
+
+//=================================================================================
+// pkl_fdopen
+//=================================================================================
+PKLExport PKLImage pkl_fdopen(FILE *in)
+{
+	PKLImage pkl;
+	int result;
+	
+	pkl = malloc( sizeof(struct _PKLImage) );
+	if(!pkl) return(NULL);
+	memset(pkl, 0, sizeof(struct _PKLImage));
+	
+	pkl->compress = -1;
+	
+	format_type(pkl, in);
 
 	switch(pkl->format){
 		case PKL_FORMAT_JPEG:
-			result = load_jpeg(pkl, image);
+			result = load_jpeg(pkl, in);
 			break;
 		case PKL_FORMAT_PNG:
-			result = load_png(pkl, image);
+			result = load_png(pkl, in);
 			break;
 		case PKL_FORMAT_BITMAP:
-			result = load_bitmap(pkl, image);
+			result = load_bitmap(pkl, in);
 			break;
 		default:
 			result = 1;
 	}
-	fclose(image);
 	
 	if(result){
 		free(pkl);
-		pkl = NULL;
+		pkl=NULL;
 	}
-	
 	return(pkl);
 }
 
@@ -51,10 +117,42 @@ PKLExport PKLImage pkl_open(const char *in)
 //=============================================================================
 PKLExport void pkl_close(PKLImage pkl)
 {
+	if(!pkl) return;
 	if(pkl->image) free(pkl->image);
 	free(pkl);
 }
 
+//=============================================================================
+// pkl_dup
+//=============================================================================
+PKLExport PKLImage pkl_dup(PKLImage pkl)
+{
+	PKLImage dst;
+	
+	if(!pkl) return(NULL);
+	
+	dst = malloc(sizeof(struct _PKLImage));
+	if(!dst) return(NULL);
+	memset(dst, 0, sizeof(struct _PKLImage));
+	
+	dst->width = pkl->width;
+	dst->height = pkl->height;
+	dst->color = pkl->color;
+	dst->channel = pkl->channel;
+	dst->format = pkl->format;
+	dst->compress = pkl->compress;
+	
+	if(pkl->image){
+		dst->image = malloc(pkl->width*pkl->height*pkl->channel);
+		if(!dst->image){
+			free(dst);
+			return(NULL);
+		}
+		memcpy(dst->image, pkl->image, pkl->width*pkl->height*pkl->channel);
+	}
+	return(dst);
+}
+
 //=============================================================================
 // format_type
 //=============================================================================
@@ -100,6 +198,14 @@ PKLExport int pkl_height(PKLImage pkl)
 	return(pkl->height);
 }
 
+//=============================================================================
+// pkl_colorspace
+//=============================================================================
+PKLExport PKL_COLOR_SPACE pkl_colorspace(PKLImage pkl)
+{
+	return(pkl->color);
+}
+
 //=============================================================================
 // pkl_compress
 //=============================================================================
@@ -116,24 +222,69 @@ PKLExport int pkl_compress(PKLImage pkl, int level)
 PKLExport int pkl_save(PKLImage pkl, const char *out, PKL_FORMAT format)
 {
 	FILE *image;
-	int result=0;
+	int result;
 	
 	image = fopen(out, "wb");
 	if(!image) return(1);
 	
+	result = pkl_output(pkl, image, format);
+	
+	fclose(image);
+	return(result);
+}
+
+//=================================================================================
+// pkl_output
+//=================================================================================
+PKLExport int pkl_output(PKLImage pkl, FILE *out, PKL_FORMAT format)
+{
 	switch(format){
 		case PKL_FORMAT_JPEG:
-			result = save_jpeg(pkl, image);
-			break;
+			return save_jpeg(pkl, out);
 		case PKL_FORMAT_PNG:
-			result = save_png(pkl, image);
-			break;
+			return save_png(pkl, out);
 		case PKL_FORMAT_BITMAP:
-			result = save_bitmap(pkl, image);
-			break;
+			return save_bitmap(pkl, out);
 		default:
-			result=1;
+			return(1);
 	}
-	fclose(image);
-	return(result);
+	return(1);
+}
+
+//=============================================================================
+// pkl_count
+//=============================================================================
+PKLExport int pkl_count(PKLImage pkl)
+{
+	unsigned char *colors;
+	int i, j, byte, bit, count=0, channel;
+	union {
+		int color;
+		unsigned char row[PKL_CHANNEL];
+	} pixel;
+	
+	switch(pkl->channel){
+		case 1: channel=1; break;
+		case 3:
+		case 4: channel=3; break;
+		default: return(0);
+	}
+
+	colors = malloc(256 * 256 * 32);
+	memset(colors, 0, 256 * 256 * 32);
+
+	for(i=0; i<pkl->height; i++){
+		for(j=0; j<pkl->width; j++){
+			pixel.color=0;
+			memcpy(pixel.row, &pkl->image[(i*pkl->width+j)*pkl->channel], channel);
+			byte = pixel.color / 8;
+			bit = pixel.color  % 8;
+			
+			if((colors[byte]&(1<<bit))) continue;
+			colors[byte] = colors[byte]|(1<<bit);
+			count++;
+		}
+	}
+	free(colors);
+	return(count);
 }