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

data/ext/pikl/pikl_rotate2.c

@@ -1,312 +0,0 @@
-#include "pikl_rotate2.h"
-
-static void get_rect(PIKL_RECT *rect, int w, int h, float rad);
-static int ext_cmp_int(const void *a, const void *b);
-static int pkl_rotate_nn(PKLImage pkl, float angle, unsigned char *backcolor);
-static int pkl_rotate_bl(PKLImage pkl, float angle, unsigned char *backcolor);
-static int pkl_rotate_bc(PKLImage pkl, float angle, unsigned char *backcolor);
-//static int pkl_rotate_pa(PKLImage pkl, float angle, int backcolor);
-//===================================================================
-// pkl_rotate2
-//===================================================================
-PKLExport int pkl_rotate2(PKLImage pkl, float angle, PKL_SAMPLE sample,
-								unsigned char a, unsigned char b, unsigned char c, unsigned char d)
-{
-	unsigned char backcolor[4];
-	
-	backcolor[0] = a;
-	backcolor[1] = b;
-	backcolor[2] = c;
-	backcolor[3] = d;
-	
-	switch(sample){
-		case PKL_SAMPLE_NN:
-			return pkl_rotate_nn(pkl, angle, backcolor);
-		case PKL_SAMPLE_BL:
-			return pkl_rotate_bl(pkl, angle, backcolor);
-		case PKL_SAMPLE_BC:
-		case PKL_SAMPLE_PA:
-		case PKL_SAMPLE_LZ:
-			return pkl_rotate_bc(pkl, angle, backcolor);
-			//return pkl_rotate_pa(pkl, angle, backcolor);
-		default:
-			return(1);
-	}
-	return(1);
-}
-
-//=============================================================================
-// rotate_pos
-//=============================================================================
-static void get_rect(PIKL_RECT *rect, int width, int height, float rad)
-{
-	int nimg_x[4], nimg_y[4];
-	int i, x, y;
-
-	nimg_x[0] = 0;
-	nimg_y[0] = 0;
-	nimg_x[1] = width;
-	nimg_y[1] = 0;
-	nimg_x[2] = 0;
-	nimg_y[2] = height;
-	nimg_x[3] = width;
-	nimg_y[3] = height;
-
-	for(i=0; i<4; i++){
-		x = (int)(cos(-rad)*nimg_x[i] - sin(-rad)*nimg_y[i]);
-		y = (int)(sin(-rad)*nimg_x[i] + cos(-rad)*nimg_y[i]);
-		nimg_x[i] = x;
-		nimg_y[i] = y;
-	}
-	qsort(nimg_x, 4, sizeof(int), ext_cmp_int);
-	qsort(nimg_y, 4, sizeof(int), ext_cmp_int);
-	rect->left   = nimg_x[0];
-	rect->top    = nimg_y[0];
-	rect->right  = nimg_x[3];
-	rect->bottom = nimg_y[3];
-}
-
-//=================================================================================
-// ext_cmp_int
-//=================================================================================
-static int ext_cmp_int(const void *a, const void *b)
-{
-	return *((int *)a) - *((int *)b);
-}
-
-//=============================================================================
-// pkl_rotate_nn
-//=============================================================================
-static int pkl_rotate_nn(PKLImage pkl, float angle, unsigned char *backcolor)
-{
-	int width, height;
-	PIKL_RECT rect;
-	float rad;
-	unsigned char *wrk, back[4];
-	int i, j, px, py;
-	
-	rad = -angle*M_PI/180;
-	get_rect(&rect, pkl->width, pkl->height, rad);
-	width = rect.right - rect.left;
-	height = rect.bottom - rect.top;
-
-	wrk = malloc(width * height * pkl->channel);
-	if(!wrk) return(1);
-	memset(wrk, 0, width*height*pkl->channel);
-	
-	//for(i=0; i<pkl->channel; i++)
-	//	back[i] = (backcolor>>((pkl->channel-i)*8) & 0xFF);
-	memcpy(back, backcolor, pkl->channel);
-
-	for(i=rect.top; i<rect.bottom; i++){
-		for(j=rect.left; j<rect.right; j++){
-			px = (int)(cos(rad) * j - sin(rad) * i);
-			py = (int)(sin(rad) * j + cos(rad) * i);
-			if(px>=0 && px<pkl->width && py>=0 && py<pkl->height){
-				memcpy(&wrk[((i-rect.top)*width+j-rect.left)*pkl->channel],
-					&pkl->image[(py*pkl->width+px)*pkl->channel], pkl->channel);
-			}else{
-				memcpy(&wrk[((i-rect.top)*width+j-rect.left)*pkl->channel], back, pkl->channel);
-			}
-		}
-	}
-
-	free(pkl->image);
-	pkl->image = wrk;
-	pkl->width = width;
-	pkl->height = height;
-	return(0);
-}
-
-//=============================================================================
-// pkl_rotate_bl
-//=============================================================================
-static int pkl_rotate_bl(PKLImage pkl, float angle, unsigned char *backcolor)
-{
-	int width, height;
-	PIKL_RECT rect;
-	float rad;
-	unsigned char *wrk, back[4];
-	int i, j, k, wx, wy, sx, sy;
-	double dx, dy, px, py, f[4];
-	
-	rad = -angle*M_PI/180;
-	get_rect(&rect, pkl->width, pkl->height, rad);
-	width = rect.right - rect.left;
-	height = rect.bottom - rect.top;
-
-	wrk = malloc(width * height * pkl->channel);
-	if(!wrk) return(1);
-	memset(wrk, 0, width*height*pkl->channel);
-	
-	//for(i=0; i<pkl->channel; i++)
-	//	back[i] = (backcolor>>((pkl->channel-i)*8) & 0xFF);
-	memcpy(back, backcolor, pkl->channel);
-	
-	for(i=rect.top; i<rect.bottom; i++){
-		for(j=rect.left; j<rect.right; j++){
-			dx = modf(cos(rad)*j-sin(rad)*i, &px);
-			dy = modf(sin(rad)*j+cos(rad)*i, &py);
-			f[0] = (1.0-dx)*(1.0-dy);
-			f[1] = dx*(1.0-dy);
-			f[2] = (1.0-dx)*dy;
-			f[3] = dx*dy;
-
-			for(wy=0; wy<2; wy++){
-				for(wx=0; wx<2; wx++){
-					sx = ((int)px+wx<0) ? pkl->width +((int)px+wx)%pkl->width -1 : ((int)px+wx)%pkl->width;
-					sy = ((int)py+wy<0) ? pkl->height+((int)py+wy)%pkl->height-1 : ((int)py+wy)%pkl->height;
-					if(px>=0 && px<pkl->width && py>=0 && py<pkl->height){
-						for(k=0; k<pkl->channel; k++){
-							wrk[((i-rect.top)*width+j-rect.left)*pkl->channel+k] = 
-								PKL_COLOR_CLIP(wrk[((i-rect.top)*width+j-rect.left)*pkl->channel+k] +
-										pkl->image[(sy*pkl->width+sx)*pkl->channel+k] * f[wy*2+wx]);
-						}
-					}else{
-						memcpy(&wrk[((i-rect.top)*width+j-rect.left)*pkl->channel], back, pkl->channel);
-					}
-				}
-			}
-		}
-	}
-
-	free(pkl->image);
-	pkl->image = wrk;
-	pkl->width = width;
-	pkl->height = height;
-	return(0);
-}
-
-//=============================================================================
-// pkl_rotate_bc
-//=============================================================================
-static int pkl_rotate_bc(PKLImage pkl, float angle, unsigned char *backcolor)
-{
-	int width, height;
-	PIKL_RECT rect;
-	float rad;
-	unsigned char *wrk, back[4];
-	int i, j, k, px, py, x0, y0;
-	double wx, wy, dx, dy, sx, sy;
-	double data[PKL_CHANNEL];
-
-	rad = -angle*M_PI/180;
-	get_rect(&rect, pkl->width, pkl->height, rad);
-	width = rect.right - rect.left;
-	height = rect.bottom - rect.top;
-
-	wrk = malloc(width * height * pkl->channel);
-	if(!wrk) return(1);
-	memset(wrk, 0, width*height*pkl->channel);
-	
-	//for(i=0; i<pkl->channel; i++)
-	//	back[i] = (backcolor>>((pkl->channel-i)*8) & 0xFF);
-	memcpy(back, backcolor, pkl->channel);
-	
-	for(i=rect.top; i<rect.bottom; i++){
-		for(j=rect.left; j<rect.right; j++){
-			memset(&data, 0, sizeof(data));
-			sx = cos(rad) * j - sin(rad) * i;
-			sy = sin(rad) * j + cos(rad) * i;
-			for(py=(int)sy-1; py<=(int)sy+2; py++){
-				for(px=(int)sx-1; px<=(int)sx+2; px++){
-					dx = fabs(sx-px);
-					dy = fabs(sy-py);
-					wx = (dx<1) ? (dx-1)*(dx*dx-dx-1) : -(dx-1)*(dx-2)*(dx-2);
-					wy = (dy<1) ? (dy-1)*(dy*dy-dy-1) : -(dy-1)*(dy-2)*(dy-2);
-					x0 = (px<0 || px>pkl->width -1) ? sx : px;
-					y0 = (py<0 || py>pkl->height-1) ? sy : py;
-					
-					if(x0>=0 && x0<pkl->width && y0>=0 && y0<pkl->height){
-						for(k=0; k<pkl->channel; k++)
-							data[k] += pkl->image[(y0*pkl->width+x0)*pkl->channel+k]*wx*wy;
-					}
-				}
-			}
-			
-			if(sx>=0 && sx<pkl->width && sy>=0 && sy<pkl->height){
-				for(k=0; k<pkl->channel; k++)
-					wrk[((i-rect.top)*width+j-rect.left)*pkl->channel+k] = PKL_COLOR_CLIP(data[k]);
-			}else{
-				memcpy(&wrk[((i-rect.top)*width+j-rect.left)*pkl->channel], back, pkl->channel);
-			}
-		}
-	}
-
-	free(pkl->image);
-	pkl->image = wrk;
-	pkl->width = width;
-	pkl->height = height;
-	return(0);
-}
-
-////=============================================================================
-//// pkl_rotate_pa
-////=============================================================================
-//static int pkl_rotate_pa(PKLImage pkl, float angle, int backcolor)
-//{
-//	int width, height;
-//	PIKL_RECT rect;
-//	float rad;
-//	unsigned char *wrk, back[4];
-//	int i, j;
-//	double zx, zy, power;
-//	
-//	rad = -angle*M_PI/180;
-//	get_rect(&rect, pkl->width, pkl->height, rad);
-//	width = rect.right - rect.left;
-//	height = rect.bottom - rect.top;
-//
-//	wrk = malloc(width * height * pkl->channel);
-//	if(!wrk) return(1);
-//	memset(wrk, 0, width*height*pkl->channel);
-//	
-//	for(i=0; i<pkl->channel; i++)
-//		back[i] = (backcolor>>((pkl->channel-i)*8) & 0xFF);
-//
-//	zx = (double)pkl->width  / (double)width;
-//	zy = (double)pkl->height / (double)height;
-//	//���_�����������ϒl�Z�o�l
-//	power= zx*zy + (zx*zy * angle*M_PI/180 * angle*M_PI/180);
-//
-//	for(i=rect.top; i<rect.bottom; i++){
-//		for(j=rect.left; j<rect.right; j++){
-//			double w1, w2, h1, h2;
-//			double w1b, w2b, h1b, h2b;
-//			double bi, ixg[PKL_CHANNEL] = {0.0, 0.0, 0.0, 0.0};
-//			int fsx ,fsy, s, t, k;
-//			
-//			w1b = modf(cos(rad)*j    -sin(rad)*i,     &w1);
-//			w2b = modf(cos(rad)*(j+1)-sin(rad)*i, &w2);
-//			h1b = modf(sin(rad)*j    +cos(rad)*i,     &h1);
-//			h2b = modf(sin(rad)*j+cos(rad)*(i+1), &h2);
-//
-//			for(s=(int)w1; s<=(int)w2; s++){
-//				for(t=(int)h1; t<=(int)h2; t++){
-//					bi = 1.0;
-//					if(s == (int)w1) bi*=(1-w1b);
-//					if(s == (int)w2) bi*=(w2b);
-//					if(t == (int)h1) bi*=(1-h1b);
-//					if(t == (int)h2) bi*=(h2b);
-//					fsx = (s < 0) ? 0 : (s > pkl->width -1) ? pkl->width -1 : s;
-//					fsy = (t < 0) ? 0 : (t > pkl->height-1) ? pkl->height-1 : t;
-//					for(k=0; k<pkl->channel; k++)
-//						ixg[k] += pkl->image[(fsy*pkl->width+fsx)*pkl->channel+k] * bi;
-//				}
-//			}
-//			
-//			if((int)w1>=0 && (int)w1<pkl->width && (int)h1>=0 && (int)h1<pkl->height){
-//				for(k=0; k<pkl->channel; k++)
-//					wrk[((i-rect.top)*width+j-rect.left)*pkl->channel+k] = PKL_RGB(ixg[k]/power);
-//			}else{
-//				memcpy(&wrk[((i-rect.top)*width+j-rect.left)*pkl->channel], back, pkl->channel);
-//			}
-//
-//		}
-//	}
-//	free(pkl->image);
-//	pkl->image = wrk;
-//	pkl->width = width;
-//	pkl->height = height;
-//	return(0);
-//}

data/ext/pikl/pikl_rotate2.h

@@ -1,19 +0,0 @@
-#ifndef _LIB_PIKL_ROTATE2_
-#define _LIB_PIKL_ROTATE2_
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <math.h>
-#include "pikl.h"
-#include "pikl_private.h"
-
-typedef struct{
-	int left;
-	int top;
-	int right;
-	int bottom;
-} PIKL_RECT;
-
-#endif
-

data/ext/pikl/pikl_trim.c

@@ -1,28 +0,0 @@
-#include "pikl_trim.h"
-
-//=================================================================================
-// 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);
-}