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