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 testbox(int argn, char*argv[])
 170 {
 171     gfxline_t*box1 = gfxline_makerectangle(-100,-100,100,100);
 172     gfxline_t*box2 = gfxline_makerectangle(-50,-50,150,150);
 173     gfxpoly_t*poly1 = gfxpoly_from_fill(box1, 0.05);
 174     gfxpoly_t*poly2 = gfxpoly_from_fill(box2, 0.05);
 175     gfxline_free(box1);
 176     gfxline_free(box2);
 177
 178     gfxpoly_t*poly12 = gfxpoly_process(poly1, poly2, &windrule_intersect, &twopolygons);
 179     gfxpoly_dump(poly12);
 180     assert(gfxpoly_check(poly12, 0));
 181     gfxpoly_destroy(poly12);
 182 }
 183
 184 int teststroke(int argn, char*argv[])
 185 {
 186     //gfxline_t*box1 = gfxline_makerectangle(-100,-100,100,100);
 187     gfxline_t*box1 = gfxline_makerectangle(100,100,200,200);
 188     gfxpoly_t*poly = gfxpoly_from_stroke(box1, 10.0, gfx_capRound, gfx_joinMiter, 1000, 0.05);
 189     assert(gfxpoly_check(poly, 1));
 190 }
 191
 192 int test0(int argn, char*argv[])
 193 {
 194     gfxline_t*box1 = gfxline_makerectangle(-100,-100,100,100);
 195     gfxline_t*box2 = gfxline_makerectangle(-100,-100,100,100);
 196     gfxline_t*box3 = gfxline_makerectangle(-100,-100,100,100);
 197     //gfxline_append(box2, box3);
 198
 199     gfxmatrix_t matrix;
 200     memset(&matrix, 0, sizeof(gfxmatrix_t));
 201     double ua=M_PI/4;
 202     matrix.m00=cos(ua);matrix.m10=sin(ua);
 203     matrix.m01=-sin(ua);matrix.m11=cos(ua);
 204     gfxline_transform(box1, &matrix);
 205
 206     //gfxline_t*b = 0;
 207     //b = gfxline_append(b, box1);
 208     //b = gfxline_append(b, box2);
 209     //gfxline_dump(b, stderr, "");
 210
 211     gfxpoly_t*poly1 = gfxpoly_from_fill(box1, 0.05);
 212     gfxpoly_t*poly2 = gfxpoly_from_fill(box2, 0.05);
 213
 214     gfxline_free(box1);
 215     gfxline_free(box2);
 216
 217     //gfxpoly_t*poly3 = gfxpoly_process(poly1, poly2, &windrule_intersect, &twopolygons);
 218     gfxpoly_t*poly3 = gfxpoly_process(poly1, poly2, &windrule_intersect, &twopolygons);
 219     gfxpoly_dump(poly3);
 220
 221     gfxline_t*line = gfxline_from_gfxpoly(poly3);
 222
 223     gfxline_dump(line, stdout, "");
 224     gfxline_free(line);
 225     gfxpoly_destroy(poly1);
 226     gfxpoly_destroy(poly2);
 227     gfxpoly_destroy(poly3);
 228 }
 229
 230
 231 int test1(int argn, char*argv[])
 232 {
 233     gfxline_t*box1 = gfxline_makerectangle(50,50,150,150);
 234     gfxline_t*box2 = gfxline_makerectangle(100,100,200,200);
 235     gfxline_t*box3 = gfxline_makerectangle(200,100,300,200);
 236     gfxline_t*box4 = gfxline_makerectangle(300,200,400,400);
 237     gfxline_t* board = mkchessboard();
 238     gfxline_t*star = mkstar(50,50, 150,150);
 239     gfxline_t*b = 0;
 240     b = gfxline_append(b, box1);
 241     b = gfxline_append(b, box2);
 242     b = gfxline_append(b, box3);
 243     b = gfxline_append(b, box4);
 244
 245     gfxmatrix_t matrix;
 246     memset(&matrix, 0, sizeof(gfxmatrix_t));
 247     matrix.m00 = 1.0;
 248     matrix.m11 = 1.0;
 249     matrix.tx = 200;
 250     matrix.ty = 200;
 251     gfxline_transform(board, &matrix);
 252     b = gfxline_append(b, board);
 253
 254     //gfxline_transform(b, &matrix);
 255
 256     //gfxline_dump(b, stderr, "");
 257     gfxpoly_t*poly = gfxpoly_from_fill(b, 0.05);
 258
 259     gfxline_free(box1);
 260     gfxline_free(box2);
 261     gfxline_free(box3);
 262     gfxline_free(star);
 263
 264     //gfxpoly_dump(poly);
 265     gfxpoly_t*poly2 = gfxpoly_process(poly, 0, &windrule_evenodd, &onepolygon);
 266     //gfxpoly_dump(poly2);
 267     gfxpoly_save_arrows(poly2, "test.ps");
 268     gfxpoly_destroy(poly);
 269     gfxpoly_destroy(poly2);
 270 }
 271
 272 int test_square(int width, int height, int num, double gridsize, char bitmaptest)
 273 {
 274     int t;
 275     gfxline_t* line = malloc(sizeof(gfxline_t)*num);
 276     for(t=0;t<num;t++) {
 277         line[t].type = t?gfx_lineTo:gfx_moveTo;
 278         line[t].x = (lrand48()%width);
 279         line[t].y = (lrand48()%height);
 280         line[t].next = &line[t+1];
 281     }
 282     line[num-1].x = line[0].x;
 283     line[num-1].y = line[0].y;
 284     line[num-1].next = 0;
 285
 286     gfxpoly_t*poly1 = gfxpoly_from_fill(line, gridsize);
 287     gfxline_free(line);
 288
 289     windrule_t*rule = &windrule_circular;
 290     gfxpoly_t*poly2 = gfxpoly_process(poly1, 0, rule, &onepolygon);
 291     if(bitmaptest) {
 292         intbbox_t bbox = intbbox_new(0, 0, width, height);
 293         unsigned char*bitmap1 = render_polygon(poly1, &bbox, 1.0, rule, &onepolygon);
 294         assert(bitmap_ok(&bbox, bitmap1));
 295         unsigned char*bitmap2 = render_polygon(poly2, &bbox, 1.0, &windrule_evenodd, &onepolygon);
 296         assert(bitmap_ok(&bbox, bitmap2));
 297         if(!compare_bitmaps(&bbox, bitmap1, bitmap2)) {
 298             save_two_bitmaps(&bbox, bitmap1, bitmap2, "error.png");
 299             assert(!"bitmaps don't match");
 300         }
 301     }
 302     gfxpoly_destroy(poly1);
 303     gfxpoly_destroy(poly2);
 304 }
 305
 306 int test2(int argn, char*argv[])
 307 {
 308     test_square(400,400, 3, 0.05, 1);
 309
 310     int t;
 311     for(t=0;t<400;t++) {
 312         fprintf(stderr, "%d\n", t);
 313         test_square(400,400, 50, 0.05, 1);
 314         test_square(200,3, 1000, 1.0, 0);
 315         test_square(3,200, 1000, 1.0, 0);
 316         test_square(10,10, 200, 1.0, 0);
 317     }
 318 }
 319
 320 #include "../rfxswf.h"
 321 void test3(int argn, char*argv[])
 322 {
 323 #undef N
 324 #undef RANGE
 325 #define N 100
 326 #define RANGE 400
 327
 328     //gfxline_t*line = mkrandomshape(RANGE, N);
 329     //windrule_t*rule = &windrule_circular;
 330     gfxline_t*line = mkchessboard();
 331     //gfxline_t*line = make_circles(30);
 332     windrule_t*rule = &windrule_evenodd;
 333     //windrule_t*rule = &windrule_circular;
 334
 335     gfxmatrix_t m;
 336     memset(&m, 0, sizeof(m));
 337
 338     SWF swf;
 339     memset(&swf, 0, sizeof(SWF));
 340     swf.movieSize.xmax = RANGE*20*1.41;
 341     swf.movieSize.ymax = RANGE*20*1.41;
 342     swf.fileVersion = 9;
 343     swf.frameRate = 25*0x100;
 344     TAG * tag = swf.firstTag = swf_InsertTag(0, ST_SETBACKGROUNDCOLOR);
 345     swf_SetU8(tag, 0);
 346     swf_SetU8(tag, 0);
 347     swf_SetU8(tag, 0);
 348
 349     int t;
 350     for(t=0;t<360;t++) {
 351         fprintf(stderr, "%d\n", t);
 352         m.m00 = cos(t*M_PI/180.0);
 353         m.m01 = sin(t*M_PI/180.0);
 354         m.m10 = -sin(t*M_PI/180.0);
 355         m.m11 = cos(t*M_PI/180.0);
 356         m.tx = RANGE*1.41/2;
 357         m.ty = RANGE*1.41/2;
 358
 359         gfxline_t*l = gfxline_clone(line);
 360         gfxline_transform(l, &m);
 361
 362         gfxpoly_t*poly1 = gfxpoly_from_fill(l, 0.05);
 363
 364         gfxpoly_t*poly2 = gfxpoly_process(poly1, 0, rule, &onepolygon);
 365         assert(gfxpoly_check(poly2, 0));
 366
 367         tag = swf_InsertTag(tag, ST_DEFINESHAPE);
 368         SHAPE* s;
 369         swf_ShapeNew(&s);
 370         RGBA rgb;
 371         rgb.r = rgb.g = 0x00; rgb.b = 0xff;
 372         rgb.a = 255;
 373         int fs = swf_ShapeAddSolidFillStyle(s,&rgb);
 374         int ls = swf_ShapeAddLineStyle(s,20,&rgb);
 375         swf_SetU16(tag,t+1);
 376         swf_SetRect(tag,&swf.movieSize);
 377         swf_SetShapeHeader(tag,s);
 378
 379 #define FILL
 380 #ifdef FILL
 381         swf_ShapeSetAll(tag,s,UNDEFINED_COORD,UNDEFINED_COORD,0,fs,0);
 382
 383         int i,j;
 384         gfxpolystroke_t*stroke = poly2->strokes;
 385         for(;stroke;stroke=stroke->next) {
 386             for(j=0;j<stroke->num_points-1;j++) {
 387                 point_t a = stroke->points[j];
 388                 point_t b = stroke->points[j+1];
 389 #define ROTATE
 390 #ifdef ROTATE
 391                 swf_ShapeSetMove(tag, s, a.y, a.x);
 392                 swf_ShapeSetLine(tag, s, b.y - a.y, b.x - a.x);
 393 #else
 394                 swf_ShapeSetMove(tag, s, a.x, a.y);
 395                 swf_ShapeSetLine(tag, s, b.x - a.x, b.y - a.y);
 396 #endif
 397             }
 398         }
 399 #else
 400         swf_ShapeSetAll(tag,s,0,0,ls,0,0);
 401         edge_t*e = poly2->edges;
 402         while(e) {
 403             swf_ShapeSetMove(tag, s, e->a.x, e->a.y);
 404             swf_ShapeSetLine(tag, s, e->b.x - e->a.x, e->b.y - e->a.y);
 405
 406             swf_ShapeSetCircle(tag, s, e->a.x, e->a.y, 5*20, 5*20);
 407             swf_ShapeSetCircle(tag, s, e->b.x, e->b.y, 5*20, 5*20);
 408             e = e->next;
 409         }
 410 #endif
 411
 412         swf_ShapeSetEnd(tag);
 413         swf_ShapeFree(s);
 414
 415         gfxpoly_destroy(poly1);
 416         gfxpoly_destroy(poly2);
 417
 418         gfxline_free(l);
 419
 420         if(t) {
 421             tag = swf_InsertTag(tag,ST_REMOVEOBJECT2);
 422             swf_SetU16(tag, t);
 423         }
 424         tag = swf_InsertTag(tag,ST_PLACEOBJECT2);
 425         swf_ObjectPlace(tag,t+1,t+1,NULL,NULL,NULL);
 426
 427         tag = swf_InsertTag(tag, ST_SHOWFRAME);
 428     }
 429     tag = swf_InsertTag(tag, ST_END);
 430
 431     swf_SaveSWF(&swf, "test.swf");
 432 }
 433
 434 void rotate90(gfxpoly_t*poly)
 435 {
 436     int i,j;
 437     gfxpolystroke_t*stroke = poly->strokes;
 438     for(;stroke;stroke=stroke->next) {
 439         for(j=0;j<stroke->num_points;j++) {
 440             point_t a = stroke->points[j];
 441             stroke->points[j].x = a.y;
 442             stroke->points[j].y = a.x;
 443         }
 444     }
 445 }
 446
 447 #include <dirent.h>
 448 void test4(int argn, char*argv[])
 449 {
 450     char*dir = "ps";
 451     DIR*_dir = opendir(dir);
 452     if(!_dir) return;
 453     struct dirent*file;
 454     while(1) {
 455         file = readdir(_dir);
 456         if (!file)
 457             break;
 458         if(!strstr(file->d_name, ".ps"))
 459             continue;
 460
 461         char* filename;
 462
 463         if(argn<2)
 464             filename = allocprintf("%s/%s", dir, file->d_name);
 465         else
 466             filename = argv[1];
 467
 468         windrule_t*rule = &windrule_evenodd;
 469         gfxpoly_t*poly1 = gfxpoly_from_file(filename, 1.0);//0.01);
 470
 471         if(argn!=2)
 472             free(filename);
 473
 474         double zoom = 1.0;
 475
 476         if(!gfxpoly_check(poly1, 0)) {
 477             printf("bad polygon\n");
 478             goto end_of_loop;
 479         }
 480
 481         gfxpoly_t*poly2 = gfxpoly_process(poly1, 0, rule, &onepolygon);
 482         gfxpoly_dump(poly2);
 483         assert(gfxpoly_check(poly2, 1));
 484
 485         int pass;
 486         for(pass=0;pass<2;pass++) {
 487             intbbox_t bbox = intbbox_from_polygon(poly1, zoom);
 488             unsigned char*bitmap1 = render_polygon(poly1, &bbox, zoom, rule, &onepolygon);
 489             unsigned char*bitmap2 = render_polygon(poly2, &bbox, zoom, &windrule_circular, &onepolygon);
 490             if(!bitmap_ok(&bbox, bitmap1) || !bitmap_ok(&bbox, bitmap2)) {
 491                 save_two_bitmaps(&bbox, bitmap1, bitmap2, "error.png");
 492                 assert(!"error in bitmaps");
 493             }
 494             if(!compare_bitmaps(&bbox, bitmap1, bitmap2)) {
 495                 save_two_bitmaps(&bbox, bitmap1, bitmap2, "error.png");
 496                 assert(!"bitmaps don't match");
 497             }
 498             free(bitmap1);
 499             free(bitmap2);
 500
 501             // second pass renders the 90° rotated version
 502             rotate90(poly1);
 503             rotate90(poly2);
 504         }
 505
 506         gfxpoly_destroy(poly1);
 507         gfxpoly_destroy(poly2);
 508
 509         end_of_loop:
 510         if(argn==2)
 511             break;
 512     }
 513     closedir(_dir);
 514 }
 515
 516 #include "../gfxdevice.h"
 517 #include "../pdf/pdf.h"
 518
 519 static int max_segments = 0;
 520 static int max_any_segments = 0;
 521 void extract_polygons_fill(gfxdevice_t*dev, gfxline_t*line, gfxcolor_t*color)
 522 {
 523     //gfxpoly_t*c = gfxpoly_from_fill(line, 0.05);
 524     //gfxpoly_free(c);
 525
 526     //gfxpoly_t*poly1 = gfxpoly_from_fill(line, 0.05);
 527     gfxpoly_t*poly1 = gfxpoly_from_fill(line, 0.05);
 528
 529     //gfxline_dump(line, stderr, "");
 530     //gfxpoly_dump(poly);
 531
 532     int size = gfxpoly_size(poly1);
 533     if(size == 4) {
 534         //rectangles are boring.
 535         gfxpoly_destroy(poly1);
 536         return;
 537     }
 538
 539     max_any_segments = size > max_any_segments? size : max_any_segments;
 540     if(size>100000) {
 541         fprintf(stderr, "%d segments (skipping)\n", size);
 542         return;
 543     } else {
 544         max_segments = size > max_segments? size : max_segments;
 545         fprintf(stderr, "%d segments (max so far: %d/%d)\n", size, max_segments, max_any_segments);
 546     }
 547
 548     if(!gfxpoly_check(poly1, 0)) {
 549         gfxpoly_destroy(poly1);
 550         fprintf(stderr, "bad polygon\n");
 551         return;
 552     }
 553
 554     windrule_t*rule = &windrule_evenodd;
 555
 556     double zoom = 1.0;
 557     intbbox_t bbox = intbbox_from_polygon(poly1, zoom);
 558     unsigned char*bitmap1 = render_polygon(poly1, &bbox, zoom, rule, &onepolygon);
 559     if(!bitmap_ok(&bbox, bitmap1)) {
 560         fprintf(stderr, "bad polygon or error in renderer\n");
 561         return;
 562     }
 563     gfxpoly_t*poly2 = gfxpoly_process(poly1, 0, rule, &onepolygon);
 564     unsigned char*bitmap2 = render_polygon(poly2, &bbox, zoom, &windrule_evenodd, &onepolygon);
 565     if(!bitmap_ok(&bbox, bitmap2)) {
 566         save_two_bitmaps(&bbox, bitmap1, bitmap2, "error.png");
 567         assert(!"error in bitmap");
 568     }
 569     if(!compare_bitmaps(&bbox, bitmap1, bitmap2)) {
 570         save_two_bitmaps(&bbox, bitmap1, bitmap2, "error.png");
 571         assert(!"bitmaps don't match");
 572     }
 573     free(bitmap1);
 574     free(bitmap2);
 575
 576     gfxpoly_destroy(poly1);
 577     gfxpoly_destroy(poly2);
 578 }
 579 int extract_polygons_setparameter(gfxdevice_t*dev, const char*key, const char*value) {
 580     return 0;
 581 }
 582 void extract_polygons_startclip(gfxdevice_t*dev, gfxline_t*line)
 583 {
 584     extract_polygons_fill(dev, line, 0);
 585 }
 586 void extract_polygons_fillbitmap(gfxdevice_t*dev, gfxline_t*line, gfximage_t*img, gfxmatrix_t*imgcoord2devcoord, gfxcxform_t*cxform)
 587 {
 588     extract_polygons_fill(dev, line, 0);
 589 }
 590 void extract_polygons_fillgradient(gfxdevice_t*dev, gfxline_t*line, gfxgradient_t*gradient, gfxgradienttype_t type, gfxmatrix_t*gradcoord2devcoord)
 591 {
 592     extract_polygons_fill(dev, line, 0);
 593 }
 594 void extract_polygons_drawlink(gfxdevice_t*dev, gfxline_t*line, const char*action)
 595 {
 596     extract_polygons_fill(dev, line, 0);
 597 }
 598 void extract_polygons_addfont(gfxdevice_t*dev, gfxfont_t*font)
 599 {
 600     int t;
 601     for(t=0;t<font->num_glyphs;t++) {
 602         //extract_polygons_fill(dev, font->glyphs[t].line, 0);
 603     }
 604 }
 605 void extract_polygons_endclip(gfxdevice_t*dev)
 606 {
 607 }
 608 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)
 609 {
 610 }
 611 void extract_polygons_drawchar(gfxdevice_t*dev, gfxfont_t*font, int glyph, gfxcolor_t*color, gfxmatrix_t*matrix)
 612 {
 613 }
 614
 615 gfxdevice_t extract_polygons =
 616 {
 617 name: "extract polygons",
 618 setparameter:extract_polygons_setparameter,
 619 startclip: extract_polygons_startclip,
 620 endclip: extract_polygons_endclip,
 621 stroke: extract_polygons_stroke,
 622 fill: extract_polygons_fill,
 623 fillbitmap: extract_polygons_fillbitmap,
 624 fillgradient: extract_polygons_fillgradient,
 625 addfont: extract_polygons_addfont,
 626 drawchar: extract_polygons_drawchar,
 627 drawlink: extract_polygons_drawlink,
 628 startpage: 0,
 629 endpage: 0,
 630 geterror: 0,
 631 finish: 0,
 632 internal: 0
 633 };
 634
 635 #if 0
 636 void test5(int argn, char*argv[])
 637 {
 638     gfxsource_t*driver = gfxsource_pdf_create();
 639     char*dir = "pdfs";
 640     DIR*_dir = opendir(dir);
 641     if(!_dir) return;
 642     struct dirent*file;
 643     while(1) {
 644         file = readdir(_dir);
 645         if (!file)
 646             break;
 647         if(!strstr(file->d_name, ".pdf"))
 648             continue;
 649         char* filename = allocprintf("%s/%s", dir, file->d_name);
 650
 651         if(argn>1)
 652             filename = argv[1];
 653
 654         gfxdocument_t*doc = driver->open(driver, filename);
 655         gfxdevice_t*out = &extract_polygons;
 656         int t;
 657         for(t=1;t<=doc->num_pages;t++) {
 658             fprintf(stderr, "%s (page %d)\n", filename, t);
 659             gfxpage_t* page = doc->getpage(doc, t);
 660             page->render(page, out);
 661             page->destroy(page);
 662         }
 663         doc->destroy(doc);
 664         if(argn>1)
 665             break;
 666         free(filename);
 667     }
 668     closedir(_dir);
 669     driver->destroy(driver);
 670 }
 671 #endif
 672
 673 int main(int argn, char*argv[])
 674 {
 675     test0(argn, argv);
 676 }
 677