X-Git-Url: http://git.asbjorn.biz/?p=swftools.git;a=blobdiff_plain;f=lib%2Fgfxpoly%2Ftest.c;h=a6a5ab51d95cc7322eeb16e0306fd1c17278411c;hp=82ceb9a92d2cc244508c0f859dee2cd3e615f911;hb=fec1ab31707e68c2396b186e0e4928632402d649;hpb=71b11cc925e384ecad5b0f48b511bcadc2867f9b

diff --git a/lib/gfxpoly/test.c b/lib/gfxpoly/test.c
index 82ceb9a..a6a5ab5 100644
--- a/lib/gfxpoly/test.c
+++ b/lib/gfxpoly/test.c
@@ -126,7 +126,8 @@ gfxline_t* make_circles(int n)
 	int y = c%200;;
 	c = crc32_add_byte(c, t^0x55);
 	int r = c%100;
-	b = gfxline_append(b, gfxline_makecircle(x,y,r,r));
+	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;
@@ -138,12 +139,12 @@ int test_speed()
 {
     //gfxline_t* b = mkchessboard();
     //gfxline_t* b = mkrandomshape(100,7);
-    gfxline_t* b = make_circles(30);
+    gfxline_t* b = make_circles(100);
 
     gfxmatrix_t m;
     memset(&m, 0, sizeof(gfxmatrix_t));
     int t;
-    for(t=0;t<10;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);
@@ -153,10 +154,10 @@ int test_speed()
 	m.ty = 400*1.41/2;
 	gfxline_t*l = gfxline_clone(b);
 	gfxline_transform(l, &m);
-	gfxcompactpoly_t*poly = gfxcompactpoly_from_gfxline(b, 0.05);
+	gfxpoly_t*poly = gfxpoly_from_gfxline(b, 0.05);
 
 	gfxpoly_t*poly2 = gfxpoly_process(poly, &windrule_evenodd, &onepolygon);
-	gfxcompactpoly_destroy(poly);
+	gfxpoly_destroy(poly);
 	gfxpoly_destroy(poly2);
 	gfxline_free(l);
     }
@@ -183,39 +184,19 @@ int test1(int argn, char*argv[])
     //gfxline_transform(b, &matrix);
 
     gfxline_dump(b, stderr, "");
-
-    gfxcompactpoly_t*poly = gfxcompactpoly_from_gfxline(b, 0.05);
+    gfxpoly_t*poly = gfxpoly_from_gfxline(b, 0.05);
+    
     gfxline_free(box1);
     gfxline_free(box2);
     gfxline_free(box3);
     gfxline_free(star);
 
-    gfxcompactpoly_dump(poly);
+    gfxpoly_dump(poly);
     gfxpoly_t*poly2 = gfxpoly_process(poly, &windrule_evenodd, &onepolygon);
-    gfxcompactpoly_destroy(poly);
+    gfxpoly_destroy(poly);
     gfxpoly_destroy(poly2);
 }
 
-static void test_conversion(gfxline_t*line, double gridsize)
-{
-    double zoom=1.0;
-    gfxcompactpoly_t*poly = gfxcompactpoly_from_gfxline(line, gridsize);
-    gfxpoly_t*poly1 = gfxpoly_from_gfxline(line, gridsize);
-    gfxpoly_t*poly2 = gfxpoly_from_gfxcompactpoly(poly);
-    assert(gfxpoly_check(poly1));
-    assert(gfxpoly_check(poly2));
-    assert(gfxcompactpoly_check(poly));
-    intbbox_t bbox = intbbox_from_polygon(poly1, zoom);
-    unsigned char*bitmap1 = render_polygon(poly1, &bbox, zoom, &windrule_evenodd, &onepolygon);
-    assert(bitmap_ok(&bbox, bitmap1));
-    unsigned char*bitmap2 = render_polygon(poly2, &bbox, zoom, &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");
-    }
-}
-
 int test_square(int width, int height, int num, double gridsize, char bitmaptest)
 {
     int t;
@@ -230,14 +211,11 @@ int test_square(int width, int height, int num, double gridsize, char bitmaptest
     line[num-1].y = line[0].y;
     line[num-1].next = 0;
 
-    test_conversion(line, gridsize);
-    
-    gfxcompactpoly_t*poly = gfxcompactpoly_from_gfxline(line, gridsize);
+    gfxpoly_t*poly1 = gfxpoly_from_gfxline(line, gridsize);
     gfxline_free(line);
-    gfxpoly_t*poly1 = gfxpoly_from_gfxcompactpoly(poly);
 
     windrule_t*rule = &windrule_circular;
-    gfxpoly_t*poly2 = gfxpoly_process(poly, rule, &onepolygon);
+    gfxpoly_t*poly2 = gfxpoly_process(poly1, rule, &onepolygon);
     if(bitmaptest) {
         intbbox_t bbox = intbbox_new(0, 0, width, height);
         unsigned char*bitmap1 = render_polygon(poly1, &bbox, 1.0, rule, &onepolygon);
@@ -251,7 +229,6 @@ int test_square(int width, int height, int num, double gridsize, char bitmaptest
     }
     gfxpoly_destroy(poly1);
     gfxpoly_destroy(poly2);
-    gfxcompactpoly_destroy(poly);
 }
 
 int test2(int argn, char*argv[])
@@ -310,10 +287,9 @@ void test3(int argn, char*argv[])
         gfxline_t*l = gfxline_clone(line);
         gfxline_transform(l, &m);
 
-	test_conversion(l, 0.05);
-        
-        gfxcompactpoly_t*poly = gfxcompactpoly_from_gfxline(l, 0.05);
-        gfxpoly_t*poly2 = gfxpoly_process(poly, rule, &onepolygon);
+        gfxpoly_t*poly1 = gfxpoly_from_gfxline(l, 0.05);
+
+        gfxpoly_t*poly2 = gfxpoly_process(poly1, rule, &onepolygon);
 
         tag = swf_InsertTag(tag, ST_DEFINESHAPE);
         SHAPE* s;
@@ -329,19 +305,24 @@ void test3(int argn, char*argv[])
 
 #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;
@@ -358,7 +339,7 @@ void test3(int argn, char*argv[])
         swf_ShapeSetEnd(tag);
         swf_ShapeFree(s);
 
-        gfxcompactpoly_destroy(poly);
+        gfxpoly_destroy(poly1);
         gfxpoly_destroy(poly2);
 
         gfxline_free(l);
@@ -379,15 +360,14 @@ void test3(int argn, char*argv[])
 
 void rotate90(gfxpoly_t*poly)
 {
-    edge_t*e = poly->edges;
-    while(e) {
-	point_t a = e->a;
-	point_t b = e->b;
-	e->a.x = a.y;
-	e->a.y = a.x;
-	e->b.x = b.y;
-	e->b.y = b.x;
-	e = e->next;
+    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;
+	}
     }
 }
 
@@ -413,20 +393,19 @@ void test4(int argn, char*argv[])
             filename = argv[1];
 
         windrule_t*rule = &windrule_evenodd;
-        gfxcompactpoly_t*poly = gfxcompactpoly_from_file(filename, 1.0);//0.01);
+        gfxpoly_t*poly1 = gfxpoly_from_file(filename, 1.0);//0.01);
 
         if(argn!=2)
             free(filename);
 
         double zoom = 1.0;
 
-        if(!gfxcompactpoly_check(poly)) {
+        if(!gfxpoly_check(poly1)) {
             printf("bad polygon\n");
             continue;
         }
 
-	gfxpoly_t*poly1 = gfxpoly_from_gfxcompactpoly(poly);
-        gfxpoly_t*poly2 = gfxpoly_process(poly, rule, &onepolygon);
+        gfxpoly_t*poly2 = gfxpoly_process(poly1, rule, &onepolygon);
 
 	int pass;
 	for(pass=0;pass<2;pass++) {
@@ -451,7 +430,6 @@ void test4(int argn, char*argv[])
 
         gfxpoly_destroy(poly1);
         gfxpoly_destroy(poly2);
-        gfxcompactpoly_destroy(poly);
         if(argn==2) 
             break;
     }
@@ -463,31 +441,29 @@ void test4(int argn, char*argv[])
 
 void extract_polygons_fill(gfxdevice_t*dev, gfxline_t*line, gfxcolor_t*color) 
 {
-    //gfxcompactpoly_t*c = gfxcompactpoly_from_gfxline(line, 0.05);
-    //gfxcompactpoly_free(c);
+    //gfxpoly_t*c = gfxpoly_from_gfxline(line, 0.05);
+    //gfxpoly_free(c);
 
-    gfxcompactpoly_t*poly = gfxcompactpoly_from_gfxline(line, 0.05);
+    gfxpoly_t*poly1 = gfxpoly_from_gfxline(line, 0.05);
 
     //gfxline_dump(line, stderr, "");
-    //gfxcompactpoly_dump(poly);
+    //gfxpoly_dump(poly);
 
-    if(gfxcompactpoly_size(poly)>100000) {
-	fprintf(stderr, "%d segments (skipping)\n", gfxcompactpoly_size(poly));
+    if(gfxpoly_size(poly1)>100000) {
+	fprintf(stderr, "%d segments (skipping)\n", gfxpoly_size(poly1));
 	return;
     } else {
 	//fprintf(stderr, "%d segments\n", gfxpoly_size(poly));
     }
 
-    if(!gfxcompactpoly_check(poly)) {
-        gfxcompactpoly_destroy(poly);
+    if(!gfxpoly_check(poly1)) {
+        gfxpoly_destroy(poly1);
         fprintf(stderr, "bad polygon\n");
         return;
     }
 
     windrule_t*rule = &windrule_evenodd;
 
-    gfxpoly_t*poly1 = gfxpoly_from_gfxcompactpoly(poly);
-        
     double zoom = 1.0;
     intbbox_t bbox = intbbox_from_polygon(poly1, zoom);
     unsigned char*bitmap1 = render_polygon(poly1, &bbox, zoom, rule, &onepolygon);
@@ -495,7 +471,7 @@ void extract_polygons_fill(gfxdevice_t*dev, gfxline_t*line, gfxcolor_t*color)
         fprintf(stderr, "bad polygon or error in renderer\n");
         return;
     }
-    gfxpoly_t*poly2 = gfxpoly_process(poly, rule, &onepolygon);
+    gfxpoly_t*poly2 = gfxpoly_process(poly1, 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");
@@ -510,7 +486,6 @@ void extract_polygons_fill(gfxdevice_t*dev, gfxline_t*line, gfxcolor_t*color)
 
     gfxpoly_destroy(poly1);
     gfxpoly_destroy(poly2);
-    gfxcompactpoly_destroy(poly);
 }
 int extract_polygons_setparameter(gfxdevice_t*dev, const char*key, const char*value) {
     return 0;
@@ -606,6 +581,6 @@ void test5(int argn, char*argv[])
 
 int main(int argn, char*argv[])
 {
-    test_speed(argn, argv);
+    test4(argn, argv);
 }