bugfixes and speedups
[swftools.git] / lib / gfxpoly / poly.c
index 9c45bdf..6d82159 100644 (file)
@@ -11,7 +11,7 @@
 #include "wind.h"
 #include "convert.h"
 
-static gfxcompactpoly_t*current_polygon = 0;
+static gfxpoly_t*current_polygon = 0;
 void gfxpoly_fail(char*expr, char*file, int line, const char*function)
 {
     if(!current_polygon) {
@@ -22,8 +22,8 @@ void gfxpoly_fail(char*expr, char*file, int line, const char*function)
     void*md5 = init_md5();
    
     int s,t;
-    for(s=0;s<current_polygon->num_strokes;s++) {
-       gfxpolystroke_t*stroke = &current_polygon->strokes[s];
+    gfxpolystroke_t*stroke = current_polygon->strokes;
+    for(;stroke;stroke=stroke->next) {
        for(t=0;t<stroke->num_points;t++) {
            update_md5(md5, (unsigned char*)&stroke->points[t].x, sizeof(stroke->points[t].x));
            update_md5(md5, (unsigned char*)&stroke->points[t].y, sizeof(stroke->points[t].y));
@@ -38,7 +38,7 @@ void gfxpoly_fail(char*expr, char*file, int line, const char*function)
     fprintf(stderr, "assert(%s) failed in %s in line %d: %s\n", expr, file, line, function);
     fprintf(stderr, "I'm saving a debug file \"%s\" to the current directory.\n", filename);
 
-    gfxcompactpoly_save(current_polygon, filename);
+    gfxpoly_save(current_polygon, filename);
     exit(1);
 }
 
@@ -138,38 +138,12 @@ static int compare_events(const void*_a,const void*_b)
     //return d;
 }
 
-gfxpoly_t* gfxpoly_new(double gridsize)
-{
-    gfxpoly_t*p = (gfxpoly_t*)rfx_calloc(sizeof(gfxpoly_t));
-    p->gridsize = gridsize;
-    return p;
-}
-void gfxpoly_destroy(gfxpoly_t*poly)
-{
-    edge_t* s = poly->edges;
-    while(s) {
-        edge_t*next  = s->next;
-        free(s);
-        s = next;
-    }
-    free(poly);
-}
 int gfxpoly_size(gfxpoly_t*poly)
 {
-    edge_t*e = poly->edges;
-    int count = 0;
-    while(e) {
-       count++;
-       e = e->next;
-    }
-    return count;
-}
-int gfxcompactpoly_size(gfxcompactpoly_t*poly)
-{
     int s,t;
     int edges = 0;
-    for(t=0;t<poly->num_strokes;t++) {
-       gfxpolystroke_t*stroke = &poly->strokes[t];
+    gfxpolystroke_t*stroke = poly->strokes;
+    for(;stroke;stroke=stroke->next) {
        edges += stroke->num_points-1;
     }
     return edges;
@@ -177,45 +151,10 @@ int gfxcompactpoly_size(gfxcompactpoly_t*poly)
 
 char gfxpoly_check(gfxpoly_t*poly)
 {
-    edge_t* s = poly->edges;
-    dict_t*d = dict_new2(&point_type);
-    while(s) {
-        if(!dict_contains(d, &s->a)) {
-            dict_put(d, &s->a, (void*)(ptroff_t)1);
-        } else {
-            int count = (ptroff_t)dict_lookup(d, &s->a);
-            dict_del(d, &s->a);
-            count++;
-            dict_put(d, &s->a, (void*)(ptroff_t)count);
-        }
-        if(!dict_contains(d, &s->b)) {
-            dict_put(d, &s->b, (void*)(ptroff_t)1);
-        } else {
-            int count = (ptroff_t)dict_lookup(d, &s->b);
-            dict_del(d, &s->b);
-            count++;
-            dict_put(d, &s->b, (void*)(ptroff_t)count);
-        }
-        s = s->next;
-    }
-    DICT_ITERATE_ITEMS(d, point_t*, p, void*, c) {
-        int count = (ptroff_t)c;
-        if(count&1) {
-            fprintf(stderr, "Point (%f,%f) occurs %d times\n", p->x*poly->gridsize, p->y*poly->gridsize, count);
-            dict_destroy(d);
-            return 0;
-        }
-    }
-    dict_destroy(d);
-    return 1;
-}
-
-char gfxcompactpoly_check(gfxcompactpoly_t*poly)
-{
     dict_t*d = dict_new2(&point_type);
     int s,t;
-    for(t=0;t<poly->num_strokes;t++) {
-       gfxpolystroke_t*stroke = &poly->strokes[t];
+    gfxpolystroke_t*stroke = poly->strokes;
+    for(;stroke;stroke=stroke->next) {
        for(s=0;s<stroke->num_points;s++) {
            point_t p = stroke->points[s];
            int num = (s>=1 && s<stroke->num_points-1)?2:1; // mid points are two points (start+end)
@@ -243,47 +182,37 @@ char gfxcompactpoly_check(gfxcompactpoly_t*poly)
 
 void gfxpoly_dump(gfxpoly_t*poly)
 {
-    edge_t* s = poly->edges;
-    double g = poly->gridsize;
-    fprintf(stderr, "polyon %08x (gridsize: %f)\n", poly, poly->gridsize);
-    while(s) {
-        fprintf(stderr, "(%f,%f) -> (%f,%f)\n", s->a.x*g, s->a.y*g, s->b.x*g, s->b.y*g);
-        s = s->next;
-    }
-}
-
-void gfxcompactpoly_dump(gfxcompactpoly_t*poly)
-{
     int s,t;
     double g = poly->gridsize;
     fprintf(stderr, "polyon %08x (gridsize: %f)\n", poly, poly->gridsize);
-    for(t=0;t<poly->num_strokes;t++) {
-       gfxpolystroke_t*stroke = &poly->strokes[t];
+    gfxpolystroke_t*stroke = poly->strokes;
+    for(;stroke;stroke=stroke->next) {
+       fprintf(stderr, "%08x", stroke);
        for(s=0;s<stroke->num_points-1;s++) {
            point_t a = stroke->points[s];
            point_t b = stroke->points[s+1];
-           fprintf(stderr, "%s(%f,%f) -> (%f,%f)%s\n", s?" ":"[", a.x*g, a.y*g, b.x*g, b.y*g,
+           fprintf(stderr, "%s (%f,%f) -> (%f,%f)%s\n", s?"        ":"", a.x*g, a.y*g, b.x*g, b.y*g,
                                                        s==stroke->num_points-2?"]":"");
        }
     }
 }
 
-void gfxcompactpoly_save(gfxcompactpoly_t*poly, const char*filename)
+void gfxpoly_save(gfxpoly_t*poly, const char*filename)
 {
     FILE*fi = fopen(filename, "wb");
     fprintf(fi, "%% gridsize %f\n", poly->gridsize);
     fprintf(fi, "%% begin\n");
     int s,t;
-    for(t=0;t<poly->num_strokes;t++) {
-       gfxpolystroke_t*stroke = &poly->strokes[t];
-       for(s=0;s<stroke->num_points-1;s++) {
-           point_t a = stroke->points[s];
-           point_t b = stroke->points[s+1];
+    gfxpolystroke_t*stroke = poly->strokes;
+    for(;stroke;stroke=stroke->next) {
            fprintf(fi, "%g setgray\n", stroke->dir==DIR_UP ? 0.7 : 0);
-           fprintf(fi, "%d %d moveto\n", a.x, a.y);
-           fprintf(fi, "%d %d lineto\n", b.x, b.y);
-           fprintf(fi, "stroke\n");
+       point_t p = stroke->points[0];
+       fprintf(fi, "%d %d moveto\n", p.x, p.y);
+       for(s=1;s<stroke->num_points;s++) {
+           p = stroke->points[s];
+           fprintf(fi, "%d %d lineto\n", p.x, p.y);
        }
+       fprintf(fi, "stroke\n");
     }
     fprintf(fi, "showpage\n");
     fclose(fi);
@@ -327,10 +256,10 @@ static void segment_init(segment_t*s, int32_t x1, int32_t y1, int32_t x2, int32_
     if(y1!=y2) {
        assert(y1<y2);
     } else {
-        /* up/down for horizontal segments is handled by "rotating"
+        /* We need to make sure horizontal segments always go from left to right.
+          "up/down" for horizontal segments is handled by "rotating"
            them 90° anticlockwise in screen coordinates (tilt your head to
-           the right) 
-           TODO: is this still needed?
+           the right).
         */
         s->dir = DIR_UP;
         if(x1>x2) {
@@ -396,17 +325,23 @@ static void segment_destroy(segment_t*s)
 
 static void advance_stroke(heap_t*queue, gfxpolystroke_t*stroke, int polygon_nr, int pos)
 {
+    if(!stroke) 
+       return;
+    segment_t*s = 0;
+    /* we need to queue multiple segments at once because we need to process start events
+       before horizontal events */
     while(pos < stroke->num_points-1) {
        assert(stroke->points[pos].y <= stroke->points[pos+1].y);
-       segment_t*s = segment_new(stroke->points[pos], stroke->points[pos+1], polygon_nr, stroke->dir);
-       s->stroke = stroke;
-       s->stroke_pos = ++pos;
+       s = segment_new(stroke->points[pos], stroke->points[pos+1], polygon_nr, stroke->dir);
+       pos++;
+       s->stroke = 0;
+       s->stroke_pos = 0;
 #ifdef DEBUG
        /*if(l->tmp)
            s->nr = l->tmp;*/
-       fprintf(stderr, "[%d] (%d,%d) -> (%d,%d) %s (%d more to come)\n",
+       fprintf(stderr, "[%d] (%d,%d) -> (%d,%d) %s (stroke %08x, %d more to come)\n",
                s->nr, s->a.x, s->a.y, s->b.x, s->b.y,
-               s->dir==DIR_UP?"up":"down", stroke->num_points - 1 - pos);
+               s->dir==DIR_UP?"up":"down", stroke, stroke->num_points - 1 - pos);
 #endif
        event_t e = event_new();
        e.type = s->delta.y ? EVENT_START : EVENT_HORIZONTAL;
@@ -418,13 +353,21 @@ static void advance_stroke(heap_t*queue, gfxpolystroke_t*stroke, int polygon_nr,
            break;
        }
     }
+    if(s) {
+#ifdef DEBUG
+       fprintf(stderr, "attaching contingency of stroke %08x to segment [%d] %s\n",
+               stroke, s, s->delta.y?"":"(horizontal)");
+#endif
+       s->stroke = stroke;
+       s->stroke_pos = pos;
+    }
 }
 
-static void gfxpoly_enqueue(gfxcompactpoly_t*p, heap_t*queue, int polygon_nr)
+static void gfxpoly_enqueue(gfxpoly_t*p, heap_t*queue, int polygon_nr)
 {
     int t;
-    for(t=0;t<p->num_strokes;t++) {
-       gfxpolystroke_t*stroke = &p->strokes[t];
+    gfxpolystroke_t*stroke = p->strokes;
+    for(;stroke;stroke=stroke->next) {
        assert(stroke->num_points > 1);
 
 #ifdef CHECKS
@@ -485,6 +428,7 @@ static void schedule_crossing(status_t*status, segment_t*s1, segment_t*s2)
         return;
     }
 
+#ifndef DONT_REMEMBER_CROSSINGS
     if(dict_contains(&s1->scheduled_crossings, (void*)(ptroff_t)s2->nr)) {
         /* FIXME: this whole segment hashing thing is really slow */
 #ifdef DEBUG
@@ -495,6 +439,7 @@ static void schedule_crossing(status_t*status, segment_t*s1, segment_t*s2)
 #endif
         return; // we already know about this one
     }
+#endif
 
     double det = (double)s1->delta.x*s2->delta.y - (double)s1->delta.y*s2->delta.x;
     if(!det) {
@@ -512,23 +457,8 @@ static void schedule_crossing(status_t*status, segment_t*s1, segment_t*s2)
             return;
         }
     }
+
     double asign2 = LINE_EQ(s1->a, s2);
-    double bsign2 = LINE_EQ(s1->b, s2);
-    if(asign2<0 && bsign2<0) {
-        // segment1 is completely to the left of segment2
-#ifdef DEBUG
-            fprintf(stderr, "[%d] doesn't intersect with [%d] because: [%d] is completely to the left of [%d]\n", s1->nr, s2->nr, s1->nr, s2->nr);
-#endif
-        return;
-    }
-    if(asign2>0 && bsign2>0)  {
-       // TODO: can this ever happen?
-#ifdef DEBUG
-            fprintf(stderr, "[%d] doesn't intersect with [%d] because: [%d] is completely to the left of [%d]\n", s1->nr, s2->nr, s2->nr, s1->nr);
-#endif
-        // segment2 is completely to the left of segment1
-        return;
-    }
     if(asign2==0) {
         // segment1 touches segment2 in a single point (ignored)
 #ifdef DEBUG
@@ -536,6 +466,7 @@ static void schedule_crossing(status_t*status, segment_t*s1, segment_t*s2)
 #endif
         return;
     }
+    double bsign2 = LINE_EQ(s1->b, s2);
     if(bsign2==0) {
         // segment1 touches segment2 in a single point (ignored)
 #ifdef DEBUG
@@ -543,22 +474,26 @@ static void schedule_crossing(status_t*status, segment_t*s1, segment_t*s2)
 #endif
         return;
     }
-    double asign1 = LINE_EQ(s2->a, s1);
-    double bsign1 = LINE_EQ(s2->b, s1);
-    if(asign1<0 && bsign1<0) {
+
+    if(asign2<0 && bsign2<0) {
         // segment1 is completely to the left of segment2
 #ifdef DEBUG
             fprintf(stderr, "[%d] doesn't intersect with [%d] because: [%d] is completely to the left of [%d]\n", s1->nr, s2->nr, s1->nr, s2->nr);
 #endif
         return;
     }
-    if(asign1>0 && bsign1>0)  {
-        // segment2 is completely to the left of segment1
+    if(asign2>0 && bsign2>0)  {
+        // segment1 is completely to the right of segment2
+#ifndef DONT_REMEMBER_CROSSINGS
+       assert(0);
+#endif
 #ifdef DEBUG
             fprintf(stderr, "[%d] doesn't intersect with [%d] because: [%d] is completely to the left of [%d]\n", s1->nr, s2->nr, s2->nr, s1->nr);
 #endif
         return;
     }
+    
+    double asign1 = LINE_EQ(s2->a, s1);
     if(asign1==0) {
         // segment2 touches segment1 in a single point (ignored)
 #ifdef DEBUG
@@ -566,6 +501,7 @@ static void schedule_crossing(status_t*status, segment_t*s1, segment_t*s2)
 #endif
         return;
     }
+    double bsign1 = LINE_EQ(s2->b, s1);
     if(asign2==0) {
         // segment2 touches segment1 in a single point (ignored)
 #ifdef DEBUG
@@ -574,6 +510,34 @@ static void schedule_crossing(status_t*status, segment_t*s1, segment_t*s2)
         return;
     }
 
+    if(asign1<0 && bsign1<0) {
+        // segment2 is completely to the left of segment1
+#ifndef DONT_REMEMBER_CROSSINGS
+       assert(0);
+#endif
+#ifdef DEBUG
+            fprintf(stderr, "[%d] doesn't intersect with [%d] because: [%d] is completely to the left of [%d]\n", s1->nr, s2->nr, s1->nr, s2->nr);
+#endif
+        return;
+    }
+    if(asign1>0 && bsign1>0)  {
+        // segment2 is completely to the right of segment1
+#ifdef DEBUG
+            fprintf(stderr, "[%d] doesn't intersect with [%d] because: [%d] is completely to the left of [%d]\n", s1->nr, s2->nr, s2->nr, s1->nr);
+#endif
+        return;
+    }
+
+#ifdef DONT_REMEMBER_CROSSINGS
+    /* s2 crosses s1 from *left* to *right*. This is a crossing we already processed- 
+       there's not way s2 would be to the left of s1 otherwise */
+    if(asign1<0 && bsign1>0) return;
+    if(asign2>0 && bsign2<0) return;
+#endif
+
+    assert(!(asign1<0 && bsign1>0));
+    assert(!(asign2>0 && bsign2<0));
+
     /* TODO: should we precompute these? */
     double la = (double)s1->a.x*(double)s1->b.y - (double)s1->a.y*(double)s1->b.x;
     double lb = (double)s2->a.x*(double)s2->b.y - (double)s2->a.y*(double)s2->b.x;
@@ -590,17 +554,21 @@ static void schedule_crossing(status_t*status, segment_t*s1, segment_t*s2)
     point_t pair;
     pair.x = s1->nr;
     pair.y = s2->nr;
+#ifndef DONT_REMEMBER_CROSSINGS
     assert(!dict_contains(status->seen_crossings, &pair));
     dict_put(status->seen_crossings, &pair, 0);
 #endif
+#endif
 #ifdef DEBUG
     fprintf(stderr, "schedule crossing between [%d] and [%d] at (%d,%d)\n", s1->nr, s2->nr, p.x, p.y);
 #endif
 
+#ifndef DONT_REMEMBER_CROSSINGS
     /* we insert into each other's intersection history because these segments might switch
        places and we still want to look them up quickly after they did */
     dict_put(&s1->scheduled_crossings, (void*)(ptroff_t)(s2->nr), 0);
     dict_put(&s2->scheduled_crossings, (void*)(ptroff_t)(s1->nr), 0);
+#endif
 
     event_t e = event_new();
     e.type = EVENT_CROSS;
@@ -648,7 +616,6 @@ static inline box_t box_new(int32_t x, int32_t y)
     return box;
 }
 
-
 static void insert_point_into_segment(status_t*status, segment_t*s, point_t p)
 {
     assert(s->pos.x != p.x || s->pos.y != p.y);
@@ -1047,18 +1014,22 @@ static void event_apply(status_t*status, event_t*e)
 #ifdef DEBUG
                fprintf(stderr, "Ignore this crossing ([%d] not next to [%d])\n", e->s1->nr, e->s2->nr);
 #endif
+#ifndef DONT_REMEMBER_CROSSINGS
                 /* ignore this crossing for now (there are some line segments in between).
                    it'll get rescheduled as soon as the "obstacles" are gone */
                 char del1 = dict_del(&e->s1->scheduled_crossings, (void*)(ptroff_t)e->s2->nr);
                 char del2 = dict_del(&e->s2->scheduled_crossings, (void*)(ptroff_t)e->s1->nr);
                 assert(del1 && del2);
+#endif
 #ifdef CHECKS
                 point_t pair;
                 pair.x = e->s1->nr;
                 pair.y = e->s2->nr;
+#ifndef DONT_REMEMBER_CROSSINGS
                 assert(dict_contains(status->seen_crossings, &pair));
                 dict_del(status->seen_crossings, &pair);
 #endif
+#endif
             }
         }
     }
@@ -1081,7 +1052,7 @@ static void check_status(status_t*status)
 }
 #endif
 
-static void add_horizontals(gfxcompactpoly_t*poly, windrule_t*windrule, windcontext_t*context)
+static void add_horizontals(gfxpoly_t*poly, windrule_t*windrule, windcontext_t*context)
 {
     /*
           |..|        |...........|                 |           |
@@ -1100,9 +1071,6 @@ static void add_horizontals(gfxcompactpoly_t*poly, windrule_t*windrule, windcont
     actlist_t* actlist = actlist_new();
 
     event_t*e = heap_chopmax(queue);
-    int newstrokes_size = 4;
-    int num_newstrokes = 0;
-    gfxpolystroke_t*newstrokes = malloc(sizeof(gfxpolystroke_t)*newstrokes_size);
     while(e) {
         int32_t y = e->p.y;
         int32_t x = 0;
@@ -1121,11 +1089,10 @@ static void add_horizontals(gfxcompactpoly_t*poly, windrule_t*windrule, windcont
 #endif
                assert(x<e->p.x);
 
-               if(num_newstrokes == newstrokes_size) {
-                   newstrokes_size = (newstrokes_size)<<1;
-                   newstrokes = rfx_realloc(newstrokes, sizeof(gfxpolystroke_t)*newstrokes_size);
-               }
-                gfxpolystroke_t*stroke = &newstrokes[num_newstrokes++];
+                gfxpolystroke_t*stroke = rfx_calloc(sizeof(gfxpolystroke_t));
+               stroke->next = poly->strokes;
+               poly->strokes = stroke;
+
                stroke->num_points = 2;
                stroke->points = malloc(sizeof(point_t)*2);
                stroke->dir = DIR_UP; // FIXME
@@ -1195,16 +1162,11 @@ static void add_horizontals(gfxcompactpoly_t*poly, windrule_t*windrule, windcont
         assert(!fill); // check that polygon is not bleeding
     }
 
-    poly->strokes = rfx_realloc(poly->strokes, sizeof(gfxpolystroke_t)*(num_newstrokes+poly->num_strokes));
-    memcpy(&poly->strokes[poly->num_strokes], newstrokes, sizeof(gfxpolystroke_t)*num_newstrokes);
-    poly->num_strokes += num_newstrokes;
-    free(newstrokes);
-
     actlist_destroy(actlist);
     heap_destroy(queue);
 }
 
-gfxpoly_t* gfxpoly_process(gfxcompactpoly_t*poly, windrule_t*windrule, windcontext_t*context)
+gfxpoly_t* gfxpoly_process(gfxpoly_t*poly, windrule_t*windrule, windcontext_t*context)
 {
     current_polygon = poly;
     heap_t* queue = heap_new(sizeof(event_t), compare_events);
@@ -1217,7 +1179,7 @@ gfxpoly_t* gfxpoly_process(gfxcompactpoly_t*poly, windrule_t*windrule, windconte
     status.windrule = windrule;
     status.context = context;
     status.actlist = actlist_new();
-    gfxcompactpolywriter_init(&status.writer);
+    gfxpolywriter_init(&status.writer);
     status.writer.setgridsize(&status.writer, poly->gridsize);
 
 #ifdef CHECKS
@@ -1275,7 +1237,8 @@ gfxpoly_t* gfxpoly_process(gfxcompactpoly_t*poly, windrule_t*windrule, windconte
     heap_destroy(queue);
     xrow_destroy(status.xrow);
 
-    gfxcompactpoly_t*p = (gfxcompactpoly_t*)status.writer.finish(&status.writer);
+    gfxpoly_t*p = (gfxpoly_t*)status.writer.finish(&status.writer);
+
     add_horizontals(p, &windrule_evenodd, context); // output is always even/odd
-    return gfxpoly_from_gfxcompactpoly(p);
+    return p;
 }