#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) {
void*md5 = init_md5();
int s,t;
- for(s=0;s<current_polygon->num_strokes;s++) {
- gfxpolystroke_t*stroke = ¤t_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));
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);
}
//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;
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)
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) {
for(s=0;s<stroke->num_points-1;s++) {
point_t a = stroke->points[s];
point_t b = stroke->points[s+1];
}
}
-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];
+ gfxpolystroke_t*stroke = poly->strokes;
+ for(;stroke;stroke=stroke->next) {
for(s=0;s<stroke->num_points-1;s++) {
point_t a = stroke->points[s];
point_t b = stroke->points[s+1];
}
}
-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
return;
}
+#define REMEMBER_CROSSINGS
+#ifdef REMEMBER_CROSSINGS
if(dict_contains(&s1->scheduled_crossings, (void*)(ptroff_t)s2->nr)) {
/* FIXME: this whole segment hashing thing is really slow */
#ifdef DEBUG
#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) {
p.x = (int32_t)ceil((-la*s2->delta.x + lb*s1->delta.x) / det);
p.y = (int32_t)ceil((+lb*s1->delta.y - la*s2->delta.y) / det);
+#ifndef REMEMBER_CROSSINGS
+ if(p.y < status->y) return;
+#endif
+
assert(p.y >= status->y);
#ifdef CHECKS
assert(p.x >= s1->minx && p.x <= s1->maxx);
point_t pair;
pair.x = s1->nr;
pair.y = s2->nr;
+#ifdef 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
+#ifdef 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;
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);
#ifdef DEBUG
fprintf(stderr, "Ignore this crossing ([%d] not next to [%d])\n", e->s1->nr, e->s2->nr);
#endif
+#ifdef 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;
+#ifdef REMEMBER_CROSSINGS
assert(dict_contains(status->seen_crossings, &pair));
dict_del(status->seen_crossings, &pair);
#endif
+#endif
}
}
}
}
#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)
{
/*
|..| |...........| | |
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;
#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
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);
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
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
- gfxpoly_t*pp = gfxpoly_from_gfxcompactpoly(p);
- gfxcompactpoly_destroy(p);
- return pp;
+ return p;
}
git.asbjorn.biz / swftools.git / blobdiff