pikl 0.1.0

data/ext/pikl/pikl_bitmap.c

@@ -0,0 +1,152 @@
+#include "pikl_bitmap.h"
+
+static void bmp_header(unsigned char *data, int offset, int value, int size);
+static int convert_numeric(unsigned char *src, int size);
+static int color_b2p(int biBitCount);
+static int bmp_channel(int biBitCount);
+static int bmp_width(int width, int channel);
+
+//=============================================================================
+// load_bitmap
+//=============================================================================
+int load_bitmap(PKLImage pkl, FILE *image)
+{
+	unsigned char header[BF_SIZE + BI_SIZE];
+	unsigned char *p, stuck;
+	int i, j, offset, scansize;
+	
+	if( fread(header, 1, sizeof(header), image) != sizeof(header) ) return(1);
+
+	pkl->width   = convert_numeric(&header[18], 4);
+	pkl->height  = convert_numeric(&header[22], 4);
+	pkl->color   = color_b2p(convert_numeric(&header[28], 2));
+	pkl->channel = bmp_channel(convert_numeric(&header[28], 2));
+	if(pkl->color==PKL_UNKNOWN) return(1);
+	
+	pkl->image = malloc(pkl->width * pkl->height * pkl->channel);
+	if(!pkl->image) return(1);
+	
+	offset = convert_numeric(&header[10], 4);
+	scansize = bmp_width(pkl->width, pkl->channel);
+
+	p = pkl->image + ((pkl->height-1) * pkl->width * pkl->channel);
+	fseek(image, offset, SEEK_SET);
+	
+	for(i=0; i<pkl->height; i++){
+		fread(p, 1, pkl->width*pkl->channel, image);
+		for(j=0; j<pkl->width; j++){
+			stuck = p[j*pkl->channel];
+			p[j*pkl->channel] = p[j*pkl->channel+2];
+			p[j*pkl->channel+2] = stuck;
+		}
+		p -= pkl->width*pkl->channel;
+		offset += scansize;
+		fseek(image, offset, SEEK_SET);
+	}
+	
+	return(0);
+}
+
+//=============================================================================
+// color_b2p
+//	biBitCount = 1,4,8,16,24,32
+//=============================================================================
+static int color_b2p(int biBitCount)
+{
+	switch(biBitCount){
+		case 24:
+			return PKL_RGB;
+		default:
+			return PKL_UNKNOWN;
+	}
+	return PKL_UNKNOWN;
+}
+
+//=============================================================================
+// bmp_channel
+//	biBitCount = 1,4,8,16,24,32
+//=============================================================================
+static int bmp_channel(int biBitCount)
+{
+	switch(biBitCount){
+		case 24:
+			return 3;
+		default:
+			return 0;
+	}
+	return 0;
+}
+
+//=============================================================================
+// convert_nv
+//=============================================================================
+static int convert_numeric(unsigned char *src, int size)
+{
+	int i, dst=0;
+	for(i=0; i<size; i++){
+		dst += (src[i]<<(8*i));
+	}
+	return(dst);
+}
+
+//=============================================================================
+// bmp_width
+//=============================================================================
+static int bmp_width(int width, int channel)
+{
+	int length;
+	if( width*channel % 4 ){
+		length = width*channel + (4 - width*channel % 4);
+	}else{
+		length = width*channel;
+	}
+	return(length);
+}
+
+//=============================================================================
+// save_bitmap
+//=============================================================================
+int save_bitmap(PKLImage pkl, FILE *image)
+{
+	unsigned char data[BF_SIZE+BI_SIZE], *wrk, stuck;
+	int linesize, i, j;
+	
+	linesize = bmp_width(pkl->width, pkl->channel);
+	
+	data[0] = 'B';
+	data[1] = 'M';
+	bmp_header(data, 2, BF_SIZE + BI_SIZE + linesize*pkl->height, 4);
+	bmp_header(data, 6, 0, 4);
+	bmp_header(data, 10, BF_SIZE + BI_SIZE, 4);
+	bmp_header(data, 14, BI_SIZE, 4);
+	bmp_header(data, 18, pkl->width, 4);
+	bmp_header(data, 22, pkl->height, 4);
+	bmp_header(data, 26, 1, 2);
+	bmp_header(data, 28, 24, 2);
+	bmp_header(data, 30, 0, 24);
+	fwrite(data, 1, BF_SIZE+BI_SIZE, image);
+	
+	wrk = malloc(linesize);
+	for(i=pkl->height-1; i>=0; i--){
+		memcpy(wrk, &pkl->image[i*pkl->width*pkl->channel], pkl->width*pkl->channel);
+		for(j=0; j<pkl->width; j++){
+			stuck = wrk[j*pkl->channel];
+			wrk[j*pkl->channel] = wrk[j*pkl->channel+2];
+			wrk[j*pkl->channel+2] = stuck;
+		}
+		fwrite(wrk, 1, linesize, image);
+	}
+	free(wrk);
+	return(0);
+}
+
+//=============================================================================
+// bmp_header
+//=============================================================================
+static void bmp_header(unsigned char *data, int offset, int value, int size)
+{
+	int i;
+	for(i=0; i<size; i++){
+		data[offset+i] = (unsigned char)(value >> (8*i));
+	}
+}

data/ext/pikl/pikl_bitmap.h

@@ -0,0 +1,18 @@
+#ifndef _LIB_PIKL_BITMAP_
+#define _LIB_PIKL_BITMAP_
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "pikl.h"
+#include "pikl_private.h"
+
+#define BF_SIZE 14		//BITMAPFILEHEADER size
+#define BI_SIZE 40		//BITMAPINFOHEADER size
+
+int load_bitmap(PKLImage pkl, FILE *image);
+int save_bitmap(PKLImage pkl, FILE *image);
+
+#endif
+

data/ext/pikl/pikl_effect.c

@@ -0,0 +1,191 @@
+#include "pikl_effect.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;
+	
+	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++;
+					}
+				}
+			}
+			for(k=0; k<pkl->channel; k++){
+				wrk[(i * pkl->width + j) * pkl->channel+k] = 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_RGB(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_RGB(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_RGB(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;
+
+	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] ]++;
+		}
+	}
+
+	for(i=0; i<pkl->channel; i++){
+		cnt=0;
+		for(j=0; j<PKL_COLOR; j++){
+			cnt += hst[i].data[j];
+			if(cnt > low/100*pkl->height*pkl->width){
+				hst[i].min = j;
+				break;
+			}
+		}
+		cnt=0;
+		for(j=PKL_COLOR-1; j>=0; j--){
+			cnt += hst[i].data[j];
+			if(cnt > high/100*pkl->height*pkl->width){
+				hst[i].max = j;
+				break;
+			}
+		}
+	}
+
+	for(i=0; i<pkl->width*pkl->height; i++){
+		for(j=0; j<pkl->channel; j++){
+			value = ((coeff * pkl->image[i*pkl->channel+j])-hst[j].min)/(hst[j].max-hst[j].min) * 255;
+			pkl->image[i*pkl->channel+j] = PKL_RGB(value);
+		}
+	}
+
+	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_RGB(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_RGB(c1 + y);
+		pkl->image[i*pkl->channel+1] = PKL_RGB(y - (0.299*c1 + 0.114*c2)/0.587);
+		pkl->image[i*pkl->channel+2] = PKL_RGB(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_RGB(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);
+}

data/ext/pikl/pikl_effect.h

@@ -0,0 +1,24 @@
+#ifndef _LIB_PIKL_EFFECT_
+#define _LIB_PIKL_EFFECT_
+
+#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
+
+#ifndef M_PI
+	#define M_PI 3.14159265358979323846
+#endif
+
+typedef struct {
+	int max, min;
+	long data[PKL_COLOR];
+} PKL_HISTGRAM;
+
+#endif

data/ext/pikl/pikl_io.c

@@ -0,0 +1,137 @@
+#include "pikl_io.h"
+
+static int format_type(PKLImage pkl, FILE *image);
+//=============================================================================
+// pkl_open
+//=============================================================================
+PKLExport PKLImage pkl_open(const char *in)
+{
+	PKLImage pkl;
+	FILE *image;
+	int result=0;
+	
+	pkl = malloc( sizeof(struct _PKLImage) );
+	if(!pkl) return(NULL);
+	memset(pkl, 0, sizeof(struct _PKLImage));
+	
+	pkl->compress = -1;
+	
+	image = fopen(in, "rb");
+	if(!image) return(NULL);
+	
+	format_type(pkl, image);
+
+	switch(pkl->format){
+		case PKL_FORMAT_JPEG:
+			result = load_jpeg(pkl, image);
+			break;
+		case PKL_FORMAT_PNG:
+			result = load_png(pkl, image);
+			break;
+		case PKL_FORMAT_BITMAP:
+			result = load_bitmap(pkl, image);
+			break;
+		default:
+			result = 1;
+	}
+	fclose(image);
+	
+	if(result){
+		free(pkl);
+		pkl = NULL;
+	}
+	
+	return(pkl);
+}
+
+//=============================================================================
+// pkl_close
+//=============================================================================
+PKLExport void pkl_close(PKLImage pkl)
+{
+	if(pkl->image) free(pkl->image);
+	free(pkl);
+}
+
+//=============================================================================
+// format_type
+//=============================================================================
+static int format_type(PKLImage pkl, FILE *image)
+{
+	unsigned char mark[PKL_HEADER_SIZE];
+	int count, i;
+
+	if( fread(mark, 1, PKL_HEADER_SIZE, image) < PKL_HEADER_SIZE ) return(1);
+
+	count = sizeof(pklheader) /sizeof(struct PKL_HEADER);
+	for(i=0; i<count; i++){
+		if( !memcmp(mark, pklheader[i].mark, pklheader[i].size) ){
+			pkl->format = pklheader[i].format;
+			fseek(image, 0, SEEK_SET);
+			return(0);
+		}
+	}
+	return(1);
+}
+
+//=============================================================================
+// pkl_format
+//=============================================================================
+PKLExport PKL_FORMAT pkl_format(PKLImage pkl)
+{
+	return(pkl->format);
+}
+
+//=================================================================================
+// pkl_width
+//=================================================================================
+PKLExport int pkl_width(PKLImage pkl)
+{
+	return(pkl->width);
+}
+
+//=================================================================================
+// pkl_height
+//=================================================================================
+PKLExport int pkl_height(PKLImage pkl)
+{
+	return(pkl->height);
+}
+
+//=============================================================================
+// pkl_compress
+//=============================================================================
+PKLExport int pkl_compress(PKLImage pkl, int level)
+{
+	if(level < 0 || level > 10) return(pkl->compress);
+	pkl->compress = level;
+	return(pkl->compress);
+}
+
+//=================================================================================
+// pkl_save
+//=================================================================================
+PKLExport int pkl_save(PKLImage pkl, const char *out, PKL_FORMAT format)
+{
+	FILE *image;
+	int result=0;
+	
+	image = fopen(out, "wb");
+	if(!image) return(1);
+	
+	switch(format){
+		case PKL_FORMAT_JPEG:
+			result = save_jpeg(pkl, image);
+			break;
+		case PKL_FORMAT_PNG:
+			result = save_png(pkl, image);
+			break;
+		case PKL_FORMAT_BITMAP:
+			result = save_bitmap(pkl, image);
+			break;
+		default:
+			result=1;
+	}
+	fclose(image);
+	return(result);
+}