pikl 0.2.7-x86-mswin32 → 0.2.8-x86-mswin32
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- data/Manifest.txt +23 -0
- data/ext/pikl/decrease/fsdither.h +554 -0
- data/ext/pikl/decrease/median.c +1179 -0
- data/ext/pikl/decrease/median.h +7 -0
- data/ext/pikl/decrease/neuquan5.c +563 -0
- data/ext/pikl/decrease/neuquant.h +62 -0
- data/ext/pikl/decrease/wu.c +447 -0
- data/ext/pikl/decrease/wu.h +7 -0
- data/ext/pikl/pikl_affine.c +250 -0
- data/ext/pikl/pikl_affine.h +20 -0
- data/ext/pikl/pikl_blur.c +244 -0
- data/ext/pikl/pikl_blur.h +12 -0
- data/ext/pikl/pikl_decrease.c +126 -0
- data/ext/pikl/pikl_decrease.h +19 -0
- data/ext/pikl/pikl_effect2.c +240 -0
- data/ext/pikl/pikl_effect2.h +55 -0
- data/ext/pikl/pikl_effect3.c +266 -0
- data/ext/pikl/pikl_effect3.h +12 -0
- data/ext/pikl/pikl_effect4.c +495 -0
- data/ext/pikl/pikl_effect4.h +12 -0
- data/ext/pikl/pikl_pattern.c +611 -0
- data/ext/pikl/pikl_pattern.h +12 -0
- data/ext/pikl/pikl_scrap.c +731 -0
- data/ext/pikl/pikl_scrap.h +12 -0
- data/lib/pikl/version.rb +1 -1
- metadata +26 -3
@@ -0,0 +1,250 @@
|
|
1
|
+
#include "pikl_affine.h"
|
2
|
+
|
3
|
+
static int pkl_affine_nn(PKLImage pkl, point2 *p, unsigned char *dst);
|
4
|
+
static int pkl_affine_bl(PKLImage pkl, point2 *p, unsigned char *dst);
|
5
|
+
static point2 *transform(matrix *mat, int x, int y, point2 *p);
|
6
|
+
static matrix *pkl_matrix(PKLImage pkl, matrix *mat);
|
7
|
+
|
8
|
+
static void matrix_init(matrix *mat);
|
9
|
+
static void matrix_scale(matrix *mat, double x_scale, double y_scale);
|
10
|
+
static void matrix_translate(matrix *mat, double x_trns, double y_trns);
|
11
|
+
static void matrix_rotate(matrix *mat, double angle);
|
12
|
+
static void matrix_build(matrix *mat1, matrix *mat2);
|
13
|
+
|
14
|
+
//=============================================================================
|
15
|
+
// pkl_matrix_scale
|
16
|
+
//=============================================================================
|
17
|
+
PKLExport void pkl_matrix_scale(PKLImage pkl, double x_scale, double y_scale)
|
18
|
+
{
|
19
|
+
pkl->x_scale = x_scale;
|
20
|
+
pkl->y_scale = y_scale;
|
21
|
+
}
|
22
|
+
|
23
|
+
//=============================================================================
|
24
|
+
// pkl_matrix_rotate
|
25
|
+
//=============================================================================
|
26
|
+
PKLExport void pkl_matrix_rotate(PKLImage pkl, double angle)
|
27
|
+
{
|
28
|
+
pkl->angle = angle;
|
29
|
+
}
|
30
|
+
|
31
|
+
//=============================================================================
|
32
|
+
// pkl_matrix_translate
|
33
|
+
//=============================================================================
|
34
|
+
PKLExport void pkl_matrix_translate(PKLImage pkl, int x, int y)
|
35
|
+
{
|
36
|
+
pkl->x_trns = x;
|
37
|
+
pkl->y_trns = y;
|
38
|
+
}
|
39
|
+
|
40
|
+
//=============================================================================
|
41
|
+
// pkl_affine
|
42
|
+
//=============================================================================
|
43
|
+
PKLExport int pkl_affine(PKLImage pkl, PKL_SAMPLE sampler, int width, int height, int backcolor)
|
44
|
+
{
|
45
|
+
int (*sample)(PKLImage pkl, point2 *p, unsigned char *dst);
|
46
|
+
unsigned char *wrk, back[4];
|
47
|
+
int i, j;
|
48
|
+
point2 p;
|
49
|
+
matrix mat;
|
50
|
+
|
51
|
+
//affine-matrix�̍\�z
|
52
|
+
pkl_matrix(pkl, &mat);
|
53
|
+
|
54
|
+
//�T���v�����O��ݒ�
|
55
|
+
switch(sampler){
|
56
|
+
case PKL_SAMPLE_NN:
|
57
|
+
sample = pkl_affine_nn;
|
58
|
+
break;
|
59
|
+
default:
|
60
|
+
sample = pkl_affine_bl;
|
61
|
+
}
|
62
|
+
|
63
|
+
wrk = malloc(width * height * pkl->channel);
|
64
|
+
if(!wrk) return(1);
|
65
|
+
memset(wrk, 0, width*height*pkl->channel);
|
66
|
+
|
67
|
+
//�w�i�F�����
|
68
|
+
for(i=0; i<pkl->channel; i++)
|
69
|
+
back[i] = (backcolor>>((pkl->channel-i)*8) & 0xFF);
|
70
|
+
|
71
|
+
//�ό`��T�C�Y��loop
|
72
|
+
for(i=0; i<height; i++){
|
73
|
+
for(j=0; j<width; j++){
|
74
|
+
if(sample(pkl, transform(&mat, j, i, &p), &wrk[(i*width+j)*pkl->channel]))
|
75
|
+
memcpy(&wrk[(i*width+j)*pkl->channel], back, pkl->channel);
|
76
|
+
}
|
77
|
+
}
|
78
|
+
|
79
|
+
free(pkl->image);
|
80
|
+
pkl->image = wrk;
|
81
|
+
pkl->width = width;
|
82
|
+
pkl->height = height;
|
83
|
+
return(0);
|
84
|
+
}
|
85
|
+
|
86
|
+
//=============================================================================
|
87
|
+
// pkl_affine_nn
|
88
|
+
//=============================================================================
|
89
|
+
static int pkl_affine_nn(PKLImage pkl, point2 *p, unsigned char *dst)
|
90
|
+
{
|
91
|
+
int x, y;
|
92
|
+
|
93
|
+
x = p->x < 0.0f ? (int)(p->x-0.5f) : (int)(p->x+0.5f);
|
94
|
+
y = p->y < 0.0f ? (int)(p->y-0.5f) : (int)(p->y+0.5f);
|
95
|
+
|
96
|
+
if(x>=0 && x<pkl->width && y>=0 && y<pkl->height){
|
97
|
+
memcpy(dst, &pkl->image[(y*pkl->width+x)*pkl->channel], pkl->channel);
|
98
|
+
return(0);
|
99
|
+
}
|
100
|
+
return(1);
|
101
|
+
}
|
102
|
+
|
103
|
+
|
104
|
+
//=============================================================================
|
105
|
+
// pkl_affine_bl
|
106
|
+
//=============================================================================
|
107
|
+
static int pkl_affine_bl(PKLImage pkl, point2 *p, unsigned char *dst)
|
108
|
+
{
|
109
|
+
int p0x, p0y, i;
|
110
|
+
double fracx, fracy;
|
111
|
+
double pixel[PKL_CHANNEL];
|
112
|
+
|
113
|
+
memset(pixel, 0, sizeof(double)*PKL_CHANNEL);
|
114
|
+
p0x = (int)floor(p->x);
|
115
|
+
p0y = (int)floor(p->y);
|
116
|
+
fracx = p->x - p0x;
|
117
|
+
fracy = p->y - p0y;
|
118
|
+
if(p0x<0 || p0x>=pkl->width || p0y<0 || p0y>=pkl->height) return(1);
|
119
|
+
|
120
|
+
if(p0x+1 < pkl->width){
|
121
|
+
if(p0y+1 < pkl->height){
|
122
|
+
for(i=0; i<pkl->channel; i++){
|
123
|
+
pixel[i] += pkl->image[(p0y*pkl->width+p0x)*pkl->channel+i] * (1-fracx)*(1-fracy);
|
124
|
+
pixel[i] += pkl->image[(p0y*pkl->width+p0x+1)*pkl->channel+i] * fracx*(1-fracy);
|
125
|
+
pixel[i] += pkl->image[((p0y+1)*pkl->width+p0x)*pkl->channel+i] * (1-fracx)*fracy;
|
126
|
+
pixel[i] += pkl->image[((p0y+1)*pkl->width+p0x+1)*pkl->channel+i] * fracx*fracy;
|
127
|
+
}
|
128
|
+
}else{
|
129
|
+
for(i=0; i<pkl->channel; i++){
|
130
|
+
pixel[i] += pkl->image[(p0y*pkl->width+p0x)*pkl->channel+i] * (1-fracx);
|
131
|
+
pixel[i] += pkl->image[(p0y*pkl->width+p0x+1)*pkl->channel+i] * fracx;
|
132
|
+
}
|
133
|
+
}
|
134
|
+
}else{
|
135
|
+
if(p0y+1 < pkl->height){
|
136
|
+
for(i=0; i<pkl->channel; i++){
|
137
|
+
pixel[i] += pkl->image[(p0y*pkl->width+p0x)*pkl->channel+i] * (1-fracy);
|
138
|
+
pixel[i] += pkl->image[((p0y+1)*pkl->width+p0x)*pkl->channel+i] * fracy;
|
139
|
+
}
|
140
|
+
}else{
|
141
|
+
for(i=0; i<pkl->channel; i++)
|
142
|
+
pixel[i] += pkl->image[((p0y+1)*pkl->width+p0x)*pkl->channel+i];
|
143
|
+
}
|
144
|
+
}
|
145
|
+
|
146
|
+
for(i=0; i<pkl->channel; i++)
|
147
|
+
dst[i] = PKL_COLOR_CLIP(pixel[i]);
|
148
|
+
return(0);
|
149
|
+
}
|
150
|
+
|
151
|
+
//=============================================================================
|
152
|
+
// pkl_matrix
|
153
|
+
//=============================================================================
|
154
|
+
static matrix *pkl_matrix(PKLImage pkl, matrix *mat)
|
155
|
+
{
|
156
|
+
matrix mat2;
|
157
|
+
|
158
|
+
matrix_init(mat);
|
159
|
+
|
160
|
+
//scale
|
161
|
+
matrix_scale(&mat2, pkl->x_scale, pkl->y_scale);
|
162
|
+
matrix_build(mat, &mat2);
|
163
|
+
|
164
|
+
//rotate
|
165
|
+
matrix_rotate(&mat2, pkl->angle);
|
166
|
+
matrix_build(mat, &mat2);
|
167
|
+
|
168
|
+
//translate
|
169
|
+
matrix_translate(&mat2, pkl->x_trns, pkl->y_trns);
|
170
|
+
matrix_build(mat, &mat2);
|
171
|
+
|
172
|
+
return(mat);
|
173
|
+
}
|
174
|
+
|
175
|
+
//=============================================================================
|
176
|
+
// matrix_init
|
177
|
+
//=============================================================================
|
178
|
+
static void matrix_init(matrix *mat)
|
179
|
+
{
|
180
|
+
mat->a = 1.0;
|
181
|
+
mat->b = 0.0;
|
182
|
+
mat->c = 0.0;
|
183
|
+
mat->d = 1.0;
|
184
|
+
mat->e = 0.0;
|
185
|
+
mat->f = 0.0;
|
186
|
+
}
|
187
|
+
|
188
|
+
//=============================================================================
|
189
|
+
// matrix_init
|
190
|
+
//=============================================================================
|
191
|
+
static void matrix_scale(matrix *mat, double x_scale, double y_scale)
|
192
|
+
{
|
193
|
+
matrix_init(mat);
|
194
|
+
mat->a = x_scale;
|
195
|
+
mat->d = y_scale;
|
196
|
+
}
|
197
|
+
|
198
|
+
//=============================================================================
|
199
|
+
// matrix_translate
|
200
|
+
//=============================================================================
|
201
|
+
static void matrix_translate(matrix *mat, double x_trns, double y_trns)
|
202
|
+
{
|
203
|
+
matrix_init(mat);
|
204
|
+
mat->e = x_trns;
|
205
|
+
mat->f = y_trns;
|
206
|
+
}
|
207
|
+
|
208
|
+
//=============================================================================
|
209
|
+
// matrix_rotate
|
210
|
+
//=============================================================================
|
211
|
+
static void matrix_rotate(matrix *mat, double angle)
|
212
|
+
{
|
213
|
+
double c, s;
|
214
|
+
|
215
|
+
matrix_init(mat);
|
216
|
+
|
217
|
+
c = cos(angle*3.14/180.0);
|
218
|
+
s = sin(angle*3.14/180.0);
|
219
|
+
mat->a = c;
|
220
|
+
mat->b = s;
|
221
|
+
mat->c = -s;
|
222
|
+
mat->d = c;
|
223
|
+
}
|
224
|
+
|
225
|
+
//=============================================================================
|
226
|
+
// matrix_init
|
227
|
+
//=============================================================================
|
228
|
+
static void matrix_build(matrix *mat1, matrix *mat2)
|
229
|
+
{
|
230
|
+
matrix mat;
|
231
|
+
memcpy(&mat, mat1, sizeof(matrix));
|
232
|
+
|
233
|
+
mat1->a = mat.a * mat2->a + mat.b * mat2->c;
|
234
|
+
mat1->b = mat.a * mat2->b + mat.b * mat2->d;
|
235
|
+
mat1->c = mat.c * mat2->a + mat.d * mat2->c;
|
236
|
+
mat1->d = mat.c * mat2->b + mat.d * mat2->d;
|
237
|
+
mat1->e = mat.e * mat2->a + mat.f * mat2->c + mat2->e;
|
238
|
+
mat1->f = mat.e * mat2->b + mat.f * mat2->d + mat2->f;
|
239
|
+
}
|
240
|
+
|
241
|
+
//=============================================================================
|
242
|
+
// transform
|
243
|
+
//=============================================================================
|
244
|
+
static point2 *transform(matrix *mat, int x, int y, point2 *p)
|
245
|
+
{
|
246
|
+
p->x = mat->a*x + mat->c*y + mat->e;
|
247
|
+
p->y = mat->b*x + mat->d*y + mat->f;
|
248
|
+
return p;
|
249
|
+
}
|
250
|
+
|
@@ -0,0 +1,20 @@
|
|
1
|
+
#ifndef _LIB_PIKL_AFFINE_
|
2
|
+
#define _LIB_PIKL_AFFINE_
|
3
|
+
|
4
|
+
#include <stdio.h>
|
5
|
+
#include <stdlib.h>
|
6
|
+
#include <string.h>
|
7
|
+
#include <math.h>
|
8
|
+
|
9
|
+
#include "pikl.h"
|
10
|
+
#include "pikl_private.h"
|
11
|
+
|
12
|
+
typedef struct {
|
13
|
+
double x, y;
|
14
|
+
} point2;
|
15
|
+
|
16
|
+
typedef struct {
|
17
|
+
double a,b,c,d,e,f;
|
18
|
+
} matrix;
|
19
|
+
|
20
|
+
#endif
|
@@ -0,0 +1,244 @@
|
|
1
|
+
#include "pikl_blur.h"
|
2
|
+
|
3
|
+
static int pkl_raw_blur(PKLImage pkl, int x, int y, double ef, int weight, double angle, double adr);
|
4
|
+
|
5
|
+
//=============================================================================
|
6
|
+
// pkl_blur
|
7
|
+
//=============================================================================
|
8
|
+
PKLExport int pkl_blur(PKLImage pkl, int weight)
|
9
|
+
{
|
10
|
+
int i, j, p, q, k;
|
11
|
+
int cnt, stock[PKL_CHANNEL];
|
12
|
+
unsigned char *wrk;
|
13
|
+
|
14
|
+
wrk = malloc(pkl->height * pkl->width * pkl->channel);
|
15
|
+
if(!wrk) return(1);
|
16
|
+
memset(wrk, 0, pkl->height * pkl->width * pkl->channel);
|
17
|
+
|
18
|
+
for(i=0; i<pkl->height; i++){
|
19
|
+
for(j=0; j<pkl->width; j++){
|
20
|
+
cnt = 0;
|
21
|
+
memset(stock, 0, sizeof(stock));
|
22
|
+
|
23
|
+
for(p=-weight; p<=weight; p++){
|
24
|
+
for(q=-weight; q<=weight; q++){
|
25
|
+
if(j+q>=0 && j+q<pkl->width && i+p>=0 && i+p<pkl->height){
|
26
|
+
for(k=0; k<pkl->channel; k++)
|
27
|
+
stock[k] += pkl->image[((i+p)*pkl->width+(j+q))*pkl->channel+k];
|
28
|
+
cnt++;
|
29
|
+
}
|
30
|
+
}
|
31
|
+
}
|
32
|
+
if(cnt==0) continue;
|
33
|
+
for(k=0; k<pkl->channel; k++)
|
34
|
+
wrk[(i * pkl->width + j) * pkl->channel+k] = PKL_COLOR_CLIP(stock[k]/cnt);
|
35
|
+
}
|
36
|
+
}
|
37
|
+
|
38
|
+
free(pkl->image);
|
39
|
+
pkl->image = wrk;
|
40
|
+
return(0);
|
41
|
+
}
|
42
|
+
|
43
|
+
//=============================================================================
|
44
|
+
// pkl_gaussblur
|
45
|
+
//=============================================================================
|
46
|
+
PKLExport int pkl_gaussblur(PKLImage pkl, double weight)
|
47
|
+
{
|
48
|
+
int range, i, j, s, t, p;
|
49
|
+
double sg, *gauss, value[PKL_CHANNEL];
|
50
|
+
unsigned char *wrk;
|
51
|
+
|
52
|
+
if(weight<=0.0) return(1);
|
53
|
+
|
54
|
+
wrk = malloc(pkl->height * pkl->width * pkl->channel);
|
55
|
+
if(!wrk) return(1);
|
56
|
+
memset(wrk, 0, pkl->height * pkl->width * pkl->channel);
|
57
|
+
|
58
|
+
range = weight * 3;
|
59
|
+
gauss = malloc(sizeof(double)*(range+1));
|
60
|
+
memset(gauss, 0, sizeof(gauss));
|
61
|
+
|
62
|
+
//gaussian table
|
63
|
+
for(i=0; i<=range; i++)
|
64
|
+
gauss[i] = exp( -1.0*i*i / (2*weight*weight));
|
65
|
+
|
66
|
+
//horizon(pkl-->wrk)
|
67
|
+
for(i=0; i<pkl->height; i++){
|
68
|
+
for(j=0; j<pkl->width; j++){
|
69
|
+
memset(value, 0, sizeof(double)*PKL_CHANNEL);
|
70
|
+
sg=0;
|
71
|
+
for(s=-range; s<=range; s++){
|
72
|
+
t = j+s<0 ? 0 : j+s>=pkl->width ? pkl->width-1 : j+s;
|
73
|
+
sg += gauss[abs(s)];
|
74
|
+
for(p=0; p<pkl->channel; p++){
|
75
|
+
value[p] += pkl->image[(i*pkl->width+t)*pkl->channel+p] * gauss[abs(s)];
|
76
|
+
}
|
77
|
+
}
|
78
|
+
for(p=0; p<pkl->channel; p++)
|
79
|
+
wrk[(i*pkl->width+j)*pkl->channel+p] = PKL_COLOR_CLIP(value[p]/sg);
|
80
|
+
}
|
81
|
+
}
|
82
|
+
|
83
|
+
//vertical(wrk-->pkl)
|
84
|
+
for(i=0; i<pkl->height; i++){
|
85
|
+
for(j=0; j<pkl->width; j++){
|
86
|
+
memset(value, 0, sizeof(double)*PKL_CHANNEL);
|
87
|
+
sg=0;
|
88
|
+
for(s=-range; s<=range; s++){
|
89
|
+
t = i+s<0 ? 0 : i+s>=pkl->height ? pkl->height-1 : i+s;
|
90
|
+
sg += gauss[abs(s)];
|
91
|
+
for(p=0; p<pkl->channel; p++){
|
92
|
+
value[p] += wrk[(t*pkl->width+j)*pkl->channel+p] * gauss[abs(s)];
|
93
|
+
}
|
94
|
+
}
|
95
|
+
for(p=0; p<pkl->channel; p++)
|
96
|
+
pkl->image[(i*pkl->width+j)*pkl->channel+p] = PKL_COLOR_CLIP(value[p]/sg);
|
97
|
+
}
|
98
|
+
}
|
99
|
+
|
100
|
+
free(gauss);
|
101
|
+
free(wrk);
|
102
|
+
return(0);
|
103
|
+
}
|
104
|
+
|
105
|
+
|
106
|
+
//=============================================================================
|
107
|
+
// pkl_rblur(����)
|
108
|
+
//=============================================================================
|
109
|
+
PKLExport int pkl_rblur(PKLImage pkl, int x, int y, double ef, int weight)
|
110
|
+
{
|
111
|
+
return pkl_raw_blur(pkl, x, y, ef, weight, 0.0, 0.0);
|
112
|
+
}
|
113
|
+
|
114
|
+
//=============================================================================
|
115
|
+
// pkl_ablur(��])
|
116
|
+
//=============================================================================
|
117
|
+
PKLExport int pkl_ablur(PKLImage pkl, int x, int y, double ef, int weight)
|
118
|
+
{
|
119
|
+
return pkl_raw_blur(pkl, x, y, ef, weight, 0.0, M_PI/2.0);
|
120
|
+
}
|
121
|
+
|
122
|
+
//=============================================================================
|
123
|
+
// pkl_wblur
|
124
|
+
//=============================================================================
|
125
|
+
PKLExport int pkl_wblur(PKLImage pkl, int x, int y, double ef, int weight, double angle)
|
126
|
+
{
|
127
|
+
return pkl_raw_blur(pkl, x, y, ef, weight, angle, M_PI*angle/180.0);
|
128
|
+
}
|
129
|
+
|
130
|
+
//=============================================================================
|
131
|
+
// pkl_rab_blur(����,��],�����܂��̃R�A)
|
132
|
+
//=============================================================================
|
133
|
+
static int pkl_raw_blur(PKLImage pkl, int x, int y, double ef, int weight, double angle, double adr)
|
134
|
+
{
|
135
|
+
unsigned char *wrk;
|
136
|
+
int i, j, k, t, tx, ty, pat;
|
137
|
+
long color[PKL_CHANNEL], range;
|
138
|
+
double rad, dis, disI, rate, disMAX;
|
139
|
+
double ox, oy, dx, dy, nf;
|
140
|
+
|
141
|
+
if(ef==0.0 || weight==0) return(1);
|
142
|
+
|
143
|
+
wrk = malloc(pkl->width*pkl->height*pkl->channel);
|
144
|
+
if(!wrk) return(1);
|
145
|
+
memset(wrk, 0, pkl->width*pkl->height*pkl->channel);
|
146
|
+
|
147
|
+
nf = weight/2;
|
148
|
+
//ox = (double)(pkl->width)/2.0;
|
149
|
+
//oy = (double)(pkl->height)/2.0;
|
150
|
+
ox = (x<0 || x>=pkl->width) ? (double)(pkl->width)/2.0 : (double)x; //���S�_�����߂�
|
151
|
+
oy = (y<0 || y>=pkl->height) ? (double)(pkl->height)/2.0 : (double)y; //���S�_�����߂�
|
152
|
+
dx = (double)pkl->width-ox;
|
153
|
+
dy = (double)pkl->height-oy;
|
154
|
+
disMAX = sqrt(dx*dx+dy*dy);
|
155
|
+
|
156
|
+
for(i=0; i<pkl->height; i++){
|
157
|
+
for(j=0; j<pkl->width; j++){
|
158
|
+
range=0;
|
159
|
+
memset(color, 0, sizeof(color));
|
160
|
+
|
161
|
+
dx = (double)j-ox;
|
162
|
+
dy = (double)i-oy;
|
163
|
+
//rad = ((dx!=0.0) ? atan(dy/dx) : M_PI/2.0) + (M_PI*angle/180.0); //�����܂���
|
164
|
+
//rad = ((dx!=0.0) ? atan(dy/dx) : M_PI/2.0); //���ˏ�
|
165
|
+
//rad = ((dx!=0.0) ? atan(dy/dx) : M_PI/2.0) + (M_PI/2.0); //��]
|
166
|
+
rad = ((dx!=0.0) ? atan(dy/dx) : M_PI/2.0) + adr;
|
167
|
+
dis = sqrt(dx*dx+dy*dy);
|
168
|
+
rate = (ef*dis/disMAX) / (double)nf;
|
169
|
+
|
170
|
+
for(t=0; t<weight; t++){
|
171
|
+
pat = (t==nf) ? 3 : 1;
|
172
|
+
disI = (double)(t-nf)*rate;
|
173
|
+
tx = (int)(disI * cos(rad)) + j;
|
174
|
+
ty = (int)(disI * sin(rad)) + i;
|
175
|
+
tx = tx<0 ? 0 : tx>=pkl->width ? pkl->width-1 : tx;
|
176
|
+
ty = ty<0 ? 0 : ty>=pkl->height ? pkl->height-1 : ty;
|
177
|
+
for(k=0; k<pkl->channel; k++)
|
178
|
+
color[k] += pkl->image[(ty*pkl->width+tx)*pkl->channel+k] * pat;
|
179
|
+
range += pat;
|
180
|
+
}
|
181
|
+
|
182
|
+
for(k=0; k<pkl->channel; k++)
|
183
|
+
wrk[(i*pkl->width+j)*pkl->channel+k] = PKL_COLOR_CLIP(color[k]/range);
|
184
|
+
}
|
185
|
+
}
|
186
|
+
|
187
|
+
free(pkl->image);
|
188
|
+
pkl->image = wrk;
|
189
|
+
return(0);
|
190
|
+
}
|
191
|
+
|
192
|
+
//=============================================================================
|
193
|
+
// pkl_mblur
|
194
|
+
//=============================================================================
|
195
|
+
PKLExport int pkl_mblur(PKLImage pkl, double angle, int weight)
|
196
|
+
{
|
197
|
+
unsigned char *wrk;
|
198
|
+
int i, j, k, t, tx, ty;
|
199
|
+
int *dx, *dy, color[PKL_CHANNEL];
|
200
|
+
double s, c;
|
201
|
+
|
202
|
+
if(weight < 2) return(0);
|
203
|
+
|
204
|
+
wrk = malloc(pkl->width*pkl->height*pkl->channel);
|
205
|
+
if(!wrk) return(1);
|
206
|
+
memset(wrk, 0, pkl->width*pkl->height*pkl->channel);
|
207
|
+
|
208
|
+
//�C�ӊp�x�̃Y���ʃe�[�u�����쐬
|
209
|
+
s = sin((angle+180.0) * M_PI / 180.0);
|
210
|
+
c = cos((angle+180.0) * M_PI / 180.0);
|
211
|
+
|
212
|
+
dx = malloc(sizeof(int)*(weight+1));
|
213
|
+
dy = malloc(sizeof(int)*(weight+1));
|
214
|
+
memset(dx, 0, sizeof(int)*(weight+1));
|
215
|
+
memset(dy, 0, sizeof(int)*(weight+1));
|
216
|
+
|
217
|
+
for(i=1; i<=weight; i++){
|
218
|
+
dx[i] = (int)(c * (i+1) + 0.5);
|
219
|
+
dy[i] = (int)(s * (i+1) + 0.5);
|
220
|
+
}
|
221
|
+
|
222
|
+
for(i=0; i<pkl->height; i++){
|
223
|
+
for(j=0; j<pkl->width; j++){
|
224
|
+
memset(color, 0, sizeof(color));
|
225
|
+
for(t=0; t<=weight; t++){
|
226
|
+
tx = j+dx[t] < 0 ? 0 : j+dx[t]>=pkl->width ? pkl->width-1 : j+dx[t];
|
227
|
+
ty = i+dy[t] < 0 ? 0 : i+dy[t]>=pkl->height ? pkl->height-1 : i+dy[t];
|
228
|
+
|
229
|
+
for(k=0; k<pkl->channel; k++)
|
230
|
+
color[k] += pkl->image[(ty*pkl->width+tx)*pkl->channel+k];
|
231
|
+
}
|
232
|
+
|
233
|
+
for(k=0; k<pkl->channel; k++)
|
234
|
+
wrk[(i*pkl->width+j)*pkl->channel+k] = PKL_COLOR_CLIP(color[k]/weight);
|
235
|
+
}
|
236
|
+
}
|
237
|
+
|
238
|
+
free(dx);
|
239
|
+
free(dy);
|
240
|
+
free(pkl->image);
|
241
|
+
pkl->image = wrk;
|
242
|
+
return(0);
|
243
|
+
}
|
244
|
+
|