c990ca281113953fb17e0d383807a3be4a675319
[swftools.git] / 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()
118 {
119     gfxline_t*b = 0;
120     unsigned int c = 0;
121     int t;
122     for(t=0;t<30;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     }
131     return b;
132 }
133
134 static windcontext_t onepolygon = {1};
135
136 int test0()
137 {
138     //gfxline_t* b = mkchessboard();
139     //gfxline_t* b = mkrandomshape(100,7);
140     gfxline_t* b = gfxline_makecircle(100,100,100,100);
141
142     gfxmatrix_t m;
143     memset(&m, 0, sizeof(gfxmatrix_t));
144     int t;
145     for(t=0;t<360;t++) {
146         m.m00 = cos(t*M_PI/180.0);
147         m.m01 = sin(t*M_PI/180.0);
148         m.m10 = -sin(t*M_PI/180.0);
149         m.m11 = cos(t*M_PI/180.0);
150         m.tx = 400*1.41/2;
151         m.ty = 400*1.41/2;
152         gfxline_transform(b, &m);
153         gfxpoly_t*poly = gfxpoly_from_gfxline(b, 0.05);
154
155         gfxpoly_t*poly2 = gfxpoly_process(poly, &windrule_evenodd, &onepolygon);
156         gfxpoly_destroy(poly2);
157         gfxpoly_destroy(poly);
158     }
159     gfxline_free(b);
160 }
161
162 int test1(int argn, char*argv[])
163 {
164     gfxline_t*box1 = gfxline_makerectangle(50,50,150,150);
165     // put box2 and box3 on top of each other *snicker*
166     gfxline_t*box2 = gfxline_makerectangle(100,100,200,200);
167     gfxline_t*box3 = gfxline_makerectangle(100,100,200,200);
168     gfxline_t*star = mkstar(50,50, 150,150);
169     gfxline_t*b = 0;
170     b = gfxline_append(b, box1);
171     b = gfxline_append(b, box2);
172     b = gfxline_append(b, box3);
173     //b = gfxline_append(b, star);
174
175     gfxmatrix_t matrix;
176     memset(&matrix, 0, sizeof(gfxmatrix_t));
177     double ua=0.1;
178     matrix.m00=cos(ua);matrix.m10=sin(ua);
179     matrix.m01=-sin(ua);matrix.m11=cos(ua);
180
181     //gfxline_transform(b, &matrix);
182
183     gfxpoly_t*poly = gfxpoly_from_gfxline(b, 0.05);
184     gfxline_free(box1);
185     gfxline_free(box2);
186     gfxline_free(box3);
187     gfxline_free(star);
188
189     gfxpoly_dump(poly);
190     gfxpoly_t*poly2 = gfxpoly_process(poly, &windrule_evenodd, &onepolygon);
191     gfxpoly_destroy(poly2);
192     gfxpoly_destroy(poly);
193 }
194
195 int test_square(int width, int height, int num, double gridsize, char bitmaptest)
196 {
197     int t;
198     gfxline_t* line = malloc(sizeof(gfxline_t)*num);
199     for(t=0;t<num;t++) {
200         line[t].type = t?gfx_lineTo:gfx_moveTo;
201         line[t].x = (lrand48()%width);
202         line[t].y = (lrand48()%height);
203         line[t].next = &line[t+1];
204     }
205     line[num-1].x = line[0].x;
206     line[num-1].y = line[0].y;
207     line[num-1].next = 0;
208     
209     gfxpoly_t*poly = gfxpoly_from_gfxline(line, gridsize);
210     gfxline_free(line);
211
212     windrule_t*rule = &windrule_circular;
213     gfxpoly_t*poly2 = gfxpoly_process(poly, rule, &onepolygon);
214     if(bitmaptest) {
215         intbbox_t bbox = intbbox_new(0, 0, width, height);
216         unsigned char*bitmap1 = render_polygon(poly, &bbox, 1.0, rule, &onepolygon);
217         unsigned char*bitmap2 = render_polygon(poly2, &bbox, 1.0, &windrule_evenodd, &onepolygon);
218         if(!compare_bitmaps(&bbox, bitmap1, bitmap2)) {
219             save_two_bitmaps(&bbox, bitmap1, bitmap2, "error.png");
220             assert(!"bitmaps don't match");
221         }
222     }
223     gfxpoly_destroy(poly2);
224     gfxpoly_destroy(poly);
225 }
226
227 int test2(int argn, char*argv[])
228 {
229     test_square(400,400, 3, 0.05, 1);
230
231     int t;
232     for(t=0;t<400;t++) {
233         test_square(400,400, 50, 0.05, 1);
234         test_square(200,3, 1000, 1.0, 0);
235         test_square(3,200, 1000, 1.0, 0);
236         test_square(10,10, 200, 1.0, 0);
237     }
238 }
239
240 #include "../rfxswf.h"
241 void test3(int argn, char*argv[])
242 {
243 #undef N
244 #undef RANGE
245 #define N 100
246 #define RANGE 400
247
248     //gfxline_t*line = mkrandomshape(RANGE, N);
249     //windrule_t*rule = &windrule_circular;
250     //gfxline_t*line = mkchessboard();
251     gfxline_t*line = make_circles();
252     windrule_t*rule = &windrule_evenodd;
253     //windrule_t*rule = &windrule_circular;
254
255     gfxmatrix_t m;
256     memset(&m, 0, sizeof(m));
257
258     SWF swf;
259     memset(&swf, 0, sizeof(SWF));
260     swf.movieSize.xmax = RANGE*20*1.41;
261     swf.movieSize.ymax = RANGE*20*1.41;
262     swf.fileVersion = 9;
263     swf.frameRate = 25*0x100;
264     TAG * tag = swf.firstTag = swf_InsertTag(0, ST_SETBACKGROUNDCOLOR);
265     swf_SetU8(tag, 0);
266     swf_SetU8(tag, 0);
267     swf_SetU8(tag, 0);
268
269     int t;
270     for(t=0;t<360;t++) {
271         fprintf(stderr, "%d\n", t);
272         m.m00 = cos(t*M_PI/180.0);
273         m.m01 = sin(t*M_PI/180.0);
274         m.m10 = -sin(t*M_PI/180.0);
275         m.m11 = cos(t*M_PI/180.0);
276         m.tx = RANGE*1.41/2;
277         m.ty = RANGE*1.41/2;
278
279         gfxline_t*l = gfxline_clone(line);
280         gfxline_transform(l, &m);
281         
282         gfxpoly_t*poly = gfxpoly_from_gfxline(l, 0.05);
283         gfxpoly_t*poly2 = gfxpoly_process(poly, rule, &onepolygon);
284
285         tag = swf_InsertTag(tag, ST_DEFINESHAPE);
286         SHAPE* s;
287         swf_ShapeNew(&s);
288         RGBA rgb;
289         rgb.r = rgb.g = 0x00; rgb.b = 0xff;
290         rgb.a = 255;
291         int fs = swf_ShapeAddSolidFillStyle(s,&rgb);
292         int ls = swf_ShapeAddLineStyle(s,20,&rgb);
293         swf_SetU16(tag,t+1);
294         swf_SetRect(tag,&swf.movieSize);
295         swf_SetShapeHeader(tag,s);
296
297 #define FILL
298 #ifdef FILL
299         swf_ShapeSetAll(tag,s,0,0,0,fs,0);
300         edge_t*e = poly2->edges;
301         while(e) {
302 #define ROTATE
303 #ifdef ROTATE
304             swf_ShapeSetMove(tag, s, e->a.y, e->a.x);
305             swf_ShapeSetLine(tag, s, e->b.y - e->a.y, e->b.x - e->a.x);
306 #else
307             swf_ShapeSetMove(tag, s, e->a.x, e->a.y);
308             swf_ShapeSetLine(tag, s, e->b.x - e->a.x, e->b.y - e->a.y);
309 #endif
310             e = e->next;
311         }
312 #else
313         swf_ShapeSetAll(tag,s,0,0,ls,0,0);
314         edge_t*e = poly2->edges;
315         while(e) {
316             swf_ShapeSetMove(tag, s, e->a.x, e->a.y);
317             swf_ShapeSetLine(tag, s, e->b.x - e->a.x, e->b.y - e->a.y);
318             
319             swf_ShapeSetCircle(tag, s, e->a.x, e->a.y, 5*20, 5*20);
320             swf_ShapeSetCircle(tag, s, e->b.x, e->b.y, 5*20, 5*20);
321             e = e->next;
322         }
323 #endif
324
325         swf_ShapeSetEnd(tag);
326         swf_ShapeFree(s);
327
328         gfxpoly_destroy(poly);
329         gfxpoly_destroy(poly2);
330
331         gfxline_free(l);
332    
333         if(t) {
334             tag = swf_InsertTag(tag,ST_REMOVEOBJECT2);
335             swf_SetU16(tag, t);
336         }
337         tag = swf_InsertTag(tag,ST_PLACEOBJECT2);
338         swf_ObjectPlace(tag,t+1,t+1,NULL,NULL,NULL);
339
340         tag = swf_InsertTag(tag, ST_SHOWFRAME);
341     }
342     tag = swf_InsertTag(tag, ST_END);
343
344     swf_SaveSWF(&swf, "test.swf");
345 }
346
347 void rotate90(gfxpoly_t*poly)
348 {
349     edge_t*e = poly->edges;
350     while(e) {
351         point_t a = e->a;
352         point_t b = e->b;
353         e->a.x = a.y;
354         e->a.y = a.x;
355         e->b.x = b.y;
356         e->b.y = b.x;
357         e = e->next;
358     }
359 }
360
361 #include <dirent.h>
362 void test4(int argn, char*argv[])
363 {
364     char*dir = "ps";
365     DIR*_dir = opendir(dir);
366     if(!_dir) return;
367     struct dirent*file;
368     while(1) {
369         file = readdir(_dir);
370         if (!file) 
371             break;
372         if(!strstr(file->d_name, ".ps")) 
373             continue;
374
375         char* filename;
376
377         if(argn<2)
378             filename = allocprintf("%s/%s", dir, file->d_name);
379         else
380             filename = argv[1];
381
382         windrule_t*rule = &windrule_evenodd;
383         gfxpoly_t*poly = gfxpoly_from_file(filename, 1.0);//0.01);
384
385         if(argn!=2)
386             free(filename);
387
388         double zoom = 1.0;
389
390         if(!gfxpoly_check(poly)) {
391             printf("bad polygon\n");
392             continue;
393         }
394
395         gfxpoly_t*poly2 = gfxpoly_process(poly, rule, &onepolygon);
396
397         int pass;
398         for(pass=0;pass<2;pass++) {
399             intbbox_t bbox = intbbox_from_polygon(poly, zoom);
400             unsigned char*bitmap1 = render_polygon(poly, &bbox, zoom, rule, &onepolygon);
401             unsigned char*bitmap2 = render_polygon(poly2, &bbox, zoom, &windrule_evenodd, &onepolygon);
402             if(!bitmap_ok(&bbox, bitmap1) || !bitmap_ok(&bbox, bitmap2)) {
403                 save_two_bitmaps(&bbox, bitmap1, bitmap2, "error.png");
404                 assert(!"error in bitmaps");
405             }
406             if(!compare_bitmaps(&bbox, bitmap1, bitmap2)) {
407                 save_two_bitmaps(&bbox, bitmap1, bitmap2, "error.png");
408                 assert(!"bitmaps don't match");
409             }
410             free(bitmap1);
411             free(bitmap2);
412             
413             // second pass renders the 90° rotated version
414             rotate90(poly);
415             rotate90(poly2);
416         }
417
418         gfxpoly_destroy(poly);
419         gfxpoly_destroy(poly2);
420         if(argn==2) 
421             break;
422     }
423     closedir(_dir);
424 }
425
426 #include "../gfxdevice.h"
427 #include "../pdf/pdf.h"
428
429 void extract_polygons_fill(gfxdevice_t*dev, gfxline_t*line, gfxcolor_t*color) 
430 {
431     //gfxcompactpoly_t*c = gfxcompactpoly_from_gfxline(line, 0.05);
432     //gfxcompactpoly_free(c);
433
434     gfxpoly_t*poly = gfxpoly_from_gfxline(line, 0.05);
435
436     gfxline_dump(line, stderr, "");
437     gfxpoly_dump(poly);
438
439     if(gfxpoly_size(poly)>100000) {
440         fprintf(stderr, "%d segments (skipping)\n", gfxpoly_size(poly));
441         return;
442     } else {
443         //fprintf(stderr, "%d segments\n", gfxpoly_size(poly));
444     }
445
446     if(!gfxpoly_check(poly)) {
447         gfxpoly_destroy(poly);
448         fprintf(stderr, "bad polygon\n");
449         return;
450     }
451
452     windrule_t*rule = &windrule_evenodd;
453         
454     double zoom = 1.0;
455     intbbox_t bbox = intbbox_from_polygon(poly, zoom);
456     unsigned char*bitmap1 = render_polygon(poly, &bbox, zoom, rule, &onepolygon);
457     if(!bitmap_ok(&bbox, bitmap1)) {
458         fprintf(stderr, "bad polygon or error in renderer\n");
459         return;
460     }
461     gfxpoly_t*poly2 = gfxpoly_process(poly, rule, &onepolygon);
462     unsigned char*bitmap2 = render_polygon(poly2, &bbox, zoom, &windrule_evenodd, &onepolygon);
463     if(!bitmap_ok(&bbox, bitmap2)) {
464         save_two_bitmaps(&bbox, bitmap1, bitmap2, "error.png");
465         assert(!"error in bitmap");
466     }
467     if(!compare_bitmaps(&bbox, bitmap1, bitmap2)) {
468         save_two_bitmaps(&bbox, bitmap1, bitmap2, "error.png");
469         assert(!"bitmaps don't match");
470     }
471     free(bitmap1);
472     free(bitmap2);
473
474     gfxpoly_destroy(poly);
475     gfxpoly_destroy(poly2);
476 }
477 int extract_polygons_setparameter(gfxdevice_t*dev, const char*key, const char*value) {
478     return 0;
479 }
480 void extract_polygons_startclip(gfxdevice_t*dev, gfxline_t*line) 
481 {
482     extract_polygons_fill(dev, line, 0);
483 }
484 void extract_polygons_fillbitmap(gfxdevice_t*dev, gfxline_t*line, gfximage_t*img, gfxmatrix_t*imgcoord2devcoord, gfxcxform_t*cxform)
485 {
486     extract_polygons_fill(dev, line, 0);
487 }
488 void extract_polygons_fillgradient(gfxdevice_t*dev, gfxline_t*line, gfxgradient_t*gradient, gfxgradienttype_t type, gfxmatrix_t*gradcoord2devcoord)
489 {
490     extract_polygons_fill(dev, line, 0);
491 }
492 void extract_polygons_drawlink(gfxdevice_t*dev, gfxline_t*line, const char*action)
493 {
494     extract_polygons_fill(dev, line, 0);
495 }
496 void extract_polygons_addfont(gfxdevice_t*dev, gfxfont_t*font)
497 {
498     int t;
499     for(t=0;t<font->num_glyphs;t++) {
500         //extract_polygons_fill(dev, font->glyphs[t].line, 0);
501     }
502 }
503 void extract_polygons_endclip(gfxdevice_t*dev)
504 {
505 }
506 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)
507 {
508 }
509 void extract_polygons_drawchar(gfxdevice_t*dev, gfxfont_t*font, int glyph, gfxcolor_t*color, gfxmatrix_t*matrix)
510 {
511 }
512     
513 gfxdevice_t extract_polygons = 
514 {
515 name: "extract polygons",
516 setparameter:extract_polygons_setparameter,
517 startclip: extract_polygons_startclip,
518 endclip: extract_polygons_endclip,
519 stroke: extract_polygons_stroke,
520 fill: extract_polygons_fill,
521 fillbitmap: extract_polygons_fillbitmap,
522 fillgradient: extract_polygons_fillgradient,
523 addfont: extract_polygons_addfont,
524 drawchar: extract_polygons_drawchar,
525 drawlink: extract_polygons_drawlink,
526 startpage: 0,
527 endpage: 0,
528 geterror: 0,
529 finish: 0,
530 internal: 0
531 };
532
533 void test5(int argn, char*argv[])
534 {
535     gfxsource_t*driver = gfxsource_pdf_create();
536     char*dir = "pdfs";
537     DIR*_dir = opendir(dir);
538     if(!_dir) return;
539     struct dirent*file;
540     while(1) {
541         file = readdir(_dir);
542         if (!file) 
543             break;
544         if(!strstr(file->d_name, ".pdf")) 
545             continue;
546         char* filename = allocprintf("%s/%s", dir, file->d_name);
547
548         if(argn>1) 
549             filename = argv[1];
550
551         gfxdocument_t*doc = driver->open(driver, filename);
552         gfxdevice_t*out = &extract_polygons;
553         int t;
554         for(t=1;t<=doc->num_pages;t++) {
555             fprintf(stderr, "%s (page %d)\n", filename, t);
556             gfxpage_t* page = doc->getpage(doc, t);
557             page->render(page, out);
558             page->destroy(page);
559         }
560         doc->destroy(doc);
561         if(argn>1) 
562             break;
563         free(filename);
564     }
565     closedir(_dir);
566     driver->destroy(driver);
567 }
568
569 int main(int argn, char*argv[])
570 {
571     test3(argn, argv);
572 }
573