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

Comparing CV/CV.xs (file contents):
Revision 1.22 by root, Sun Aug 14 02:25:44 2005 UTC vs.
Revision 1.41 by root, Sat Mar 1 04:11:26 2008 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
129# missing in Gtk2 perl module 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);
130 254
131gboolean 255gboolean
132gdk_net_wm_supports (GdkAtom property) 256gdk_net_wm_supports (GdkAtom property)
133 CODE: 257 CODE:
134#if defined(GDK_WINDOWING_X11) && !defined(GDK_MULTIHEAD_SAFE) 258#if defined(GDK_WINDOWING_X11) && !defined(GDK_MULTIHEAD_SAFE)
… …
138#endif 262#endif
139 OUTPUT: 263 OUTPUT:
140 RETVAL 264 RETVAL
141 265
142GdkPixbuf_noinc * 266GdkPixbuf_noinc *
143transpose (GdkPixbuf *pb) 267dealpha_expose (GdkPixbuf *pb)
144 CODE: 268 CODE:
145{ 269{
146 int w = gdk_pixbuf_get_width (pb); 270 int w = gdk_pixbuf_get_width (pb);
147 int h = gdk_pixbuf_get_height (pb); 271 int h = gdk_pixbuf_get_height (pb);
148 int bpp = gdk_pixbuf_get_n_channels (pb); 272 int bpp = gdk_pixbuf_get_n_channels (pb);
149 int x, y, i; 273 int x, y, i;
150 guchar *src = gdk_pixbuf_get_pixels (pb), *dst; 274 guchar *src = gdk_pixbuf_get_pixels (pb), *dst;
151 int sstr = gdk_pixbuf_get_rowstride (pb), dstr; 275 int sstr = gdk_pixbuf_get_rowstride (pb), dstr;
152 276
153 RETVAL = gdk_pixbuf_new (GDK_COLORSPACE_RGB, bpp == 4, 8, h, w); 277 RETVAL = gdk_pixbuf_new (GDK_COLORSPACE_RGB, 0, 8, w, h);
154 278
155 dst = gdk_pixbuf_get_pixels (RETVAL); 279 dst = gdk_pixbuf_get_pixels (RETVAL);
156 dstr = gdk_pixbuf_get_rowstride (RETVAL); 280 dstr = gdk_pixbuf_get_rowstride (RETVAL);
157 281
158 for (y = 0; y < h; y++)
159 for (x = 0; x < w; x++) 282 for (x = 0; x < w; x++)
283 for (y = 0; y < h; y++)
160 for (i = 0; i < bpp; i++) 284 for (i = 0; i < 3; i++)
161 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];
162} 286}
163 OUTPUT: 287 OUTPUT:
164 RETVAL 288 RETVAL
165 289
166GdkPixbuf_noinc * 290GdkPixbuf_noinc *
167flop (GdkPixbuf *pb) 291rotate (GdkPixbuf *pb, int angle)
168 CODE: 292 CODE:
169{ 293 RETVAL = gdk_pixbuf_rotate_simple (pb, angle == 0 ? GDK_PIXBUF_ROTATE_NONE
170 int w = gdk_pixbuf_get_width (pb); 294 : angle == 90 ? GDK_PIXBUF_ROTATE_COUNTERCLOCKWISE
171 int h = gdk_pixbuf_get_height (pb); 295 : angle == 180 ? GDK_PIXBUF_ROTATE_UPSIDEDOWN
172 int bpp = gdk_pixbuf_get_n_channels (pb); 296 : angle == 270 ? GDK_PIXBUF_ROTATE_CLOCKWISE
173 int x, y, i; 297 : angle);
174 guchar *src = gdk_pixbuf_get_pixels (pb), *dst;
175 int sstr = gdk_pixbuf_get_rowstride (pb), dstr;
176
177 RETVAL = gdk_pixbuf_new (GDK_COLORSPACE_RGB, bpp == 4, 8, w, h);
178
179 dst = gdk_pixbuf_get_pixels (RETVAL);
180 dstr = gdk_pixbuf_get_rowstride (RETVAL);
181
182 for (y = 0; y < h; y++)
183 for (x = 0; x < w; x++)
184 for (i = 0; i < bpp; i++)
185 dst[(w - 1 - x) * bpp + y * dstr + i] = src[x * bpp + y * sstr + i];
186}
187 OUTPUT: 298 OUTPUT:
188 RETVAL 299 RETVAL
189 300
190GdkPixbuf_noinc * 301GdkPixbuf_noinc *
191load_jpeg (char *path, int thumbnail=0) 302load_jpeg (SV *path, int thumbnail=0)
192 CODE: 303 CODE:
193{ 304{
194 struct jpeg_decompress_struct cinfo; 305 struct jpeg_decompress_struct cinfo;
195 struct jpg_err_mgr jerr; 306 struct jpg_err_mgr jerr;
196 guchar *data; 307 guchar *data;
197 int rs; 308 int rs;
198 FILE *fp; 309 FILE *fp;
199 volatile GdkPixbuf *pb = 0; 310 volatile GdkPixbuf *pb = 0;
311
200 RETVAL = 0; 312 RETVAL = 0;
201 313
202 if (!(fp = fopen (path, "rb"))) 314 fp = fopen (SvPVbyte_nolen (path), "rb");
315
316 if (!fp)
203 XSRETURN_UNDEF; 317 XSRETURN_UNDEF;
204 318
205 cinfo.err = jpeg_std_error (&jerr.err); 319 cinfo.err = jpeg_std_error (&jerr.err);
206 320
207 jerr.err.error_exit = cv_error_exit; 321 jerr.err.error_exit = cv_error_exit;
… …
278 jpeg_destroy_decompress (&cinfo); 392 jpeg_destroy_decompress (&cinfo);
279} 393}
280 OUTPUT: 394 OUTPUT:
281 RETVAL 395 RETVAL
282 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
283############################################################################# 441#############################################################################
284 442
285MODULE = Gtk2::CV PACKAGE = Gtk2::CV::Schnauzer 443MODULE = Gtk2::CV PACKAGE = Gtk2::CV::Schnauzer
444
445# currently only works for filenames (octet strings)
286 446
287SV * 447SV *
288foldcase (SV *pathsv) 448foldcase (SV *pathsv)
289 PROTOTYPE: $ 449 PROTOTYPE: $
290 CODE: 450 CODE:
291{ 451{
292 STRLEN plen; 452 STRLEN plen;
293 U8 *path = SvPVutf8 (pathsv, plen); 453 U8 *path = (U8 *)SvPV (pathsv, plen);
294 U8 *pend = path + plen; 454 U8 *pend = path + plen;
295 U8 dst [plen * 6 * 3], *dstp = dst; 455 U8 dst [plen * 6 * 3], *dstp = dst;
296 456
297 while (path < pend) 457 while (path < pend)
298 { 458 {
299 U8 ch = *path; 459 U8 ch = *path;
300 460
301 if (ch >= 'a' && ch <= 'z') 461 if (ch >= 'a' && ch <= 'z')
302 *dstp++ = *path++; 462 *dstp++ = *path++;
463 else if (ch >= 'A' && ch <= 'Z')
464 *dstp++ = *path++ + ('a' - 'A');
303 else if (ch >= '0' && ch <= '9') 465 else if (ch >= '0' && ch <= '9')
304 { 466 {
305 STRLEN el, nl = 0; 467 STRLEN el, nl = 0;
306 while (*path >= '0' && *path <= '9' && path < pend) 468 while (*path >= '0' && *path <= '9' && path < pend)
307 path++, nl++; 469 path++, nl++;
… …
310 *dstp++ = '0'; 472 *dstp++ = '0';
311 473
312 memcpy (dstp, path - nl, nl); 474 memcpy (dstp, path - nl, nl);
313 dstp += nl; 475 dstp += nl;
314 } 476 }
477 else
478 *dstp++ = *path++;
479#if 0
315 else 480 else
316 { 481 {
317 STRLEN cl; 482 STRLEN cl;
318 to_utf8_fold (path, dstp, &cl); 483 to_utf8_fold (path, dstp, &cl);
319 dstp += cl; 484 dstp += cl;
320 path += is_utf8_char (path); 485 path += is_utf8_char (path);
321 } 486 }
487#endif
322 } 488 }
323 489
324 RETVAL = newSVpvn (dst, dstp - dst); 490 RETVAL = newSVpvn ((const char *)dst, dstp - dst);
325} 491}
326 OUTPUT: 492 OUTPUT:
327 RETVAL 493 RETVAL
328 494
329GdkPixbuf_noinc * 495GdkPixbuf_noinc *
330p7_to_pb (int w, int h, guchar *src) 496p7_to_pb (int w, int h, SV *src_sv)
331 PROTOTYPE: @ 497 PROTOTYPE: @
332 CODE: 498 CODE:
333{ 499{
334 int x, y; 500 int x, y;
335 guchar *dst, *d; 501 guchar *dst, *d;
336 int dstr; 502 int dstr;
503 guchar *src = (guchar *)SvPVbyte_nolen (src_sv);
337 504
338 RETVAL = gdk_pixbuf_new (GDK_COLORSPACE_RGB, 0, 8, w, h); 505 RETVAL = gdk_pixbuf_new (GDK_COLORSPACE_RGB, 0, 8, w, h);
339 dst = gdk_pixbuf_get_pixels (RETVAL); 506 dst = gdk_pixbuf_get_pixels (RETVAL);
340 dstr = gdk_pixbuf_get_rowstride (RETVAL); 507 dstr = gdk_pixbuf_get_rowstride (RETVAL);
341 508
… …
350 } 517 }
351} 518}
352 OUTPUT: 519 OUTPUT:
353 RETVAL 520 RETVAL
354 521
522#############################################################################
523
524MODULE = Gtk2::CV PACKAGE = Gtk2::CV::PostScript
525
526void
527dump_ascii85 (PerlIO *fp, GdkPixbuf *pb)
528 CODE:
529{
530 int w = gdk_pixbuf_get_width (pb);
531 int h = gdk_pixbuf_get_height (pb);
532 int x, y, i;
533 guchar *dst;
534 int bpp = gdk_pixbuf_get_n_channels (pb);
535 guchar *src = gdk_pixbuf_get_pixels (pb);
536 int sstr = gdk_pixbuf_get_rowstride (pb);
537
538 a85_init ();
539
540 for (y = 0; y < h; y++)
541 for (x = 0; x < w; x++)
542 for (i = 0; i < (bpp < 3 ? 1 : 3); i++)
543 a85_push (fp, src [x * bpp + y * sstr + i]);
544
545 a85_finish (fp);
546}
547
548void
549dump_binary (PerlIO *fp, GdkPixbuf *pb)
550 CODE:
551{
552 int w = gdk_pixbuf_get_width (pb);
553 int h = gdk_pixbuf_get_height (pb);
554 int x, y, i;
555 guchar *dst;
556 int bpp = gdk_pixbuf_get_n_channels (pb);
557 guchar *src = gdk_pixbuf_get_pixels (pb);
558 int sstr = gdk_pixbuf_get_rowstride (pb);
559
560 for (y = 0; y < h; y++)
561 for (x = 0; x < w; x++)
562 for (i = 0; i < (bpp < 3 ? 1 : 3); i++)
563 PerlIO_putc (fp, src [x * bpp + y * sstr + i]);
564}
565
566#############################################################################
567
568MODULE = Gtk2::CV PACKAGE = Gtk2::CV
569
355SV * 570SV *
356pb_to_p7 (GdkPixbuf *pb) 571pb_to_hv84 (GdkPixbuf *pb)
357 CODE: 572 CODE:
358{ 573{
359 int w = gdk_pixbuf_get_width (pb); 574 int w = gdk_pixbuf_get_width (pb);
360 int h = gdk_pixbuf_get_height (pb); 575 int h = gdk_pixbuf_get_height (pb);
361 int x, y; 576 int x, y;
362 guchar *dst; 577 guchar *dst;
363 int bpp = gdk_pixbuf_get_n_channels (pb); 578 int bpp = gdk_pixbuf_get_n_channels (pb);
364 guchar *src = gdk_pixbuf_get_pixels (pb); 579 guchar *src = gdk_pixbuf_get_pixels (pb);
365 int sstr = gdk_pixbuf_get_rowstride (pb); 580 int sstr = gdk_pixbuf_get_rowstride (pb);
366 int Er[IW], Eg[IW], Eb[IW];
367 int seed = 77;
368
369 RETVAL = newSV (w * h);
370 SvPOK_only (RETVAL);
371 SvCUR_set (RETVAL, w * h);
372
373 dst = SvPVX (RETVAL);
374
375 memset (Er, 0, sizeof (int) * IW);
376 memset (Eg, 0, sizeof (int) * IW);
377 memset (Eb, 0, sizeof (int) * IW);
378
379 /* some primitive error distribution + random dithering */
380
381 for (y = 0; y < h; y++)
382 {
383 int er = 0, eg = 0, eb = 0;
384
385 for (x = 0; x < w; x++)
386 {
387 int r, g, b;
388 guchar *p = src + x * bpp + y * sstr;
389
390 r = ((p[0] + er + Er[x]) * 7 + (RAND & 127) + 64) / 255;
391 g = ((p[1] + eg + Eg[x]) * 7 + (RAND & 127) + 64) / 255;
392 b = ((p[2] + eb + Eb[x]) * 3 + (RAND & 127) + 64) / 255;
393
394 r = r > 7 ? 7 : r < 0 ? 0 : r;
395 g = g > 7 ? 7 : g < 0 ? 0 : g;
396 b = b > 3 ? 3 : b < 0 ? 0 : b;
397
398 er += p[0] - (r * 255 + 4) / 7;
399 eg += p[1] - (g * 255 + 4) / 7;
400 eb += p[2] - (b * 255 + 2) / 3;
401
402 Er[x] = er >> 1; er -= (er + 1) >> 1;
403 Eg[x] = eg >> 1; eg -= (eg + 1) >> 1;
404 Eb[x] = eb >> 1; eb -= (eb + 1) >> 1;
405
406 *dst++ = r << 5 | g << 2 | b;
407 }
408 }
409}
410 OUTPUT:
411 RETVAL
412
413#############################################################################
414
415MODULE = Gtk2::CV PACKAGE = Gtk2::CV::PostScript
416
417void
418dump_ascii85 (PerlIO *fp, GdkPixbuf *pb)
419 CODE:
420{
421 int w = gdk_pixbuf_get_width (pb);
422 int h = gdk_pixbuf_get_height (pb);
423 int x, y, i;
424 guchar *dst;
425 int bpp = gdk_pixbuf_get_n_channels (pb);
426 guchar *src = gdk_pixbuf_get_pixels (pb);
427 int sstr = gdk_pixbuf_get_rowstride (pb);
428
429 a85_init ();
430
431 for (y = 0; y < h; y++)
432 for (x = 0; x < w; x++)
433 for (i = 0; i < (bpp < 3 ? 1 : 3); i++)
434 a85_push (fp, src [x * bpp + y * sstr + i]);
435
436 a85_finish (fp);
437}
438
439void
440dump_binary (PerlIO *fp, GdkPixbuf *pb)
441 CODE:
442{
443 int w = gdk_pixbuf_get_width (pb);
444 int h = gdk_pixbuf_get_height (pb);
445 int x, y, i;
446 guchar *dst;
447 int bpp = gdk_pixbuf_get_n_channels (pb);
448 guchar *src = gdk_pixbuf_get_pixels (pb);
449 int sstr = gdk_pixbuf_get_rowstride (pb);
450
451 for (y = 0; y < h; y++)
452 for (x = 0; x < w; x++)
453 for (i = 0; i < (bpp < 3 ? 1 : 3); i++)
454 PerlIO_putc (fp, src [x * bpp + y * sstr + i]);
455}
456
457#############################################################################
458
459MODULE = Gtk2::CV PACKAGE = Gtk2::CV
460
461SV *
462pb_to_hv84 (GdkPixbuf *pb)
463 CODE:
464{
465 int w = gdk_pixbuf_get_width (pb);
466 int h = gdk_pixbuf_get_height (pb);
467 int x, y;
468 guchar *dst;
469 int bpp = gdk_pixbuf_get_n_channels (pb);
470 guchar *src = gdk_pixbuf_get_pixels (pb);
471 int sstr = gdk_pixbuf_get_rowstride (pb);
472 581
473 RETVAL = newSV (6 * 8 * 12 / 8); 582 RETVAL = newSV (6 * 8 * 12 / 8);
474 SvPOK_only (RETVAL); 583 SvPOK_only (RETVAL);
475 SvCUR_set (RETVAL, 6 * 8 * 12 / 8); 584 SvCUR_set (RETVAL, 6 * 8 * 12 / 8);
476 585
477 dst = SvPVX (RETVAL); 586 dst = (guchar *)SvPVX (RETVAL);
478 587
479 /* some primitive error distribution + random dithering */ 588 /* some primitive error distribution + random dithering */
480 589
481 for (y = 0; y < h; y++) 590 for (y = 0; y < h; y++)
482 { 591 {
… …
545############################################################################# 654#############################################################################
546 655
547MODULE = Gtk2::CV PACKAGE = Gtk2::CV::Plugin::RCluster 656MODULE = Gtk2::CV PACKAGE = Gtk2::CV::Plugin::RCluster
548 657
549SV * 658SV *
550make_histograms (SV *ar) 659extract_features (SV *ar)
551 CODE: 660 CODE:
552{ 661{
553 int i; 662 int i;
554 AV *av, *result; 663 AV *av, *result;
555 664
556 if (!SvROK (ar) || SvTYPE (SvRV (ar)) != SVt_PVAV) 665 if (!SvROK (ar) || SvTYPE (SvRV (ar)) != SVt_PVAV)
557 croak ("Not an array ref as first argument to make_histogram"); 666 croak ("Not an array ref as first argument to extract_features");
558 667
559 av = (AV *) SvRV (ar); 668 av = (AV *) SvRV (ar);
560 result = newAV (); 669 result = newAV ();
561 670
562 for (i = 0; i <= av_len (av); ++i) 671 for (i = 0; i <= av_len (av); ++i)
563 { 672 {
564 const int HISTSIZE = 64;
565
566 int j;
567 SV *sv = *av_fetch (av, i, 1); 673 SV *sv = *av_fetch (av, i, 1);
568 STRLEN len;
569 char *buf = SvPVbyte (sv, len);
570
571 int tmphist[HISTSIZE];
572 float *hist;
573
574 SV *histsv = newSV (HISTSIZE * sizeof (float) + 1); 674 SV *histsv = newSV (9 * sizeof (float) + 1);
675
575 SvPOK_on (histsv); 676 SvPOK_on (histsv);
576 SvCUR_set (histsv, HISTSIZE * sizeof (float)); 677 SvCUR_set (histsv, 9 * sizeof (float));
577 hist = (float *)SvPVX (histsv); 678 float *hist = (float *)SvPVX (histsv);
578 679
579 Zero (tmphist, sizeof (tmphist), char); 680 struct feature f_h, f_s, f_v;
681 feature_init (&f_h);
682 feature_init (&f_s);
683 feature_init (&f_v);
580 684
581 for (j = len; j--; )
582 {
583 unsigned int idx
584 = ((*buf & 0xc0) >> 2)
585 | ((*buf & 0x18) >> 1)
586 | (*buf & 0x03);
587
588 ++tmphist[idx];
589 ++buf;
590 }
591 685 {
592 for (j = 0; j < HISTSIZE; ++j) 686 STRLEN len;
593 hist[j] = (float)tmphist[j] / (len + 1e-30); 687 unsigned char *buf = (unsigned char *)SvPVbyte (sv, len);
688 while (len >= 3)
689 {
690 unsigned int r, g, b, h, s, v;
691 r = *buf++; g = *buf++; b = *buf++;
692 rgb_to_hsv (r, g, b, &h, &s, &v);
693
694 feature_update_pass_1 (&f_h, h);
695 feature_update_pass_1 (&f_s, s);
696 feature_update_pass_1 (&f_v, v);
697
698 len -= 3;
699 }
700
701 feature_finish_pass_1 (&f_h);
702 feature_finish_pass_1 (&f_s);
703 feature_finish_pass_1 (&f_v);
704 }
705
706 {
707 STRLEN len;
708 unsigned char *buf = (unsigned char *)SvPVbyte (sv, len);
709 while (len >= 3)
710 {
711 unsigned int r, g, b, h, s, v;
712 r = *buf++; g = *buf++; b = *buf++;
713 rgb_to_hsv (r, g, b, &h, &s, &v);
714
715 feature_update_pass_2 (&f_h, h);
716 feature_update_pass_2 (&f_s, s);
717 feature_update_pass_2 (&f_v, v);
718
719 len -= 3;
720 }
721
722 feature_finish_pass_2 (&f_h);
723 feature_finish_pass_2 (&f_s);
724 feature_finish_pass_2 (&f_v);
725 }
726
727 hist [0] = f_h.v1 * 2.; hist [1] = f_h.v2 * 2.; hist [2] = f_h.v3 * 2.;
728 hist [3] = f_s.v1 ; hist [4] = f_s.v2 ; hist [5] = f_s.v3 ;
729 hist [6] = f_v.v1 * .5; hist [7] = f_v.v2 * .5; hist [8] = f_v.v3 * .5;
594 730
595 av_push (result, histsv); 731 av_push (result, histsv);
596 } 732 }
597 733
598 RETVAL = newRV_noinc ((SV *)result); 734 RETVAL = newRV_noinc ((SV *)result);
599} 735}
600 OUTPUT: 736 OUTPUT:
601 RETVAL 737 RETVAL
602 738
603

Diff Legend

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