X-Git-Url: http://git.asbjorn.biz/?p=swftools.git;a=blobdiff_plain;f=lib%2Fgfxpoly%2Ftest.c;h=6d125138aef6a8b7e2515b2699ec5fd288f0c441;hp=a04f7792a8edfb7201efe70ee5d4797b4e8b09c8;hb=82228fda28e4361ca674fb2513f1c23c471421e6;hpb=8d76501168e44398feb36ae4d378178a676d8f2c

diff --git a/lib/gfxpoly/test.c b/lib/gfxpoly/test.c
index a04f779..6d12513 100644
--- a/lib/gfxpoly/test.c
+++ b/lib/gfxpoly/test.c
@@ -6,6 +6,7 @@
 #include "poly.h"
 #include "convert.h"
 #include "renderpoly.h"
+#include "stroke.h"
 
 gfxline_t*mkstar(int x1, int y1, int x2, int y2)
 {
@@ -126,19 +127,21 @@ 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;
 }
 
 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(100);
+    gfxline_t* b = make_circles(30);
 
     gfxmatrix_t m;
     memset(&m, 0, sizeof(gfxmatrix_t));
@@ -153,9 +156,9 @@ int test_speed()
 	m.ty = 400*1.41/2;
 	gfxline_t*l = gfxline_clone(b);
 	gfxline_transform(l, &m);
-	gfxpoly_t*poly = gfxpoly_from_gfxline(b, 0.05);
+	gfxpoly_t*poly = gfxpoly_from_fill(b, 0.05);
 
-	gfxpoly_t*poly2 = gfxpoly_process(poly, &windrule_evenodd, &onepolygon);
+	gfxpoly_t*poly2 = gfxpoly_process(poly, 0, &windrule_evenodd, &onepolygon);
 	gfxpoly_destroy(poly);
 	gfxpoly_destroy(poly2);
 	gfxline_free(l);
@@ -163,6 +166,47 @@ int test_speed()
     gfxline_free(b);
 }
 
+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);
+
+    gfxpoly_check(gfxpoly_from_stroke(box1, 2.0, gfx_capRound, gfx_joinRound, 0, 0.05));
+
+    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(poly3);
+}
+
+
 int test1(int argn, char*argv[])
 {
     gfxline_t*box1 = gfxline_makerectangle(50,50,150,150);
@@ -183,15 +227,15 @@ int test1(int argn, char*argv[])
     //gfxline_transform(b, &matrix);
 
     gfxline_dump(b, stderr, "");
-
-    gfxpoly_t*poly = gfxpoly_from_gfxline(b, 0.05);
+    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, &onepolygon);
+    gfxpoly_t*poly2 = gfxpoly_process(poly, 0, &windrule_evenodd, &onepolygon);
     gfxpoly_destroy(poly);
     gfxpoly_destroy(poly2);
 }
@@ -210,11 +254,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;
 
-    gfxpoly_t*poly1 = 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(poly1, rule, &onepolygon);
+    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(poly1, &bbox, 1.0, rule, &onepolygon);
@@ -286,8 +330,9 @@ void test3(int argn, char*argv[])
         gfxline_t*l = gfxline_clone(line);
         gfxline_transform(l, &m);
 
-        gfxpoly_t*poly1 = gfxpoly_from_gfxline(l, 0.05);
-        gfxpoly_t*poly2 = gfxpoly_process(poly1, rule, &onepolygon);
+        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;
@@ -303,11 +348,11 @@ void test3(int argn, char*argv[])
 
 #define FILL
 #ifdef FILL
-        swf_ShapeSetAll(tag,s,0,0,0,fs,0);
+        swf_ShapeSetAll(tag,s,UNDEFINED_COORD,UNDEFINED_COORD,0,fs,0);
 
 	int i,j;
-	for(i=0;i<poly2->num_strokes;i++) {
-	    gfxpolystroke_t*stroke = &poly2->strokes[i];
+	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];
@@ -359,8 +404,8 @@ void test3(int argn, char*argv[])
 void rotate90(gfxpoly_t*poly)
 {
     int i,j;
-    for(i=0;i<poly->num_strokes;i++) {
-	gfxpolystroke_t*stroke = &poly->strokes[i];
+    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;
@@ -403,7 +448,7 @@ void test4(int argn, char*argv[])
             continue;
         }
 
-        gfxpoly_t*poly2 = gfxpoly_process(poly1, rule, &onepolygon);
+        gfxpoly_t*poly2 = gfxpoly_process(poly1, 0, rule, &onepolygon);
 
 	int pass;
 	for(pass=0;pass<2;pass++) {
@@ -437,21 +482,33 @@ void test4(int argn, char*argv[])
 #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*c = gfxpoly_from_gfxline(line, 0.05);
+    //gfxpoly_t*c = gfxpoly_from_fill(line, 0.05);
     //gfxpoly_free(c);
 
-    gfxpoly_t*poly1 = gfxpoly_from_gfxline(line, 0.05);
+    //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_size(poly1)>100000) {
-	fprintf(stderr, "%d segments (skipping)\n", gfxpoly_size(poly1));
+    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 {
-	//fprintf(stderr, "%d segments\n", gfxpoly_size(poly));
+	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)) {
@@ -469,7 +526,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(poly1, rule, &onepolygon);
+    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");
@@ -541,6 +598,7 @@ finish: 0,
 internal: 0
 };
 
+#if 0
 void test5(int argn, char*argv[])
 {
     gfxsource_t*driver = gfxsource_pdf_create();
@@ -576,9 +634,10 @@ void test5(int argn, char*argv[])
     closedir(_dir);
     driver->destroy(driver);
 }
+#endif
 
 int main(int argn, char*argv[])
 {
-    test4(argn, argv);
+    test3(argn, argv);
 }