X-Git-Url: http://git.asbjorn.biz/?p=swftools.git;a=blobdiff_plain;f=lib%2Fgfxpoly%2Ftest.c;h=46df1f5c50fe5f026b9db30e64e0586108d72705;hp=aff9208ede9b49ae9ed7e00065706a2bebff5f40;hb=879d0eec420fe0fd5ddcd56c8fe62b82a6744edd;hpb=ae7c92fe5721f97e786a8bbe9153eadbf292460d

diff --git a/lib/gfxpoly/test.c b/lib/gfxpoly/test.c
index aff9208..46df1f5 100644
--- a/lib/gfxpoly/test.c
+++ b/lib/gfxpoly/test.c
@@ -1,12 +1,12 @@
 #include <stdlib.h>
 #include <stdio.h>
-#include <assert.h>
 #include <memory.h>
 #include <math.h>
 #include "../gfxtools.h"
 #include "poly.h"
 #include "convert.h"
 #include "renderpoly.h"
+#include "stroke.h"
 
 gfxline_t*mkstar(int x1, int y1, int x2, int y2)
 {
@@ -29,21 +29,17 @@ gfxline_t*mkstar(int x1, int y1, int x2, int y2)
 gfxline_t* mkrandomshape(int range, int n)
 {
     int i;
-    gfxline_t* line = malloc(sizeof(gfxline_t)*n*2);
+    gfxline_t* line = malloc(sizeof(gfxline_t)*n);
     for(i=0;i<n;i++) {
         line[i].type = i?gfx_lineTo:gfx_moveTo;
         line[i].x = lrand48()%range - range/2;
         line[i].y = lrand48()%range - range/2;
         line[i].next = &line[i+1];
-        line[n*2-i-1].type = gfx_lineTo;
-        line[n*2-i-1].x = line[i].x;
-        line[n*2-i-1].y = line[i].y;
-        line[n*2-i-1].next = &line[n*2-i];
     }
-    line[n*2-1].next = 0;
     line[n-1].x = line[0].x;
     line[n-1].y = line[0].y;
     line[n-1].next = 0;
+    return line;
 }
 
 gfxline_t* mkchessboard()
@@ -53,13 +49,13 @@ gfxline_t* mkchessboard()
     unsigned int r = 0;
     int spacing = 20;
 
-    //int num_caros = 40;
-    //int l = 5;
-    //char do_centerpiece=1;
+    int num_caros = 40;
+    int l = 5;
+    char do_centerpiece=1;
 
-    int num_caros = 4;
-    int l=1;
-    char do_centerpiece=0;
+    //int num_caros = 4;
+    //int l=1;
+    //char do_centerpiece=0;
 
     for(x=-l;x<=l;x++) 
     for(y=-l;y<=l;y++) {
@@ -103,72 +99,172 @@ gfxline_t* mkchessboard()
         l[4].y = y-sizey;
         gfxline_append(b, l);
     }
-    if(do_centerpiece)
-    for(t=0;t<5;t++) {
-        gfxline_t*l = gfxline_makerectangle(-9*spacing,-10,9*spacing,10);
-        gfxmatrix_t matrix;
-        memset(&matrix, 0, sizeof(gfxmatrix_t));
-        double ua=t*0.43;
-        matrix.m00=cos(ua);matrix.m10=sin(ua);
-        matrix.m01=-sin(ua);matrix.m11=cos(ua);
-        gfxline_transform(l, &matrix);
-        gfxline_append(b, l);
+    if(do_centerpiece) {
+	for(t=0;t<5;t++) {
+	    gfxline_t*l = gfxline_makerectangle(-9*spacing,-10,9*spacing,10);
+	    gfxmatrix_t matrix;
+	    memset(&matrix, 0, sizeof(gfxmatrix_t));
+	    double ua=t*0.43;
+	    matrix.m00=cos(ua);matrix.m10=sin(ua);
+	    matrix.m01=-sin(ua);matrix.m11=cos(ua);
+	    gfxline_transform(l, &matrix);
+	    gfxline_append(b, l);
+	}
+	gfxline_append(b, gfxline_makecircle(100,100,100,100));
     }
     return b;
 }
 
-int test0()
+gfxline_t* make_circles(int n)
 {
-    gfxline_t* b = mkchessboard();
+    gfxline_t*b = 0;
+    unsigned int c = 0;
+    int t;
+    for(t=0;t<n;t++) {
+        c = crc32_add_byte(c, t);
+	int x = c%200;
+	c = crc32_add_byte(c, t);
+	int y = c%200;;
+	c = crc32_add_byte(c, t^0x55);
+	int r = c%100;
+	gfxline_t*c = gfxline_makecircle(x,y,r,r);
+	b = gfxline_append(b, c);
+	//b = gfxline_append(b, gfxline_makerectangle(10,10,100,100));
+    }
+    return b;
+}
+
+static windcontext_t onepolygon = {1};
+static windcontext_t twopolygons = {2};
+
+int test_speed()
+{
+    //gfxline_t* b = mkchessboard();
+    //gfxline_t* b = mkrandomshape(100,7);
+    gfxline_t* b = make_circles(30);
 
     gfxmatrix_t m;
     memset(&m, 0, sizeof(gfxmatrix_t));
-    int t = 28;
-    m.m00 = cos(t*M_PI/180.0);
-    m.m01 = sin(t*M_PI/180.0);
-    m.m10 = -sin(t*M_PI/180.0);
-    m.m11 = cos(t*M_PI/180.0);
-    m.tx = 400*1.41/2;
-    m.ty = 400*1.41/2;
-    gfxline_transform(b, &m);
-
-    gfxpoly_t*poly = gfxpoly_from_gfxline(b, 0.05);
-    gfxpoly_t*poly2 = gfxpoly_process(poly, &windrule_evenodd);
+    int t;
+    for(t=0;t<360;t++) {
+	printf("%d\n", t);
+	m.m00 = cos(t*M_PI/180.0);
+	m.m01 = sin(t*M_PI/180.0);
+	m.m10 = -sin(t*M_PI/180.0);
+	m.m11 = cos(t*M_PI/180.0);
+	m.tx = 400*1.41/2;
+	m.ty = 400*1.41/2;
+	gfxline_t*l = gfxline_clone(b);
+	gfxline_transform(l, &m);
+	gfxpoly_t*poly = gfxpoly_from_fill(b, 0.05);
+
+	gfxpoly_t*poly2 = gfxpoly_process(poly, 0, &windrule_evenodd, &onepolygon);
+	gfxpoly_destroy(poly);
+	gfxpoly_destroy(poly2);
+	gfxline_free(l);
+    }
+    gfxline_free(b);
+}
+
+int testbox(int argn, char*argv[])
+{
+    gfxline_t*box1 = gfxline_makerectangle(-100,-100,100,100);
+    gfxline_t*box2 = gfxline_makerectangle(-50,-50,150,150);
+    gfxpoly_t*poly1 = gfxpoly_from_fill(box1, 0.05);
+    gfxpoly_t*poly2 = gfxpoly_from_fill(box2, 0.05);
+    gfxline_free(box1);
+    gfxline_free(box2);
+    
+    gfxpoly_t*poly12 = gfxpoly_process(poly1, poly2, &windrule_intersect, &twopolygons);
+    gfxpoly_dump(poly12);
+    assert(gfxpoly_check(poly12, 0));
+    gfxpoly_destroy(poly12);
+}
+
+int teststroke(int argn, char*argv[])
+{
+    gfxline_t*box1 = gfxline_makerectangle(-100,-100,100,100);
+    assert(gfxpoly_check(gfxpoly_from_stroke(box1, 2.0, gfx_capRound, gfx_joinRound, 0, 0.05), 1));
+}
+
+int test0(int argn, char*argv[])
+{
+    gfxline_t*box1 = gfxline_makerectangle(-100,-100,100,100);
+    gfxline_t*box2 = gfxline_makerectangle(-100,-100,100,100);
+    gfxline_t*box3 = gfxline_makerectangle(-100,-100,100,100);
+    //gfxline_append(box2, box3);
+
+    gfxmatrix_t matrix;
+    memset(&matrix, 0, sizeof(gfxmatrix_t));
+    double ua=M_PI/4;
+    matrix.m00=cos(ua);matrix.m10=sin(ua);
+    matrix.m01=-sin(ua);matrix.m11=cos(ua);
+    gfxline_transform(box1, &matrix);
+    
+    //gfxline_t*b = 0;
+    //b = gfxline_append(b, box1);
+    //b = gfxline_append(b, box2);
+    //gfxline_dump(b, stderr, "");
+
+    gfxpoly_t*poly1 = gfxpoly_from_fill(box1, 0.05);
+    gfxpoly_t*poly2 = gfxpoly_from_fill(box2, 0.05);
+    
+    gfxline_free(box1);
+    gfxline_free(box2);
+    
+    //gfxpoly_t*poly3 = gfxpoly_process(poly1, poly2, &windrule_intersect, &twopolygons);
+    gfxpoly_t*poly3 = gfxpoly_process(poly1, poly2, &windrule_intersect, &twopolygons);
+    gfxpoly_dump(poly3);
+    
+    gfxline_t*line = gfxline_from_gfxpoly(poly3);
+
+    gfxline_dump(line, stdout, "");
+    gfxline_free(line);
+    gfxpoly_destroy(poly1);
     gfxpoly_destroy(poly2);
-    gfxpoly_destroy(poly);
+    gfxpoly_destroy(poly3);
 }
 
-int test1()
+
+int test1(int argn, char*argv[])
 {
     gfxline_t*box1 = gfxline_makerectangle(50,50,150,150);
-    // put box2 and box3 on top of each other *snicker*
     gfxline_t*box2 = gfxline_makerectangle(100,100,200,200);
-    gfxline_t*box3 = gfxline_makerectangle(100,100,200,200);
+    gfxline_t*box3 = gfxline_makerectangle(200,100,300,200);
+    gfxline_t*box4 = gfxline_makerectangle(300,200,400,400);
+    gfxline_t* board = mkchessboard();
     gfxline_t*star = mkstar(50,50, 150,150);
     gfxline_t*b = 0;
     b = gfxline_append(b, box1);
     b = gfxline_append(b, box2);
     b = gfxline_append(b, box3);
-    //b = gfxline_append(b, star);
+    b = gfxline_append(b, box4);
 
     gfxmatrix_t matrix;
     memset(&matrix, 0, sizeof(gfxmatrix_t));
-    double ua=0.1;
-    matrix.m00=cos(ua);matrix.m10=sin(ua);
-    matrix.m01=-sin(ua);matrix.m11=cos(ua);
+    matrix.m00 = 1.0;
+    matrix.m11 = 1.0;
+    matrix.tx = 200;
+    matrix.ty = 200;
+    gfxline_transform(board, &matrix);
+    b = gfxline_append(b, board);
 
     //gfxline_transform(b, &matrix);
 
-    gfxpoly_t*poly = gfxpoly_from_gfxline(b, 0.05);
+    //gfxline_dump(b, stderr, "");
+    gfxpoly_t*poly = gfxpoly_from_fill(b, 0.05);
+    
     gfxline_free(box1);
     gfxline_free(box2);
     gfxline_free(box3);
     gfxline_free(star);
 
-    gfxpoly_dump(poly);
-    gfxpoly_t*poly2 = gfxpoly_process(poly, &windrule_evenodd);
-    gfxpoly_destroy(poly2);
+    //gfxpoly_dump(poly);
+    gfxpoly_t*poly2 = gfxpoly_process(poly, 0, &windrule_evenodd, &onepolygon);
+    //gfxpoly_dump(poly2);
+    gfxpoly_save_arrows(poly2, "test.ps");
     gfxpoly_destroy(poly);
+    gfxpoly_destroy(poly2);
 }
 
 int test_square(int width, int height, int num, double gridsize, char bitmaptest)
@@ -184,31 +280,34 @@ int test_square(int width, int height, int num, double gridsize, char bitmaptest
     line[num-1].x = line[0].x;
     line[num-1].y = line[0].y;
     line[num-1].next = 0;
-    
-    gfxpoly_t*poly = gfxpoly_from_gfxline(line, gridsize);
+
+    gfxpoly_t*poly1 = gfxpoly_from_fill(line, gridsize);
     gfxline_free(line);
 
     windrule_t*rule = &windrule_circular;
-    gfxpoly_t*poly2 = gfxpoly_process(poly, rule);
+    gfxpoly_t*poly2 = gfxpoly_process(poly1, 0, rule, &onepolygon);
     if(bitmaptest) {
         intbbox_t bbox = intbbox_new(0, 0, width, height);
-        unsigned char*bitmap1 = render_polygon(poly, &bbox, 1.0, rule);
-        unsigned char*bitmap2 = render_polygon(poly2, &bbox, 1.0, &windrule_evenodd);
+        unsigned char*bitmap1 = render_polygon(poly1, &bbox, 1.0, rule, &onepolygon);
+	assert(bitmap_ok(&bbox, bitmap1));
+        unsigned char*bitmap2 = render_polygon(poly2, &bbox, 1.0, &windrule_evenodd, &onepolygon);
+	assert(bitmap_ok(&bbox, bitmap2));
         if(!compare_bitmaps(&bbox, bitmap1, bitmap2)) {
             save_two_bitmaps(&bbox, bitmap1, bitmap2, "error.png");
             assert(!"bitmaps don't match");
         }
     }
+    gfxpoly_destroy(poly1);
     gfxpoly_destroy(poly2);
-    gfxpoly_destroy(poly);
 }
 
-int test2()
+int test2(int argn, char*argv[])
 {
     test_square(400,400, 3, 0.05, 1);
 
     int t;
     for(t=0;t<400;t++) {
+	fprintf(stderr, "%d\n", t);
         test_square(400,400, 50, 0.05, 1);
         test_square(200,3, 1000, 1.0, 0);
         test_square(3,200, 1000, 1.0, 0);
@@ -217,7 +316,7 @@ int test2()
 }
 
 #include "../rfxswf.h"
-void test3()
+void test3(int argn, char*argv[])
 {
 #undef N
 #undef RANGE
@@ -226,8 +325,10 @@ void test3()
 
     //gfxline_t*line = mkrandomshape(RANGE, N);
     //windrule_t*rule = &windrule_circular;
-    gfxline_t*line = mkchessboard();
+    //gfxline_t*line = mkchessboard();
+    gfxline_t*line = make_circles(30);
     windrule_t*rule = &windrule_evenodd;
+    //windrule_t*rule = &windrule_circular;
 
     gfxmatrix_t m;
     memset(&m, 0, sizeof(m));
@@ -245,19 +346,20 @@ void test3()
 
     int t;
     for(t=0;t<360;t++) {
+	fprintf(stderr, "%d\n", t);
         m.m00 = cos(t*M_PI/180.0);
         m.m01 = sin(t*M_PI/180.0);
         m.m10 = -sin(t*M_PI/180.0);
         m.m11 = cos(t*M_PI/180.0);
         m.tx = RANGE*1.41/2;
         m.ty = RANGE*1.41/2;
-        printf("%d\n", t);
 
         gfxline_t*l = gfxline_clone(line);
         gfxline_transform(l, &m);
-        
-        gfxpoly_t*poly = gfxpoly_from_gfxline(l, 0.05);
-        gfxpoly_t*poly2 = gfxpoly_process(poly, rule);
+
+        gfxpoly_t*poly1 = gfxpoly_from_fill(l, 0.05);
+
+        gfxpoly_t*poly2 = gfxpoly_process(poly1, 0, rule, &onepolygon);
 
         tag = swf_InsertTag(tag, ST_DEFINESHAPE);
         SHAPE* s;
@@ -273,19 +375,24 @@ void test3()
 
 #define FILL
 #ifdef FILL
-        swf_ShapeSetAll(tag,s,0,0,0,fs,0);
-        edge_t*e = poly2->edges;
-        while(e) {
+        swf_ShapeSetAll(tag,s,UNDEFINED_COORD,UNDEFINED_COORD,0,fs,0);
+
+	int i,j;
+	gfxpolystroke_t*stroke = poly2->strokes;
+	for(;stroke;stroke=stroke->next) {
+	    for(j=0;j<stroke->num_points-1;j++) {
+		point_t a = stroke->points[j];
+		point_t b = stroke->points[j+1];
 #define ROTATE
 #ifdef ROTATE
-            swf_ShapeSetMove(tag, s, e->a.y, e->a.x);
-            swf_ShapeSetLine(tag, s, e->b.y - e->a.y, e->b.x - e->a.x);
+		swf_ShapeSetMove(tag, s, a.y, a.x);
+		swf_ShapeSetLine(tag, s, b.y - a.y, b.x - a.x);
 #else
-            swf_ShapeSetMove(tag, s, e->a.x, e->a.y);
-            swf_ShapeSetLine(tag, s, e->b.x - e->a.x, e->b.y - e->a.y);
+		swf_ShapeSetMove(tag, s, a.x, a.y);
+		swf_ShapeSetLine(tag, s, b.x - a.x, b.y - a.y);
 #endif
-            e = e->next;
-        }
+	    }
+	}
 #else
         swf_ShapeSetAll(tag,s,0,0,ls,0,0);
         edge_t*e = poly2->edges;
@@ -302,7 +409,7 @@ void test3()
         swf_ShapeSetEnd(tag);
         swf_ShapeFree(s);
 
-        gfxpoly_destroy(poly);
+        gfxpoly_destroy(poly1);
         gfxpoly_destroy(poly2);
 
         gfxline_free(l);
@@ -321,8 +428,21 @@ void test3()
     swf_SaveSWF(&swf, "test.swf");
 }
 
+void rotate90(gfxpoly_t*poly)
+{
+    int i,j;
+    gfxpolystroke_t*stroke = poly->strokes;
+    for(;stroke;stroke=stroke->next) {
+	for(j=0;j<stroke->num_points;j++) {
+	    point_t a = stroke->points[j];
+	    stroke->points[j].x = a.y;
+	    stroke->points[j].y = a.x;
+	}
+    }
+}
+
 #include <dirent.h>
-void test4()
+void test4(int argn, char*argv[])
 {
     char*dir = "ps";
     DIR*_dir = opendir(dir);
@@ -335,59 +455,107 @@ void test4()
         if(!strstr(file->d_name, ".ps")) 
             continue;
 
-        char* filename = allocprintf("%s/%s", dir, file->d_name);
+        char* filename;
+
+        if(argn<2)
+            filename = allocprintf("%s/%s", dir, file->d_name);
+        else
+            filename = argv[1];
+
         windrule_t*rule = &windrule_evenodd;
-        gfxpoly_t*poly = gfxpoly_from_file(filename, 0.01);
-        free(filename);
+        gfxpoly_t*poly1 = gfxpoly_from_file(filename, 1.0);//0.01);
+
+        if(argn!=2)
+            free(filename);
 
         double zoom = 1.0;
-        intbbox_t bbox = intbbox_from_polygon(poly, zoom);
 
-        if(!gfxpoly_check(poly)) {
+        if(!gfxpoly_check(poly1, 0)) {
             printf("bad polygon\n");
             continue;
         }
 
-        gfxpoly_t*poly2 = gfxpoly_process(poly, rule);
-        unsigned char*bitmap1 = render_polygon(poly, &bbox, zoom, rule);
-        unsigned char*bitmap2 = render_polygon(poly2, &bbox, zoom, &windrule_evenodd);
-        if(!bitmap_ok(&bbox, bitmap1) || !bitmap_ok(&bbox, bitmap2)) {
-            save_two_bitmaps(&bbox, bitmap1, bitmap2, "error.png");
-            assert(!"error in bitmaps");
-        }
-        if(!compare_bitmaps(&bbox, bitmap1, bitmap2)) {
-            save_two_bitmaps(&bbox, bitmap1, bitmap2, "error.png");
-            assert(!"bitmaps don't match");
-        }
+        gfxpoly_t*poly2 = gfxpoly_process(poly1, 0, rule, &onepolygon);
+	assert(gfxpoly_check(poly2, 1));
+
+	int pass;
+	for(pass=0;pass<2;pass++) {
+	    intbbox_t bbox = intbbox_from_polygon(poly1, zoom);
+	    unsigned char*bitmap1 = render_polygon(poly1, &bbox, zoom, rule, &onepolygon);
+	    unsigned char*bitmap2 = render_polygon(poly2, &bbox, zoom, &windrule_circular, &onepolygon);
+	    if(!bitmap_ok(&bbox, bitmap1) || !bitmap_ok(&bbox, bitmap2)) {
+		save_two_bitmaps(&bbox, bitmap1, bitmap2, "error.png");
+		assert(!"error in bitmaps");
+	    }
+	    if(!compare_bitmaps(&bbox, bitmap1, bitmap2)) {
+		save_two_bitmaps(&bbox, bitmap1, bitmap2, "error.png");
+		assert(!"bitmaps don't match");
+	    }
+	    free(bitmap1);
+	    free(bitmap2);
+
+	    // second pass renders the 90° rotated version
+	    rotate90(poly1);
+	    rotate90(poly2);
+	}
+
+        gfxpoly_destroy(poly1);
         gfxpoly_destroy(poly2);
+        if(argn==2) 
+            break;
     }
+    closedir(_dir);
 }
 
 #include "../gfxdevice.h"
 #include "../pdf/pdf.h"
 
+static int max_segments = 0;
+static int max_any_segments = 0;
 void extract_polygons_fill(gfxdevice_t*dev, gfxline_t*line, gfxcolor_t*color) 
 {
-    gfxpoly_t*poly = gfxpoly_from_gfxline(line, 0.05);
-    printf("%d segments\n", gfxpoly_size(poly));
+    //gfxpoly_t*c = gfxpoly_from_fill(line, 0.05);
+    //gfxpoly_free(c);
+
+    //gfxpoly_t*poly1 = gfxpoly_from_fill(line, 0.05);
+    gfxpoly_t*poly1 = gfxpoly_from_fill(line, 0.05);
+
+    //gfxline_dump(line, stderr, "");
+    //gfxpoly_dump(poly);
 
-    if(!gfxpoly_check(poly)) {
-        gfxpoly_destroy(poly);
-        printf("bad polygon\n");
+    int size = gfxpoly_size(poly1);
+    if(size == 4) {
+	//rectangles are boring.
+	gfxpoly_destroy(poly1);
+	return;
+    }
+
+    max_any_segments = size > max_any_segments? size : max_any_segments;
+    if(size>100000) {
+	fprintf(stderr, "%d segments (skipping)\n", size);
+	return;
+    } else {
+	max_segments = size > max_segments? size : max_segments;
+	fprintf(stderr, "%d segments (max so far: %d/%d)\n", size, max_segments, max_any_segments);
+    }
+
+    if(!gfxpoly_check(poly1, 0)) {
+        gfxpoly_destroy(poly1);
+        fprintf(stderr, "bad polygon\n");
         return;
     }
 
     windrule_t*rule = &windrule_evenodd;
-    gfxpoly_t*poly2 = gfxpoly_process(poly, rule);
-        
+
     double zoom = 1.0;
-    intbbox_t bbox = intbbox_from_polygon(poly, zoom);
-    unsigned char*bitmap1 = render_polygon(poly, &bbox, zoom, rule);
-    unsigned char*bitmap2 = render_polygon(poly2, &bbox, zoom, &windrule_evenodd);
+    intbbox_t bbox = intbbox_from_polygon(poly1, zoom);
+    unsigned char*bitmap1 = render_polygon(poly1, &bbox, zoom, rule, &onepolygon);
     if(!bitmap_ok(&bbox, bitmap1)) {
-        printf("bad polygon or error in renderer\n");
+        fprintf(stderr, "bad polygon or error in renderer\n");
         return;
     }
+    gfxpoly_t*poly2 = gfxpoly_process(poly1, 0, rule, &onepolygon);
+    unsigned char*bitmap2 = render_polygon(poly2, &bbox, zoom, &windrule_evenodd, &onepolygon);
     if(!bitmap_ok(&bbox, bitmap2)) {
         save_two_bitmaps(&bbox, bitmap1, bitmap2, "error.png");
         assert(!"error in bitmap");
@@ -396,8 +564,10 @@ void extract_polygons_fill(gfxdevice_t*dev, gfxline_t*line, gfxcolor_t*color)
         save_two_bitmaps(&bbox, bitmap1, bitmap2, "error.png");
         assert(!"bitmaps don't match");
     }
+    free(bitmap1);
+    free(bitmap2);
 
-    gfxpoly_destroy(poly);
+    gfxpoly_destroy(poly1);
     gfxpoly_destroy(poly2);
 }
 int extract_polygons_setparameter(gfxdevice_t*dev, const char*key, const char*value) {
@@ -456,8 +626,10 @@ finish: 0,
 internal: 0
 };
 
-void test5()
+#if 0
+void test5(int argn, char*argv[])
 {
+    gfxsource_t*driver = gfxsource_pdf_create();
     char*dir = "pdfs";
     DIR*_dir = opendir(dir);
     if(!_dir) return;
@@ -470,22 +642,30 @@ void test5()
             continue;
         char* filename = allocprintf("%s/%s", dir, file->d_name);
 
-        gfxsource_t*driver = gfxsource_pdf_create();
+	if(argn>1) 
+	    filename = argv[1];
+
         gfxdocument_t*doc = driver->open(driver, filename);
         gfxdevice_t*out = &extract_polygons;
         int t;
         for(t=1;t<=doc->num_pages;t++) {
-            printf("%s (page %d)\n", filename, t);
+            fprintf(stderr, "%s (page %d)\n", filename, t);
             gfxpage_t* page = doc->getpage(doc, t);
             page->render(page, out);
             page->destroy(page);
-            break;
         }
+        doc->destroy(doc);
+	if(argn>1) 
+	    break;
         free(filename);
     }
+    closedir(_dir);
+    driver->destroy(driver);
 }
+#endif
 
-int main()
+int main(int argn, char*argv[])
 {
-    test0();
+    teststroke(argn, argv);
 }
+