lib/gfxpoly/test.c

   1 #include <stdlib.h>
   2 #include <stdio.h>
   3 #include <memory.h>
   4 #include <math.h>
   5 #include "../gfxtools.h"
   6 #include "poly.h"
   7 #include "convert.h"
   8 #include "renderpoly.h"
   9
  10 gfxline_t*mkstar(int x1, int y1, int x2, int y2)
  11 {
  12     gfxline_t*l=0,*line = 0;
  13     int x;
  14     for(x=x1;x<=x2;x+=50) {
  15         l = rfx_calloc(sizeof(gfxline_t));
  16         l->type = gfx_moveTo;
  17         l->x = x;l->y = y1;
  18         line = gfxline_append(line, l);
  19
  20         l = rfx_calloc(sizeof(gfxline_t));
  21         l->type = gfx_lineTo;
  22         l->x = x2-x;l->y = y2;
  23         line = gfxline_append(line, l);
  24     }
  25     return line;
  26 }
  27
  28 gfxline_t* mkrandomshape(int range, int n)
  29 {
  30     int i;
  31     gfxline_t* line = malloc(sizeof(gfxline_t)*n);
  32     for(i=0;i<n;i++) {
  33         line[i].type = i?gfx_lineTo:gfx_moveTo;
  34         line[i].x = lrand48()%range - range/2;
  35         line[i].y = lrand48()%range - range/2;
  36         line[i].next = &line[i+1];
  37     }
  38     line[n-1].x = line[0].x;
  39     line[n-1].y = line[0].y;
  40     line[n-1].next = 0;
  41     return line;
  42 }
  43
  44 gfxline_t* mkchessboard()
  45 {
  46     gfxline_t*b = 0;
  47     int x,y;
  48     unsigned int r = 0;
  49     int spacing = 20;
  50
  51     int num_caros = 40;
  52     int l = 5;
  53     char do_centerpiece=1;
  54
  55     //int num_caros = 4;
  56     //int l=1;
  57     //char do_centerpiece=0;
  58
  59     for(x=-l;x<=l;x++)
  60     for(y=-l;y<=l;y++) {
  61         /* pseudo random */
  62         r = crc32_add_byte(r, x);r = crc32_add_byte(r, y);
  63         if(r&1) {
  64             gfxline_t*box;
  65             if(r&2) {
  66                 box = gfxline_makerectangle(x*spacing,y*spacing,(x+1)*spacing,(y+1)*spacing);
  67             } else {
  68                 box = gfxline_makerectangle((x+1)*spacing,y*spacing,x*spacing,(y+1)*spacing);
  69             }
  70             b = gfxline_append(b, box);
  71         }
  72     }
  73
  74     int t;
  75     for(t=0;t<num_caros;t++) {
  76         r = crc32_add_byte(r, t);
  77         int x=(r%10-5)*spacing;
  78         int y=((r>>4)%10-5)*spacing;
  79         int sizex = ((r>>8)%4)*spacing;
  80         int sizey = sizex;
  81         if(r&65536)
  82             sizex = -sizex;
  83         gfxline_t*l = malloc(sizeof(gfxline_t)*5);
  84         l[0].type = gfx_moveTo;l[0].next = &l[1];
  85         l[1].type = gfx_lineTo;l[1].next = &l[2];
  86         l[2].type = gfx_lineTo;l[2].next = &l[3];
  87         l[3].type = gfx_lineTo;l[3].next = &l[4];
  88         l[4].type = gfx_lineTo;l[4].next = 0;
  89         l[0].x = x;
  90         l[0].y = y-sizey;
  91         l[1].x = x+sizex;
  92         l[1].y = y;
  93         l[2].x = x;
  94         l[2].y = y+sizey;
  95         l[3].x = x-sizex;
  96         l[3].y = y;
  97         l[4].x = x;
  98         l[4].y = y-sizey;
  99         gfxline_append(b, l);
 100     }
 101     if(do_centerpiece) {
 102         for(t=0;t<5;t++) {
 103             gfxline_t*l = gfxline_makerectangle(-9*spacing,-10,9*spacing,10);
 104             gfxmatrix_t matrix;
 105             memset(&matrix, 0, sizeof(gfxmatrix_t));
 106             double ua=t*0.43;
 107             matrix.m00=cos(ua);matrix.m10=sin(ua);
 108             matrix.m01=-sin(ua);matrix.m11=cos(ua);
 109             gfxline_transform(l, &matrix);
 110             gfxline_append(b, l);
 111         }
 112         gfxline_append(b, gfxline_makecircle(100,100,100,100));
 113     }
 114     return b;
 115 }
 116
 117 gfxline_t* make_circles(int n)
 118 {
 119     gfxline_t*b = 0;
 120     unsigned int c = 0;
 121     int t;
 122     for(t=0;t<n;t++) {
 123         c = crc32_add_byte(c, t);
 124         int x = c%200;
 125         c = crc32_add_byte(c, t);
 126         int y = c%200;;
 127         c = crc32_add_byte(c, t^0x55);
 128         int r = c%100;
 129         b = gfxline_append(b, gfxline_makecircle(x,y,r,r));
 130         //b = gfxline_append(b, gfxline_makerectangle(10,10,100,100));
 131     }
 132     return b;
 133 }
 134
 135 static windcontext_t onepolygon = {1};
 136
 137 int test_speed()
 138 {
 139     //gfxline_t* b = mkchessboard();
 140     //gfxline_t* b = mkrandomshape(100,7);
 141     gfxline_t* b = make_circles(30);
 142
 143     gfxmatrix_t m;
 144     memset(&m, 0, sizeof(gfxmatrix_t));
 145     int t;
 146     for(t=0;t<10;t++) {
 147         printf("%d\n", t);
 148         m.m00 = cos(t*M_PI/180.0);
 149         m.m01 = sin(t*M_PI/180.0);
 150         m.m10 = -sin(t*M_PI/180.0);
 151         m.m11 = cos(t*M_PI/180.0);
 152         m.tx = 400*1.41/2;
 153         m.ty = 400*1.41/2;
 154         gfxline_t*l = gfxline_clone(b);
 155         gfxline_transform(l, &m);
 156         gfxcompactpoly_t*poly = gfxcompactpoly_from_gfxline(b, 0.05);
 157
 158         gfxpoly_t*poly2 = gfxpoly_process(poly, &windrule_evenodd, &onepolygon);
 159         gfxcompactpoly_destroy(poly);
 160         gfxpoly_destroy(poly2);
 161         gfxline_free(l);
 162     }
 163     gfxline_free(b);
 164 }
 165
 166 int test1(int argn, char*argv[])
 167 {
 168     gfxline_t*box1 = gfxline_makerectangle(50,50,150,150);
 169     gfxline_t*box2 = gfxline_makerectangle(100,100,200,200);
 170     gfxline_t*box3 = gfxline_makerectangle(100,100,200,200);
 171     gfxline_t*star = mkstar(50,50, 150,150);
 172     gfxline_t*b = 0;
 173     b = gfxline_append(b, box1);
 174     b = gfxline_append(b, box2);
 175     b = gfxline_append(b, box3);
 176
 177     gfxmatrix_t matrix;
 178     memset(&matrix, 0, sizeof(gfxmatrix_t));
 179     double ua=0.1;
 180     matrix.m00=cos(ua);matrix.m10=sin(ua);
 181     matrix.m01=-sin(ua);matrix.m11=cos(ua);
 182
 183     //gfxline_transform(b, &matrix);
 184
 185     gfxline_dump(b, stderr, "");
 186
 187     gfxcompactpoly_t*poly = gfxcompactpoly_from_gfxline(b, 0.05);
 188     gfxline_free(box1);
 189     gfxline_free(box2);
 190     gfxline_free(box3);
 191     gfxline_free(star);
 192
 193     gfxcompactpoly_dump(poly);
 194     gfxpoly_t*poly2 = gfxpoly_process(poly, &windrule_evenodd, &onepolygon);
 195     gfxcompactpoly_destroy(poly);
 196     gfxpoly_destroy(poly2);
 197 }
 198
 199 static void test_conversion(gfxline_t*line, double gridsize)
 200 {
 201     double zoom=1.0;
 202     gfxcompactpoly_t*poly = gfxcompactpoly_from_gfxline(line, gridsize);
 203     gfxpoly_t*poly1 = gfxpoly_from_gfxline(line, gridsize);
 204     gfxpoly_t*poly2 = gfxpoly_from_gfxcompactpoly(poly);
 205     assert(gfxpoly_check(poly1));
 206     assert(gfxpoly_check(poly2));
 207     assert(gfxcompactpoly_check(poly));
 208     intbbox_t bbox = intbbox_from_polygon(poly1, zoom);
 209     unsigned char*bitmap1 = render_polygon(poly1, &bbox, zoom, &windrule_evenodd, &onepolygon);
 210     assert(bitmap_ok(&bbox, bitmap1));
 211     unsigned char*bitmap2 = render_polygon(poly2, &bbox, zoom, &windrule_evenodd, &onepolygon);
 212     assert(bitmap_ok(&bbox, bitmap2));
 213     if(!compare_bitmaps(&bbox, bitmap1, bitmap2)) {
 214         save_two_bitmaps(&bbox, bitmap1, bitmap2, "error.png");
 215         assert(!"bitmaps don't match");
 216     }
 217 }
 218
 219 int test_square(int width, int height, int num, double gridsize, char bitmaptest)
 220 {
 221     int t;
 222     gfxline_t* line = malloc(sizeof(gfxline_t)*num);
 223     for(t=0;t<num;t++) {
 224         line[t].type = t?gfx_lineTo:gfx_moveTo;
 225         line[t].x = (lrand48()%width);
 226         line[t].y = (lrand48()%height);
 227         line[t].next = &line[t+1];
 228     }
 229     line[num-1].x = line[0].x;
 230     line[num-1].y = line[0].y;
 231     line[num-1].next = 0;
 232
 233     test_conversion(line, gridsize);
 234
 235     gfxcompactpoly_t*poly = gfxcompactpoly_from_gfxline(line, gridsize);
 236     gfxline_free(line);
 237     gfxpoly_t*poly1 = gfxpoly_from_gfxcompactpoly(poly);
 238
 239     windrule_t*rule = &windrule_circular;
 240     gfxpoly_t*poly2 = gfxpoly_process(poly, rule, &onepolygon);
 241     if(bitmaptest) {
 242         intbbox_t bbox = intbbox_new(0, 0, width, height);
 243         unsigned char*bitmap1 = render_polygon(poly1, &bbox, 1.0, rule, &onepolygon);
 244         assert(bitmap_ok(&bbox, bitmap1));
 245         unsigned char*bitmap2 = render_polygon(poly2, &bbox, 1.0, &windrule_evenodd, &onepolygon);
 246         assert(bitmap_ok(&bbox, bitmap2));
 247         if(!compare_bitmaps(&bbox, bitmap1, bitmap2)) {
 248             save_two_bitmaps(&bbox, bitmap1, bitmap2, "error.png");
 249             assert(!"bitmaps don't match");
 250         }
 251     }
 252     gfxpoly_destroy(poly1);
 253     gfxpoly_destroy(poly2);
 254     gfxcompactpoly_destroy(poly);
 255 }
 256
 257 int test2(int argn, char*argv[])
 258 {
 259     test_square(400,400, 3, 0.05, 1);
 260
 261     int t;
 262     for(t=0;t<400;t++) {
 263         fprintf(stderr, "%d\n", t);
 264         test_square(400,400, 50, 0.05, 1);
 265         test_square(200,3, 1000, 1.0, 0);
 266         test_square(3,200, 1000, 1.0, 0);
 267         test_square(10,10, 200, 1.0, 0);
 268     }
 269 }
 270
 271 #include "../rfxswf.h"
 272 void test3(int argn, char*argv[])
 273 {
 274 #undef N
 275 #undef RANGE
 276 #define N 100
 277 #define RANGE 400
 278
 279     //gfxline_t*line = mkrandomshape(RANGE, N);
 280     //windrule_t*rule = &windrule_circular;
 281     //gfxline_t*line = mkchessboard();
 282     gfxline_t*line = make_circles(30);
 283     windrule_t*rule = &windrule_evenodd;
 284     //windrule_t*rule = &windrule_circular;
 285
 286     gfxmatrix_t m;
 287     memset(&m, 0, sizeof(m));
 288
 289     SWF swf;
 290     memset(&swf, 0, sizeof(SWF));
 291     swf.movieSize.xmax = RANGE*20*1.41;
 292     swf.movieSize.ymax = RANGE*20*1.41;
 293     swf.fileVersion = 9;
 294     swf.frameRate = 25*0x100;
 295     TAG * tag = swf.firstTag = swf_InsertTag(0, ST_SETBACKGROUNDCOLOR);
 296     swf_SetU8(tag, 0);
 297     swf_SetU8(tag, 0);
 298     swf_SetU8(tag, 0);
 299
 300     int t;
 301     for(t=0;t<360;t++) {
 302         fprintf(stderr, "%d\n", t);
 303         m.m00 = cos(t*M_PI/180.0);
 304         m.m01 = sin(t*M_PI/180.0);
 305         m.m10 = -sin(t*M_PI/180.0);
 306         m.m11 = cos(t*M_PI/180.0);
 307         m.tx = RANGE*1.41/2;
 308         m.ty = RANGE*1.41/2;
 309
 310         gfxline_t*l = gfxline_clone(line);
 311         gfxline_transform(l, &m);
 312
 313         test_conversion(l, 0.05);
 314
 315         gfxcompactpoly_t*poly = gfxcompactpoly_from_gfxline(l, 0.05);
 316         gfxpoly_t*poly2 = gfxpoly_process(poly, rule, &onepolygon);
 317
 318         tag = swf_InsertTag(tag, ST_DEFINESHAPE);
 319         SHAPE* s;
 320         swf_ShapeNew(&s);
 321         RGBA rgb;
 322         rgb.r = rgb.g = 0x00; rgb.b = 0xff;
 323         rgb.a = 255;
 324         int fs = swf_ShapeAddSolidFillStyle(s,&rgb);
 325         int ls = swf_ShapeAddLineStyle(s,20,&rgb);
 326         swf_SetU16(tag,t+1);
 327         swf_SetRect(tag,&swf.movieSize);
 328         swf_SetShapeHeader(tag,s);
 329
 330 #define FILL
 331 #ifdef FILL
 332         swf_ShapeSetAll(tag,s,0,0,0,fs,0);
 333         edge_t*e = poly2->edges;
 334         while(e) {
 335 #define ROTATE
 336 #ifdef ROTATE
 337             swf_ShapeSetMove(tag, s, e->a.y, e->a.x);
 338             swf_ShapeSetLine(tag, s, e->b.y - e->a.y, e->b.x - e->a.x);
 339 #else
 340             swf_ShapeSetMove(tag, s, e->a.x, e->a.y);
 341             swf_ShapeSetLine(tag, s, e->b.x - e->a.x, e->b.y - e->a.y);
 342 #endif
 343             e = e->next;
 344         }
 345 #else
 346         swf_ShapeSetAll(tag,s,0,0,ls,0,0);
 347         edge_t*e = poly2->edges;
 348         while(e) {
 349             swf_ShapeSetMove(tag, s, e->a.x, e->a.y);
 350             swf_ShapeSetLine(tag, s, e->b.x - e->a.x, e->b.y - e->a.y);
 351
 352             swf_ShapeSetCircle(tag, s, e->a.x, e->a.y, 5*20, 5*20);
 353             swf_ShapeSetCircle(tag, s, e->b.x, e->b.y, 5*20, 5*20);
 354             e = e->next;
 355         }
 356 #endif
 357
 358         swf_ShapeSetEnd(tag);
 359         swf_ShapeFree(s);
 360
 361         gfxcompactpoly_destroy(poly);
 362         gfxpoly_destroy(poly2);
 363
 364         gfxline_free(l);
 365
 366         if(t) {
 367             tag = swf_InsertTag(tag,ST_REMOVEOBJECT2);
 368             swf_SetU16(tag, t);
 369         }
 370         tag = swf_InsertTag(tag,ST_PLACEOBJECT2);
 371         swf_ObjectPlace(tag,t+1,t+1,NULL,NULL,NULL);
 372
 373         tag = swf_InsertTag(tag, ST_SHOWFRAME);
 374     }
 375     tag = swf_InsertTag(tag, ST_END);
 376
 377     swf_SaveSWF(&swf, "test.swf");
 378 }
 379
 380 void rotate90(gfxpoly_t*poly)
 381 {
 382     edge_t*e = poly->edges;
 383     while(e) {
 384         point_t a = e->a;
 385         point_t b = e->b;
 386         e->a.x = a.y;
 387         e->a.y = a.x;
 388         e->b.x = b.y;
 389         e->b.y = b.x;
 390         e = e->next;
 391     }
 392 }
 393
 394 #include <dirent.h>
 395 void test4(int argn, char*argv[])
 396 {
 397     char*dir = "ps";
 398     DIR*_dir = opendir(dir);
 399     if(!_dir) return;
 400     struct dirent*file;
 401     while(1) {
 402         file = readdir(_dir);
 403         if (!file)
 404             break;
 405         if(!strstr(file->d_name, ".ps"))
 406             continue;
 407
 408         char* filename;
 409
 410         if(argn<2)
 411             filename = allocprintf("%s/%s", dir, file->d_name);
 412         else
 413             filename = argv[1];
 414
 415         windrule_t*rule = &windrule_evenodd;
 416         gfxcompactpoly_t*poly = gfxcompactpoly_from_file(filename, 1.0);//0.01);
 417
 418         if(argn!=2)
 419             free(filename);
 420
 421         double zoom = 1.0;
 422
 423         if(!gfxcompactpoly_check(poly)) {
 424             printf("bad polygon\n");
 425             continue;
 426         }
 427
 428         gfxpoly_t*poly1 = gfxpoly_from_gfxcompactpoly(poly);
 429         gfxpoly_t*poly2 = gfxpoly_process(poly, rule, &onepolygon);
 430
 431         int pass;
 432         for(pass=0;pass<2;pass++) {
 433             intbbox_t bbox = intbbox_from_polygon(poly1, zoom);
 434             unsigned char*bitmap1 = render_polygon(poly1, &bbox, zoom, rule, &onepolygon);
 435             unsigned char*bitmap2 = render_polygon(poly2, &bbox, zoom, &windrule_evenodd, &onepolygon);
 436             if(!bitmap_ok(&bbox, bitmap1) || !bitmap_ok(&bbox, bitmap2)) {
 437                 save_two_bitmaps(&bbox, bitmap1, bitmap2, "error.png");
 438                 assert(!"error in bitmaps");
 439             }
 440             if(!compare_bitmaps(&bbox, bitmap1, bitmap2)) {
 441                 save_two_bitmaps(&bbox, bitmap1, bitmap2, "error.png");
 442                 assert(!"bitmaps don't match");
 443             }
 444             free(bitmap1);
 445             free(bitmap2);
 446
 447             // second pass renders the 90° rotated version
 448             rotate90(poly1);
 449             rotate90(poly2);
 450         }
 451
 452         gfxpoly_destroy(poly1);
 453         gfxpoly_destroy(poly2);
 454         gfxcompactpoly_destroy(poly);
 455         if(argn==2)
 456             break;
 457     }
 458     closedir(_dir);
 459 }
 460
 461 #include "../gfxdevice.h"
 462 #include "../pdf/pdf.h"
 463
 464 void extract_polygons_fill(gfxdevice_t*dev, gfxline_t*line, gfxcolor_t*color)
 465 {
 466     //gfxcompactpoly_t*c = gfxcompactpoly_from_gfxline(line, 0.05);
 467     //gfxcompactpoly_free(c);
 468
 469     gfxcompactpoly_t*poly = gfxcompactpoly_from_gfxline(line, 0.05);
 470
 471     //gfxline_dump(line, stderr, "");
 472     //gfxcompactpoly_dump(poly);
 473
 474     if(gfxcompactpoly_size(poly)>100000) {
 475         fprintf(stderr, "%d segments (skipping)\n", gfxcompactpoly_size(poly));
 476         return;
 477     } else {
 478         //fprintf(stderr, "%d segments\n", gfxpoly_size(poly));
 479     }
 480
 481     if(!gfxcompactpoly_check(poly)) {
 482         gfxcompactpoly_destroy(poly);
 483         fprintf(stderr, "bad polygon\n");
 484         return;
 485     }
 486
 487     windrule_t*rule = &windrule_evenodd;
 488
 489     gfxpoly_t*poly1 = gfxpoly_from_gfxcompactpoly(poly);
 490
 491     double zoom = 1.0;
 492     intbbox_t bbox = intbbox_from_polygon(poly1, zoom);
 493     unsigned char*bitmap1 = render_polygon(poly1, &bbox, zoom, rule, &onepolygon);
 494     if(!bitmap_ok(&bbox, bitmap1)) {
 495         fprintf(stderr, "bad polygon or error in renderer\n");
 496         return;
 497     }
 498     gfxpoly_t*poly2 = gfxpoly_process(poly, rule, &onepolygon);
 499     unsigned char*bitmap2 = render_polygon(poly2, &bbox, zoom, &windrule_evenodd, &onepolygon);
 500     if(!bitmap_ok(&bbox, bitmap2)) {
 501         save_two_bitmaps(&bbox, bitmap1, bitmap2, "error.png");
 502         assert(!"error in bitmap");
 503     }
 504     if(!compare_bitmaps(&bbox, bitmap1, bitmap2)) {
 505         save_two_bitmaps(&bbox, bitmap1, bitmap2, "error.png");
 506         assert(!"bitmaps don't match");
 507     }
 508     free(bitmap1);
 509     free(bitmap2);
 510
 511     gfxpoly_destroy(poly1);
 512     gfxpoly_destroy(poly2);
 513     gfxcompactpoly_destroy(poly);
 514 }
 515 int extract_polygons_setparameter(gfxdevice_t*dev, const char*key, const char*value) {
 516     return 0;
 517 }
 518 void extract_polygons_startclip(gfxdevice_t*dev, gfxline_t*line)
 519 {
 520     extract_polygons_fill(dev, line, 0);
 521 }
 522 void extract_polygons_fillbitmap(gfxdevice_t*dev, gfxline_t*line, gfximage_t*img, gfxmatrix_t*imgcoord2devcoord, gfxcxform_t*cxform)
 523 {
 524     extract_polygons_fill(dev, line, 0);
 525 }
 526 void extract_polygons_fillgradient(gfxdevice_t*dev, gfxline_t*line, gfxgradient_t*gradient, gfxgradienttype_t type, gfxmatrix_t*gradcoord2devcoord)
 527 {
 528     extract_polygons_fill(dev, line, 0);
 529 }
 530 void extract_polygons_drawlink(gfxdevice_t*dev, gfxline_t*line, const char*action)
 531 {
 532     extract_polygons_fill(dev, line, 0);
 533 }
 534 void extract_polygons_addfont(gfxdevice_t*dev, gfxfont_t*font)
 535 {
 536     int t;
 537     for(t=0;t<font->num_glyphs;t++) {
 538         //extract_polygons_fill(dev, font->glyphs[t].line, 0);
 539     }
 540 }
 541 void extract_polygons_endclip(gfxdevice_t*dev)
 542 {
 543 }
 544 void extract_polygons_stroke(gfxdevice_t*dev, gfxline_t*line, gfxcoord_t width, gfxcolor_t*color, gfx_capType cap_style, gfx_joinType joint_style, gfxcoord_t miterLimit)
 545 {
 546 }
 547 void extract_polygons_drawchar(gfxdevice_t*dev, gfxfont_t*font, int glyph, gfxcolor_t*color, gfxmatrix_t*matrix)
 548 {
 549 }
 550
 551 gfxdevice_t extract_polygons =
 552 {
 553 name: "extract polygons",
 554 setparameter:extract_polygons_setparameter,
 555 startclip: extract_polygons_startclip,
 556 endclip: extract_polygons_endclip,
 557 stroke: extract_polygons_stroke,
 558 fill: extract_polygons_fill,
 559 fillbitmap: extract_polygons_fillbitmap,
 560 fillgradient: extract_polygons_fillgradient,
 561 addfont: extract_polygons_addfont,
 562 drawchar: extract_polygons_drawchar,
 563 drawlink: extract_polygons_drawlink,
 564 startpage: 0,
 565 endpage: 0,
 566 geterror: 0,
 567 finish: 0,
 568 internal: 0
 569 };
 570
 571 void test5(int argn, char*argv[])
 572 {
 573     gfxsource_t*driver = gfxsource_pdf_create();
 574     char*dir = "pdfs";
 575     DIR*_dir = opendir(dir);
 576     if(!_dir) return;
 577     struct dirent*file;
 578     while(1) {
 579         file = readdir(_dir);
 580         if (!file)
 581             break;
 582         if(!strstr(file->d_name, ".pdf"))
 583             continue;
 584         char* filename = allocprintf("%s/%s", dir, file->d_name);
 585
 586         if(argn>1)
 587             filename = argv[1];
 588
 589         gfxdocument_t*doc = driver->open(driver, filename);
 590         gfxdevice_t*out = &extract_polygons;
 591         int t;
 592         for(t=1;t<=doc->num_pages;t++) {
 593             fprintf(stderr, "%s (page %d)\n", filename, t);
 594             gfxpage_t* page = doc->getpage(doc, t);
 595             page->render(page, out);
 596             page->destroy(page);
 597         }
 598         doc->destroy(doc);
 599         if(argn>1)
 600             break;
 601         free(filename);
 602     }
 603     closedir(_dir);
 604     driver->destroy(driver);
 605 }
 606
 607 int main(int argn, char*argv[])
 608 {
 609     test_speed(argn, argv);
 610 }
 611