ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/CV/CV.xs
(Generate patch)

Comparing CV/CV.xs (file contents):
Revision 1.19 by root, Wed Jul 20 22:33:01 2005 UTC vs.
Revision 1.40 by root, Sat Nov 25 15:00:51 2006 UTC

… …
2#include "perl.h" 2#include "perl.h"
3#include "XSUB.h" 3#include "XSUB.h"
4 4
5#include <string.h> 5#include <string.h>
6#include <setjmp.h> 6#include <setjmp.h>
7#include <math.h>
8
9#include <magic.h>
7 10
8#include <jpeglib.h> 11#include <jpeglib.h>
12#include <glib.h>
13#include <gtk/gtk.h>
9#include <gdk-pixbuf/gdk-pixbuf.h> 14#include <gdk-pixbuf/gdk-pixbuf.h>
10 15
11#include <gperl.h> 16#include <gperl.h>
12#include <gtk2perl.h> 17#include <gtk2perl.h>
13 18
14#define IW 80 /* MUST match Schnauer.pm! */ 19#define IW 80 /* MUST match Schnauzer.pm! */
15#define IH 60 /* MUST match Schnauer.pm! */ 20#define IH 60 /* MUST match Schnauzer.pm! */
16 21
17#define RAND (seed = (seed + 7141) * 54773 % 134456) 22#define RAND (seed = (seed + 7141) * 54773 % 134456)
18 23
19#define LINELENGTH 240 24#define LINELENGTH 240
20 25
… …
63 68
64 *h &= 255; 69 *h &= 255;
65 } 70 }
66} 71}
67 72
73struct feature {
74 float v1, v2, v3; // mean, square, cube
75 int n;
76};
77
78static void
79feature_init (struct feature *f)
80{
81 f->v1 = 0.;
82 f->v2 = 0.;
83 f->v3 = 0.;
84 f->n = 0;
85}
86
87// didn't find an algorithm to neatly do mean, variance and skew in one pass.
88// elmex ist schuld.
89static void
90feature_update_pass_1 (struct feature *f, unsigned int v)
91{
92 f->v1 += v;
93 f->n += 1;
94}
95
96static void
97feature_finish_pass_1 (struct feature *f)
98{
99 if (f->n < 1)
100 return;
101
102 f->v1 /= f->n;
103}
104
105static void
106feature_update_pass_2 (struct feature *f, unsigned int v)
107{
108 float d = v - f->v1;
109
110 f->v2 += d * d;
111 f->v3 += d * d * d;
112}
113
114static void
115feature_finish_pass_2 (struct feature *f)
116{
117 if (f->n < 1)
118 return;
119
120 f->v2 /= f->n;
121 f->v3 /= f->n;
122
123 f->v1 /= 255.;
124 f->v2 /= 255. * 255.; f->v2 = sqrtf (f->v2);
125 f->v3 /= 255. * 255. * 255.; f->v3 = powf (fabsf (f->v3), 1./3.);
126}
127
68static guint32 a85_val; 128static guint32 a85_val;
69static guint a85_cnt; 129static guint a85_cnt;
70static guchar a85_buf[LINELENGTH], *a85_ptr; 130static guchar a85_buf[LINELENGTH], *a85_ptr;
71 131
72static void 132static void
… …
124 184
125MODULE = Gtk2::CV PACKAGE = Gtk2::CV 185MODULE = Gtk2::CV PACKAGE = Gtk2::CV
126 186
127PROTOTYPES: ENABLE 187PROTOTYPES: ENABLE
128 188
189# missing function in perl. really :)
190int
191common_prefix_length (a, b)
192 unsigned char *a = (unsigned char *)SvPVutf8_nolen ($arg);
193 unsigned char *b = (unsigned char *)SvPVutf8_nolen ($arg);
194 CODE:
195 RETVAL = 0;
196
197 while (*a == *b && *a)
198 {
199 RETVAL += (*a & 0xc0) != 0x80;
200 a++, b++;
201 }
202
203 OUTPUT:
204 RETVAL
205
206const char *
207magic (const char *path)
208 CODE:
209{
210 static magic_t cookie;
211
212 if (!cookie)
213 {
214 cookie = magic_open (MAGIC_NONE);
215
216 if (cookie)
217 magic_load (cookie, 0);
218 else
219 XSRETURN_UNDEF;
220 }
221
222 RETVAL = magic_file (cookie, path);
223}
224 OUTPUT:
225 RETVAL
226
227const char *
228magic_mime (const char *path)
229 CODE:
230{
231 static magic_t cookie;
232
233 if (!cookie)
234 {
235 cookie = magic_open (MAGIC_MIME);
236
237 if (cookie)
238 magic_load (cookie, 0);
239 else
240 XSRETURN_UNDEF;
241 }
242
243 RETVAL = magic_file (cookie, path);
244}
245 OUTPUT:
246 RETVAL
247
248# missing/broken in Gtk2 perl module
249
250void
251gdk_window_clear_hints (GdkWindow *window)
252 CODE:
253 gdk_window_set_geometry_hints (window, 0, 0);
254
255gboolean
256gdk_net_wm_supports (GdkAtom property)
257 CODE:
258#if defined(GDK_WINDOWING_X11) && !defined(GDK_MULTIHEAD_SAFE)
259 RETVAL = gdk_net_wm_supports (property);
260#else
261 RETVAL = 0;
262#endif
263 OUTPUT:
264 RETVAL
265
129GdkPixbuf_noinc * 266GdkPixbuf_noinc *
130transpose (GdkPixbuf *pb) 267dealpha_expose (GdkPixbuf *pb)
131 CODE: 268 CODE:
132{ 269{
133 int w = gdk_pixbuf_get_width (pb); 270 int w = gdk_pixbuf_get_width (pb);
134 int h = gdk_pixbuf_get_height (pb); 271 int h = gdk_pixbuf_get_height (pb);
135 int bpp = gdk_pixbuf_get_n_channels (pb); 272 int bpp = gdk_pixbuf_get_n_channels (pb);
136 int x, y, i; 273 int x, y, i;
137 guchar *src = gdk_pixbuf_get_pixels (pb), *dst; 274 guchar *src = gdk_pixbuf_get_pixels (pb), *dst;
138 int sstr = gdk_pixbuf_get_rowstride (pb), dstr; 275 int sstr = gdk_pixbuf_get_rowstride (pb), dstr;
139 276
140 RETVAL = gdk_pixbuf_new (GDK_COLORSPACE_RGB, bpp == 4, 8, h, w); 277 RETVAL = gdk_pixbuf_new (GDK_COLORSPACE_RGB, 0, 8, w, h);
141 278
142 dst = gdk_pixbuf_get_pixels (RETVAL); 279 dst = gdk_pixbuf_get_pixels (RETVAL);
143 dstr = gdk_pixbuf_get_rowstride (RETVAL); 280 dstr = gdk_pixbuf_get_rowstride (RETVAL);
144 281
145 for (y = 0; y < h; y++)
146 for (x = 0; x < w; x++) 282 for (x = 0; x < w; x++)
283 for (y = 0; y < h; y++)
147 for (i = 0; i < bpp; i++) 284 for (i = 0; i < 3; i++)
148 dst[y * bpp + x * dstr + i] = src[x * bpp + y * sstr + i]; 285 dst[x * 3 + y * dstr + i] = src[x * bpp + y * sstr + i];
149} 286}
150 OUTPUT: 287 OUTPUT:
151 RETVAL 288 RETVAL
152 289
153GdkPixbuf_noinc * 290GdkPixbuf_noinc *
154flop (GdkPixbuf *pb) 291rotate (GdkPixbuf *pb, int angle)
155 CODE: 292 CODE:
156{ 293 RETVAL = gdk_pixbuf_rotate_simple (pb, angle == 0 ? GDK_PIXBUF_ROTATE_NONE
157 int w = gdk_pixbuf_get_width (pb); 294 : angle == 90 ? GDK_PIXBUF_ROTATE_COUNTERCLOCKWISE
158 int h = gdk_pixbuf_get_height (pb); 295 : angle == 180 ? GDK_PIXBUF_ROTATE_UPSIDEDOWN
159 int bpp = gdk_pixbuf_get_n_channels (pb); 296 : angle == 270 ? GDK_PIXBUF_ROTATE_CLOCKWISE
160 int x, y, i; 297 : angle);
161 guchar *src = gdk_pixbuf_get_pixels (pb), *dst;
162 int sstr = gdk_pixbuf_get_rowstride (pb), dstr;
163
164 RETVAL = gdk_pixbuf_new (GDK_COLORSPACE_RGB, bpp == 4, 8, w, h);
165
166 dst = gdk_pixbuf_get_pixels (RETVAL);
167 dstr = gdk_pixbuf_get_rowstride (RETVAL);
168
169 for (y = 0; y < h; y++)
170 for (x = 0; x < w; x++)
171 for (i = 0; i < bpp; i++)
172 dst[(w - 1 - x) * bpp + y * dstr + i] = src[x * bpp + y * sstr + i];
173}
174 OUTPUT: 298 OUTPUT:
175 RETVAL 299 RETVAL
176 300
177GdkPixbuf_noinc * 301GdkPixbuf_noinc *
178load_jpeg (char *path, int thumbnail=0) 302load_jpeg (SV *path, int thumbnail=0)
179 CODE: 303 CODE:
180{ 304{
181 struct jpeg_decompress_struct cinfo; 305 struct jpeg_decompress_struct cinfo;
182 struct jpg_err_mgr jerr; 306 struct jpg_err_mgr jerr;
183 guchar *data; 307 guchar *data;
184 int rs; 308 int rs;
185 FILE *fp; 309 FILE *fp;
186 volatile GdkPixbuf *pb = 0; 310 volatile GdkPixbuf *pb = 0;
311
187 RETVAL = 0; 312 RETVAL = 0;
188 313
189 if (!(fp = fopen (path, "rb"))) 314 fp = fopen (SvPVbyte_nolen (path), "rb");
315
316 if (!fp)
190 XSRETURN_UNDEF; 317 XSRETURN_UNDEF;
191 318
192 cinfo.err = jpeg_std_error (&jerr.err); 319 cinfo.err = jpeg_std_error (&jerr.err);
193 320
194 jerr.err.error_exit = cv_error_exit; 321 jerr.err.error_exit = cv_error_exit;
… …
225 { 352 {
226 cinfo.dct_method = JDCT_FASTEST; 353 cinfo.dct_method = JDCT_FASTEST;
227 cinfo.do_fancy_upsampling = FALSE; 354 cinfo.do_fancy_upsampling = FALSE;
228 355
229 while (cinfo.scale_denom < 8 356 while (cinfo.scale_denom < 8
230 && (cinfo.output_width >> 1) >= IW 357 && cinfo.output_width >= IW*4
231 && (cinfo.output_height >> 1) >= IH) 358 && cinfo.output_height >= IH*4)
232 { 359 {
233 cinfo.scale_denom <<= 1; 360 cinfo.scale_denom <<= 1;
234 jpeg_calc_output_dimensions (&cinfo); 361 jpeg_calc_output_dimensions (&cinfo);
235 } 362 }
236 } 363 }
… …
265 jpeg_destroy_decompress (&cinfo); 392 jpeg_destroy_decompress (&cinfo);
266} 393}
267 OUTPUT: 394 OUTPUT:
268 RETVAL 395 RETVAL
269 396
397void
398compare (GdkPixbuf *a, GdkPixbuf *b)
399 PPCODE:
400{
401 int w = gdk_pixbuf_get_width (a);
402 int h = gdk_pixbuf_get_height (a);
403 int sa = gdk_pixbuf_get_rowstride (a);
404 int sb = gdk_pixbuf_get_rowstride (b);
405
406 guchar *pa = gdk_pixbuf_get_pixels (a);
407 guchar *pb = gdk_pixbuf_get_pixels (b);
408
409 int x, y;
410
411 assert (w == gdk_pixbuf_get_width (b));
412 assert (h == gdk_pixbuf_get_height (b));
413
414 assert (gdk_pixbuf_get_n_channels (a) == 3);
415 assert (gdk_pixbuf_get_n_channels (b) == 3);
416
417 double diff = 0.;
418 int peak = 0;
419
420 if (w && h)
421 for (y = 0; y < h; y++)
422 {
423 guchar *pa_ = pa + y * sa;
424 guchar *pb_ = pb + y * sb;
425
426 for (x = 0; x < w; x++)
427 {
428 int d;
429
430 d = ((int)*pa_++) - ((int)*pb_++); diff += d*d; peak = MAX (peak, abs (d));
431 d = ((int)*pa_++) - ((int)*pb_++); diff += d*d; peak = MAX (peak, abs (d));
432 d = ((int)*pa_++) - ((int)*pb_++); diff += d*d; peak = MAX (peak, abs (d));
433 }
434 }
435
436 EXTEND (SP, 2);
437 PUSHs (sv_2mortal (newSVnv (sqrt (diff / (w * h * 3. * 255. * 255.)))));
438 PUSHs (sv_2mortal (newSVnv (peak / 255.)));
439}
440
270############################################################################# 441#############################################################################
271 442
272MODULE = Gtk2::CV PACKAGE = Gtk2::CV::Schnauzer 443MODULE = Gtk2::CV PACKAGE = Gtk2::CV::Schnauzer
273 444
274SV * 445SV *
275foldcase (SV *pathsv) 446foldcase (SV *pathsv)
276 PROTOTYPE: $ 447 PROTOTYPE: $
277 CODE: 448 CODE:
278{ 449{
279 STRLEN plen; 450 STRLEN plen;
280 U8 *path = SvPVutf8 (pathsv, plen); 451 U8 *path = (U8 *)SvPVutf8 (pathsv, plen);
281 U8 *pend = path + plen; 452 U8 *pend = path + plen;
282 U8 dst [plen * 6 * 3], *dstp = dst; 453 U8 dst [plen * 6 * 3], *dstp = dst;
283 454
284 while (path < pend) 455 while (path < pend)
285 { 456 {
… …
306 dstp += cl; 477 dstp += cl;
307 path += is_utf8_char (path); 478 path += is_utf8_char (path);
308 } 479 }
309 } 480 }
310 481
311 RETVAL = newSVpvn (dst, dstp - dst); 482 RETVAL = newSVpvn ((const char *)dst, dstp - dst);
312} 483}
313 OUTPUT: 484 OUTPUT:
314 RETVAL 485 RETVAL
315 486
316GdkPixbuf_noinc * 487GdkPixbuf_noinc *
317p7_to_pb (int w, int h, guchar *src) 488p7_to_pb (int w, int h, SV *src_sv)
489 PROTOTYPE: @
318 CODE: 490 CODE:
319{ 491{
320 int x, y; 492 int x, y;
321 guchar *dst, *d; 493 guchar *dst, *d;
322 int dstr; 494 int dstr;
495 guchar *src = (guchar *)SvPVbyte_nolen (src_sv);
323 496
324 RETVAL = gdk_pixbuf_new (GDK_COLORSPACE_RGB, 0, 8, w, h); 497 RETVAL = gdk_pixbuf_new (GDK_COLORSPACE_RGB, 0, 8, w, h);
325 dst = gdk_pixbuf_get_pixels (RETVAL); 498 dst = gdk_pixbuf_get_pixels (RETVAL);
326 dstr = gdk_pixbuf_get_rowstride (RETVAL); 499 dstr = gdk_pixbuf_get_rowstride (RETVAL);
327 500
… …
336 } 509 }
337} 510}
338 OUTPUT: 511 OUTPUT:
339 RETVAL 512 RETVAL
340 513
514#############################################################################
515
516MODULE = Gtk2::CV PACKAGE = Gtk2::CV::PostScript
517
518void
519dump_ascii85 (PerlIO *fp, GdkPixbuf *pb)
520 CODE:
521{
522 int w = gdk_pixbuf_get_width (pb);
523 int h = gdk_pixbuf_get_height (pb);
524 int x, y, i;
525 guchar *dst;
526 int bpp = gdk_pixbuf_get_n_channels (pb);
527 guchar *src = gdk_pixbuf_get_pixels (pb);
528 int sstr = gdk_pixbuf_get_rowstride (pb);
529
530 a85_init ();
531
532 for (y = 0; y < h; y++)
533 for (x = 0; x < w; x++)
534 for (i = 0; i < (bpp < 3 ? 1 : 3); i++)
535 a85_push (fp, src [x * bpp + y * sstr + i]);
536
537 a85_finish (fp);
538}
539
540void
541dump_binary (PerlIO *fp, GdkPixbuf *pb)
542 CODE:
543{
544 int w = gdk_pixbuf_get_width (pb);
545 int h = gdk_pixbuf_get_height (pb);
546 int x, y, i;
547 guchar *dst;
548 int bpp = gdk_pixbuf_get_n_channels (pb);
549 guchar *src = gdk_pixbuf_get_pixels (pb);
550 int sstr = gdk_pixbuf_get_rowstride (pb);
551
552 for (y = 0; y < h; y++)
553 for (x = 0; x < w; x++)
554 for (i = 0; i < (bpp < 3 ? 1 : 3); i++)
555 PerlIO_putc (fp, src [x * bpp + y * sstr + i]);
556}
557
558#############################################################################
559
560MODULE = Gtk2::CV PACKAGE = Gtk2::CV
561
341SV * 562SV *
342pb_to_p7 (GdkPixbuf *pb) 563pb_to_hv84 (GdkPixbuf *pb)
343 CODE: 564 CODE:
344{ 565{
345 int w = gdk_pixbuf_get_width (pb); 566 int w = gdk_pixbuf_get_width (pb);
346 int h = gdk_pixbuf_get_height (pb); 567 int h = gdk_pixbuf_get_height (pb);
347 int x, y; 568 int x, y;
348 guchar *dst; 569 guchar *dst;
349 int bpp = gdk_pixbuf_get_n_channels (pb); 570 int bpp = gdk_pixbuf_get_n_channels (pb);
350 guchar *src = gdk_pixbuf_get_pixels (pb); 571 guchar *src = gdk_pixbuf_get_pixels (pb);
351 int sstr = gdk_pixbuf_get_rowstride (pb); 572 int sstr = gdk_pixbuf_get_rowstride (pb);
352 int Er[IW], Eg[IW], Eb[IW];
353 int seed = 77;
354
355 RETVAL = newSV (w * h);
356 SvPOK_only (RETVAL);
357 SvCUR_set (RETVAL, w * h);
358
359 dst = SvPVX (RETVAL);
360
361 memset (Er, 0, sizeof (int) * IW);
362 memset (Eg, 0, sizeof (int) * IW);
363 memset (Eb, 0, sizeof (int) * IW);
364
365 /* some primitive error distribution + random dithering */
366
367 for (y = 0; y < h; y++)
368 {
369 int er = 0, eg = 0, eb = 0;
370
371 for (x = 0; x < w; x++)
372 {
373 int r, g, b;
374 guchar *p = src + x * bpp + y * sstr;
375
376 r = ((p[0] + er + Er[x]) * 7 + (RAND & 127) + 64) / 255;
377 g = ((p[1] + eg + Eg[x]) * 7 + (RAND & 127) + 64) / 255;
378 b = ((p[2] + eb + Eb[x]) * 3 + (RAND & 127) + 64) / 255;
379
380 r = r > 7 ? 7 : r < 0 ? 0 : r;
381 g = g > 7 ? 7 : g < 0 ? 0 : g;
382 b = b > 3 ? 3 : b < 0 ? 0 : b;
383
384 er += p[0] - (r * 255 + 4) / 7;
385 eg += p[1] - (g * 255 + 4) / 7;
386 eb += p[2] - (b * 255 + 2) / 3;
387
388 Er[x] = er >> 1; er -= (er + 1) >> 1;
389 Eg[x] = eg >> 1; eg -= (eg + 1) >> 1;
390 Eb[x] = eb >> 1; eb -= (eb + 1) >> 1;
391
392 *dst++ = r << 5 | g << 2 | b;
393 }
394 }
395}
396 OUTPUT:
397 RETVAL
398
399SV *
400make_histogram (SV *ar)
401 CODE:
402{
403 int i;
404 AV *av, *result;
405
406 if (!SvROK (ar) || SvTYPE (SvRV (ar)) != SVt_PVAV)
407 croak ("Not an array ref as first argument to make_histogram");
408
409 av = (AV *) SvRV (ar);
410 result = newAV ();
411
412 for (i = 0; i <= av_len (av); ++i)
413 {
414 const int HISTSIZE = 64;
415
416 int j;
417 SV *sv = *av_fetch (av, i, 1);
418 STRLEN len;
419 char *buf = SvPVbyte (sv, len);
420
421 int tmphist[HISTSIZE];
422 float *hist;
423
424 SV *histsv = newSV (HISTSIZE * sizeof (float) + 1);
425 SvPOK_on (histsv);
426 SvCUR_set (histsv, HISTSIZE * sizeof (float));
427 hist = (float *)SvPVX (histsv);
428
429 Zero (tmphist, sizeof (tmphist), char);
430
431 for (j = len; j--; )
432 {
433 unsigned int idx
434 = ((*buf & 0xc0) >> 2)
435 | ((*buf & 0x18) >> 1)
436 | (*buf & 0x03);
437
438 ++tmphist[idx];
439 ++buf;
440 }
441
442 for (j = 0; j < HISTSIZE; ++j)
443 hist[j] = (float)tmphist[j] / (len + 1e-30);
444
445 av_push (result, histsv);
446 }
447
448 RETVAL = newRV_noinc ((SV *)result);
449}
450 OUTPUT:
451 RETVAL
452
453#############################################################################
454
455MODULE = Gtk2::CV PACKAGE = Gtk2::CV::PostScript
456
457void
458dump_ascii85 (PerlIO *fp, GdkPixbuf *pb)
459 CODE:
460{
461 int w = gdk_pixbuf_get_width (pb);
462 int h = gdk_pixbuf_get_height (pb);
463 int x, y, i;
464 guchar *dst;
465 int bpp = gdk_pixbuf_get_n_channels (pb);
466 guchar *src = gdk_pixbuf_get_pixels (pb);
467 int sstr = gdk_pixbuf_get_rowstride (pb);
468
469 a85_init ();
470
471 for (y = 0; y < h; y++)
472 for (x = 0; x < w; x++)
473 for (i = 0; i < (bpp < 3 ? 1 : 3); i++)
474 a85_push (fp, src [x * bpp + y * sstr + i]);
475
476 a85_finish (fp);
477}
478
479void
480dump_binary (PerlIO *fp, GdkPixbuf *pb)
481 CODE:
482{
483 int w = gdk_pixbuf_get_width (pb);
484 int h = gdk_pixbuf_get_height (pb);
485 int x, y, i;
486 guchar *dst;
487 int bpp = gdk_pixbuf_get_n_channels (pb);
488 guchar *src = gdk_pixbuf_get_pixels (pb);
489 int sstr = gdk_pixbuf_get_rowstride (pb);
490
491 for (y = 0; y < h; y++)
492 for (x = 0; x < w; x++)
493 for (i = 0; i < (bpp < 3 ? 1 : 3); i++)
494 PerlIO_putc (fp, src [x * bpp + y * sstr + i]);
495}
496
497#############################################################################
498
499MODULE = Gtk2::CV PACKAGE = Gtk2::CV
500
501SV *
502pb_to_hv84 (GdkPixbuf *pb)
503 CODE:
504{
505 int w = gdk_pixbuf_get_width (pb);
506 int h = gdk_pixbuf_get_height (pb);
507 int x, y;
508 guchar *dst;
509 int bpp = gdk_pixbuf_get_n_channels (pb);
510 guchar *src = gdk_pixbuf_get_pixels (pb);
511 int sstr = gdk_pixbuf_get_rowstride (pb);
512 573
513 RETVAL = newSV (6 * 8 * 12 / 8); 574 RETVAL = newSV (6 * 8 * 12 / 8);
514 SvPOK_only (RETVAL); 575 SvPOK_only (RETVAL);
515 SvCUR_set (RETVAL, 6 * 8 * 12 / 8); 576 SvCUR_set (RETVAL, 6 * 8 * 12 / 8);
516 577
517 dst = SvPVX (RETVAL); 578 dst = (guchar *)SvPVX (RETVAL);
518 579
519 /* some primitive error distribution + random dithering */ 580 /* some primitive error distribution + random dithering */
520 581
521 for (y = 0; y < h; y++) 582 for (y = 0; y < h; y++)
522 { 583 {
… …
580 } 641 }
581} 642}
582 OUTPUT: 643 OUTPUT:
583 RETVAL 644 RETVAL
584 645
646#############################################################################
585 647
648MODULE = Gtk2::CV PACKAGE = Gtk2::CV::Plugin::RCluster
586 649
650SV *
651extract_features (SV *ar)
652 CODE:
653{
654 int i;
655 AV *av, *result;
656
657 if (!SvROK (ar) || SvTYPE (SvRV (ar)) != SVt_PVAV)
658 croak ("Not an array ref as first argument to extract_features");
659
660 av = (AV *) SvRV (ar);
661 result = newAV ();
662
663 for (i = 0; i <= av_len (av); ++i)
664 {
665 SV *sv = *av_fetch (av, i, 1);
666 SV *histsv = newSV (9 * sizeof (float) + 1);
667
668 SvPOK_on (histsv);
669 SvCUR_set (histsv, 9 * sizeof (float));
670 float *hist = (float *)SvPVX (histsv);
671
672 struct feature f_h, f_s, f_v;
673 feature_init (&f_h);
674 feature_init (&f_s);
675 feature_init (&f_v);
676
677 {
678 STRLEN len;
679 unsigned char *buf = (unsigned char *)SvPVbyte (sv, len);
680 while (len >= 3)
681 {
682 unsigned int r, g, b, h, s, v;
683 r = *buf++; g = *buf++; b = *buf++;
684 rgb_to_hsv (r, g, b, &h, &s, &v);
685
686 feature_update_pass_1 (&f_h, h);
687 feature_update_pass_1 (&f_s, s);
688 feature_update_pass_1 (&f_v, v);
689
690 len -= 3;
691 }
692
693 feature_finish_pass_1 (&f_h);
694 feature_finish_pass_1 (&f_s);
695 feature_finish_pass_1 (&f_v);
696 }
697
698 {
699 STRLEN len;
700 unsigned char *buf = (unsigned char *)SvPVbyte (sv, len);
701 while (len >= 3)
702 {
703 unsigned int r, g, b, h, s, v;
704 r = *buf++; g = *buf++; b = *buf++;
705 rgb_to_hsv (r, g, b, &h, &s, &v);
706
707 feature_update_pass_2 (&f_h, h);
708 feature_update_pass_2 (&f_s, s);
709 feature_update_pass_2 (&f_v, v);
710
711 len -= 3;
712 }
713
714 feature_finish_pass_2 (&f_h);
715 feature_finish_pass_2 (&f_s);
716 feature_finish_pass_2 (&f_v);
717 }
718
719 hist [0] = f_h.v1 * 2.; hist [1] = f_h.v2 * 2.; hist [2] = f_h.v3 * 2.;
720 hist [3] = f_s.v1 ; hist [4] = f_s.v2 ; hist [5] = f_s.v3 ;
721 hist [6] = f_v.v1 * .5; hist [7] = f_v.v2 * .5; hist [8] = f_v.v3 * .5;
722
723 av_push (result, histsv);
724 }
725
726 RETVAL = newRV_noinc ((SV *)result);
727}
728 OUTPUT:
729 RETVAL
730

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines