From f8bb3617c3a7ec598c42eff1f8562e3ccc95127f Mon Sep 17 00:00:00 2001 From: Chris Wilson Date: Wed, 17 Dec 2008 09:32:16 +0000 Subject: Eliminate self-intersecting strokes. We refactor the surface fallbacks to convert full strokes and fills to the intermediate polygon representation (as opposed to before where we returned the trapezoidal representation). This allow greater flexibility to choose how then to rasterize the polygon. Where possible we use the local spans rasteriser for its increased performance, but still have the option to use the tessellator instead (for example, with the current Render protocol which does not yet have a polygon image). In order to accommodate this, the spans interface is tweaked to accept whole polygons instead of a path and the tessellator is tweaked for speed. Performance Impact ================== ... Still measuring, expecting some severe regressions. ... --- NEWS | 18 + src/Makefile.am | 2 + src/cairo-bentley-ottmann.c | 1833 ++++++++++++--------- src/cairo-clip.c | 14 +- src/cairo-fixed-private.h | 52 +- src/cairo-fixed-type-private.h | 5 + src/cairo-gstate.c | 4 +- src/cairo-hash.c | 6 - src/cairo-matrix.c | 27 +- src/cairo-path-fill.c | 109 +- src/cairo-path-stroke.c | 1025 +++++++----- src/cairo-pen.c | 191 --- src/cairo-polygon.c | 269 ++- src/cairo-skiplist-private.h | 4 +- src/cairo-skiplist.c | 8 +- src/cairo-slope.c | 4 +- src/cairo-spans-private.h | 45 +- src/cairo-spans.c | 179 +- src/cairo-surface-fallback.c | 208 ++- src/cairo-tor-scan-converter.c | 492 +++--- src/cairo-toy-font-face.c | 3 +- src/cairo-traps.c | 72 +- src/cairo-types-private.h | 15 +- src/cairo-wideint-private.h | 47 +- src/cairo-wideint.c | 34 - src/cairoint.h | 102 +- test/Makefile.am | 90 +- test/Makefile.sources | 3 +- test/caps-joins-alpha.ref.png | Bin 2463 -> 2570 bytes test/caps-joins-alpha.xlib.ref.png | Bin 0 -> 2278 bytes test/caps-joins-curve.ref.png | Bin 5132 -> 5725 bytes test/caps-joins-curve.xlib.ref.png | Bin 0 -> 5126 bytes test/clear.pdf.argb32.ref.png | Bin 0 -> 790 bytes test/clear.ps.argb32.ref.png | Bin 0 -> 790 bytes test/clip-operator.svg12.argb32.xfail.png | Bin 8406 -> 8404 bytes test/clip-operator.svg12.rgb24.xfail.png | Bin 4540 -> 4523 bytes test/clipped-group.pdf.ref.png | Bin 310 -> 334 bytes test/clipped-trapezoids-ref.png | Bin 0 -> 1055 bytes test/clipped-trapezoids.c | 95 ++ test/clipped-trapezoids.ref.png | Bin 0 -> 963 bytes test/close-path-current-point.ref.png | Bin 1916 -> 1893 bytes test/dash-caps-joins.ref.png | Bin 4718 -> 4520 bytes test/dash-curve.ref.png | Bin 39696 -> 41284 bytes test/dash-curve.xlib.ref.png | Bin 0 -> 40109 bytes test/dash-scale.ref.png | Bin 8058 -> 7616 bytes test/degenerate-arc.ref.png | Bin 544 -> 646 bytes test/degenerate-dash.ref.png | Bin 2005 -> 2086 bytes test/degenerate-dash.xlib.ref.png | Bin 0 -> 1898 bytes test/degenerate-path.argb32.ref.png | Bin 0 -> 240 bytes test/degenerate-path.ref.png | Bin 257 -> 0 bytes test/degenerate-path.rgb24.ref.png | Bin 224 -> 210 bytes test/degenerate-pen.ref.png | Bin 1139 -> 997 bytes test/degenerate-pen.xlib.ref.png | Bin 0 -> 997 bytes test/device-offset-fractional.pdf.xfail.png | Bin 275 -> 275 bytes test/fill-and-stroke-alpha-add.ref.png | Bin 591 -> 562 bytes test/fill-and-stroke-alpha-add.svg12.xfail.png | Bin 614 -> 631 bytes test/fill-and-stroke-alpha.ref.png | Bin 519 -> 515 bytes test/fill-and-stroke.argb32.ref.png | Bin 0 -> 313 bytes test/fill-and-stroke.ref.png | Bin 279 -> 0 bytes test/fill-and-stroke.rgb24.ref.png | Bin 257 -> 287 bytes test/fill-and-stroke.xlib.argb32.ref.png | Bin 0 -> 322 bytes test/fill-and-stroke.xlib.rgb24.ref.png | Bin 0 -> 291 bytes test/filter-nearest-offset.pdf.xfail.png | Bin 1867 -> 1926 bytes test/filter-nearest-transformed.pdf.xfail.png | Bin 482 -> 488 bytes test/ft-text-vertical-layout-type1.ps.ref.png | Bin 0 -> 1634 bytes test/ft-text-vertical-layout-type1.ps2.ref.png | Bin 1846 -> 0 bytes test/ft-text-vertical-layout-type1.ps3.ref.png | Bin 1846 -> 0 bytes test/ft-text-vertical-layout-type1.ref.png | Bin 3643 -> 3647 bytes test/ft-text-vertical-layout-type1.svg.ref.png | Bin 3607 -> 3609 bytes test/ft-text-vertical-layout-type1.xlib.ref.png | Bin 3980 -> 3640 bytes test/ft-text-vertical-layout-type3.ps.ref.png | Bin 0 -> 1636 bytes test/ft-text-vertical-layout-type3.ps2.ref.png | Bin 1804 -> 0 bytes test/ft-text-vertical-layout-type3.ps3.ref.png | Bin 1804 -> 0 bytes test/ft-text-vertical-layout-type3.ref.png | Bin 3608 -> 3607 bytes test/ft-text-vertical-layout-type3.svg.ref.png | Bin 3626 -> 3626 bytes test/ft-text-vertical-layout-type3.xlib.ref.png | Bin 3934 -> 3605 bytes test/group-unaligned.svg.argb32.xfail.png | Bin 520 -> 522 bytes test/joins.ref.png | Bin 5879 -> 5708 bytes test/leaky-dashed-rectangle.pdf.ref.png | Bin 347 -> 347 bytes test/leaky-dashed-rectangle.xlib.ref.png | Bin 0 -> 347 bytes test/leaky-dashed-stroke.ref.png | Bin 9214 -> 9387 bytes test/leaky-dashed-stroke.xlib.ref.png | Bin 0 -> 9305 bytes test/line-width-scale.ref.png | Bin 6445 -> 5716 bytes test/long-dashed-lines.ref.png | Bin 2116 -> 2070 bytes test/mask-glyphs.svg.ref.png | Bin 1211147 -> 1211158 bytes test/meta-surface-pattern.pdf.argb32.ref.png | Bin 3919 -> 3835 bytes test/meta-surface-pattern.pdf.rgb24.ref.png | Bin 3867 -> 3682 bytes test/meta-surface-pattern.svg.argb32.ref.png | Bin 3930 -> 3778 bytes test/meta-surface-pattern.svg.rgb24.ref.png | Bin 3910 -> 3760 bytes test/new-sub-path.argb32.ref.png | Bin 0 -> 421 bytes test/new-sub-path.pdf.argb32.ref.png | Bin 0 -> 512 bytes test/new-sub-path.ref.png | Bin 386 -> 0 bytes test/new-sub-path.rgb24.ref.png | Bin 355 -> 381 bytes test/operator-source.svg12.argb32.xfail.png | Bin 2967 -> 2951 bytes test/operator-source.svg12.rgb24.xfail.png | Bin 2976 -> 2963 bytes test/over-around-source.pdf.argb32.ref.png | Bin 585 -> 576 bytes test/random-intersections-eo.c | 78 + test/random-intersections-eo.ps.ref.png | Bin 0 -> 78806 bytes test/random-intersections-eo.quartz.ref.png | Bin 0 -> 197778 bytes test/random-intersections-eo.ref.png | Bin 0 -> 136018 bytes test/random-intersections-eo.xlib.ref.png | Bin 0 -> 134655 bytes test/random-intersections-nonzero.c | 79 + test/random-intersections-nonzero.ps.ref.png | Bin 0 -> 77299 bytes test/random-intersections-nonzero.ref.png | Bin 0 -> 141154 bytes test/random-intersections-nonzero.xlib.ref.png | Bin 0 -> 141548 bytes test/random-intersections.c | 78 - test/random-intersections.ps2.ref.png | Bin 89253 -> 0 bytes test/random-intersections.ps3.ref.png | Bin 89253 -> 0 bytes test/random-intersections.quartz.ref.png | Bin 197778 -> 0 bytes test/random-intersections.ref.png | Bin 133462 -> 0 bytes test/random-intersections.xlib.ref.png | Bin 148722 -> 0 bytes test/reflected-stroke.ref.png | Bin 5704 -> 4978 bytes test/rel-path.ref.png | Bin 212 -> 198 bytes test/rel-path.rgb24.ref.png | Bin 228 -> 214 bytes test/scale-offset-image.meta.xfail.png | Bin 8599 -> 0 bytes test/scale-offset-image.pdf.xfail.png | Bin 8694 -> 10099 bytes test/scale-offset-image.xfail.png | Bin 8599 -> 9960 bytes test/scale-offset-image.xlib-fallback.xfail.png | Bin 8580 -> 8706 bytes test/scale-offset-image.xlib.xfail.png | Bin 9100 -> 9132 bytes test/scale-offset-similar.meta.xfail.png | Bin 9095 -> 10752 bytes test/scale-offset-similar.pdf.xfail.png | Bin 9368 -> 11024 bytes test/scale-offset-similar.xfail.png | Bin 8599 -> 9960 bytes test/scale-offset-similar.xlib-fallback.xfail.png | Bin 8580 -> 8706 bytes test/scale-offset-similar.xlib.xfail.png | Bin 8570 -> 8696 bytes test/self-intersecting.argb32.xfail.png | Bin 235 -> 0 bytes test/self-intersecting.c | 3 + test/self-intersecting.pdf.argb32.xfail.png | Bin 285 -> 0 bytes test/self-intersecting.pdf.rgb24.xfail.png | Bin 269 -> 0 bytes test/self-intersecting.ps.argb32.xfail.png | Bin 186 -> 0 bytes test/self-intersecting.ps.ref.png | Bin 0 -> 186 bytes test/self-intersecting.ps.rgb24.xfail.png | Bin 186 -> 0 bytes test/self-intersecting.ref.png | Bin 242 -> 301 bytes test/self-intersecting.rgb24.ref.png | Bin 304 -> 0 bytes test/self-intersecting.rgb24.xfail.png | Bin 240 -> 0 bytes test/self-intersecting.xlib.argb32.xfail.png | Bin 235 -> 0 bytes test/self-intersecting.xlib.ref.png | Bin 0 -> 252 bytes test/self-intersecting.xlib.rgb24.xfail.png | Bin 240 -> 0 bytes test/smask-stroke.ref.png | Bin 1845 -> 1714 bytes test/smask-stroke.xlib.ref.png | Bin 0 -> 1707 bytes test/smask.ps.ref.png | Bin 0 -> 3430 bytes test/smask.ps2.ref.png | Bin 3669 -> 0 bytes test/smask.ps3.ref.png | Bin 3669 -> 0 bytes test/smask.ref.png | Bin 3417 -> 3423 bytes test/smask.svg.ref.png | Bin 3458 -> 3457 bytes test/smask.xlib.ref.png | Bin 3393 -> 3386 bytes test/spline-decomposition.pdf.ref.png | Bin 19156 -> 19540 bytes test/spline-decomposition.ps.ref.png | Bin 9090 -> 9028 bytes test/spline-decomposition.ref.png | Bin 19107 -> 19569 bytes test/spline-decomposition.svg.ref.png | Bin 19156 -> 19540 bytes test/spline-decomposition.xlib.ref.png | Bin 0 -> 19158 bytes test/stroke-ctm-caps.ref.png | Bin 1057 -> 873 bytes test/stroke-image.pdf.ref.png | Bin 1554 -> 1475 bytes test/stroke-image.ps.ref.png | Bin 0 -> 1641 bytes test/stroke-image.ps2.ref.png | Bin 2121 -> 0 bytes test/stroke-image.ps3.ref.png | Bin 2121 -> 0 bytes test/stroke-image.ref.png | Bin 1866 -> 1344 bytes test/stroke-image.xlib.ref.png | Bin 0 -> 1440 bytes test/surface-pattern.pdf.xfail.png | Bin 10528 -> 10532 bytes test/text-rotate.pdf.ref.png | Bin 16639 -> 16757 bytes test/text-rotate.ref.png | Bin 17775 -> 16738 bytes test/text-rotate.svg.ref.png | Bin 17024 -> 17118 bytes test/text-rotate.xlib.ref.png | Bin 0 -> 16646 bytes test/twin.ps.ref.png | Bin 2197 -> 2142 bytes test/twin.ref.png | Bin 4038 -> 3979 bytes test/twin.xlib.ref.png | Bin 0 -> 4435 bytes test/unantialiased-shapes.ref.png | Bin 4459 -> 3969 bytes test/unbounded-operator.svg12.argb32.ref.png | Bin 0 -> 2767 bytes test/unbounded-operator.svg12.argb32.xfail.png | Bin 2771 -> 0 bytes test/unbounded-operator.svg12.rgb24.xfail.png | Bin 1731 -> 1719 bytes test/user-font-proxy.svg.ref.png | Bin 16814 -> 16817 bytes test/user-font.ps.ref.png | Bin 0 -> 4605 bytes test/user-font.ps2.ref.png | Bin 5043 -> 0 bytes test/user-font.ps3.ref.png | Bin 5043 -> 0 bytes test/user-font.ref.png | Bin 6082 -> 6270 bytes test/user-font.xlib.ref.png | Bin 6183 -> 5884 bytes util/.gitignore | 3 + util/Makefile.am | 23 +- util/show-edges.c | 1189 +++++++++++++ util/show-events.c | 845 ++++++++++ util/show-traps.c | 1239 ++++++++++++++ 180 files changed, 6303 insertions(+), 2190 deletions(-) create mode 100644 test/caps-joins-alpha.xlib.ref.png create mode 100644 test/caps-joins-curve.xlib.ref.png create mode 100644 test/clear.pdf.argb32.ref.png create mode 100644 test/clear.ps.argb32.ref.png create mode 100644 test/clipped-trapezoids-ref.png create mode 100644 test/clipped-trapezoids.c create mode 100644 test/clipped-trapezoids.ref.png create mode 100644 test/dash-curve.xlib.ref.png create mode 100644 test/degenerate-dash.xlib.ref.png create mode 100644 test/degenerate-path.argb32.ref.png delete mode 100644 test/degenerate-path.ref.png create mode 100644 test/degenerate-pen.xlib.ref.png create mode 100644 test/fill-and-stroke.argb32.ref.png delete mode 100644 test/fill-and-stroke.ref.png create mode 100644 test/fill-and-stroke.xlib.argb32.ref.png create mode 100644 test/fill-and-stroke.xlib.rgb24.ref.png create mode 100644 test/ft-text-vertical-layout-type1.ps.ref.png delete mode 100644 test/ft-text-vertical-layout-type1.ps2.ref.png delete mode 100644 test/ft-text-vertical-layout-type1.ps3.ref.png create mode 100644 test/ft-text-vertical-layout-type3.ps.ref.png delete mode 100644 test/ft-text-vertical-layout-type3.ps2.ref.png delete mode 100644 test/ft-text-vertical-layout-type3.ps3.ref.png create mode 100644 test/leaky-dashed-rectangle.xlib.ref.png create mode 100644 test/leaky-dashed-stroke.xlib.ref.png create mode 100644 test/new-sub-path.argb32.ref.png create mode 100644 test/new-sub-path.pdf.argb32.ref.png delete mode 100644 test/new-sub-path.ref.png create mode 100644 test/random-intersections-eo.c create mode 100644 test/random-intersections-eo.ps.ref.png create mode 100644 test/random-intersections-eo.quartz.ref.png create mode 100644 test/random-intersections-eo.ref.png create mode 100644 test/random-intersections-eo.xlib.ref.png create mode 100644 test/random-intersections-nonzero.c create mode 100644 test/random-intersections-nonzero.ps.ref.png create mode 100644 test/random-intersections-nonzero.ref.png create mode 100644 test/random-intersections-nonzero.xlib.ref.png delete mode 100644 test/random-intersections.c delete mode 100644 test/random-intersections.ps2.ref.png delete mode 100644 test/random-intersections.ps3.ref.png delete mode 100644 test/random-intersections.quartz.ref.png delete mode 100644 test/random-intersections.ref.png delete mode 100644 test/random-intersections.xlib.ref.png delete mode 100644 test/scale-offset-image.meta.xfail.png delete mode 100644 test/self-intersecting.argb32.xfail.png delete mode 100644 test/self-intersecting.pdf.argb32.xfail.png delete mode 100644 test/self-intersecting.pdf.rgb24.xfail.png delete mode 100644 test/self-intersecting.ps.argb32.xfail.png create mode 100644 test/self-intersecting.ps.ref.png delete mode 100644 test/self-intersecting.ps.rgb24.xfail.png delete mode 100644 test/self-intersecting.rgb24.ref.png delete mode 100644 test/self-intersecting.rgb24.xfail.png delete mode 100644 test/self-intersecting.xlib.argb32.xfail.png create mode 100644 test/self-intersecting.xlib.ref.png delete mode 100644 test/self-intersecting.xlib.rgb24.xfail.png create mode 100644 test/smask-stroke.xlib.ref.png create mode 100644 test/smask.ps.ref.png delete mode 100644 test/smask.ps2.ref.png delete mode 100644 test/smask.ps3.ref.png create mode 100644 test/spline-decomposition.xlib.ref.png create mode 100644 test/stroke-image.ps.ref.png delete mode 100644 test/stroke-image.ps2.ref.png delete mode 100644 test/stroke-image.ps3.ref.png create mode 100644 test/stroke-image.xlib.ref.png create mode 100644 test/text-rotate.xlib.ref.png create mode 100644 test/twin.xlib.ref.png create mode 100644 test/unbounded-operator.svg12.argb32.ref.png delete mode 100644 test/unbounded-operator.svg12.argb32.xfail.png create mode 100644 test/user-font.ps.ref.png delete mode 100644 test/user-font.ps2.ref.png delete mode 100644 test/user-font.ps3.ref.png create mode 100644 util/show-edges.c create mode 100644 util/show-events.c create mode 100644 util/show-traps.c diff --git a/NEWS b/NEWS index 9c798dd28..a4a2c83dd 100644 --- a/NEWS +++ b/NEWS @@ -69,6 +69,24 @@ New experimental backends: more offloading onto the GPU. The initial work on the backend was performed by Eric Anholt. +Long standing bugs fixed: + + Self-intersecting strokes. + + A long standing bug where the coverage from overlapping semi-opaque + strokes (including neighbouring edges) was simply summed in lieu of + a costly global calculation has been fixed (by performing the costly + global calculation!) In order to mitigate the extra cost, the + tessellator has been overhauled and tune, which handles the fallback + for when we are unable to use the new span rasteriser on the stroke + (e.g. when using the current RENDER protocol). The large number of + pixel artefacts that implementing self-intersection elimination + removes is ample justification for the potential performance + regression. If you unfortunately do suffer a substantial performance + regression in your application, please consider obtaining a + cairo-trace and submitting it to us for analysis and inclusion into + our performance suite. + Snapshot 1.9.2 (2009-06-12) =========================== diff --git a/src/Makefile.am b/src/Makefile.am index f34d79c4b..e461fbde7 100644 --- a/src/Makefile.am +++ b/src/Makefile.am @@ -99,5 +99,7 @@ COMPILE_ARGS = $(PREPROCESS_ARGS) $(AM_CFLAGS) $(CFLAGS) # cairo has been compiled with symbol hiding. .c.i: $(cairoinclude_HEADERS) $(nodist_cairoinclude_HEADERS) cairoint.h $(top_builddir)/config.h $(CPP) $(PREPROCESS_ARGS) $< -o $@ +.c.s: $(cairoinclude_HEADERS) $(nodist_cairoinclude_HEADERS) cairoint.h $(top_builddir)/config.h + $(CC) $(COMPILE_ARGS) $< -S -o $@ include $(srcdir)/Makefile.am.analysis diff --git a/src/cairo-bentley-ottmann.c b/src/cairo-bentley-ottmann.c index 1d59d7038..f64b7a377 100644 --- a/src/cairo-bentley-ottmann.c +++ b/src/cairo-bentley-ottmann.c @@ -1,6 +1,7 @@ /* * Copyright © 2004 Carl Worth * Copyright © 2006 Red Hat, Inc. + * Copyright © 2008 Chris Wilson * * This library is free software; you can redistribute it and/or * modify it either under the terms of the GNU Lesser General Public @@ -31,6 +32,7 @@ * * Contributor(s): * Carl D. Worth + * Chris Wilson */ /* Provide definitions for standalone compilation */ @@ -42,14 +44,11 @@ #define DEBUG_VALIDATE 0 #define DEBUG_PRINT_STATE 0 +#define DEBUG_EVENTS 0 +#define DEBUG_TRAPS 0 typedef cairo_point_t cairo_bo_point32_t; -typedef struct _cairo_bo_point128 { - cairo_int128_t x; - cairo_int128_t y; -} cairo_bo_point128_t; - typedef struct _cairo_bo_intersect_ordinate { int32_t ordinate; enum { EXACT, INEXACT } exactness; @@ -63,34 +62,18 @@ typedef struct _cairo_bo_intersect_point { typedef struct _cairo_bo_edge cairo_bo_edge_t; typedef struct _sweep_line_elt sweep_line_elt_t; typedef struct _cairo_bo_trap cairo_bo_trap_t; -typedef struct _cairo_bo_traps cairo_bo_traps_t; -/* A deferred trapezoid of an edge. */ +/* A deferred trapezoid of an edge */ struct _cairo_bo_trap { cairo_bo_edge_t *right; int32_t top; }; -struct _cairo_bo_traps { - cairo_traps_t *traps; - cairo_freelist_t freelist; - - /* These form the closed bounding box of the original input - * points. */ - cairo_fixed_t xmin; - cairo_fixed_t ymin; - cairo_fixed_t xmax; - cairo_fixed_t ymax; -}; - struct _cairo_bo_edge { - cairo_bo_point32_t top; - cairo_bo_point32_t middle; - cairo_bo_point32_t bottom; - int dir; + cairo_edge_t edge; cairo_bo_edge_t *prev; cairo_bo_edge_t *next; - cairo_bo_trap_t *deferred_trap; + cairo_bo_trap_t deferred_trap; sweep_line_elt_t *sweep_line_elt; }; @@ -100,35 +83,39 @@ struct _sweep_line_elt { }; #define SKIP_ELT_TO_EDGE_ELT(elt) SKIP_LIST_ELT_TO_DATA (sweep_line_elt_t, (elt)) -#define SKIP_ELT_TO_EDGE(elt) (SKIP_ELT_TO_EDGE_ELT (elt)->edge) +#define SKIP_ELT_TO_EDGE(elt) (SKIP_ELT_TO_EDGE_ELT (elt)->edge) typedef enum { - CAIRO_BO_STATUS_INTERSECTION, - CAIRO_BO_STATUS_PARALLEL, - CAIRO_BO_STATUS_NO_INTERSECTION -} cairo_bo_status_t; - -typedef enum { - CAIRO_BO_EVENT_TYPE_START, CAIRO_BO_EVENT_TYPE_STOP, - CAIRO_BO_EVENT_TYPE_INTERSECTION + CAIRO_BO_EVENT_TYPE_INTERSECTION, + CAIRO_BO_EVENT_TYPE_START } cairo_bo_event_type_t; typedef struct _cairo_bo_event { cairo_bo_event_type_t type; + cairo_point_t point; +} cairo_bo_event_t; + +typedef struct _cairo_bo_start_event { + cairo_bo_event_type_t type; + cairo_point_t point; + cairo_bo_edge_t edge; +} cairo_bo_start_event_t; + +typedef struct _cairo_bo_skiplist_event { + cairo_bo_event_type_t type; + cairo_point_t point; cairo_bo_edge_t *e1; cairo_bo_edge_t *e2; - cairo_bo_point32_t point; skip_elt_t elt; -} cairo_bo_event_t; +} cairo_bo_skiplist_event_t; -#define SKIP_ELT_TO_EVENT(elt) SKIP_LIST_ELT_TO_DATA (cairo_bo_event_t, (elt)) +#define SKIP_ELT_TO_EVENT(elt) ((cairo_bo_event_t *) SKIP_LIST_ELT_TO_DATA (cairo_bo_skiplist_event_t, (elt))) typedef struct _cairo_bo_event_queue { - cairo_skip_list_t intersection_queue; + cairo_skip_list_t event_queue; - cairo_bo_event_t *startstop_events; - cairo_bo_event_t **sorted_startstop_event_ptrs; + cairo_bo_event_t **start_events; } cairo_bo_event_queue_t; /* This structure extends #cairo_skip_list_t, which must come first. */ @@ -136,16 +123,134 @@ typedef struct _cairo_bo_sweep_line { cairo_skip_list_t active_edges; cairo_bo_edge_t *head; cairo_bo_edge_t *tail; + cairo_bo_edge_t *stopped; int32_t current_y; } cairo_bo_sweep_line_t; +#if DEBUG_TRAPS +static void +dump_traps (cairo_traps_t *traps, const char *filename) +{ + FILE *file; + int n; + + if (getenv ("CAIRO_DEBUG_TRAPS") == NULL) + return; + + if (traps->has_limits) { + printf ("%s: limits=(%d, %d, %d, %d)\n", + filename, + traps->limits.p1.x, traps->limits.p1.y, + traps->limits.p2.x, traps->limits.p2.y); + } + printf ("%s: extents=(%d, %d, %d, %d)\n", + filename, + traps->extents.p1.x, traps->extents.p1.y, + traps->extents.p2.x, traps->extents.p2.y); + + file = fopen (filename, "a"); + if (file != NULL) { + for (n = 0; n < traps->num_traps; n++) { + fprintf (file, "%d %d L:(%d, %d), (%d, %d) R:(%d, %d), (%d, %d)\n", + traps->traps[n].top, + traps->traps[n].bottom, + traps->traps[n].left.p1.x, + traps->traps[n].left.p1.y, + traps->traps[n].left.p2.x, + traps->traps[n].left.p2.y, + traps->traps[n].right.p1.x, + traps->traps[n].right.p1.y, + traps->traps[n].right.p2.x, + traps->traps[n].right.p2.y); + } + fprintf (file, "\n"); + fclose (file); + } +} + +static void +dump_edges (cairo_bo_start_event_t *events, + int num_edges, + const char *filename) +{ + FILE *file; + int n; + + if (getenv ("CAIRO_DEBUG_TRAPS") == NULL) + return; + + file = fopen (filename, "a"); + if (file != NULL) { + for (n = 0; n < num_edges; n++) { + fprintf (file, "(%d, %d), (%d, %d) %d %d %d\n", + events[n].edge.edge.line.p1.x, + events[n].edge.edge.line.p1.y, + events[n].edge.edge.line.p2.x, + events[n].edge.edge.line.p2.y, + events[n].edge.edge.top, + events[n].edge.edge.bottom, + events[n].edge.edge.dir); + } + fprintf (file, "\n"); + fclose (file); + } +} +#endif + +static cairo_fixed_t +_line_compute_intersection_x_for_y (const cairo_line_t *line, + cairo_fixed_t y) +{ + cairo_fixed_t x, dy; + + if (y == line->p1.y) + return line->p1.x; + if (y == line->p2.y) + return line->p2.x; + + x = line->p1.x; + dy = line->p2.y - line->p1.y; + if (dy != 0) { + x += _cairo_fixed_mul_div_floor (y - line->p1.y, + line->p2.x - line->p1.x, + dy); + } + + return x; +} + +static cairo_fixed_t +_line_compute_intersection_y_for_x (const cairo_line_t *line, + cairo_fixed_t x) +{ + cairo_fixed_t y, dx; + + if (x == line->p1.x) + return line->p1.y; + if (x == line->p2.x) + return line->p2.y; + + y = line->p1.y; + dx = line->p2.x - line->p1.x; + if (dx != 0) { + y += _cairo_fixed_mul_div_floor (x - line->p1.x, + line->p2.y - line->p1.y, + dx); + } + + return y; +} static inline int _cairo_bo_point32_compare (cairo_bo_point32_t const *a, cairo_bo_point32_t const *b) { - int cmp = a->y - b->y; - if (cmp) return cmp; + int cmp; + + cmp = a->y - b->y; + if (cmp) + return cmp; + return a->x - b->x; } @@ -159,7 +264,7 @@ _cairo_bo_point32_compare (cairo_bo_point32_t const *a, * * which is: * - * (dx, dy) = (bottom.x - top.x, bottom.y - top.y) + * (dx, dy) = (line.p2.x - line.p1.x, line.p2.y - line.p1.y) * * We then define the slope of each edge as dx/dy, (which is the * inverse of the slope typically used in math instruction). We never @@ -183,17 +288,17 @@ _cairo_bo_point32_compare (cairo_bo_point32_t const *a, * the sense of the result will be exactly reversed for two edges that * have a common stop point. */ -static int -_slope_compare (cairo_bo_edge_t *a, - cairo_bo_edge_t *b) +static inline int +_slope_compare (const cairo_bo_edge_t *a, + const cairo_bo_edge_t *b) { /* XXX: We're assuming here that dx and dy will still fit in 32 * bits. That's not true in general as there could be overflow. We * should prevent that before the tessellation algorithm * begins. */ - int32_t adx = a->bottom.x - a->top.x; - int32_t bdx = b->bottom.x - b->top.x; + int32_t adx = a->edge.line.p2.x - a->edge.line.p1.x; + int32_t bdx = b->edge.line.p2.x - b->edge.line.p1.x; /* Since the dy's are all positive by construction we can fast * path several common cases. @@ -211,8 +316,8 @@ _slope_compare (cairo_bo_edge_t *a, /* Finally we actually need to do the general comparison. */ { - int32_t ady = a->bottom.y - a->top.y; - int32_t bdy = b->bottom.y - b->top.y; + int32_t ady = a->edge.line.p2.y - a->edge.line.p1.y; + int32_t bdy = b->edge.line.p2.y - b->edge.line.p1.y; cairo_int64_t adx_bdy = _cairo_int32x32_64_mul (adx, bdy); cairo_int64_t bdx_ady = _cairo_int32x32_64_mul (bdx, ady); @@ -270,23 +375,46 @@ edges_compare_x_for_y_general (const cairo_bo_edge_t *a, HAVE_ALL = HAVE_DX | HAVE_ADX | HAVE_BDX } have_dx_adx_bdx = HAVE_ALL; - ady = a->bottom.y - a->top.y; - adx = a->bottom.x - a->top.x; + /* don't bother solving for abscissa if the edges' bounding boxes + * can be used to order them. */ + { + int32_t amin, amax; + int32_t bmin, bmax; + if (a->edge.line.p1.x < a->edge.line.p2.x) { + amin = a->edge.line.p1.x; + amax = a->edge.line.p2.x; + } else { + amin = a->edge.line.p2.x; + amax = a->edge.line.p1.x; + } + if (b->edge.line.p1.x < b->edge.line.p2.x) { + bmin = b->edge.line.p1.x; + bmax = b->edge.line.p2.x; + } else { + bmin = b->edge.line.p2.x; + bmax = b->edge.line.p1.x; + } + if (amax < bmin) return -1; + if (amin > bmax) return +1; + } + + ady = a->edge.line.p2.y - a->edge.line.p1.y; + adx = a->edge.line.p2.x - a->edge.line.p1.x; if (adx == 0) have_dx_adx_bdx &= ~HAVE_ADX; - bdy = b->bottom.y - b->top.y; - bdx = b->bottom.x - b->top.x; + bdy = b->edge.line.p2.y - b->edge.line.p1.y; + bdx = b->edge.line.p2.x - b->edge.line.p1.x; if (bdx == 0) have_dx_adx_bdx &= ~HAVE_BDX; - dx = a->top.x - b->top.x; + dx = a->edge.line.p1.x - b->edge.line.p1.x; if (dx == 0) have_dx_adx_bdx &= ~HAVE_DX; #define L _cairo_int64x32_128_mul (_cairo_int32x32_64_mul (ady, bdy), dx) -#define A _cairo_int64x32_128_mul (_cairo_int32x32_64_mul (adx, bdy), y - a->top.y) -#define B _cairo_int64x32_128_mul (_cairo_int32x32_64_mul (bdx, ady), y - b->top.y) +#define A _cairo_int64x32_128_mul (_cairo_int32x32_64_mul (adx, bdy), y - a->edge.line.p1.y) +#define B _cairo_int64x32_128_mul (_cairo_int32x32_64_mul (bdx, ady), y - b->edge.line.p1.y) switch (have_dx_adx_bdx) { default: case HAVE_NONE: @@ -304,7 +432,7 @@ edges_compare_x_for_y_general (const cairo_bo_edge_t *a, /* 0 ∘ (Y - B_y) * B_dx * A_dy - (Y - A_y) * A_dx * B_dy */ if ((adx ^ bdx) < 0) { return adx; - } else if (a->top.y == b->top.y) { /* common origin */ + } else if (a->edge.line.p1.y == b->edge.line.p1.y) { /* common origin */ cairo_int64_t adx_bdy, bdx_ady; /* ∴ A_dx * B_dy ∘ B_dx * A_dy */ @@ -323,7 +451,7 @@ edges_compare_x_for_y_general (const cairo_bo_edge_t *a, cairo_int64_t ady_dx, dy_adx; ady_dx = _cairo_int32x32_64_mul (ady, dx); - dy_adx = _cairo_int32x32_64_mul (a->top.y - y, adx); + dy_adx = _cairo_int32x32_64_mul (a->edge.line.p1.y - y, adx); return _cairo_int64_cmp (ady_dx, dy_adx); } @@ -335,11 +463,12 @@ edges_compare_x_for_y_general (const cairo_bo_edge_t *a, cairo_int64_t bdy_dx, dy_bdx; bdy_dx = _cairo_int32x32_64_mul (bdy, dx); - dy_bdx = _cairo_int32x32_64_mul (y - b->top.y, bdx); + dy_bdx = _cairo_int32x32_64_mul (y - b->edge.line.p1.y, bdx); return _cairo_int64_cmp (bdy_dx, dy_bdx); } case HAVE_ALL: + /* XXX try comparing (a->edge.line.p2.x - b->edge.line.p2.x) et al */ return _cairo_int128_cmp (L, _cairo_int128_sub (B, A)); } #undef B @@ -377,16 +506,21 @@ edge_compare_for_y_against_x (const cairo_bo_edge_t *a, int32_t dx, dy; cairo_int64_t L, R; - adx = a->bottom.x - a->top.x; - dx = x - a->top.x; + if (x < a->edge.line.p1.x && x < a->edge.line.p2.x) + return 1; + if (x > a->edge.line.p1.x && x > a->edge.line.p2.x) + return -1; + + adx = a->edge.line.p2.x - a->edge.line.p1.x; + dx = x - a->edge.line.p1.x; if (adx == 0) return -dx; - if ((adx ^ dx) < 0) + if (dx == 0 || (adx ^ dx) < 0) return adx; - dy = y - a->top.y; - ady = a->bottom.y - a->top.y; + dy = y - a->edge.line.p1.y; + ady = a->edge.line.p2.y - a->edge.line.p1.y; L = _cairo_int32x32_64_mul (dy, adx); R = _cairo_int32x32_64_mul (dx, ady); @@ -412,17 +546,17 @@ edges_compare_x_for_y (const cairo_bo_edge_t *a, } have_ax_bx = HAVE_BOTH; int32_t ax, bx; - if (y == a->top.y) - ax = a->top.x; - else if (y == a->bottom.y) - ax = a->bottom.x; + if (y == a->edge.line.p1.y) + ax = a->edge.line.p1.x; + else if (y == a->edge.line.p2.y) + ax = a->edge.line.p2.x; else have_ax_bx &= ~HAVE_AX; - if (y == b->top.y) - bx = b->top.x; - else if (y == b->bottom.y) - bx = b->bottom.x; + if (y == b->edge.line.p1.y) + bx = b->edge.line.p1.x; + else if (y == b->edge.line.p2.y) + bx = b->edge.line.p2.x; else have_ax_bx &= ~HAVE_BX; @@ -439,82 +573,59 @@ edges_compare_x_for_y (const cairo_bo_edge_t *a, } } +static inline int +_line_equal (const cairo_line_t *a, const cairo_line_t *b) +{ + return a->p1.x == b->p1.x && a->p1.y == b->p1.y && + a->p2.x == b->p2.x && a->p2.y == b->p2.y; +} + static int _cairo_bo_sweep_line_compare_edges (cairo_bo_sweep_line_t *sweep_line, - cairo_bo_edge_t *a, - cairo_bo_edge_t *b) + const cairo_bo_edge_t *a, + const cairo_bo_edge_t *b) { int cmp; - if (a == b) - return 0; - - /* don't bother solving for abscissa if the edges' bounding boxes - * can be used to order them. */ - { - int32_t amin, amax; - int32_t bmin, bmax; - if (a->middle.x < a->bottom.x) { - amin = a->middle.x; - amax = a->bottom.x; - } else { - amin = a->bottom.x; - amax = a->middle.x; - } - if (b->middle.x < b->bottom.x) { - bmin = b->middle.x; - bmax = b->bottom.x; - } else { - bmin = b->bottom.x; - bmax = b->middle.x; - } - if (amax < bmin) return -1; - if (amin > bmax) return +1; - } - - cmp = edges_compare_x_for_y (a, b, sweep_line->current_y); - if (cmp) - return cmp; + /* compare the edges if not identical */ + if (! _line_equal (&a->edge.line, &b->edge.line)) { + cmp = edges_compare_x_for_y (a, b, sweep_line->current_y); + if (cmp) + return cmp; - /* The two edges intersect exactly at y, so fall back on slope - * comparison. We know that this compare_edges function will be - * called only when starting a new edge, (not when stopping an - * edge), so we don't have to worry about conditionally inverting - * the sense of _slope_compare. */ - cmp = _slope_compare (a, b); - if (cmp) - return cmp; + /* The two edges intersect exactly at y, so fall back on slope + * comparison. We know that this compare_edges function will be + * called only when starting a new edge, (not when stopping an + * edge), so we don't have to worry about conditionally inverting + * the sense of _slope_compare. */ + cmp = _slope_compare (a, b); + if (cmp) + return cmp; - /* We've got two collinear edges now. */ + /* We've got two collinear edges now. */ - /* Since we're dealing with start events, prefer comparing top - * edges before bottom edges. */ - cmp = _cairo_bo_point32_compare (&a->top, &b->top); - if (cmp) - return cmp; + /* Since we're dealing with start events, prefer comparing top + * edges before bottom edges. */ + cmp = a->edge.top - b->edge.top; + if (cmp) + return cmp; - cmp = _cairo_bo_point32_compare (&a->bottom, &b->bottom); - if (cmp) - return cmp; + cmp = a->edge.bottom - b->edge.bottom; + if (cmp) + return cmp; + } - /* Finally, we've got two identical edges. Let's finally - * discriminate by a simple pointer comparison, (which works only - * because we "know" the edges are all in a single array and don't - * move. */ - if (a > b) - return 1; - else - return -1; + return a - b; } static int _sweep_line_elt_compare (void *list, - void *a, - void *b) + const void *a, + const void *b) { cairo_bo_sweep_line_t *sweep_line = list; - sweep_line_elt_t *edge_elt_a = a; - sweep_line_elt_t *edge_elt_b = b; + const sweep_line_elt_t *edge_elt_a = a; + const sweep_line_elt_t *edge_elt_b = b; return _cairo_bo_sweep_line_compare_edges (sweep_line, edge_elt_a->edge, @@ -522,157 +633,44 @@ _sweep_line_elt_compare (void *list, } static inline int -cairo_bo_event_compare (cairo_bo_event_t const *a, - cairo_bo_event_t const *b) +cairo_bo_event_compare (const cairo_bo_event_t *a, + const cairo_bo_event_t *b) { int cmp; - /* The major motion of the sweep line is vertical (top-to-bottom), - * and the minor motion is horizontal (left-to-right), dues to the - * infinitesimal tilt rule. - * - * Our point comparison function respects these rules. - */ cmp = _cairo_bo_point32_compare (&a->point, &b->point); if (cmp) return cmp; - /* The events share a common point, so further discrimination is - * determined by the event type. Due to the infinitesimal - * shortening rule, stop events come first, then intersection - * events, then start events. - */ - if (a->type != b->type) { - if (a->type == CAIRO_BO_EVENT_TYPE_STOP) - return -1; - if (a->type == CAIRO_BO_EVENT_TYPE_START) - return 1; - - if (b->type == CAIRO_BO_EVENT_TYPE_STOP) - return 1; - if (b->type == CAIRO_BO_EVENT_TYPE_START) - return -1; - } - - /* At this stage we are looking at two events of the same type at - * the same point. The final sort key is a slope comparison. We - * need a different sense for start and stop events based on the - * shortening rule. - * - * Note: Fortunately, we get to ignore errors in the relative - * ordering of intersection events. This means we don't even have - * to look at e2 here, nor worry about which sense of the slope - * comparison test is used for intersection events. - */ - cmp = _slope_compare (a->e1, b->e1); - if (cmp) { - if (a->type == CAIRO_BO_EVENT_TYPE_START) - return cmp; - else - return - cmp; - } - - /* Next look at the opposite point. This leaves ambiguities only - * for identical edges. */ - if (a->type == CAIRO_BO_EVENT_TYPE_START) { - cmp = _cairo_bo_point32_compare (&b->e1->bottom, - &a->e1->bottom); - if (cmp) - return cmp; - } - else if (a->type == CAIRO_BO_EVENT_TYPE_STOP) { - cmp = _cairo_bo_point32_compare (&a->e1->top, - &b->e1->top); - if (cmp) - return cmp; - } - else { /* CAIRO_BO_EVENT_TYPE_INTERSECT */ - /* For two intersection events at the identical point, we - * don't care what order they sort in, but we do care that we - * have a stable sort. In particular intersections between - * different pairs of edges must never return 0. */ - cmp = _cairo_bo_point32_compare (&a->e2->top, &b->e2->top); - if (cmp) - return cmp; - cmp = _cairo_bo_point32_compare (&a->e2->bottom, &b->e2->bottom); - if (cmp) - return cmp; - cmp = _cairo_bo_point32_compare (&a->e1->top, &b->e1->top); - if (cmp) - return cmp; - cmp = _cairo_bo_point32_compare (&a->e1->bottom, &b->e1->bottom); - if (cmp) - return cmp; - } - - /* Discrimination based on the edge pointers. */ - if (a->e1 < b->e1) - return -1; - if (a->e1 > b->e1) - return +1; - if (a->e2 < b->e2) - return -1; - if (a->e2 > b->e2) - return +1; - return 0; -} - -static int -cairo_bo_event_compare_abstract (void *list, - void *a, - void *b) -{ - cairo_bo_event_t *event_a = a; - cairo_bo_event_t *event_b = b; + cmp = a->type - b->type; + if (cmp) + return cmp; - return cairo_bo_event_compare (event_a, event_b); + return a - b; } static int -cairo_bo_event_compare_pointers (const cairo_bo_event_t *a, - const cairo_bo_event_t *b) +cairo_bo_event_compare_skiplist (void *list, const void *a, const void *b) { - int cmp; - - if (a == b) - return 0; - cmp = cairo_bo_event_compare (a, b); - if (cmp) - return cmp; - - return a - b; + return cairo_bo_event_compare (a, b); } static inline cairo_int64_t -det32_64 (int32_t a, - int32_t b, - int32_t c, - int32_t d) +det32_64 (int32_t a, int32_t b, + int32_t c, int32_t d) { - cairo_int64_t ad; - cairo_int64_t bc; - /* det = a * d - b * c */ - ad = _cairo_int32x32_64_mul (a, d); - bc = _cairo_int32x32_64_mul (b, c); - - return _cairo_int64_sub (ad, bc); + return _cairo_int64_sub (_cairo_int32x32_64_mul (a, d), + _cairo_int32x32_64_mul (b, c)); } static inline cairo_int128_t -det64x32_128 (cairo_int64_t a, - int32_t b, - cairo_int64_t c, - int32_t d) +det64x32_128 (cairo_int64_t a, int32_t b, + cairo_int64_t c, int32_t d) { - cairo_int128_t ad; - cairo_int128_t bc; - /* det = a * d - b * c */ - ad = _cairo_int64x32_128_mul (a, d); - bc = _cairo_int64x32_128_mul (c, b); - - return _cairo_int128_sub (ad, bc); + return _cairo_int128_sub (_cairo_int64x32_128_mul (a, d), + _cairo_int64x32_128_mul (c, b)); } /* Compute the intersection of two lines as defined by two edges. The @@ -681,7 +679,7 @@ det64x32_128 (cairo_int64_t a, * Returns %CAIRO_BO_STATUS_INTERSECTION if there is an intersection or * %CAIRO_BO_STATUS_PARALLEL if the two lines are exactly parallel. */ -static cairo_bo_status_t +static cairo_bool_t intersect_lines (cairo_bo_edge_t *a, cairo_bo_edge_t *b, cairo_bo_intersect_point_t *intersection) @@ -694,11 +692,11 @@ intersect_lines (cairo_bo_edge_t *a, * What we're doing to mitigate this is to perform clamping in * cairo_bo_tessellate_polygon(). */ - int32_t dx1 = a->top.x - a->bottom.x; - int32_t dy1 = a->top.y - a->bottom.y; + int32_t dx1 = a->edge.line.p1.x - a->edge.line.p2.x; + int32_t dy1 = a->edge.line.p1.y - a->edge.line.p2.y; - int32_t dx2 = b->top.x - b->bottom.x; - int32_t dy2 = b->top.y - b->bottom.y; + int32_t dx2 = b->edge.line.p1.x - b->edge.line.p2.x; + int32_t dy2 = b->edge.line.p1.y - b->edge.line.p2.y; cairo_int64_t den_det; cairo_int64_t R; @@ -706,7 +704,7 @@ intersect_lines (cairo_bo_edge_t *a, den_det = det32_64 (dx1, dy1, dx2, dy2); if (_cairo_int64_is_zero (den_det)) - return CAIRO_BO_STATUS_PARALLEL; + return FALSE; /* Q: Can we determine that the lines do not intersect (within range) * much more cheaply than computing the intersection point i.e. by @@ -727,58 +725,90 @@ intersect_lines (cairo_bo_edge_t *a, * A similar substitution can be performed for s, yielding: * s * (ady*bdx - bdy*adx) = ady * (ax - bx) - adx * (ay - by) */ - R = det32_64 (dx2, dy2, b->top.x - a->top.x, b->top.y - a->top.y); + R = det32_64 (dx2, dy2, + b->edge.line.p1.x - a->edge.line.p1.x, + b->edge.line.p1.y - a->edge.line.p1.y); if (_cairo_int64_is_zero (R)) - return CAIRO_BO_STATUS_NO_INTERSECTION; + return FALSE; if (_cairo_int64_negative (den_det) ^ _cairo_int64_negative (R)) - return CAIRO_BO_STATUS_NO_INTERSECTION; + return FALSE; if (_cairo_int64_negative (den_det)) { if (_cairo_int64_ge (den_det, R)) - return CAIRO_BO_STATUS_NO_INTERSECTION; + return FALSE; } else { if (_cairo_int64_le (den_det, R)) - return CAIRO_BO_STATUS_NO_INTERSECTION; + return FALSE; } - R = det32_64 (dy1, dx1, a->top.y - b->top.y, a->top.x - b->top.x); + R = det32_64 (dy1, dx1, + a->edge.line.p1.y - b->edge.line.p1.y, + a->edge.line.p1.x - b->edge.line.p1.x); if (_cairo_int64_is_zero (R)) - return CAIRO_BO_STATUS_NO_INTERSECTION; + return FALSE; if (_cairo_int64_negative (den_det) ^ _cairo_int64_negative (R)) - return CAIRO_BO_STATUS_NO_INTERSECTION; + return FALSE; if (_cairo_int64_negative (den_det)) { if (_cairo_int64_ge (den_det, R)) - return CAIRO_BO_STATUS_NO_INTERSECTION; + return FALSE; } else { if (_cairo_int64_le (den_det, R)) - return CAIRO_BO_STATUS_NO_INTERSECTION; + return FALSE; } /* We now know that the two lines should intersect within range. */ - a_det = det32_64 (a->top.x, a->top.y, - a->bottom.x, a->bottom.y); - b_det = det32_64 (b->top.x, b->top.y, - b->bottom.x, b->bottom.y); + a_det = det32_64 (a->edge.line.p1.x, a->edge.line.p1.y, + a->edge.line.p2.x, a->edge.line.p2.y); + b_det = det32_64 (b->edge.line.p1.x, b->edge.line.p1.y, + b->edge.line.p2.x, b->edge.line.p2.y); /* x = det (a_det, dx1, b_det, dx2) / den_det */ qr = _cairo_int_96by64_32x64_divrem (det64x32_128 (a_det, dx1, b_det, dx2), den_det); if (_cairo_int64_eq (qr.rem, den_det)) - return CAIRO_BO_STATUS_NO_INTERSECTION; - intersection->x.ordinate = _cairo_int64_to_int32 (qr.quo); + return FALSE; +#if 0 intersection->x.exactness = _cairo_int64_is_zero (qr.rem) ? EXACT : INEXACT; +#else + intersection->x.exactness = EXACT; + if (! _cairo_int64_is_zero (qr.rem)) { + if (_cairo_int64_negative (den_det) ^ _cairo_int64_negative (qr.rem)) + qr.rem = _cairo_int64_negate (qr.rem); + qr.rem = _cairo_int64_mul (qr.rem, _cairo_int32_to_int64 (2)); + if (_cairo_int64_ge (qr.rem, den_det)) { + qr.quo = _cairo_int64_add (qr.quo, + _cairo_int32_to_int64 (_cairo_int64_negative (qr.quo) ? -1 : 1)); + } else + intersection->x.exactness = INEXACT; + } +#endif + intersection->x.ordinate = _cairo_int64_to_int32 (qr.quo); /* y = det (a_det, dy1, b_det, dy2) / den_det */ qr = _cairo_int_96by64_32x64_divrem (det64x32_128 (a_det, dy1, b_det, dy2), den_det); if (_cairo_int64_eq (qr.rem, den_det)) - return CAIRO_BO_STATUS_NO_INTERSECTION; - intersection->y.ordinate = _cairo_int64_to_int32 (qr.quo); + return FALSE; +#if 0 intersection->y.exactness = _cairo_int64_is_zero (qr.rem) ? EXACT : INEXACT; +#else + intersection->y.exactness = EXACT; + if (! _cairo_int64_is_zero (qr.rem)) { + if (_cairo_int64_negative (den_det) ^ _cairo_int64_negative (qr.rem)) + qr.rem = _cairo_int64_negate (qr.rem); + qr.rem = _cairo_int64_mul (qr.rem, _cairo_int32_to_int64 (2)); + if (_cairo_int64_ge (qr.rem, den_det)) { + qr.quo = _cairo_int64_add (qr.quo, + _cairo_int32_to_int64 (_cairo_int64_negative (qr.quo) ? -1 : 1)); + } else + intersection->y.exactness = INEXACT; + } +#endif + intersection->y.ordinate = _cairo_int64_to_int32 (qr.quo); - return CAIRO_BO_STATUS_INTERSECTION; + return TRUE; } static int @@ -825,8 +855,10 @@ _cairo_bo_edge_contains_intersect_point (cairo_bo_edge_t *edge, * finder which needs them. */ - cmp_top = _cairo_bo_intersect_ordinate_32_compare (point->y, edge->top.y); - cmp_bottom = _cairo_bo_intersect_ordinate_32_compare (point->y, edge->bottom.y); + cmp_top = _cairo_bo_intersect_ordinate_32_compare (point->y, + edge->edge.top); + cmp_bottom = _cairo_bo_intersect_ordinate_32_compare (point->y, + edge->edge.bottom); if (cmp_top < 0 || cmp_bottom > 0) { @@ -849,10 +881,19 @@ _cairo_bo_edge_contains_intersect_point (cairo_bo_edge_t *edge, * edge, then the x value of the point must be less to be * considered as inside. */ - if (cmp_top == 0) - return (_cairo_bo_intersect_ordinate_32_compare (point->x, edge->top.x) > 0); - else /* cmp_bottom == 0 */ - return (_cairo_bo_intersect_ordinate_32_compare (point->x, edge->bottom.x) < 0); + if (cmp_top == 0) { + cairo_fixed_t top_x; + + top_x = _line_compute_intersection_x_for_y (&edge->edge.line, + edge->edge.top); + return _cairo_bo_intersect_ordinate_32_compare (point->x, top_x) > 0; + } else { /* cmp_bottom == 0 */ + cairo_fixed_t bot_x; + + bot_x = _line_compute_intersection_x_for_y (&edge->edge.line, + edge->edge.bottom); + return _cairo_bo_intersect_ordinate_32_compare (point->x, bot_x) < 0; + } } /* Compute the intersection of two edges. The result is provided as a @@ -871,23 +912,21 @@ _cairo_bo_edge_contains_intersect_point (cairo_bo_edge_t *edge, * effectively outside (no intersection is returned). Also, if the * intersection point has the same */ -static cairo_bo_status_t +static cairo_bool_t _cairo_bo_edge_intersect (cairo_bo_edge_t *a, cairo_bo_edge_t *b, cairo_bo_point32_t *intersection) { - cairo_bo_status_t status; cairo_bo_intersect_point_t quorem; - status = intersect_lines (a, b, &quorem); - if (status) - return status; + if (! intersect_lines (a, b, &quorem)) + return FALSE; if (! _cairo_bo_edge_contains_intersect_point (a, &quorem)) - return CAIRO_BO_STATUS_NO_INTERSECTION; + return FALSE; if (! _cairo_bo_edge_contains_intersect_point (b, &quorem)) - return CAIRO_BO_STATUS_NO_INTERSECTION; + return FALSE; /* Now that we've correctly compared the intersection point and * determined that it lies within the edge, then we know that we @@ -897,31 +936,32 @@ _cairo_bo_edge_intersect (cairo_bo_edge_t *a, intersection->x = quorem.x.ordinate; intersection->y = quorem.y.ordinate; - return CAIRO_BO_STATUS_INTERSECTION; + return TRUE; } static void -_cairo_bo_event_init (cairo_bo_event_t *event, - cairo_bo_event_type_t type, - cairo_bo_edge_t *e1, - cairo_bo_edge_t *e2, - cairo_bo_point32_t point) +_cairo_bo_skiplist_event_init (cairo_bo_skiplist_event_t *event, + cairo_bo_event_type_t type, + cairo_bo_edge_t *e1, + cairo_bo_edge_t *e2, + const cairo_point_t *point) { event->type = type; event->e1 = e1; event->e2 = e2; - event->point = point; + event->point = *point; } static cairo_status_t _cairo_bo_event_queue_insert (cairo_bo_event_queue_t *queue, - cairo_bo_event_t *event) + cairo_bo_skiplist_event_t *event) { cairo_status_t status = CAIRO_STATUS_SUCCESS; - /* Don't insert if there's already an equivalent intersection event in the queue. */ - if (_cairo_skip_list_insert (&queue->intersection_queue, event, - event->type == CAIRO_BO_EVENT_TYPE_INTERSECTION) == NULL) + + /* Only insert if there is no prior identical intersection event. */ + if (unlikely (_cairo_skip_list_insert (&queue->event_queue, event) == NULL)) status = _cairo_error (CAIRO_STATUS_NO_MEMORY); + return status; } @@ -929,126 +969,102 @@ static void _cairo_bo_event_queue_delete (cairo_bo_event_queue_t *queue, cairo_bo_event_t *event) { - if (CAIRO_BO_EVENT_TYPE_INTERSECTION == event->type) - _cairo_skip_list_delete_given ( &queue->intersection_queue, &event->elt ); + _cairo_skip_list_delete_given (&queue->event_queue, + &((cairo_bo_skiplist_event_t *) event)->elt); } +#define NEXT_EVENT(Q) \ + ((Q)->chains[0] ? SKIP_ELT_TO_EVENT ((Q)->chains[0]) : NULL) static cairo_bo_event_t * _cairo_bo_event_dequeue (cairo_bo_event_queue_t *event_queue) { - skip_elt_t *elt = event_queue->intersection_queue.chains[0]; - cairo_bo_event_t *intersection = elt ? SKIP_ELT_TO_EVENT (elt) : NULL; - cairo_bo_event_t *startstop; + cairo_bo_event_t *event, *cmp; - startstop = *event_queue->sorted_startstop_event_ptrs; - if (startstop == NULL) - return intersection; + event = NEXT_EVENT (&event_queue->event_queue); - if (intersection == NULL || - cairo_bo_event_compare (startstop, intersection) <= 0) + cmp = *event_queue->start_events; + if (event == NULL || + (cmp != NULL && cairo_bo_event_compare (cmp, event) < 0)) { - event_queue->sorted_startstop_event_ptrs++; - return startstop; + event = cmp; + event_queue->start_events++; } - return intersection; + return event; } CAIRO_COMBSORT_DECLARE (_cairo_bo_event_queue_sort, cairo_bo_event_t *, - cairo_bo_event_compare_pointers) + cairo_bo_event_compare) -static cairo_status_t -_cairo_bo_event_queue_init (cairo_bo_event_queue_t *event_queue, - cairo_bo_edge_t *edges, - int num_edges) +static void +_cairo_bo_event_queue_init (cairo_bo_event_queue_t *event_queue, + cairo_bo_event_t **start_events, + int num_events) { - int i; - cairo_bo_event_t *events, **sorted_event_ptrs; - unsigned num_events = 2*num_edges; - - /* The skip_elt_t field of a cairo_bo_event_t isn't used for start - * or stop events, so this allocation is safe. XXX: make the - * event type a union so it doesn't always contain the skip - * elt? */ - events = _cairo_malloc_ab_plus_c (num_events, - sizeof (cairo_bo_event_t) + - sizeof (cairo_bo_event_t *), - sizeof (cairo_bo_event_t *)); - if (unlikely (events == NULL)) - return _cairo_error (CAIRO_STATUS_NO_MEMORY); + _cairo_bo_event_queue_sort (start_events, num_events); + start_events[num_events] = NULL; - sorted_event_ptrs = (cairo_bo_event_t **) (events + num_events); - event_queue->startstop_events = events; - event_queue->sorted_startstop_event_ptrs = sorted_event_ptrs; + event_queue->start_events = start_events; - for (i = 0; i < num_edges; i++) { - sorted_event_ptrs[i] = &events[2*i]; - sorted_event_ptrs[i+num_edges] = &events[2*i+1]; - - /* Initialize "middle" to top */ - edges[i].middle = edges[i].top; - - _cairo_bo_event_init (&events[2*i], - CAIRO_BO_EVENT_TYPE_START, - &edges[i], NULL, - edges[i].top); - - _cairo_bo_event_init (&events[2*i+1], - CAIRO_BO_EVENT_TYPE_STOP, - &edges[i], NULL, - edges[i].bottom); - } + _cairo_skip_list_init (&event_queue->event_queue, + cairo_bo_event_compare_skiplist, + sizeof (cairo_bo_skiplist_event_t)); +} - _cairo_bo_event_queue_sort (sorted_event_ptrs, num_events); - event_queue->sorted_startstop_event_ptrs[num_events] = NULL; +static cairo_status_t +_cairo_bo_event_queue_insert_stop (cairo_bo_event_queue_t *event_queue, + cairo_bo_edge_t *edge) +{ + cairo_bo_point32_t point; + cairo_bo_skiplist_event_t event; - _cairo_skip_list_init (&event_queue->intersection_queue, - cairo_bo_event_compare_abstract, - sizeof (cairo_bo_event_t)); + point.y = edge->edge.bottom; + point.x = _line_compute_intersection_x_for_y (&edge->edge.line, + point.y); + _cairo_bo_skiplist_event_init (&event, + CAIRO_BO_EVENT_TYPE_STOP, + edge, NULL, + &point); - return CAIRO_STATUS_SUCCESS; + return _cairo_bo_event_queue_insert (event_queue, &event); } static void _cairo_bo_event_queue_fini (cairo_bo_event_queue_t *event_queue) { - _cairo_skip_list_fini (&event_queue->intersection_queue); - if (event_queue->startstop_events) - free (event_queue->startstop_events); + _cairo_skip_list_fini (&event_queue->event_queue); } -static cairo_status_t +static inline cairo_status_t _cairo_bo_event_queue_insert_if_intersect_below_current_y (cairo_bo_event_queue_t *event_queue, cairo_bo_edge_t *left, - cairo_bo_edge_t *right) + cairo_bo_edge_t *right) { - cairo_bo_status_t status; cairo_bo_point32_t intersection; - cairo_bo_event_t event; + cairo_bo_skiplist_event_t event; if (left == NULL || right == NULL) return CAIRO_STATUS_SUCCESS; + if (_line_equal (&left->edge.line, &right->edge.line)) + return CAIRO_STATUS_SUCCESS; + /* The names "left" and "right" here are correct descriptions of * the order of the two edges within the active edge list. So if a * slope comparison also puts left less than right, then we know - * that the intersection of these two segments has oalready + * that the intersection of these two segments has already * occurred before the current sweep line position. */ - if (_slope_compare (left, right) < 0) + if (_slope_compare (left, right) <= 0) return CAIRO_STATUS_SUCCESS; - status = _cairo_bo_edge_intersect (left, right, &intersection); - if (status == CAIRO_BO_STATUS_PARALLEL || - status == CAIRO_BO_STATUS_NO_INTERSECTION) - { + if (! _cairo_bo_edge_intersect (left, right, &intersection)) return CAIRO_STATUS_SUCCESS; - } - _cairo_bo_event_init (&event, - CAIRO_BO_EVENT_TYPE_INTERSECTION, - left, right, - intersection); + _cairo_bo_skiplist_event_init (&event, + CAIRO_BO_EVENT_TYPE_INTERSECTION, + left, right, + &intersection); return _cairo_bo_event_queue_insert (event_queue, &event); } @@ -1062,7 +1078,8 @@ _cairo_bo_sweep_line_init (cairo_bo_sweep_line_t *sweep_line) sweep_line->head = NULL; sweep_line->tail = NULL; - sweep_line->current_y = 0; + sweep_line->stopped = NULL; + sweep_line->current_y = INT32_MIN; } static void @@ -1079,14 +1096,13 @@ _cairo_bo_sweep_line_insert (cairo_bo_sweep_line_t *sweep_line, sweep_line_elt_t *sweep_line_elt; cairo_bo_edge_t **prev_of_next, **next_of_prev; - sweep_line_elt = _cairo_skip_list_insert (&sweep_line->active_edges, &edge, - 1 /* unique inserts*/); + sweep_line_elt = _cairo_skip_list_insert (&sweep_line->active_edges, &edge); if (unlikely (sweep_line_elt == NULL)) return _cairo_error (CAIRO_STATUS_NO_MEMORY); next_elt = sweep_line_elt->elt.next[0]; if (next_elt) - prev_of_next = & (SKIP_ELT_TO_EDGE (next_elt)->prev); + prev_of_next = &SKIP_ELT_TO_EDGE (next_elt)->prev; else prev_of_next = &sweep_line->tail; @@ -1170,8 +1186,8 @@ static void _cairo_bo_edge_print (cairo_bo_edge_t *edge) { printf ("(0x%x, 0x%x)-(0x%x, 0x%x)", - edge->top.x, edge->top.y, - edge->bottom.x, edge->bottom.y); + edge->edge.line.p1.x, edge->edge.line.p1.y, + edge->edge.line.p2.x, edge->edge.line.p2.y); } static void @@ -1201,19 +1217,14 @@ static void _cairo_bo_event_queue_print (cairo_bo_event_queue_t *event_queue) { skip_elt_t *elt; + /* XXX: fixme to print the start/stop array too. */ - cairo_skip_list_t *queue = &event_queue->intersection_queue; - cairo_bo_event_t *event; + cairo_skip_list_t *queue = &event_queue->event_queue; printf ("Event queue:\n"); - for (elt = queue->chains[0]; - elt; - elt = elt->next[0]) - { - event = SKIP_ELT_TO_EVENT (elt); - _cairo_bo_event_print (event); - } + for (elt = queue->chains[0]; elt; elt = elt->next[0]) + _cairo_bo_event_print (SKIP_ELT_TO_EVENT (elt)); } static void @@ -1266,140 +1277,18 @@ _cairo_bo_sweep_line_print (cairo_bo_sweep_line_t *sweep_line) static void print_state (const char *msg, + cairo_bo_event_t *event, cairo_bo_event_queue_t *event_queue, cairo_bo_sweep_line_t *sweep_line) { - printf ("%s\n", msg); + printf ("%s ", msg); + _cairo_bo_event_print (event); _cairo_bo_event_queue_print (event_queue); _cairo_bo_sweep_line_print (sweep_line); printf ("\n"); } #endif -/* Adds the trapezoid, if any, of the left edge to the #cairo_traps_t - * of bo_traps. */ -static cairo_status_t -_cairo_bo_edge_end_trap (cairo_bo_edge_t *left, - int32_t bot, - cairo_bo_traps_t *bo_traps) -{ - cairo_fixed_t fixed_top, fixed_bot; - cairo_bo_trap_t *trap = left->deferred_trap; - cairo_bo_edge_t *right; - - if (!trap) - return CAIRO_STATUS_SUCCESS; - - /* If the right edge of the trapezoid stopped earlier than the - * left edge, then cut the trapezoid bottom early. */ - right = trap->right; - if (right->bottom.y < bot) - bot = right->bottom.y; - - fixed_top = trap->top; - fixed_bot = bot; - - /* Only emit trapezoids with positive height. */ - if (fixed_top < fixed_bot) { - cairo_line_t left_line; - cairo_line_t right_line; - cairo_fixed_t xmin = bo_traps->xmin; - cairo_fixed_t ymin = bo_traps->ymin; - fixed_top += ymin; - fixed_bot += ymin; - - left_line.p1.x = left->top.x + xmin; - left_line.p1.y = left->top.y + ymin; - right_line.p1.x = right->top.x + xmin; - right_line.p1.y = right->top.y + ymin; - - left_line.p2.x = left->bottom.x + xmin; - left_line.p2.y = left->bottom.y + ymin; - right_line.p2.x = right->bottom.x + xmin; - right_line.p2.y = right->bottom.y + ymin; - - /* Avoid emitting the trapezoid if it is obviously degenerate. - * TODO: need a real collinearity test here for the cases - * where the trapezoid is degenerate, yet the top and bottom - * coordinates aren't equal. */ - if (left_line.p1.x != right_line.p1.x || - left_line.p1.y != right_line.p1.y || - left_line.p2.x != right_line.p2.x || - left_line.p2.y != right_line.p2.y) - { - _cairo_traps_add_trap (bo_traps->traps, - fixed_top, fixed_bot, - &left_line, &right_line); - -#if DEBUG_PRINT_STATE - printf ("Deferred trap: left=(%08x, %08x)-(%08x,%08x) " - "right=(%08x,%08x)-(%08x,%08x) top=%08x, bot=%08x\n", - left->top.x, left->top.y, left->bottom.x, left->bottom.y, - right->top.x, right->top.y, right->bottom.x, right->bottom.y, - trap->top, bot); -#endif - } - } - - _cairo_freelist_free (&bo_traps->freelist, trap); - left->deferred_trap = NULL; - - return _cairo_traps_status (bo_traps->traps); -} - -/* Start a new trapezoid at the given top y coordinate, whose edges - * are `edge' and `edge->next'. If `edge' already has a trapezoid, - * then either add it to the traps in `bo_traps', if the trapezoid's - * right edge differs from `edge->next', or do nothing if the new - * trapezoid would be a continuation of the existing one. */ -static cairo_status_t -_cairo_bo_edge_start_or_continue_trap (cairo_bo_edge_t *edge, - int32_t top, - cairo_bo_traps_t *bo_traps) -{ - cairo_status_t status; - cairo_bo_trap_t *trap = edge->deferred_trap; - - if (trap) { - if (trap->right == edge->next) return CAIRO_STATUS_SUCCESS; - status = _cairo_bo_edge_end_trap (edge, top, bo_traps); - if (status) - return status; - } - - if (edge->next) { - trap = edge->deferred_trap = _cairo_freelist_alloc (&bo_traps->freelist); - if (!edge->deferred_trap) - return _cairo_error (CAIRO_STATUS_NO_MEMORY); - - trap->right = edge->next; - trap->top = top; - } - return CAIRO_STATUS_SUCCESS; -} - -static void -_cairo_bo_traps_init (cairo_bo_traps_t *bo_traps, - cairo_traps_t *traps, - cairo_fixed_t xmin, - cairo_fixed_t ymin, - cairo_fixed_t xmax, - cairo_fixed_t ymax) -{ - bo_traps->traps = traps; - _cairo_freelist_init (&bo_traps->freelist, sizeof(cairo_bo_trap_t)); - bo_traps->xmin = xmin; - bo_traps->ymin = ymin; - bo_traps->xmax = xmax; - bo_traps->ymax = ymax; -} - -static void -_cairo_bo_traps_fini (cairo_bo_traps_t *bo_traps) -{ - _cairo_freelist_fini (&bo_traps->freelist); -} - #if DEBUG_VALIDATE static void _cairo_bo_sweep_line_validate (cairo_bo_sweep_line_t *sweep_line) @@ -1428,184 +1317,403 @@ _cairo_bo_sweep_line_validate (cairo_bo_sweep_line_t *sweep_line) } #endif +#if DEBUG_EVENTS +static void CAIRO_PRINTF_FORMAT (1, 2) +event_log (const char *fmt, ...) +{ + FILE *file; + + if (getenv ("CAIRO_DEBUG_EVENTS") == NULL) + return; + + file = fopen ("bo-events.txt", "a"); + if (file != NULL) { + va_list ap; + + va_start (ap, fmt); + vfprintf (file, fmt, ap); + va_end (ap); + + fclose (file); + } +} +#endif + +static inline cairo_bool_t +edges_colinear (const cairo_bo_edge_t *a, const cairo_bo_edge_t *b) +{ + if (_line_equal (&a->edge.line, &b->edge.line)) + return TRUE; + + /* The choice of y is not truly arbitrary since we must guarantee that it + * is greater than the start of either line. + */ + return _slope_compare (a, b) == 0 && + edges_compare_x_for_y (a, b, + MAX (a->edge.line.p1.y, + b->edge.line.p1.y)) == 0; +} +/* Adds the trapezoid, if any, of the left edge to the #cairo_traps_t */ static cairo_status_t -_active_edges_to_traps (cairo_bo_edge_t *head, +_cairo_bo_edge_end_trap (cairo_bo_edge_t *left, + int32_t bot, + cairo_traps_t *traps) +{ + cairo_bo_trap_t *trap = &left->deferred_trap; + + /* Only emit (trivial) non-degenerate trapezoids with positive height. */ + if (likely (trap->top < bot && ! edges_colinear (left, trap->right))) { + assert (trap->right->edge.bottom >= bot); + _cairo_traps_add_trap (traps, + trap->top, bot, + &left->edge.line, &trap->right->edge.line); + +#if DEBUG_PRINT_STATE + printf ("Deferred trap: left=(%x, %x)-(%x,%x) " + "right=(%x,%x)-(%x,%x) top=%x, bot=%x\n", + left->edge.line.p1.x, left->edge.line.p1.y, + left->edge.line.p2.x, left->edge.line.p2.y, + trap->right->edge.line.p1.x, trap->right->edge.line.p1.y, + trap->right->edge.line.p2.x, trap->right->edge.line.p2.y, + trap->top, bot); +#endif +#if DEBUG_EVENTS + event_log ("end trap: %lu %lu %d %d\n", + (long) left, + (long) trap->right, + trap->top, + bot); +#endif + } + + trap->right = NULL; + + return _cairo_traps_status (traps); +} + + +/* Start a new trapezoid at the given top y coordinate, whose edges + * are `edge' and `edge->next'. If `edge' already has a trapezoid, + * then either add it to the traps in `traps', if the trapezoid's + * right edge differs from `edge->next', or do nothing if the new + * trapezoid would be a continuation of the existing one. */ +static inline cairo_status_t +_cairo_bo_edge_start_or_continue_trap (cairo_bo_edge_t *left, + cairo_bo_edge_t *right, + int top, + cairo_traps_t *traps) +{ + cairo_status_t status; + + if (left->deferred_trap.right == right) + return CAIRO_STATUS_SUCCESS; + + if (left->deferred_trap.right != NULL) { + if (right != NULL && edges_colinear (left->deferred_trap.right, right)) + { + /* continuation on right, so just swap edges */ + left->deferred_trap.right = right; + return CAIRO_STATUS_SUCCESS; + } + + status = _cairo_bo_edge_end_trap (left, top, traps); + if (unlikely (status)) + return status; + } + + if (right != NULL) { + left->deferred_trap.top = top; + left->deferred_trap.right = right; + +#if DEBUG_EVENTS + event_log ("begin trap: %lu %lu %d\n", + (long) left, + (long) right, + top); +#endif + } + + return CAIRO_STATUS_SUCCESS; +} + +static inline cairo_status_t +_active_edges_to_traps (cairo_bo_edge_t *left, int32_t top, cairo_fill_rule_t fill_rule, - cairo_bo_traps_t *bo_traps) + cairo_traps_t *traps) { + cairo_bo_edge_t *right; cairo_status_t status; - int in_out = 0; - cairo_bo_edge_t *edge; - for (edge = head; edge; edge = edge->next) { - if (fill_rule == CAIRO_FILL_RULE_WINDING) { - in_out += edge->dir; - if (in_out == 0) { - status = _cairo_bo_edge_end_trap (edge, top, bo_traps); - if (status) - return status; - continue; +#if DEBUG_PRINT_STATE + printf ("Processing active edges for %x\n", top); +#endif + + if (fill_rule == CAIRO_FILL_RULE_WINDING) { + while (left != NULL) { + int in_out; + + /* Greedily search for the closing edge, so that we generate the + * maximal span width with the minimal number of trapezoids. + */ + in_out = left->edge.dir; + + /* Check if there is a co-linear edge with an existing trap */ + right = left->next; + if (left->deferred_trap.right == NULL) { + while (right != NULL && right->deferred_trap.right == NULL) + right = right->next; + + if (right != NULL && edges_colinear (left, right)) { + /* continuation on left */ + left->deferred_trap = right->deferred_trap; + right->deferred_trap.right = NULL; + } } - } else { - in_out++; - if ((in_out & 1) == 0) { - status = _cairo_bo_edge_end_trap (edge, top, bo_traps); - if (status) - return status; - continue; + + /* End all subsumed traps */ + right = left->next; + while (right != NULL) { + if (right->deferred_trap.right != NULL) { + status = _cairo_bo_edge_end_trap (right, top, traps); + if (unlikely (status)) + return status; + } + + in_out += right->edge.dir; + if (in_out == 0) { + cairo_bo_edge_t *next; + cairo_bool_t skip = FALSE; + + /* skip co-linear edges */ + next = right->next; + if (next != NULL) + skip = edges_colinear (right, next); + + if (! skip) + break; + } + + right = right->next; } + + status = _cairo_bo_edge_start_or_continue_trap (left, right, + top, traps); + if (unlikely (status)) + return status; + + left = right; + if (left != NULL) + left = left->next; } + } else { + while (left != NULL) { + int in_out = 0; + + right = left->next; + while (right != NULL) { + if (right->deferred_trap.right != NULL) { + status = _cairo_bo_edge_end_trap (right, top, traps); + if (unlikely (status)) + return status; + } - status = _cairo_bo_edge_start_or_continue_trap (edge, top, bo_traps); - if (status) - return status; + if ((in_out++ & 1) == 0) { + cairo_bo_edge_t *next; + cairo_bool_t skip = FALSE; + + /* skip co-linear edges */ + next = right->next; + if (next != NULL) + skip = edges_colinear (right, next); + + if (! skip) + break; + } + + right = right->next; + } + + status = _cairo_bo_edge_start_or_continue_trap (left, right, + top, traps); + if (unlikely (status)) + return status; + + left = right; + if (left != NULL) + left = left->next; + } } return CAIRO_STATUS_SUCCESS; } + /* Execute a single pass of the Bentley-Ottmann algorithm on edges, * generating trapezoids according to the fill_rule and appending them * to traps. */ static cairo_status_t -_cairo_bentley_ottmann_tessellate_bo_edges (cairo_bo_edge_t *edges, - int num_edges, +_cairo_bentley_ottmann_tessellate_bo_edges (cairo_bo_event_t **start_events, + int num_events, cairo_fill_rule_t fill_rule, cairo_traps_t *traps, - cairo_fixed_t xmin, - cairo_fixed_t ymin, - cairo_fixed_t xmax, - cairo_fixed_t ymax, int *num_intersections) { - cairo_status_t status; + cairo_status_t status = CAIRO_STATUS_SUCCESS; /* silence compiler */ int intersection_count = 0; cairo_bo_event_queue_t event_queue; cairo_bo_sweep_line_t sweep_line; - cairo_bo_traps_t bo_traps; - cairo_bo_event_t *event, event_saved; - cairo_bo_edge_t *edge; + cairo_bo_event_t *event; cairo_bo_edge_t *left, *right; - cairo_bo_edge_t *edge1, *edge2; - - if (num_edges == 0) - return CAIRO_STATUS_SUCCESS; - - status = _cairo_bo_event_queue_init (&event_queue, edges, num_edges); - if (status) - return status; - - _cairo_bo_sweep_line_init (&sweep_line); - - _cairo_bo_traps_init (&bo_traps, traps, xmin, ymin, xmax, ymax); + cairo_bo_edge_t *e1, *e2; -#if DEBUG_PRINT_STATE - print_state ("After initializing", &event_queue, &sweep_line); +#if DEBUG_EVENTS + { + int i; + + for (i = 0; i < num_events; i++) { + cairo_bo_start_event_t *event = + ((cairo_bo_start_event_t **) start_events)[i]; + event_log ("edge: %lu (%d, %d) (%d, %d) (%d, %d) %d\n", + (long) &events[i].edge, + event->edge.edge.line.p1.x, + event->edge.edge.line.p1.y, + event->edge.edge.line.p2.x, + event->edge.edge.line.p2.y, + event->edge.top, + event->edge.bottom, + event->edge.edge.dir); + } + } #endif - while (1) - { - event = _cairo_bo_event_dequeue (&event_queue); - if (!event) - break; + _cairo_bo_event_queue_init (&event_queue, start_events, num_events); + _cairo_bo_sweep_line_init (&sweep_line); + while ((event = _cairo_bo_event_dequeue (&event_queue))) { if (event->point.y != sweep_line.current_y) { + for (e1 = sweep_line.stopped; e1; e1 = e1->next) { + if (e1->deferred_trap.right != NULL) { + status = _cairo_bo_edge_end_trap (e1, + e1->edge.bottom, + traps); + if (unlikely (status)) + goto unwind; + } + } + sweep_line.stopped = NULL; + status = _active_edges_to_traps (sweep_line.head, sweep_line.current_y, - fill_rule, &bo_traps); - if (status) + fill_rule, traps); + if (unlikely (status)) goto unwind; sweep_line.current_y = event->point.y; } - event_saved = *event; - _cairo_bo_event_queue_delete (&event_queue, event); - event = &event_saved; +#if DEBUG_EVENTS + event_log ("event: %d (%ld, %ld) %lu, %lu\n", + event->type, + (long) event->point.x, + (long) event->point.y, + (long) event->e1, + (long) event->e2); +#endif switch (event->type) { case CAIRO_BO_EVENT_TYPE_START: - edge = event->e1; + e1 = &((cairo_bo_start_event_t *) event)->edge; + + status = _cairo_bo_sweep_line_insert (&sweep_line, e1); + if (unlikely (status)) + goto unwind; - status = _cairo_bo_sweep_line_insert (&sweep_line, edge); - if (status) + status = _cairo_bo_event_queue_insert_stop (&event_queue, e1); + if (unlikely (status)) goto unwind; - /* Cache the insert position for use in pass 2. - event->e2 = Sortlist::prev (sweep_line, edge); - */ - left = edge->prev; - right = edge->next; + /* check to see if this is a continuation of a stopped edge */ + /* XXX change to an infinitesimal lengthening rule */ + for (left = sweep_line.stopped; left; left = left->next) { + if (e1->edge.top <= left->edge.bottom && + edges_colinear (e1, left)) + { + e1->deferred_trap = left->deferred_trap; + if (left->prev != NULL) + left->prev = left->next; + else + sweep_line.stopped = left->next; + if (left->next != NULL) + left->next->prev = left->prev; + break; + } + } + + left = e1->prev; + right = e1->next; - status = _cairo_bo_event_queue_insert_if_intersect_below_current_y (&event_queue, left, edge); - if (status) + status = _cairo_bo_event_queue_insert_if_intersect_below_current_y (&event_queue, left, e1); + if (unlikely (status)) goto unwind; - status = _cairo_bo_event_queue_insert_if_intersect_below_current_y (&event_queue, edge, right); - if (status) + status = _cairo_bo_event_queue_insert_if_intersect_below_current_y (&event_queue, e1, right); + if (unlikely (status)) goto unwind; -#if DEBUG_PRINT_STATE - print_state ("After processing start", &event_queue, &sweep_line); -#endif break; case CAIRO_BO_EVENT_TYPE_STOP: - edge = event->e1; + e1 = ((cairo_bo_skiplist_event_t *) event)->e1; + _cairo_bo_event_queue_delete (&event_queue, event); - left = edge->prev; - right = edge->next; + left = e1->prev; + right = e1->next; - _cairo_bo_sweep_line_delete (&sweep_line, edge); + _cairo_bo_sweep_line_delete (&sweep_line, e1); - status = _cairo_bo_edge_end_trap (edge, edge->bottom.y, &bo_traps); - if (status) - goto unwind; + /* first, check to see if we have a continuation via a fresh edge */ + if (e1->deferred_trap.right != NULL) { + e1->next = sweep_line.stopped; + if (sweep_line.stopped != NULL) + sweep_line.stopped->prev = e1; + sweep_line.stopped = e1; + e1->prev = NULL; + } status = _cairo_bo_event_queue_insert_if_intersect_below_current_y (&event_queue, left, right); - if (status) + if (unlikely (status)) goto unwind; -#if DEBUG_PRINT_STATE - print_state ("After processing stop", &event_queue, &sweep_line); -#endif break; case CAIRO_BO_EVENT_TYPE_INTERSECTION: - edge1 = event->e1; - edge2 = event->e2; + e1 = ((cairo_bo_skiplist_event_t *) event)->e1; + e2 = ((cairo_bo_skiplist_event_t *) event)->e2; + _cairo_bo_event_queue_delete (&event_queue, event); /* skip this intersection if its edges are not adjacent */ - if (edge2 != edge1->next) + if (e2 != e1->next) break; intersection_count++; - edge1->middle = event->point; - edge2->middle = event->point; + left = e1->prev; + right = e2->next; - left = edge1->prev; - right = edge2->next; - - _cairo_bo_sweep_line_swap (&sweep_line, edge1, edge2); + _cairo_bo_sweep_line_swap (&sweep_line, e1, e2); /* after the swap e2 is left of e1 */ - status = _cairo_bo_event_queue_insert_if_intersect_below_current_y (&event_queue, - left, edge2); - if (status) + status = _cairo_bo_event_queue_insert_if_intersect_below_current_y (&event_queue, left, e2); + if (unlikely (status)) goto unwind; - status = _cairo_bo_event_queue_insert_if_intersect_below_current_y (&event_queue, - edge1, right); - if (status) + status = _cairo_bo_event_queue_insert_if_intersect_below_current_y (&event_queue, e1, right); + if (unlikely (status)) goto unwind; -#if DEBUG_PRINT_STATE - print_state ("After processing intersection", &event_queue, &sweep_line); -#endif break; } #if DEBUG_VALIDATE @@ -1614,29 +1722,22 @@ _cairo_bentley_ottmann_tessellate_bo_edges (cairo_bo_edge_t *edges, } *num_intersections = intersection_count; - unwind: - for (edge = sweep_line.head; edge; edge = edge->next) { - cairo_status_t status2 = _cairo_bo_edge_end_trap (edge, - sweep_line.current_y, - &bo_traps); - if (!status) - status = status2; + for (e1 = sweep_line.stopped; e1; e1 = e1->next) { + if (e1->deferred_trap.right != NULL) { + status = _cairo_bo_edge_end_trap (e1, e1->edge.bottom, traps); + if (unlikely (status)) + break; + } } - _cairo_bo_traps_fini (&bo_traps); + unwind: _cairo_bo_sweep_line_fini (&sweep_line); _cairo_bo_event_queue_fini (&event_queue); - return status; -} -static void -update_minmax(cairo_fixed_t *inout_min, - cairo_fixed_t *inout_max, - cairo_fixed_t v) -{ - if (v < *inout_min) - *inout_min = v; - if (v > *inout_max) - *inout_max = v; +#if DEBUG_EVENTS + event_log ("\n"); +#endif + + return status; } cairo_status_t @@ -1646,116 +1747,332 @@ _cairo_bentley_ottmann_tessellate_polygon (cairo_traps_t *traps, { int intersections; cairo_status_t status; - cairo_bo_edge_t stack_edges[CAIRO_STACK_ARRAY_LENGTH (cairo_bo_edge_t)]; - cairo_bo_edge_t *edges; - cairo_fixed_t xmin = 0x7FFFFFFF; - cairo_fixed_t ymin = 0x7FFFFFFF; - cairo_fixed_t xmax = -0x80000000; - cairo_fixed_t ymax = -0x80000000; - cairo_box_t limit; - cairo_bool_t has_limits; - int num_bo_edges; + cairo_bo_start_event_t stack_events[CAIRO_STACK_ARRAY_LENGTH (cairo_bo_start_event_t)]; + cairo_bo_start_event_t *events; + cairo_bo_event_t *stack_event_ptrs[ARRAY_LENGTH (stack_events) + 1]; + cairo_bo_event_t **event_ptrs; + int num_events; int i; - if (0 == polygon->num_edges) + num_events = polygon->num_edges; + if (unlikely (0 == num_events)) return CAIRO_STATUS_SUCCESS; - if (CAIRO_INJECT_FAULT ()) - return _cairo_error (CAIRO_STATUS_NO_MEMORY); - - has_limits = _cairo_traps_get_limit (traps, &limit); - - edges = stack_edges; - if (polygon->num_edges > ARRAY_LENGTH (stack_edges)) { - edges = _cairo_malloc_ab (polygon->num_edges, sizeof (cairo_bo_edge_t)); - if (unlikely (edges == NULL)) + events = stack_events; + event_ptrs = stack_event_ptrs; + if (num_events > ARRAY_LENGTH (stack_events)) { + events = _cairo_malloc_ab_plus_c (num_events, + sizeof (cairo_bo_start_event_t) + + sizeof (cairo_bo_event_t *), + sizeof (cairo_bo_event_t *)); + if (unlikely (events == NULL)) return _cairo_error (CAIRO_STATUS_NO_MEMORY); - } - /* Figure out the bounding box of the input coordinates and - * validate that we're not given invalid polygon edges. */ - for (i = 0; i < polygon->num_edges; i++) { - update_minmax (&xmin, &xmax, polygon->edges[i].edge.p1.x); - update_minmax (&ymin, &ymax, polygon->edges[i].edge.p1.y); - update_minmax (&xmin, &xmax, polygon->edges[i].edge.p2.x); - update_minmax (&ymin, &ymax, polygon->edges[i].edge.p2.y); - assert (polygon->edges[i].edge.p1.y <= polygon->edges[i].edge.p2.y && - "BUG: tessellator given upside down or horizontal edges"); + event_ptrs = (cairo_bo_event_t **) (events + num_events); } - /* The tessellation functions currently assume that no line - * segment extends more than 2^31-1 in either dimension. We - * guarantee this by offsetting the internal coordinates to the - * range [0,2^31-1], and clamping to 2^31-1 if a coordinate - * exceeds the range (and yes, this generates an incorrect - * result). First we have to clamp the bounding box itself. */ - /* XXX: Rather than changing the input values, a better approach - * would be to detect out-of-bounds input and return a - * CAIRO_STATUS_OVERFLOW value to the user. */ - if (xmax - xmin < 0) - xmax = xmin + 0x7FFFFFFF; - if (ymax - ymin < 0) - ymax = ymin + 0x7FFFFFFF; - - for (i = 0, num_bo_edges = 0; i < polygon->num_edges; i++) { - cairo_bo_edge_t *edge = &edges[num_bo_edges]; - cairo_point_t top = polygon->edges[i].edge.p1; - cairo_point_t bot = polygon->edges[i].edge.p2; - - /* Discard the edge if it lies outside the limits of traps. */ - if (has_limits) { - /* Strictly above or below the limits? */ - if (bot.y <= limit.p1.y || top.y >= limit.p2.y) - continue; - } + for (i = 0; i < num_events; i++) { + event_ptrs[i] = (cairo_bo_event_t *) &events[i]; - /* Offset coordinates into the non-negative range. */ - top.x -= xmin; - top.y -= ymin; - bot.x -= xmin; - bot.y -= ymin; - - /* If the coordinates are still negative, then their extent is - * overflowing 2^31-1. We're going to kludge it and clamp the - * coordinates into the clamped bounding box. */ - if (top.x < 0) top.x = xmax - xmin; - if (top.y < 0) top.y = ymax - ymin; - if (bot.x < 0) bot.x = xmax - xmin; - if (bot.y < 0) bot.y = ymax - ymin; - - if (top.y == bot.y) { - /* Clamping might have produced horizontal edges. Ignore - * those. */ - continue; - } - assert (top.y < bot.y && - "BUG: clamping the input range flipped the " - "orientation of an edge"); - - edge->top.x = top.x; - edge->top.y = top.y; - edge->bottom.x = bot.x; - edge->bottom.y = bot.y; - edge->dir = polygon->edges[i].dir; - edge->deferred_trap = NULL; - edge->prev = NULL; - edge->next = NULL; - edge->sweep_line_elt = NULL; - - num_bo_edges++; + events[i].type = CAIRO_BO_EVENT_TYPE_START; + events[i].point.y = polygon->edges[i].top; + events[i].point.x = + _line_compute_intersection_x_for_y (&polygon->edges[i].line, + events[i].point.y); + + events[i].edge.edge = polygon->edges[i]; + events[i].edge.deferred_trap.right = NULL; + events[i].edge.prev = NULL; + events[i].edge.next = NULL; + events[i].edge.sweep_line_elt = NULL; } +#if DEBUG_TRAPS + dump_edges (events, num_events, "bo-polygon-edges.txt"); +#endif + /* XXX: This would be the convenient place to throw in multiple * passes of the Bentley-Ottmann algorithm. It would merely * require storing the results of each pass into a temporary * cairo_traps_t. */ - status = _cairo_bentley_ottmann_tessellate_bo_edges (edges, num_bo_edges, + status = _cairo_bentley_ottmann_tessellate_bo_edges (event_ptrs, + num_events, fill_rule, traps, - xmin, ymin, xmax, ymax, &intersections); +#if DEBUG_TRAPS + dump_traps (traps, "bo-polygon-out.txt"); +#endif - if (edges != stack_edges) - free (edges); + if (events != stack_events) + free (events); + + return status; +} + +static cairo_bool_t +_points_outside (const cairo_fixed_t *x, const cairo_box_t *limits) +{ + if (x[0] < limits->p1.x || x[0] > limits->p2.x) + return TRUE; + if (x[1] < limits->p1.x || x[1] > limits->p2.x) + return TRUE; + if (x[2] < limits->p1.x || x[2] > limits->p2.x) + return TRUE; + if (x[3] < limits->p1.x || x[3] > limits->p2.x) + return TRUE; + + return FALSE; +} + +static int +_add_event (const cairo_line_t *line, + int32_t top, int32_t bottom, + int dir, + cairo_bo_start_event_t *event) +{ + if (top == bottom) + return 0; + + event->type = CAIRO_BO_EVENT_TYPE_START; + event->point.y = top; + event->point.x = _line_compute_intersection_x_for_y (line, top); + + event->edge.edge.line = *line; + event->edge.edge.top = top; + event->edge.edge.bottom = bottom; + event->edge.edge.dir = dir; + + event->edge.deferred_trap.right = NULL; + event->edge.prev = NULL; + event->edge.next = NULL; + event->edge.sweep_line_elt = NULL; + + return 1; +} + +static int +_compute_clipped_trapezoid_edges (const cairo_traps_t *traps, + const cairo_trapezoid_t *t, + cairo_bo_start_event_t *events) +{ + cairo_fixed_t x[4]; + int num_events = 0; + int top, bot; + + /* compute points in clockwise orientation */ + top = t->top; + bot = t->bottom; + + x[0] = _line_compute_intersection_x_for_y (&t->left, top); + x[1] = _line_compute_intersection_x_for_y (&t->right, top); + x[2] = _line_compute_intersection_x_for_y (&t->right, bot); + x[3] = _line_compute_intersection_x_for_y (&t->left, bot); + + if (traps->has_limits && _points_outside (x, &traps->limits)) { + cairo_line_t limits[2]; + cairo_fixed_t ly[2], ry[2]; + cairo_fixed_t ymin, ymax; + + limits[0].p1.x = traps->limits.p1.x; + limits[0].p1.y = traps->limits.p1.y; + limits[0].p2.x = traps->limits.p1.x; + limits[0].p2.y = traps->limits.p2.y; + + limits[1].p1.x = traps->limits.p2.x; + limits[1].p1.y = traps->limits.p1.y; + limits[1].p2.x = traps->limits.p2.x; + limits[1].p2.y = traps->limits.p2.y; + + ly[0] = _line_compute_intersection_y_for_x (&t->left, + traps->limits.p1.x); + ymin = ymax = ly[0]; + + ly[1] = _line_compute_intersection_y_for_x (&t->left, + traps->limits.p2.x); + if (ly[1] < ymin) + ymin = ly[1]; + if (ly[1] > ymax) + ymax = ly[1]; + + ry[0] = _line_compute_intersection_y_for_x (&t->right, + traps->limits.p1.x); + if (ry[0] < ymin) + ymin = ry[0]; + if (ry[0] > ymax) + ymax = ry[0]; + + ry[1] = _line_compute_intersection_y_for_x (&t->right, + traps->limits.p2.x); + if (ry[1] < ymin) + ymin = ry[1]; + if (ry[1] > ymax) + ymax = ry[1]; + + if (ymin > top) + top = ymin; + if (ymax < bot) + bot = ymax; + if (top >= bot) + return 0; + + /* left hand side intersects */ + + if (x[0] <= traps->limits.p1.x && x[3] <= traps->limits.p1.x) + { + num_events += _add_event (&limits[0], top, bot, 1, + events + num_events); + } + else if (x[0] >= traps->limits.p1.x && x[3] >= traps->limits.p1.x && + x[0] <= traps->limits.p2.x && x[3] <= traps->limits.p2.x) + { + num_events += _add_event (&t->left, top, bot, 1, + events + num_events); + } + else + { + if (ly[0] < ly[1]) { + if (ly[1] >= top) { + if (ly[0] < top) + ly[0] = top; + if (ly[1] > bot) + ly[1] = bot; + num_events += _add_event (&limits[0], top, ly[0], 1, + events + num_events); + num_events += _add_event (&t->left, ly[0], ly[1], 1, + events + num_events); + num_events += _add_event (&limits[1], ly[1], bot, 1, + events + num_events); + } + } else { + if (ly[1] <= bot) { + if (ly[1] < top) + ly[1] = top; + if (ly[0] > bot) + ly[0] = bot; + num_events += _add_event (&limits[1], top, ly[1], 1, + events + num_events); + num_events += _add_event (&t->left, ly[1], ly[0], 1, + events + num_events); + num_events += _add_event (&limits[0], ly[0], bot, 1, + events + num_events); + } + } + } + + /* right hand side intersects */ + + if (x[1] >= traps->limits.p2.x && x[2] >= traps->limits.p2.x) + { + num_events += _add_event (&limits[1], top, bot, -1, + events + num_events); + } + else if (x[1] <= traps->limits.p2.x && x[2] <= traps->limits.p2.x && + x[1] >= traps->limits.p1.x && x[2] >= traps->limits.p1.x) + { + num_events += _add_event (&t->right, top, bot, -1, + events + num_events); + } + else + { + if (ry[0] < ry[1]) { + if (ry[0] <= bot) { + if (ry[0] < top) + ry[0] = top; + if (ry[1] > bot) + ry[1] = bot; + num_events += _add_event (&limits[0], top, ry[0], -1, + events + num_events); + num_events += _add_event (&t->right, ry[0], ry[1], -1, + events + num_events); + num_events += _add_event (&limits[1], ry[1], bot, -1, + events + num_events); + } + } else { + if (ry[0] >= top) { + if (ry[0] > bot) + ry[0] = bot; + if (ry[1] < top) + ry[1] = top; + num_events += _add_event (&limits[1], top, ry[1], -1, + events + num_events); + num_events += _add_event (&t->right, ry[1], ry[0], -1, + events + num_events); + num_events += _add_event (&limits[0], ry[0], bot, -1, + events + num_events); + } + } + } + } else { + num_events += _add_event (&t->left, top, bot, 1, events + num_events); + num_events += _add_event (&t->right, top, bot, -1, events + num_events); + } + + return num_events; +} + +cairo_status_t +_cairo_bentley_ottmann_tessellate_traps (cairo_traps_t *traps) +{ + int intersections; + cairo_status_t status; + cairo_bo_start_event_t stack_events[CAIRO_STACK_ARRAY_LENGTH (cairo_bo_start_event_t)]; + cairo_bo_start_event_t *events; + cairo_bo_event_t *stack_event_ptrs[ARRAY_LENGTH (stack_events) + 1]; + cairo_bo_event_t **event_ptrs; + int num_events; + int i; + + if (unlikely (0 == traps->num_traps)) + return CAIRO_STATUS_SUCCESS; + +#if DEBUG_TRAPS + dump_traps (traps, "bo-traps-in.txt"); +#endif + + /* we need at most 6 vertical edges to describe each clipped trapezoid */ + i = 6 * traps->num_traps; + + events = stack_events; + event_ptrs = stack_event_ptrs; + if (i > ARRAY_LENGTH (stack_events)) { + events = _cairo_malloc_ab_plus_c (i, + sizeof (cairo_bo_start_event_t) + + sizeof (cairo_bo_event_t *), + sizeof (cairo_bo_event_t *)); + if (unlikely (events == NULL)) + return _cairo_error (CAIRO_STATUS_NO_MEMORY); + + event_ptrs = (cairo_bo_event_t **) (events + i); + } + + num_events = 0; + for (i = 0; i < traps->num_traps; i++) { + num_events += _compute_clipped_trapezoid_edges (traps, + &traps->traps[i], + &events[num_events]); + } + + for (i = 0; i < num_events; i++) + event_ptrs[i] = (cairo_bo_event_t *) &events[i]; + + +#if DEBUG_TRAPS + dump_edges (events, num_events, "bo-traps-edges.txt"); +#endif + + _cairo_traps_clear (traps); + status = _cairo_bentley_ottmann_tessellate_bo_edges (event_ptrs, + num_events, + CAIRO_FILL_RULE_WINDING, + traps, + &intersections); + +#if DEBUG_TRAPS + dump_traps (traps, "bo-traps-out.txt"); +#endif + + if (events != stack_events) + free (events); return status; } @@ -1769,15 +2086,14 @@ edges_have_an_intersection_quadratic (cairo_bo_edge_t *edges, int i, j; cairo_bo_edge_t *a, *b; cairo_bo_point32_t intersection; - cairo_bo_status_t status; /* We must not be given any upside-down edges. */ for (i = 0; i < num_edges; i++) { assert (_cairo_bo_point32_compare (&edges[i].top, &edges[i].bottom) < 0); - edges[i].top.x <<= CAIRO_BO_GUARD_BITS; - edges[i].top.y <<= CAIRO_BO_GUARD_BITS; - edges[i].bottom.x <<= CAIRO_BO_GUARD_BITS; - edges[i].bottom.y <<= CAIRO_BO_GUARD_BITS; + edges[i].line.p1.x <<= CAIRO_BO_GUARD_BITS; + edges[i].line.p1.y <<= CAIRO_BO_GUARD_BITS; + edges[i].line.p2.x <<= CAIRO_BO_GUARD_BITS; + edges[i].line.p2.y <<= CAIRO_BO_GUARD_BITS; } for (i = 0; i < num_edges; i++) { @@ -1788,20 +2104,16 @@ edges_have_an_intersection_quadratic (cairo_bo_edge_t *edges, a = &edges[i]; b = &edges[j]; - status = _cairo_bo_edge_intersect (a, b, &intersection); - if (status == CAIRO_BO_STATUS_PARALLEL || - status == CAIRO_BO_STATUS_NO_INTERSECTION) - { + if (! _cairo_bo_edge_intersect (a, b, &intersection)) continue; - } printf ("Found intersection (%d,%d) between (%d,%d)-(%d,%d) and (%d,%d)-(%d,%d)\n", intersection.x, intersection.y, - a->top.x, a->top.y, - a->bottom.x, a->bottom.y, - b->top.x, b->top.y, - b->bottom.x, b->bottom.y); + a->line.p1.x, a->line.p1.y, + a->line.p2.x, a->line.p2.y, + b->line.p1.x, b->line.p1.y, + b->line.p2.x, b->line.p2.y); return TRUE; } @@ -2041,16 +2353,16 @@ main (void) for (i = 0; i < num_random; i++) { do { edge = &random_edges[i]; - edge->top.x = (int32_t) (10.0 * (rand() / (RAND_MAX + 1.0))); - edge->top.y = (int32_t) (10.0 * (rand() / (RAND_MAX + 1.0))); - edge->bottom.x = (int32_t) (10.0 * (rand() / (RAND_MAX + 1.0))); - edge->bottom.y = (int32_t) (10.0 * (rand() / (RAND_MAX + 1.0))); - if (edge->top.y > edge->bottom.y) { - int32_t tmp = edge->top.y; - edge->top.y = edge->bottom.y; - edge->bottom.y = tmp; + edge->line.p1.x = (int32_t) (10.0 * (rand() / (RAND_MAX + 1.0))); + edge->line.p1.y = (int32_t) (10.0 * (rand() / (RAND_MAX + 1.0))); + edge->line.p2.x = (int32_t) (10.0 * (rand() / (RAND_MAX + 1.0))); + edge->line.p2.y = (int32_t) (10.0 * (rand() / (RAND_MAX + 1.0))); + if (edge->line.p1.y > edge->line.p2.y) { + int32_t tmp = edge->line.p1.y; + edge->line.p1.y = edge->line.p2.y; + edge->line.p2.y = tmp; } - } while (edge->top.y == edge->bottom.y); + } while (edge->line.p1.y == edge->line.p2.y); } sprintf (random_name, "random-%02d", num_random); @@ -2061,4 +2373,3 @@ main (void) return 0; } #endif - diff --git a/src/cairo-clip.c b/src/cairo-clip.c index 93348945d..c26f4fa2f 100644 --- a/src/cairo-clip.c +++ b/src/cairo-clip.c @@ -588,17 +588,19 @@ _cairo_clip_path_to_region (cairo_clip_path_t *clip_path) _cairo_box_from_rectangle (&box, &clip_path->extents); _cairo_traps_limit (&traps, &box); - status = _cairo_path_fixed_fill_to_traps (&clip_path->path, - clip_path->fill_rule, - clip_path->tolerance, - &traps); - if (unlikely (status)) + status = _cairo_path_fixed_fill_rectilinear_to_traps (&clip_path->path, + clip_path->fill_rule, + &traps); + if (status) { + _cairo_traps_fini (&traps); + clip_path->flags |= CAIRO_CLIP_PATH_REGION_IS_UNSUPPORTED; return status; + } status = _cairo_traps_extract_region (&traps, &clip_path->region); _cairo_traps_fini (&traps); - if (status) { + if (unlikely (status)) { clip_path->flags |= CAIRO_CLIP_PATH_REGION_IS_UNSUPPORTED; return status; } diff --git a/src/cairo-fixed-private.h b/src/cairo-fixed-private.h index 630f0327c..e3add4aec 100644 --- a/src/cairo-fixed-private.h +++ b/src/cairo-fixed-private.h @@ -226,15 +226,61 @@ _cairo_fixed_mul (cairo_fixed_t a, cairo_fixed_t b) return _cairo_int64_to_int32(_cairo_int64_rsl (temp, CAIRO_FIXED_FRAC_BITS)); } -/* computes a * b / c */ +/* computes round (a * b / c) */ static inline cairo_fixed_t _cairo_fixed_mul_div (cairo_fixed_t a, cairo_fixed_t b, cairo_fixed_t c) { cairo_int64_t ab = _cairo_int32x32_64_mul (a, b); cairo_int64_t c64 = _cairo_int32_to_int64 (c); - cairo_int64_t quo = _cairo_int64_divrem (ab, c64).quo; + return _cairo_int64_to_int32 (_cairo_int64_divrem (ab, c64).quo); +} + +/* computes floor (a * b / c) */ +static inline cairo_fixed_t +_cairo_fixed_mul_div_floor (cairo_fixed_t a, cairo_fixed_t b, cairo_fixed_t c) +{ + return _cairo_int64_32_div (_cairo_int32x32_64_mul (a, b), c); +} + + +static inline cairo_fixed_t +_cairo_edge_compute_intersection_y_for_x (const cairo_point_t *p1, + const cairo_point_t *p2, + cairo_fixed_t x) +{ + cairo_fixed_t y, dx; + + if (x == p1->x) + return p1->y; + if (x == p2->x) + return p2->y; - return _cairo_int64_to_int32(quo); + y = p1->y; + dx = p2->x - p1->x; + if (dx != 0) + y += _cairo_fixed_mul_div_floor (x - p1->x, p2->y - p1->y, dx); + + return y; +} + +static inline cairo_fixed_t +_cairo_edge_compute_intersection_x_for_y (const cairo_point_t *p1, + const cairo_point_t *p2, + cairo_fixed_t y) +{ + cairo_fixed_t x, dy; + + if (y == p1->y) + return p1->x; + if (y == p2->y) + return p2->x; + + x = p1->x; + dy = p2->y - p1->y; + if (dy != 0) + x += _cairo_fixed_mul_div_floor (y - p1->y, p2->x - p1->x, dy); + + return x; } #else diff --git a/src/cairo-fixed-type-private.h b/src/cairo-fixed-type-private.h index 7dd579706..730ed3e12 100644 --- a/src/cairo-fixed-type-private.h +++ b/src/cairo-fixed-type-private.h @@ -67,4 +67,9 @@ typedef int32_t cairo_fixed_t; /* An unsigned type of the same size as #cairo_fixed_t */ typedef uint32_t cairo_fixed_unsigned_t; +typedef struct _cairo_point { + cairo_fixed_t x; + cairo_fixed_t y; +} cairo_point_t; + #endif /* CAIRO_FIXED_TYPE_PRIVATE_H */ diff --git a/src/cairo-gstate.c b/src/cairo-gstate.c index 2257db0f7..3508b5e95 100644 --- a/src/cairo-gstate.c +++ b/src/cairo-gstate.c @@ -1184,7 +1184,7 @@ _cairo_gstate_stroke_extents (cairo_gstate_t *gstate, &gstate->ctm_inverse, gstate->tolerance, &traps); - if (status == CAIRO_STATUS_SUCCESS) { + if (likely (status == CAIRO_STATUS_SUCCESS)) { _cairo_gstate_traps_extents_to_user_rectangle (gstate, &traps, x1, y1, x2, y2); } @@ -1209,7 +1209,7 @@ _cairo_gstate_fill_extents (cairo_gstate_t *gstate, gstate->fill_rule, gstate->tolerance, &traps); - if (status == CAIRO_STATUS_SUCCESS) { + if (likely (status == CAIRO_STATUS_SUCCESS)) { _cairo_gstate_traps_extents_to_user_rectangle (gstate, &traps, x1, y1, x2, y2); } diff --git a/src/cairo-hash.c b/src/cairo-hash.c index 51303f5a7..15159d928 100644 --- a/src/cairo-hash.c +++ b/src/cairo-hash.c @@ -191,9 +191,6 @@ _cairo_hash_table_create (cairo_hash_keys_equal_func_t keys_equal) void _cairo_hash_table_destroy (cairo_hash_table_t *hash_table) { - if (hash_table == NULL) - return; - /* The hash table must be empty. Otherwise, halt. */ assert (hash_table->live_entries == 0); /* No iterators can be running. Otherwise, halt. */ @@ -525,9 +522,6 @@ _cairo_hash_table_foreach (cairo_hash_table_t *hash_table, unsigned long i; cairo_hash_entry_t *entry; - if (hash_table == NULL) - return; - /* Mark the table for iteration */ ++hash_table->iterating; for (i = 0; i < hash_table->arrangement->size; i++) { diff --git a/src/cairo-matrix.c b/src/cairo-matrix.c index 6c83388e9..94ed0e915 100644 --- a/src/cairo-matrix.c +++ b/src/cairo-matrix.c @@ -688,16 +688,9 @@ _cairo_matrix_is_integer_translation (const cairo_matrix_t *matrix, return FALSE; } -/* By pixel exact here, we mean a matrix that is composed only of - * 90 degree rotations, flips, and integer translations and produces a 1:1 - * mapping between source and destination pixels. If we transform an image - * with a pixel-exact matrix, filtering is not useful. - */ -cairo_private cairo_bool_t -_cairo_matrix_is_pixel_exact (const cairo_matrix_t *matrix) +cairo_bool_t +_cairo_matrix_has_unity_scale (const cairo_matrix_t *matrix) { - cairo_fixed_t x0_fixed, y0_fixed; - if (matrix->xy == 0.0 && matrix->yx == 0.0) { if (! (matrix->xx == 1.0 || matrix->xx == -1.0)) return FALSE; @@ -711,6 +704,22 @@ _cairo_matrix_is_pixel_exact (const cairo_matrix_t *matrix) } else return FALSE; + return TRUE; +} + +/* By pixel exact here, we mean a matrix that is composed only of + * 90 degree rotations, flips, and integer translations and produces a 1:1 + * mapping between source and destination pixels. If we transform an image + * with a pixel-exact matrix, filtering is not useful. + */ +cairo_bool_t +_cairo_matrix_is_pixel_exact (const cairo_matrix_t *matrix) +{ + cairo_fixed_t x0_fixed, y0_fixed; + + if (! _cairo_matrix_has_unity_scale (matrix)) + return FALSE; + x0_fixed = _cairo_fixed_from_double (matrix->x0); y0_fixed = _cairo_fixed_from_double (matrix->y0); diff --git a/src/cairo-path-fill.c b/src/cairo-path-fill.c index 123da96e2..2b5c4c8ea 100644 --- a/src/cairo-path-fill.c +++ b/src/cairo-path-fill.c @@ -39,29 +39,25 @@ typedef struct cairo_filler { double tolerance; - cairo_traps_t *traps; - cairo_point_t current_point; - - cairo_polygon_t polygon; + cairo_polygon_t *polygon; } cairo_filler_t; static void -_cairo_filler_init (cairo_filler_t *filler, double tolerance, cairo_traps_t *traps) +_cairo_filler_init (cairo_filler_t *filler, + double tolerance, + cairo_polygon_t *polygon) { filler->tolerance = tolerance; - filler->traps = traps; + filler->polygon = polygon; filler->current_point.x = 0; filler->current_point.y = 0; - - _cairo_polygon_init (&filler->polygon); } static void _cairo_filler_fini (cairo_filler_t *filler) { - _cairo_polygon_fini (&filler->polygon); } static cairo_status_t @@ -69,14 +65,14 @@ _cairo_filler_move_to (void *closure, const cairo_point_t *point) { cairo_filler_t *filler = closure; - cairo_polygon_t *polygon = &filler->polygon; + cairo_polygon_t *polygon = filler->polygon; _cairo_polygon_close (polygon); _cairo_polygon_move_to (polygon, point); filler->current_point = *point; - return _cairo_polygon_status (&filler->polygon); + return _cairo_polygon_status (filler->polygon); } static cairo_status_t @@ -84,13 +80,13 @@ _cairo_filler_line_to (void *closure, const cairo_point_t *point) { cairo_filler_t *filler = closure; - cairo_polygon_t *polygon = &filler->polygon; + cairo_polygon_t *polygon = filler->polygon; _cairo_polygon_line_to (polygon, point); filler->current_point = *point; - return _cairo_polygon_status (&filler->polygon); + return _cairo_polygon_status (filler->polygon); } static cairo_status_t @@ -103,11 +99,10 @@ _cairo_filler_curve_to (void *closure, cairo_spline_t spline; if (! _cairo_spline_init (&spline, - _cairo_filler_line_to, - filler, + _cairo_filler_line_to, filler, &filler->current_point, b, c, d)) { - return CAIRO_STATUS_SUCCESS; + return _cairo_filler_line_to (closure, d); } return _cairo_spline_decompose (&spline, filler->tolerance); @@ -117,36 +112,22 @@ static cairo_status_t _cairo_filler_close_path (void *closure) { cairo_filler_t *filler = closure; - cairo_polygon_t *polygon = &filler->polygon; + cairo_polygon_t *polygon = filler->polygon; _cairo_polygon_close (polygon); return _cairo_polygon_status (polygon); } -static cairo_int_status_t -_cairo_path_fixed_fill_rectangle (const cairo_path_fixed_t *path, - cairo_fill_rule_t fill_rule, - cairo_traps_t *traps); - cairo_status_t -_cairo_path_fixed_fill_to_traps (const cairo_path_fixed_t *path, - cairo_fill_rule_t fill_rule, - double tolerance, - cairo_traps_t *traps) +_cairo_path_fixed_fill_to_polygon (const cairo_path_fixed_t *path, + double tolerance, + cairo_polygon_t *polygon) { - cairo_status_t status = CAIRO_STATUS_SUCCESS; cairo_filler_t filler; + cairo_status_t status; - traps->maybe_region = path->maybe_fill_region; - - /* Before we do anything else, we use a special-case filler for - * a device-axis aligned rectangle if possible. */ - status = _cairo_path_fixed_fill_rectangle (path, fill_rule, traps); - if (status != CAIRO_INT_STATUS_UNSUPPORTED) - return status; - - _cairo_filler_init (&filler, tolerance, traps); + _cairo_filler_init (&filler, tolerance, polygon); status = _cairo_path_fixed_interpret (path, CAIRO_DIRECTION_FORWARD, @@ -156,25 +137,48 @@ _cairo_path_fixed_fill_to_traps (const cairo_path_fixed_t *path, _cairo_filler_close_path, &filler); if (unlikely (status)) - goto BAIL; + return status; - _cairo_polygon_close (&filler.polygon); - status = _cairo_polygon_status (&filler.polygon); - if (unlikely (status)) - goto BAIL; + _cairo_polygon_close (polygon); + status = _cairo_polygon_status (polygon); + _cairo_filler_fini (&filler); - status = _cairo_bentley_ottmann_tessellate_polygon (filler.traps, - &filler.polygon, - fill_rule); + return status; +} + +cairo_status_t +_cairo_path_fixed_fill_to_traps (const cairo_path_fixed_t *path, + cairo_fill_rule_t fill_rule, + double tolerance, + cairo_traps_t *traps) +{ + cairo_polygon_t polygon; + cairo_status_t status; + + if (path->is_rectilinear) { + status = _cairo_path_fixed_fill_rectilinear_to_traps (path, + fill_rule, + traps); + if (status != CAIRO_INT_STATUS_UNSUPPORTED) + return status; + } + + _cairo_polygon_init (&polygon); + status = _cairo_path_fixed_fill_to_polygon (path, + tolerance, + &polygon); if (unlikely (status)) - goto BAIL; + goto CLEANUP; -BAIL: - _cairo_filler_fini (&filler); + status = _cairo_bentley_ottmann_tessellate_polygon (traps, &polygon, + fill_rule); + CLEANUP: + _cairo_polygon_fini (&polygon); return status; } + /* This special-case filler supports only a path that describes a * device-axis aligned rectangle. It exists to avoid the overhead of * the general tessellator when drawing very common rectangles. @@ -182,15 +186,14 @@ BAIL: * If the path described anything but a device-axis aligned rectangle, * this function will return %CAIRO_INT_STATUS_UNSUPPORTED. */ -static cairo_int_status_t -_cairo_path_fixed_fill_rectangle (const cairo_path_fixed_t *path, - cairo_fill_rule_t fill_rule, - cairo_traps_t *traps) +cairo_int_status_t +_cairo_path_fixed_fill_rectilinear_to_traps (const cairo_path_fixed_t *path, + cairo_fill_rule_t fill_rule, + cairo_traps_t *traps) { cairo_box_t box; - if (! path->is_rectilinear) - return CAIRO_INT_STATUS_UNSUPPORTED; + assert (path->is_rectilinear); if (_cairo_path_fixed_is_box (path, &box)) { if (box.p1.x > box.p2.x) { diff --git a/src/cairo-path-stroke.c b/src/cairo-path-stroke.c index 4fa4ce5ac..208e39030 100644 --- a/src/cairo-path-stroke.c +++ b/src/cairo-path-stroke.c @@ -33,6 +33,7 @@ * * Contributor(s): * Carl D. Worth + * Chris Wilson */ #define _BSD_SOURCE /* for hypot() */ @@ -60,7 +61,18 @@ typedef struct cairo_stroker { double ctm_determinant; cairo_bool_t ctm_det_positive; - cairo_traps_t *traps; + void *closure; + cairo_status_t (*add_external_edge) (void *closure, + const cairo_point_t *p1, + const cairo_point_t *p2); + cairo_status_t (*add_triangle) (void *closure, + const cairo_point_t triangle[3]); + cairo_status_t (*add_triangle_fan) (void *closure, + const cairo_point_t *midpt, + const cairo_point_t *points, + int npoints); + cairo_status_t (*add_convex_quad) (void *closure, + const cairo_point_t quad[4]); cairo_pen_t pen; @@ -141,8 +153,7 @@ _cairo_stroker_init (cairo_stroker_t *stroker, cairo_stroke_style_t *stroke_style, const cairo_matrix_t *ctm, const cairo_matrix_t *ctm_inverse, - double tolerance, - cairo_traps_t *traps) + double tolerance) { cairo_status_t status; @@ -150,7 +161,6 @@ _cairo_stroker_init (cairo_stroker_t *stroker, stroker->ctm = ctm; stroker->ctm_inverse = ctm_inverse; stroker->tolerance = tolerance; - stroker->traps = traps; stroker->ctm_determinant = _cairo_matrix_compute_determinant (stroker->ctm); stroker->ctm_det_positive = stroker->ctm_determinant >= 0.0; @@ -161,35 +171,45 @@ _cairo_stroker_init (cairo_stroker_t *stroker, if (unlikely (status)) return status; + stroker->has_bounds = FALSE; + stroker->has_current_face = FALSE; stroker->has_first_face = FALSE; stroker->has_initial_sub_path = FALSE; _cairo_stroker_dash_init (&stroker->dash, stroke_style); - stroker->has_bounds = _cairo_traps_get_limit (traps, &stroker->bounds); - if (stroker->has_bounds) { - /* Extend the bounds in each direction to account for the maximum area - * we might generate trapezoids, to capture line segments that are outside - * of the bounds but which might generate rendering that's within bounds. - */ - double dx, dy; - cairo_fixed_t fdx, fdy; + stroker->add_external_edge = NULL; - _cairo_stroke_style_max_distance_from_path (stroker->style, - stroker->ctm, - &dx, &dy); + return CAIRO_STATUS_SUCCESS; +} - fdx = _cairo_fixed_from_double (dx); - stroker->bounds.p1.x -= fdx; - stroker->bounds.p2.x += fdx; +static void +_cairo_stroker_limit (cairo_stroker_t *stroker, + const cairo_box_t *box) +{ + double dx, dy; + cairo_fixed_t fdx, fdy; - fdy = _cairo_fixed_from_double (dy); - stroker->bounds.p1.y -= fdy; - stroker->bounds.p2.y += fdy; - } + stroker->has_bounds = TRUE; + stroker->bounds = *box; - return CAIRO_STATUS_SUCCESS; + /* Extend the bounds in each direction to account for the maximum area + * we might generate trapezoids, to capture line segments that are outside + * of the bounds but which might generate rendering that's within bounds. + */ + + _cairo_stroke_style_max_distance_from_path (stroker->style, stroker->ctm, + &dx, &dy); + + fdx = _cairo_fixed_from_double (dx); + fdy = _cairo_fixed_from_double (dy); + + stroker->bounds.p1.x -= fdx; + stroker->bounds.p2.x += fdx; + + stroker->bounds.p1.y -= fdy; + stroker->bounds.p2.y += fdy; } static void @@ -199,14 +219,15 @@ _cairo_stroker_fini (cairo_stroker_t *stroker) } static void -_translate_point (cairo_point_t *point, cairo_point_t *offset) +_translate_point (cairo_point_t *point, const cairo_point_t *offset) { point->x += offset->x; point->y += offset->y; } static int -_cairo_stroker_face_clockwise (cairo_stroke_face_t *in, cairo_stroke_face_t *out) +_cairo_stroker_join_is_clockwise (const cairo_stroke_face_t *in, + const cairo_stroke_face_t *out) { cairo_slope_t in_slope, out_slope; @@ -232,76 +253,209 @@ _cairo_slope_compare_sgn (double dx1, double dy1, double dx2, double dy2) return 0; } +static inline int +_range_step (int i, int step, int max) +{ + i += step; + if (i < 0) + i = max - 1; + if (i >= max) + i = 0; + return i; +} + +/* + * Construct a fan around the midpoint using the vertices from pen between + * inpt and outpt. + */ static cairo_status_t -_cairo_stroker_join (cairo_stroker_t *stroker, cairo_stroke_face_t *in, cairo_stroke_face_t *out) +_tessellate_fan (cairo_stroker_t *stroker, + const cairo_slope_t *in_vector, + const cairo_slope_t *out_vector, + const cairo_point_t *midpt, + const cairo_point_t *inpt, + const cairo_point_t *outpt, + cairo_bool_t clockwise) { - int clockwise = _cairo_stroker_face_clockwise (out, in); - cairo_point_t *inpt, *outpt; + cairo_point_t stack_points[64], *points = stack_points; + int start, stop, step, i, npoints; cairo_status_t status; - if (in->cw.x == out->cw.x - && in->cw.y == out->cw.y - && in->ccw.x == out->ccw.x - && in->ccw.y == out->ccw.y) + if (clockwise) { + step = -1; + + start = _cairo_pen_find_active_ccw_vertex_index (&stroker->pen, + in_vector); + if (_cairo_slope_compare (&stroker->pen.vertices[start].slope_ccw, + in_vector) < 0) + start = _range_step (start, -1, stroker->pen.num_vertices); + + stop = _cairo_pen_find_active_ccw_vertex_index (&stroker->pen, + out_vector); + if (_cairo_slope_compare (&stroker->pen.vertices[stop].slope_cw, + out_vector) > 0) + { + stop = _range_step (stop, 1, stroker->pen.num_vertices); + if (_cairo_slope_compare (&stroker->pen.vertices[stop].slope_ccw, + in_vector) < 0) + { + goto BEVEL; + } + } + + npoints = start - stop; + } else { + step = 1; + + start = _cairo_pen_find_active_cw_vertex_index (&stroker->pen, + in_vector); + if (_cairo_slope_compare (&stroker->pen.vertices[start].slope_cw, + in_vector) < 0) + start = _range_step (start, 1, stroker->pen.num_vertices); + + stop = _cairo_pen_find_active_cw_vertex_index (&stroker->pen, + out_vector); + if (_cairo_slope_compare (&stroker->pen.vertices[stop].slope_ccw, + out_vector) > 0) + { + stop = _range_step (stop, -1, stroker->pen.num_vertices); + if (_cairo_slope_compare (&stroker->pen.vertices[stop].slope_cw, + in_vector) < 0) + { + goto BEVEL; + } + } + + npoints = stop - start; + } + stop = _range_step (stop, step, stroker->pen.num_vertices); + + if (npoints < 0) + npoints += stroker->pen.num_vertices; + npoints += 2; + + if (npoints <= 1) + goto BEVEL; + + if (npoints > ARRAY_LENGTH (stack_points)) { + points = _cairo_malloc_ab (npoints, sizeof (cairo_point_t)); + if (unlikely (points == NULL)) + return _cairo_error (CAIRO_STATUS_NO_MEMORY); + } + + + /* Construct the fan. */ + npoints = 0; + points[npoints++] = *inpt; + for (i = start; + i != stop; + i = _range_step (i, step, stroker->pen.num_vertices)) + { + points[npoints] = *midpt; + _translate_point (&points[npoints], &stroker->pen.vertices[i].point); + npoints++; + } + points[npoints++] = *outpt; + + if (stroker->add_external_edge != NULL) { + for (i = 0; i < npoints - 1; i++) { + if (clockwise) { + status = stroker->add_external_edge (stroker->closure, + &points[i], &points[i+1]); + } else { + status = stroker->add_external_edge (stroker->closure, + &points[i+1], &points[i]); + } + if (unlikely (status)) + break; + } + } else { + status = stroker->add_triangle_fan (stroker->closure, + midpt, points, npoints); + } + + if (points != stack_points) + free (points); + + return status; + +BEVEL: + /* Ensure a leak free connection... */ + if (stroker->add_external_edge != NULL) { + if (clockwise) + return stroker->add_external_edge (stroker->closure, inpt, outpt); + else + return stroker->add_external_edge (stroker->closure, outpt, inpt); + } else { + stack_points[0] = *midpt; + stack_points[1] = *inpt; + stack_points[2] = *outpt; + return stroker->add_triangle (stroker->closure, stack_points); + } +} + +static cairo_status_t +_cairo_stroker_join (cairo_stroker_t *stroker, + const cairo_stroke_face_t *in, + const cairo_stroke_face_t *out) +{ + int clockwise = _cairo_stroker_join_is_clockwise (out, in); + const cairo_point_t *inpt, *outpt; + cairo_point_t points[4]; + cairo_status_t status; + + if (in->cw.x == out->cw.x && in->cw.y == out->cw.y && + in->ccw.x == out->ccw.x && in->ccw.y == out->ccw.y) { return CAIRO_STATUS_SUCCESS; } if (clockwise) { + if (stroker->add_external_edge != NULL) { + status = stroker->add_external_edge (stroker->closure, + &out->cw, &in->point); + if (unlikely (status)) + return status; + + status = stroker->add_external_edge (stroker->closure, + &in->point, &in->cw); + if (unlikely (status)) + return status; + } + inpt = &in->ccw; outpt = &out->ccw; } else { - inpt = &in->cw; - outpt = &out->cw; - } - - switch (stroker->style->line_join) { - case CAIRO_LINE_JOIN_ROUND: { - int i; - int start, step, stop; - cairo_point_t tri[3]; - cairo_pen_t *pen = &stroker->pen; - - tri[0] = in->point; - if (clockwise) { - start = - _cairo_pen_find_active_ccw_vertex_index (pen, &in->dev_vector); - stop = - _cairo_pen_find_active_ccw_vertex_index (pen, &out->dev_vector); - step = -1; - } else { - start = - _cairo_pen_find_active_cw_vertex_index (pen, &in->dev_vector); - stop = - _cairo_pen_find_active_cw_vertex_index (pen, &out->dev_vector); - step = +1; - } + if (stroker->add_external_edge != NULL) { + status = stroker->add_external_edge (stroker->closure, + &in->ccw, &in->point); + if (unlikely (status)) + return status; - i = start; - tri[1] = *inpt; - while (i != stop) { - tri[2] = in->point; - _translate_point (&tri[2], &pen->vertices[i].point); - status = _cairo_traps_tessellate_triangle (stroker->traps, tri); + status = stroker->add_external_edge (stroker->closure, + &in->point, &out->ccw); if (unlikely (status)) return status; - tri[1] = tri[2]; - i += step; - if (i < 0) - i = pen->num_vertices - 1; - if (i >= pen->num_vertices) - i = 0; } - tri[2] = *outpt; - - return _cairo_traps_tessellate_triangle (stroker->traps, tri); + inpt = &in->cw; + outpt = &out->cw; } + + switch (stroker->style->line_join) { + case CAIRO_LINE_JOIN_ROUND: + /* construct a fan around the common midpoint */ + return _tessellate_fan (stroker, + &in->dev_vector, + &out->dev_vector, + &in->point, inpt, outpt, + clockwise); + case CAIRO_LINE_JOIN_MITER: default: { /* dot product of incoming slope vector with outgoing slope vector */ - double in_dot_out = ((-in->usr_vector.x * out->usr_vector.x)+ - (-in->usr_vector.y * out->usr_vector.y)); + double in_dot_out = -in->usr_vector.x * out->usr_vector.x + + -in->usr_vector.y * out->usr_vector.y; double ml = stroker->style->miter_limit; /* Check the miter limit -- lines meeting at an acute angle @@ -361,13 +515,10 @@ _cairo_stroker_join (cairo_stroker_t *stroker, cairo_stroke_face_t *in, cairo_st * 2 <= ml² (1 - in · out) * */ - if (2 <= ml * ml * (1 - in_dot_out)) - { + if (2 <= ml * ml * (1 - in_dot_out)) { double x1, y1, x2, y2; double mx, my; double dx1, dx2, dy1, dy2; - cairo_point_t outer; - cairo_point_t quad[4]; double ix, iy; double fdx1, fdy1, fdx2, fdy2; double mdx, mdy; @@ -435,74 +586,90 @@ _cairo_stroker_join (cairo_stroker_t *stroker, cairo_stroke_face_t *in, cairo_st if (_cairo_slope_compare_sgn (fdx1, fdy1, mdx, mdy) != _cairo_slope_compare_sgn (fdx2, fdy2, mdx, mdy)) { - /* - * Draw the quadrilateral - */ - outer.x = _cairo_fixed_from_double (mx); - outer.y = _cairo_fixed_from_double (my); - - quad[0] = in->point; - quad[1] = *inpt; - quad[2] = outer; - quad[3] = *outpt; - - return _cairo_traps_tessellate_convex_quad (stroker->traps, quad); + if (stroker->add_external_edge != NULL) { + points[0].x = _cairo_fixed_from_double (mx); + points[0].y = _cairo_fixed_from_double (my); + + if (clockwise) { + status = stroker->add_external_edge (stroker->closure, + inpt, &points[0]); + if (unlikely (status)) + return status; + + status = stroker->add_external_edge (stroker->closure, + &points[0], outpt); + if (unlikely (status)) + return status; + } else { + status = stroker->add_external_edge (stroker->closure, + outpt, &points[0]); + if (unlikely (status)) + return status; + + status = stroker->add_external_edge (stroker->closure, + &points[0], inpt); + if (unlikely (status)) + return status; + } + + return CAIRO_STATUS_SUCCESS; + } else { + points[0] = in->point; + points[1] = *inpt; + points[2].x = _cairo_fixed_from_double (mx); + points[2].y = _cairo_fixed_from_double (my); + points[3] = *outpt; + + return stroker->add_convex_quad (stroker->closure, points); + } } } - /* fall through ... */ } - case CAIRO_LINE_JOIN_BEVEL: { - cairo_point_t tri[3]; - tri[0] = in->point; - tri[1] = *inpt; - tri[2] = *outpt; - return _cairo_traps_tessellate_triangle (stroker->traps, tri); - } + /* fall through ... */ + + case CAIRO_LINE_JOIN_BEVEL: + if (stroker->add_external_edge != NULL) { + if (clockwise) { + return stroker->add_external_edge (stroker->closure, + inpt, outpt); + } else { + return stroker->add_external_edge (stroker->closure, + outpt, inpt); + } + } else { + points[0] = in->point; + points[1] = *inpt; + points[2] = *outpt; + + return stroker->add_triangle (stroker->closure, points); + } } } static cairo_status_t -_cairo_stroker_add_cap (cairo_stroker_t *stroker, cairo_stroke_face_t *f) +_cairo_stroker_add_cap (cairo_stroker_t *stroker, + const cairo_stroke_face_t *f) { - cairo_status_t status; - - if (stroker->style->line_cap == CAIRO_LINE_CAP_BUTT) - return CAIRO_STATUS_SUCCESS; - switch (stroker->style->line_cap) { case CAIRO_LINE_CAP_ROUND: { - int i; - int start, stop; cairo_slope_t slope; - cairo_point_t tri[3]; - cairo_pen_t *pen = &stroker->pen; - - slope = f->dev_vector; - start = _cairo_pen_find_active_cw_vertex_index (pen, &slope); - slope.dx = -slope.dx; - slope.dy = -slope.dy; - stop = _cairo_pen_find_active_cw_vertex_index (pen, &slope); - - tri[0] = f->point; - tri[1] = f->cw; - for (i=start; i != stop; i = (i+1) % pen->num_vertices) { - tri[2] = f->point; - _translate_point (&tri[2], &pen->vertices[i].point); - status = _cairo_traps_tessellate_triangle (stroker->traps, tri); - if (unlikely (status)) - return status; - tri[1] = tri[2]; - } - tri[2] = f->ccw; - return _cairo_traps_tessellate_triangle (stroker->traps, tri); + slope.dx = -f->dev_vector.dx; + slope.dy = -f->dev_vector.dy; + + return _tessellate_fan (stroker, + &f->dev_vector, + &slope, + &f->point, &f->cw, &f->ccw, + FALSE); + } + case CAIRO_LINE_CAP_SQUARE: { double dx, dy; cairo_slope_t fvector; - cairo_point_t occw, ocw; - cairo_polygon_t polygon; + cairo_point_t quad[4]; dx = f->usr_vector.x; dy = f->usr_vector.y; @@ -511,38 +678,52 @@ _cairo_stroker_add_cap (cairo_stroker_t *stroker, cairo_stroke_face_t *f) cairo_matrix_transform_distance (stroker->ctm, &dx, &dy); fvector.dx = _cairo_fixed_from_double (dx); fvector.dy = _cairo_fixed_from_double (dy); - occw.x = f->ccw.x + fvector.dx; - occw.y = f->ccw.y + fvector.dy; - ocw.x = f->cw.x + fvector.dx; - ocw.y = f->cw.y + fvector.dy; - - _cairo_polygon_init (&polygon); - _cairo_polygon_move_to (&polygon, &f->cw); - _cairo_polygon_line_to (&polygon, &ocw); - _cairo_polygon_line_to (&polygon, &occw); - _cairo_polygon_line_to (&polygon, &f->ccw); - _cairo_polygon_close (&polygon); - status = _cairo_polygon_status (&polygon); - - if (status == CAIRO_STATUS_SUCCESS) { - status = _cairo_bentley_ottmann_tessellate_polygon (stroker->traps, - &polygon, - CAIRO_FILL_RULE_WINDING); - } - _cairo_polygon_fini (&polygon); + quad[0] = f->ccw; + quad[1].x = f->ccw.x + fvector.dx; + quad[1].y = f->ccw.y + fvector.dy; + quad[2].x = f->cw.x + fvector.dx; + quad[2].y = f->cw.y + fvector.dy; + quad[3] = f->cw; - return status; + if (stroker->add_external_edge != NULL) { + cairo_status_t status; + + status = stroker->add_external_edge (stroker->closure, + &quad[0], &quad[1]); + if (unlikely (status)) + return status; + + status = stroker->add_external_edge (stroker->closure, + &quad[1], &quad[2]); + if (unlikely (status)) + return status; + + status = stroker->add_external_edge (stroker->closure, + &quad[2], &quad[3]); + if (unlikely (status)) + return status; + + return CAIRO_STATUS_SUCCESS; + } else { + return stroker->add_convex_quad (stroker->closure, quad); + } } + case CAIRO_LINE_CAP_BUTT: default: - return CAIRO_STATUS_SUCCESS; + if (stroker->add_external_edge != NULL) { + return stroker->add_external_edge (stroker->closure, + &f->ccw, &f->cw); + } else { + return CAIRO_STATUS_SUCCESS; + } } } static cairo_status_t _cairo_stroker_add_leading_cap (cairo_stroker_t *stroker, - cairo_stroke_face_t *face) + const cairo_stroke_face_t *face) { cairo_stroke_face_t reversed; cairo_point_t t; @@ -563,7 +744,7 @@ _cairo_stroker_add_leading_cap (cairo_stroker_t *stroker, static cairo_status_t _cairo_stroker_add_trailing_cap (cairo_stroker_t *stroker, - cairo_stroke_face_t *face) + const cairo_stroke_face_t *face) { return _cairo_stroker_add_cap (stroker, face); } @@ -614,55 +795,6 @@ _compute_normalized_device_slope (double *dx, double *dy, return TRUE; } -static void -_compute_face (const cairo_point_t *point, cairo_slope_t *dev_slope, - double slope_dx, double slope_dy, - cairo_stroker_t *stroker, cairo_stroke_face_t *face); - -static cairo_status_t -_cairo_stroker_add_caps (cairo_stroker_t *stroker) -{ - cairo_status_t status; - /* check for a degenerative sub_path */ - if (stroker->has_initial_sub_path - && !stroker->has_first_face - && !stroker->has_current_face - && stroker->style->line_cap == CAIRO_LINE_JOIN_ROUND) - { - /* pick an arbitrary slope to use */ - double dx = 1.0, dy = 0.0; - cairo_slope_t slope = { CAIRO_FIXED_ONE, 0 }; - cairo_stroke_face_t face; - - _compute_normalized_device_slope (&dx, &dy, stroker->ctm_inverse, NULL); - - /* arbitrarily choose first_point - * first_point and current_point should be the same */ - _compute_face (&stroker->first_point, &slope, dx, dy, stroker, &face); - - status = _cairo_stroker_add_leading_cap (stroker, &face); - if (unlikely (status)) - return status; - status = _cairo_stroker_add_trailing_cap (stroker, &face); - if (unlikely (status)) - return status; - } - - if (stroker->has_first_face) { - status = _cairo_stroker_add_leading_cap (stroker, &stroker->first_face); - if (unlikely (status)) - return status; - } - - if (stroker->has_current_face) { - status = _cairo_stroker_add_trailing_cap (stroker, &stroker->current_face); - if (unlikely (status)) - return status; - } - - return CAIRO_STATUS_SUCCESS; -} - static void _compute_face (const cairo_point_t *point, cairo_slope_t *dev_slope, double slope_dx, double slope_dy, @@ -711,6 +843,55 @@ _compute_face (const cairo_point_t *point, cairo_slope_t *dev_slope, face->dev_vector = *dev_slope; } +static cairo_status_t +_cairo_stroker_add_caps (cairo_stroker_t *stroker) +{ + cairo_status_t status; + + /* check for a degenerative sub_path */ + if (stroker->has_initial_sub_path + && ! stroker->has_first_face + && ! stroker->has_current_face + && stroker->style->line_cap == CAIRO_LINE_JOIN_ROUND) + { + /* pick an arbitrary slope to use */ + double dx = 1.0, dy = 0.0; + cairo_slope_t slope = { CAIRO_FIXED_ONE, 0 }; + cairo_stroke_face_t face; + + _compute_normalized_device_slope (&dx, &dy, + stroker->ctm_inverse, NULL); + + /* arbitrarily choose first_point + * first_point and current_point should be the same */ + _compute_face (&stroker->first_point, &slope, dx, dy, stroker, &face); + + status = _cairo_stroker_add_leading_cap (stroker, &face); + if (unlikely (status)) + return status; + + status = _cairo_stroker_add_trailing_cap (stroker, &face); + if (unlikely (status)) + return status; + } + + if (stroker->has_first_face) { + status = _cairo_stroker_add_leading_cap (stroker, + &stroker->first_face); + if (unlikely (status)) + return status; + } + + if (stroker->has_current_face) { + status = _cairo_stroker_add_trailing_cap (stroker, + &stroker->current_face); + if (unlikely (status)) + return status; + } + + return CAIRO_STATUS_SUCCESS; +} + static cairo_status_t _cairo_stroker_add_sub_edge (cairo_stroker_t *stroker, const cairo_point_t *p1, @@ -720,24 +901,42 @@ _cairo_stroker_add_sub_edge (cairo_stroker_t *stroker, cairo_stroke_face_t *start, cairo_stroke_face_t *end) { - cairo_point_t rectangle[4]; - _compute_face (p1, dev_slope, slope_dx, slope_dy, stroker, start); - - /* XXX: This could be optimized slightly by not calling - _compute_face again but rather translating the relevant - fields from start. */ - _compute_face (p2, dev_slope, slope_dx, slope_dy, stroker, end); + *end = *start; if (p1->x == p2->x && p1->y == p2->y) return CAIRO_STATUS_SUCCESS; - rectangle[0] = start->cw; - rectangle[1] = start->ccw; - rectangle[2] = end->ccw; - rectangle[3] = end->cw; + end->point = *p2; + end->ccw.x += p2->x - p1->x; + end->ccw.y += p2->y - p1->y; + end->cw.x += p2->x - p1->x; + end->cw.y += p2->y - p1->y; + + if (stroker->add_external_edge != NULL) { + cairo_status_t status; - return _cairo_traps_tessellate_convex_quad (stroker->traps, rectangle); + status = stroker->add_external_edge (stroker->closure, + &end->cw, &start->cw); + if (unlikely (status)) + return status; + + status = stroker->add_external_edge (stroker->closure, + &start->ccw, &end->ccw); + if (unlikely (status)) + return status; + + return CAIRO_STATUS_SUCCESS; + } else { + cairo_point_t quad[4]; + + quad[0] = start->cw; + quad[1] = end->cw; + quad[2] = end->ccw; + quad[3] = start->ccw; + + return stroker->add_convex_quad (stroker->closure, quad); + } } static cairo_status_t @@ -747,6 +946,9 @@ _cairo_stroker_move_to (void *closure, cairo_stroker_t *stroker = closure; cairo_status_t status; + /* reset the dash pattern for new sub paths */ + _cairo_stroker_dash_start (&stroker->dash); + /* Cap the start and end of the previous sub path as needed */ status = _cairo_stroker_add_caps (stroker); if (unlikely (status)) @@ -762,41 +964,30 @@ _cairo_stroker_move_to (void *closure, return CAIRO_STATUS_SUCCESS; } -static cairo_status_t -_cairo_stroker_move_to_dashed (void *closure, - const cairo_point_t *point) -{ - cairo_stroker_t *stroker = closure; - - /* reset the dash pattern for new sub paths */ - _cairo_stroker_dash_start (&stroker->dash); - - return _cairo_stroker_move_to (closure, point); -} - static cairo_status_t _cairo_stroker_line_to (void *closure, - const cairo_point_t *p2) + const cairo_point_t *point) { - cairo_status_t status; cairo_stroker_t *stroker = closure; cairo_stroke_face_t start, end; cairo_point_t *p1 = &stroker->current_point; cairo_slope_t dev_slope; double slope_dx, slope_dy; + cairo_status_t status; stroker->has_initial_sub_path = TRUE; - if (p1->x == p2->x && p1->y == p2->y) + if (p1->x == point->x && p1->y == point->y) return CAIRO_STATUS_SUCCESS; - _cairo_slope_init (&dev_slope, p1, p2); - slope_dx = _cairo_fixed_to_double (p2->x - p1->x); - slope_dy = _cairo_fixed_to_double (p2->y - p1->y); - _compute_normalized_device_slope (&slope_dx, &slope_dy, stroker->ctm_inverse, NULL); + _cairo_slope_init (&dev_slope, p1, point); + slope_dx = _cairo_fixed_to_double (point->x - p1->x); + slope_dy = _cairo_fixed_to_double (point->y - p1->y); + _compute_normalized_device_slope (&slope_dx, &slope_dy, + stroker->ctm_inverse, NULL); status = _cairo_stroker_add_sub_edge (stroker, - p1, p2, + p1, point, &dev_slope, slope_dx, slope_dy, &start, &end); @@ -805,10 +996,12 @@ _cairo_stroker_line_to (void *closure, if (stroker->has_current_face) { /* Join with final face from previous segment */ - status = _cairo_stroker_join (stroker, &stroker->current_face, &start); + status = _cairo_stroker_join (stroker, + &stroker->current_face, + &start); if (unlikely (status)) return status; - } else if (!stroker->has_first_face) { + } else if (! stroker->has_first_face) { /* Save sub path's first face in case needed for closing join */ stroker->first_face = start; stroker->has_first_face = TRUE; @@ -816,7 +1009,7 @@ _cairo_stroker_line_to (void *closure, stroker->current_face = end; stroker->has_current_face = TRUE; - stroker->current_point = *p2; + stroker->current_point = *point; return CAIRO_STATUS_SUCCESS; } @@ -858,7 +1051,7 @@ _cairo_stroker_line_to_dashed (void *closure, slope_dy = _cairo_fixed_to_double (p2->y - p1->y); if (! _compute_normalized_device_slope (&slope_dx, &slope_dy, - stroker->ctm_inverse, &mag)) + stroker->ctm_inverse, &mag)) { return CAIRO_STATUS_SUCCESS; } @@ -971,123 +1164,24 @@ _cairo_stroker_curve_to (void *closure, const cairo_point_t *b, const cairo_point_t *c, const cairo_point_t *d) -{ - cairo_stroker_t *stroker = closure; - cairo_pen_stroke_spline_t spline_pen; - cairo_stroke_face_t start, end; - cairo_point_t extra_points[4]; - cairo_point_t *a = &stroker->current_point; - double initial_slope_dx, initial_slope_dy; - double final_slope_dx, final_slope_dy; - cairo_status_t status; - - status = _cairo_pen_stroke_spline_init (&spline_pen, - &stroker->pen, - a, b, c, d); - if (status == CAIRO_INT_STATUS_DEGENERATE) - return _cairo_stroker_line_to (closure, d); - else if (unlikely (status)) - return status; - - initial_slope_dx = _cairo_fixed_to_double (spline_pen.spline.initial_slope.dx); - initial_slope_dy = _cairo_fixed_to_double (spline_pen.spline.initial_slope.dy); - final_slope_dx = _cairo_fixed_to_double (spline_pen.spline.final_slope.dx); - final_slope_dy = _cairo_fixed_to_double (spline_pen.spline.final_slope.dy); - - if (_compute_normalized_device_slope (&initial_slope_dx, &initial_slope_dy, - stroker->ctm_inverse, NULL)) - { - _compute_face (a, - &spline_pen.spline.initial_slope, - initial_slope_dx, initial_slope_dy, - stroker, &start); - } - - if (_compute_normalized_device_slope (&final_slope_dx, &final_slope_dy, - stroker->ctm_inverse, NULL)) - { - _compute_face (d, - &spline_pen.spline.final_slope, - final_slope_dx, final_slope_dy, - stroker, &end); - } - - if (stroker->has_current_face) { - status = _cairo_stroker_join (stroker, &stroker->current_face, &start); - if (unlikely (status)) - goto CLEANUP_PEN; - } else if (! stroker->has_first_face) { - stroker->first_face = start; - stroker->has_first_face = TRUE; - } - stroker->current_face = end; - stroker->has_current_face = TRUE; - - extra_points[0] = start.cw; - extra_points[0].x -= start.point.x; - extra_points[0].y -= start.point.y; - extra_points[1] = start.ccw; - extra_points[1].x -= start.point.x; - extra_points[1].y -= start.point.y; - extra_points[2] = end.cw; - extra_points[2].x -= end.point.x; - extra_points[2].y -= end.point.y; - extra_points[3] = end.ccw; - extra_points[3].x -= end.point.x; - extra_points[3].y -= end.point.y; - - status = _cairo_pen_add_points (&spline_pen.pen, extra_points, 4); - if (unlikely (status)) - goto CLEANUP_PEN; - - status = _cairo_pen_stroke_spline (&spline_pen, - stroker->tolerance, - stroker->traps); - - CLEANUP_PEN: - _cairo_pen_stroke_spline_fini (&spline_pen); - - stroker->current_point = *d; - - return status; -} - -/* We're using two different algorithms here for dashed and un-dashed - * splines. The dashed algorithm uses the existing line dashing - * code. It's linear in path length, but gets subtly wrong results for - * self-intersecting paths (an outstanding but for self-intersecting - * non-curved paths as well). The non-dashed algorithm tessellates a - * single polygon for the whole curve. It handles the - * self-intersecting problem, but it's (unsurprisingly) not O(n) and - * more significantly, it doesn't yet handle dashes. - * - * The only reason we're doing split algorithms here is to - * minimize the impact of fixing the splines-aren't-dashed bug for - * 1.0.2. Long-term the right answer is to rewrite the whole pile - * of stroking code so that the entire result is computed as a - * single polygon that is tessellated, (that is, stroking can be - * built on top of filling). That will solve the self-intersecting - * problem. It will also increase the importance of implementing - * an efficient and more robust tessellator. - */ -static cairo_status_t -_cairo_stroker_curve_to_dashed (void *closure, - const cairo_point_t *b, - const cairo_point_t *c, - const cairo_point_t *d) { cairo_stroker_t *stroker = closure; cairo_spline_t spline; - cairo_point_t *a = &stroker->current_point; cairo_line_join_t line_join_save; - cairo_status_t status; + cairo_stroke_face_t face; + double slope_dx, slope_dy; + cairo_path_fixed_line_to_func_t *line_to; + cairo_status_t status = CAIRO_STATUS_SUCCESS; + + line_to = stroker->dash.dashed ? + _cairo_stroker_line_to_dashed : + _cairo_stroker_line_to; if (! _cairo_spline_init (&spline, - _cairo_stroker_line_to_dashed, - stroker, - a, b, c, d)) + line_to, stroker, + &stroker->current_point, b, c, d)) { - return _cairo_stroker_line_to_dashed (closure, d); + return line_to (closure, d); } /* If the line width is so small that the pen is reduced to a @@ -1095,23 +1189,71 @@ _cairo_stroker_curve_to_dashed (void *closure, if (stroker->pen.num_vertices <= 1) return CAIRO_STATUS_SUCCESS; + /* Compute the initial face */ + if (! stroker->dash.dashed || stroker->dash.dash_on) { + slope_dx = _cairo_fixed_to_double (spline.initial_slope.dx); + slope_dy = _cairo_fixed_to_double (spline.initial_slope.dy); + if (_compute_normalized_device_slope (&slope_dx, &slope_dy, + stroker->ctm_inverse, NULL)) + { + _compute_face (&stroker->current_point, + &spline.initial_slope, + slope_dx, slope_dy, + stroker, &face); + } + if (stroker->has_current_face) { + status = _cairo_stroker_join (stroker, + &stroker->current_face, &face); + if (unlikely (status)) + return status; + } else if (! stroker->has_first_face) { + stroker->first_face = face; + stroker->has_first_face = TRUE; + } + + stroker->current_face = face; + stroker->has_current_face = TRUE; + } + /* Temporarily modify the stroker to use round joins to guarantee * smooth stroked curves. */ line_join_save = stroker->style->line_join; stroker->style->line_join = CAIRO_LINE_JOIN_ROUND; status = _cairo_spline_decompose (&spline, stroker->tolerance); + if (unlikely (status)) + return status; + + /* And join the final face */ + if (! stroker->dash.dashed || stroker->dash.dash_on) { + slope_dx = _cairo_fixed_to_double (spline.final_slope.dx); + slope_dy = _cairo_fixed_to_double (spline.final_slope.dy); + if (_compute_normalized_device_slope (&slope_dx, &slope_dy, + stroker->ctm_inverse, NULL)) + { + _compute_face (&stroker->current_point, + &spline.final_slope, + slope_dx, slope_dy, + stroker, &face); + } + + status = _cairo_stroker_join (stroker, &stroker->current_face, &face); + if (unlikely (status)) + return status; + + stroker->current_face = face; + } stroker->style->line_join = line_join_save; - return status; + return CAIRO_STATUS_SUCCESS; } static cairo_status_t _cairo_stroker_close_path (void *closure) { - cairo_status_t status; cairo_stroker_t *stroker = closure; + cairo_status_t status; if (stroker->dash.dashed) status = _cairo_stroker_line_to_dashed (stroker, &stroker->first_point); @@ -1122,7 +1264,9 @@ _cairo_stroker_close_path (void *closure) if (stroker->has_first_face && stroker->has_current_face) { /* Join first and final faces of sub path */ - status = _cairo_stroker_join (stroker, &stroker->current_face, &stroker->first_face); + status = _cairo_stroker_join (stroker, + &stroker->current_face, + &stroker->first_face); if (unlikely (status)) return status; } else { @@ -1139,11 +1283,100 @@ _cairo_stroker_close_path (void *closure) return CAIRO_STATUS_SUCCESS; } -static cairo_int_status_t -_cairo_path_fixed_stroke_rectilinear (const cairo_path_fixed_t *path, - cairo_stroke_style_t *stroke_style, - const cairo_matrix_t *ctm, - cairo_traps_t *traps); +cairo_status_t +_cairo_path_fixed_stroke_to_shaper (cairo_path_fixed_t *path, + cairo_stroke_style_t *stroke_style, + cairo_matrix_t *ctm, + cairo_matrix_t *ctm_inverse, + double tolerance, + cairo_status_t (*add_triangle) (void *closure, + const cairo_point_t triangle[3]), + cairo_status_t (*add_triangle_fan) (void *closure, + const cairo_point_t *midpt, + const cairo_point_t *points, + int npoints), + cairo_status_t (*add_convex_quad) (void *closure, + const cairo_point_t quad[4]), + void *closure) +{ + cairo_stroker_t stroker; + cairo_status_t status; + + status = _cairo_stroker_init (&stroker, stroke_style, + ctm, ctm_inverse, tolerance); + if (unlikely (status)) + return status; + + stroker.add_triangle = add_triangle; + stroker.add_triangle_fan = add_triangle_fan; + stroker.add_convex_quad = add_convex_quad; + stroker.closure = closure; + + status = _cairo_path_fixed_interpret (path, + CAIRO_DIRECTION_FORWARD, + _cairo_stroker_move_to, + stroker.dash.dashed ? + _cairo_stroker_line_to_dashed : + _cairo_stroker_line_to, + _cairo_stroker_curve_to, + _cairo_stroker_close_path, + &stroker); + + if (unlikely (status)) + goto BAIL; + + /* Cap the start and end of the final sub path as needed */ + status = _cairo_stroker_add_caps (&stroker); + +BAIL: + _cairo_stroker_fini (&stroker); + + return status; +} + +cairo_status_t +_cairo_path_fixed_stroke_to_polygon (const cairo_path_fixed_t *path, + cairo_stroke_style_t *stroke_style, + const cairo_matrix_t *ctm, + const cairo_matrix_t *ctm_inverse, + double tolerance, + cairo_polygon_t *polygon) +{ + cairo_stroker_t stroker; + cairo_status_t status; + + status = _cairo_stroker_init (&stroker, stroke_style, + ctm, ctm_inverse, tolerance); + if (unlikely (status)) + return status; + + stroker.add_external_edge = _cairo_polygon_add_external_edge, + stroker.closure = polygon; + + if (polygon->has_limits) + _cairo_stroker_limit (&stroker, &polygon->limits); + + status = _cairo_path_fixed_interpret (path, + CAIRO_DIRECTION_FORWARD, + _cairo_stroker_move_to, + stroker.dash.dashed ? + _cairo_stroker_line_to_dashed : + _cairo_stroker_line_to, + _cairo_stroker_curve_to, + _cairo_stroker_close_path, + &stroker); + + if (unlikely (status)) + goto BAIL; + + /* Cap the start and end of the final sub path as needed */ + status = _cairo_stroker_add_caps (&stroker); + +BAIL: + _cairo_stroker_fini (&stroker); + + return status; +} cairo_status_t _cairo_path_fixed_stroke_to_traps (const cairo_path_fixed_t *path, @@ -1154,50 +1387,44 @@ _cairo_path_fixed_stroke_to_traps (const cairo_path_fixed_t *path, cairo_traps_t *traps) { cairo_status_t status; - cairo_stroker_t stroker; + cairo_polygon_t polygon; /* Before we do anything else, we attempt the rectilinear * stroker. It's careful to generate trapezoids that align to * device-pixel boundaries when possible. Many backends can render * those much faster than non-aligned trapezoids, (by using clip * regions, etc.) */ - status = _cairo_path_fixed_stroke_rectilinear (path, - stroke_style, - ctm, - traps); - if (status != CAIRO_INT_STATUS_UNSUPPORTED) - return status; + if (path->is_rectilinear) { + status = _cairo_path_fixed_stroke_rectilinear_to_traps (path, + stroke_style, + ctm, + traps); + if (status != CAIRO_INT_STATUS_UNSUPPORTED) + return status; + } - status = _cairo_stroker_init (&stroker, stroke_style, - ctm, ctm_inverse, tolerance, - traps); + _cairo_polygon_init (&polygon); + if (traps->has_limits) + _cairo_polygon_limit (&polygon, &traps->limits); + + status = _cairo_path_fixed_stroke_to_polygon (path, + stroke_style, + ctm, + ctm_inverse, + tolerance, + &polygon); if (unlikely (status)) - return status; + goto BAIL; - if (stroker.style->dash) - status = _cairo_path_fixed_interpret (path, - CAIRO_DIRECTION_FORWARD, - _cairo_stroker_move_to_dashed, - _cairo_stroker_line_to_dashed, - _cairo_stroker_curve_to_dashed, - _cairo_stroker_close_path, - &stroker); - else - status = _cairo_path_fixed_interpret (path, - CAIRO_DIRECTION_FORWARD, - _cairo_stroker_move_to, - _cairo_stroker_line_to, - _cairo_stroker_curve_to, - _cairo_stroker_close_path, - &stroker); + status = _cairo_polygon_status (&polygon); if (unlikely (status)) goto BAIL; - /* Cap the start and end of the final sub path as needed */ - status = _cairo_stroker_add_caps (&stroker); + status = _cairo_bentley_ottmann_tessellate_polygon (traps, &polygon, + CAIRO_FILL_RULE_WINDING); BAIL: - _cairo_stroker_fini (&stroker); + _cairo_polygon_fini (&polygon); return status; } @@ -1263,6 +1490,9 @@ _cairo_rectilinear_stroker_init (cairo_rectilinear_stroker_t *stroker, _cairo_stroker_dash_init (&stroker->dash, stroke_style); stroker->has_bounds = FALSE; + + /* As we incrementally tessellate, we do not eliminate self-intersections */ + stroker->traps->has_intersections = TRUE; } static void @@ -1583,8 +1813,7 @@ _cairo_rectilinear_stroker_line_to (void *closure, cairo_status_t status; /* We only support horizontal or vertical elements. */ - if (! (a->x == b->x || a->y == b->y)) - return CAIRO_INT_STATUS_UNSUPPORTED; + assert (a->x == b->x || a->y == b->y); /* We don't draw anything for degenerate paths. */ if (a->x == b->x && a->y == b->y) @@ -1620,8 +1849,7 @@ _cairo_rectilinear_stroker_line_to_dashed (void *closure, return CAIRO_STATUS_SUCCESS; /* We only support horizontal or vertical elements. */ - if (! (a->x == b->x || a->y == b->y)) - return CAIRO_INT_STATUS_UNSUPPORTED; + assert (a->x == b->x || a->y == b->y); fully_in_bounds = TRUE; if (stroker->has_bounds && @@ -1736,11 +1964,11 @@ _cairo_rectilinear_stroker_close_path (void *closure) return CAIRO_STATUS_SUCCESS; } -static cairo_int_status_t -_cairo_path_fixed_stroke_rectilinear (const cairo_path_fixed_t *path, - cairo_stroke_style_t *stroke_style, - const cairo_matrix_t *ctm, - cairo_traps_t *traps) +cairo_int_status_t +_cairo_path_fixed_stroke_rectilinear_to_traps (const cairo_path_fixed_t *path, + cairo_stroke_style_t *stroke_style, + const cairo_matrix_t *ctm, + cairo_traps_t *traps) { cairo_rectilinear_stroker_t rectilinear_stroker; cairo_int_status_t status; @@ -1755,8 +1983,8 @@ _cairo_path_fixed_stroke_rectilinear (const cairo_path_fixed_t *path, * UNSUPPORTED from _cairo_rectilinear_stroker_line_to if any * non-rectilinear line_to is encountered. */ - if (! path->is_rectilinear) - return CAIRO_INT_STATUS_UNSUPPORTED; + assert (path->is_rectilinear); + if (stroke_style->line_join != CAIRO_LINE_JOIN_MITER) return CAIRO_INT_STATUS_UNSUPPORTED; /* If the miter limit turns right angles into bevels, then we @@ -1770,11 +1998,8 @@ _cairo_path_fixed_stroke_rectilinear (const cairo_path_fixed_t *path, { return CAIRO_INT_STATUS_UNSUPPORTED; } - if (! (_cairo_matrix_is_identity (ctm) || - _cairo_matrix_is_translation (ctm))) - { + if (! _cairo_matrix_has_unity_scale (ctm)) return CAIRO_INT_STATUS_UNSUPPORTED; - } _cairo_rectilinear_stroker_init (&rectilinear_stroker, stroke_style, diff --git a/src/cairo-pen.c b/src/cairo-pen.c index b2fd85575..8db8fcb36 100644 --- a/src/cairo-pen.c +++ b/src/cairo-pen.c @@ -393,194 +393,3 @@ _cairo_pen_find_active_ccw_vertex_index (const cairo_pen_t *pen, return i; } - -static int -_cairo_pen_stroke_spline_add_convolved_point (cairo_pen_stroke_spline_t *stroker, - const cairo_point_t *last_point, - const cairo_slope_t *slope, - cairo_point_t *last_hull_point, - int active, - int step) -{ - do { - cairo_point_t hull_point; - - hull_point.x = last_point->x + stroker->pen.vertices[active].point.x; - hull_point.y = last_point->y + stroker->pen.vertices[active].point.y; - _cairo_polygon_add_edge (&stroker->polygon, - last_hull_point, &hull_point, - step); - *last_hull_point = hull_point; - - /* The strict inequalities here ensure that if a spline slope - * compares identically with either of the slopes of the - * active vertex, then it remains the active vertex. This is - * very important since otherwise we can trigger an infinite - * loop in the case of a degenerate pen, (a line), where - * neither vertex considers itself active for the slope---one - * will consider it as equal and reject, and the other will - * consider it unequal and reject. This is due to the inherent - * ambiguity when comparing slopes that differ by exactly - * pi. */ - if (_cairo_slope_compare (slope, - &stroker->pen.vertices[active].slope_ccw) > 0) - { - if (++active == stroker->pen.num_vertices) - active = 0; - } - else if (_cairo_slope_compare (slope, - &stroker->pen.vertices[active].slope_cw) < 0) - { - if (--active == -1) - active = stroker->pen.num_vertices - 1; - } - else - { - return active; - } - } while (TRUE); -} - - -/* Compute outline of a given spline using the pen. - * The trapezoids needed to fill that outline will be added to traps - */ -cairo_status_t -_cairo_pen_stroke_spline (cairo_pen_stroke_spline_t *stroker, - double tolerance, - cairo_traps_t *traps) -{ - cairo_status_t status; - cairo_slope_t slope; - - /* If the line width is so small that the pen is reduced to a - single point, then we have nothing to do. */ - if (stroker->pen.num_vertices <= 1) - return CAIRO_STATUS_SUCCESS; - - /* open the polygon */ - slope = stroker->spline.initial_slope; - stroker->forward_vertex = - _cairo_pen_find_active_cw_vertex_index (&stroker->pen, &slope); - stroker->forward_hull_point.x = stroker->last_point.x + - stroker->pen.vertices[stroker->forward_vertex].point.x; - stroker->forward_hull_point.y = stroker->last_point.y + - stroker->pen.vertices[stroker->forward_vertex].point.y; - - slope.dx = -slope.dx; - slope.dy = -slope.dy; - stroker->backward_vertex = - _cairo_pen_find_active_cw_vertex_index (&stroker->pen, &slope); - stroker->backward_hull_point.x = stroker->last_point.x + - stroker->pen.vertices[stroker->backward_vertex].point.x; - stroker->backward_hull_point.y = stroker->last_point.y + - stroker->pen.vertices[stroker->backward_vertex].point.y; - - _cairo_polygon_add_edge (&stroker->polygon, - &stroker->backward_hull_point, - &stroker->forward_hull_point, - 1); - - status = _cairo_spline_decompose (&stroker->spline, tolerance); - if (unlikely (status)) - return status; - - /* close the polygon */ - slope = stroker->spline.final_slope; - _cairo_pen_stroke_spline_add_convolved_point (stroker, - &stroker->last_point, - &slope, - &stroker->forward_hull_point, - stroker->forward_vertex, - 1); - - slope.dx = -slope.dx; - slope.dy = -slope.dy; - _cairo_pen_stroke_spline_add_convolved_point (stroker, - &stroker->last_point, - &slope, - &stroker->backward_hull_point, - stroker->backward_vertex, - -1); - - _cairo_polygon_add_edge (&stroker->polygon, - &stroker->forward_hull_point, - &stroker->backward_hull_point, - 1); - - status = _cairo_polygon_status (&stroker->polygon); - if (unlikely (status)) - return status; - - status = _cairo_bentley_ottmann_tessellate_polygon (traps, - &stroker->polygon, - CAIRO_FILL_RULE_WINDING); - - return status; -} - -static cairo_status_t -_cairo_pen_stroke_spline_add_point (void *closure, - const cairo_point_t *point) -{ - cairo_pen_stroke_spline_t *stroker = closure; - cairo_slope_t slope; - - _cairo_slope_init (&slope, &stroker->last_point, point); - stroker->forward_vertex = - _cairo_pen_stroke_spline_add_convolved_point (stroker, - &stroker->last_point, - &slope, - &stroker->forward_hull_point, - stroker->forward_vertex, - 1); - - slope.dx = -slope.dx; - slope.dy = -slope.dy; - stroker->backward_vertex = - _cairo_pen_stroke_spline_add_convolved_point (stroker, - &stroker->last_point, - &slope, - &stroker->backward_hull_point, - stroker->backward_vertex, - -1); - stroker->last_point = *point; - - return CAIRO_STATUS_SUCCESS; -} - -cairo_int_status_t -_cairo_pen_stroke_spline_init (cairo_pen_stroke_spline_t *stroker, - const cairo_pen_t *pen, - const cairo_point_t *a, - const cairo_point_t *b, - const cairo_point_t *c, - const cairo_point_t *d) -{ - cairo_int_status_t status; - - if (! _cairo_spline_init (&stroker->spline, - _cairo_pen_stroke_spline_add_point, - stroker, - a, b, c, d)) - { - return CAIRO_INT_STATUS_DEGENERATE; - } - - status = _cairo_pen_init_copy (&stroker->pen, pen); - if (unlikely (status)) - return status; - - _cairo_polygon_init (&stroker->polygon); - - stroker->last_point = *a; - - return CAIRO_STATUS_SUCCESS; -} - -void -_cairo_pen_stroke_spline_fini (cairo_pen_stroke_spline_t *stroker) -{ - _cairo_polygon_fini (&stroker->polygon); - _cairo_pen_fini (&stroker->pen); -} diff --git a/src/cairo-polygon.c b/src/cairo-polygon.c index 202cb4d73..ac4d0945f 100644 --- a/src/cairo-polygon.c +++ b/src/cairo-polygon.c @@ -49,6 +49,18 @@ _cairo_polygon_init (cairo_polygon_t *polygon) polygon->edges_size = ARRAY_LENGTH (polygon->edges_embedded); polygon->has_current_point = FALSE; + polygon->has_limits = FALSE; + + polygon->extents.p1.x = polygon->extents.p1.y = INT32_MAX; + polygon->extents.p2.x = polygon->extents.p2.y = INT32_MIN; +} + +void +_cairo_polygon_limit (cairo_polygon_t *polygon, + const cairo_box_t *limits) +{ + polygon->has_limits = TRUE; + polygon->limits = *limits; } void @@ -93,17 +105,16 @@ _cairo_polygon_grow (cairo_polygon_t *polygon) return TRUE; } -void -_cairo_polygon_add_edge (cairo_polygon_t *polygon, - const cairo_point_t *p1, - const cairo_point_t *p2, - int dir) +static void +_add_edge (cairo_polygon_t *polygon, + const cairo_point_t *p1, + const cairo_point_t *p2, + int top, int bottom, + int dir) { cairo_edge_t *edge; - /* drop horizontal edges */ - if (p1->y == p2->y) - return; + assert (top < bottom); if (polygon->num_edges == polygon->edges_size) { if (! _cairo_polygon_grow (polygon)) @@ -111,26 +122,247 @@ _cairo_polygon_add_edge (cairo_polygon_t *polygon, } edge = &polygon->edges[polygon->num_edges++]; + edge->line.p1 = *p1; + edge->line.p2 = *p2; + edge->top = top; + edge->bottom = bottom; + edge->dir = dir; + + if (top < polygon->extents.p1.y) + polygon->extents.p1.y = top; + if (bottom > polygon->extents.p2.y) + polygon->extents.p2.y = bottom; + + if (p1->x < polygon->extents.p1.x || p1->x > polygon->extents.p2.x) { + cairo_fixed_t x = p1->x; + if (top != p1->y) + x = _cairo_edge_compute_intersection_x_for_y (p1, p2, top); + if (x < polygon->extents.p1.x) + polygon->extents.p1.x = x; + if (x > polygon->extents.p2.x) + polygon->extents.p2.x = x; + } + + if (p2->x < polygon->extents.p1.x || p2->x > polygon->extents.p2.x) { + cairo_fixed_t x = p2->x; + if (bottom != p2->y) + x = _cairo_edge_compute_intersection_x_for_y (p1, p2, bottom); + if (x < polygon->extents.p1.x) + polygon->extents.p1.x = x; + if (x > polygon->extents.p2.x) + polygon->extents.p2.x = x; + } +} + +static void +_add_clipped_edge (cairo_polygon_t *polygon, + const cairo_point_t *p1, + const cairo_point_t *p2, + int dir) +{ + cairo_point_t p[2]; + int top_y, bot_y; + + if (p1->x <= polygon->limits.p1.x && p2->x <= polygon->limits.p1.x) + { + p[0].x = polygon->limits.p1.x; + p[0].y = polygon->limits.p1.y; + top_y = p1->y; + if (top_y < p[0].y) + top_y = p[0].y; + + p[1].x = polygon->limits.p1.x; + p[1].y = polygon->limits.p2.y; + bot_y = p2->y; + if (bot_y > p[1].y) + bot_y = p[1].y; + + _add_edge (polygon, &p[0], &p[1], top_y, bot_y, dir); + } + else if (p1->x >= polygon->limits.p2.x && p2->x >= polygon->limits.p2.x) + { + p[0].x = polygon->limits.p2.x; + p[0].y = polygon->limits.p1.y; + top_y = p1->y; + if (top_y < p[0].y) + top_y = p[0].y; + + p[1].x = polygon->limits.p2.x; + p[1].y = polygon->limits.p2.y; + bot_y = p2->y; + if (bot_y > p[1].y) + bot_y = p[1].y; + + _add_edge (polygon, &p[0], &p[1], top_y, bot_y, dir); + } + else if (p1->x >= polygon->limits.p1.x && p2->x >= polygon->limits.p1.x && + p1->x <= polygon->limits.p2.x && p2->x <= polygon->limits.p2.x) + { + top_y = p1->y; + if (top_y < polygon->limits.p1.y) + top_y = polygon->limits.p1.y; + + bot_y = p2->y; + if (bot_y > polygon->limits.p2.y) + bot_y = polygon->limits.p2.y; + + _add_edge (polygon, p1, p2, top_y, bot_y, dir); + } + else + { + int left_y, right_y; + int p1_y, p2_y; + + left_y = _cairo_edge_compute_intersection_y_for_x (p1, p2, + polygon->limits.p1.x); + right_y = _cairo_edge_compute_intersection_y_for_x (p1, p2, + polygon->limits.p2.x); + + if (left_y == right_y) /* horizontal within bounds */ + return; + + p1_y = p1->y; + p2_y = p2->y; + + if (left_y < right_y) { + if (p1->x < polygon->limits.p1.x && left_y > polygon->limits.p1.y) + { + p[0].x = polygon->limits.p1.x; + p[0].y = polygon->limits.p1.y; + top_y = p1_y; + if (top_y < p[0].y) + top_y = p[0].y; + + p[1].x = polygon->limits.p1.x; + p[1].y = polygon->limits.p2.y; + bot_y = left_y; + if (bot_y > p[1].y) + bot_y = p[1].y; + + if (bot_y > top_y) + _add_edge (polygon, &p[0], &p[1], top_y, bot_y, dir); + p1_y = bot_y; + } + + if (p2->x > polygon->limits.p2.x && right_y < polygon->limits.p2.y) + { + p[0].x = polygon->limits.p2.x; + p[0].y = polygon->limits.p1.y; + top_y = right_y; + if (top_y < p[0].y) + top_y = p[0].y; + + p[1].x = polygon->limits.p2.x; + p[1].y = polygon->limits.p2.y; + bot_y = p2_y; + if (bot_y > p[1].y) + bot_y = p[1].y; + + if (bot_y > top_y) + _add_edge (polygon, &p[0], &p[1], top_y, bot_y, dir); + p2_y = top_y; + } + } else { + if (p1->x > polygon->limits.p2.x && right_y > polygon->limits.p1.y) + { + p[0].x = polygon->limits.p2.x; + p[0].y = polygon->limits.p1.y; + top_y = p1_y; + if (top_y < p[0].y) + top_y = p[0].y; + + p[1].x = polygon->limits.p2.x; + p[1].y = polygon->limits.p2.y; + bot_y = right_y; + if (bot_y > p[1].y) + bot_y = p[1].y; + + if (bot_y > top_y) + _add_edge (polygon, &p[0], &p[1], top_y, bot_y, dir); + p1_y = bot_y; + } + + if (p2->x < polygon->limits.p1.x && left_y < polygon->limits.p2.y) + { + p[0].x = polygon->limits.p1.x; + p[0].y = polygon->limits.p1.y; + top_y = left_y; + if (top_y < p[0].y) + top_y = p[0].y; + + p[1].x = polygon->limits.p1.x; + p[1].y = polygon->limits.p2.y; + bot_y = p2_y; + if (bot_y > p[1].y) + bot_y = p[1].y; + + if (bot_y > top_y) + _add_edge (polygon, &p[0], &p[1], top_y, bot_y, dir); + p2_y = top_y; + } + } + + if (p1_y < polygon->limits.p1.y) + p1_y = polygon->limits.p1.y; + if (p2_y > polygon->limits.p2.y) + p2_y = polygon->limits.p2.y; + if (p2_y > p1_y) + _add_edge (polygon, p1, p2, p1_y, p2_y, dir); + } +} + +static void +_cairo_polygon_add_edge (cairo_polygon_t *polygon, + const cairo_point_t *p1, + const cairo_point_t *p2) +{ + int dir; + + /* drop horizontal edges */ + if (p1->y == p2->y) + return; + if (p1->y < p2->y) { - edge->edge.p1 = *p1; - edge->edge.p2 = *p2; - edge->dir = dir; + dir = 1; } else { - edge->edge.p1 = *p2; - edge->edge.p2 = *p1; - edge->dir = -dir; + const cairo_point_t *t; + t = p1, p1 = p2, p2 = t; + dir = -1; } + + if (polygon->has_limits) { + if (p2->y <= polygon->limits.p1.y) + return; + + if (p1->y >= polygon->limits.p2.y) + return; + + _add_clipped_edge (polygon, p1, p2, dir); + } else + _add_edge (polygon, p1, p2, p1->y, p2->y, dir); +} + +cairo_status_t +_cairo_polygon_add_external_edge (void *polygon, + const cairo_point_t *p1, + const cairo_point_t *p2) +{ + _cairo_polygon_add_edge (polygon, p1, p2); + return _cairo_polygon_status (polygon); } +/* flattened path operations */ + void _cairo_polygon_move_to (cairo_polygon_t *polygon, const cairo_point_t *point) { - if (! polygon->has_current_point) + if (! polygon->has_current_point) { polygon->first_point = *point; + polygon->has_current_point = TRUE; + } polygon->current_point = *point; - polygon->has_current_point = TRUE; } void @@ -138,7 +370,7 @@ _cairo_polygon_line_to (cairo_polygon_t *polygon, const cairo_point_t *point) { if (polygon->has_current_point) - _cairo_polygon_add_edge (polygon, &polygon->current_point, point, 1); + _cairo_polygon_add_edge (polygon, &polygon->current_point, point); _cairo_polygon_move_to (polygon, point); } @@ -149,8 +381,7 @@ _cairo_polygon_close (cairo_polygon_t *polygon) if (polygon->has_current_point) { _cairo_polygon_add_edge (polygon, &polygon->current_point, - &polygon->first_point, - 1); + &polygon->first_point); polygon->has_current_point = FALSE; } diff --git a/src/cairo-skiplist-private.h b/src/cairo-skiplist-private.h index 250b5a26e..c0e5bce5e 100644 --- a/src/cairo-skiplist-private.h +++ b/src/cairo-skiplist-private.h @@ -62,7 +62,7 @@ typedef struct _skip_elt { #define SKIP_LIST_ELT_TO_DATA(type, elt) ((type *) ((char *) (elt) - (sizeof (type) - sizeof (skip_elt_t)))) typedef int -(*cairo_skip_list_compare_t) (void *list, void *a, void *b); +(*cairo_skip_list_compare_t) (void *list, const void *a, const void *b); typedef struct _skip_list { cairo_skip_list_compare_t compare; @@ -101,7 +101,7 @@ _cairo_skip_list_fini (cairo_skip_list_t *list); * Otherwise data will be copied (elt_size bytes from via * memcpy) and the new element is returned. */ cairo_private void * -_cairo_skip_list_insert (cairo_skip_list_t *list, void *data, int unique); +_cairo_skip_list_insert (cairo_skip_list_t *list, void *data); /* Find an element which compare considers equal to */ cairo_private void * diff --git a/src/cairo-skiplist.c b/src/cairo-skiplist.c index 18d69ca6c..8d8c8d1f7 100644 --- a/src/cairo-skiplist.c +++ b/src/cairo-skiplist.c @@ -189,7 +189,7 @@ free_elt (cairo_skip_list_t *list, skip_elt_t *elt) * Insert 'data' into the list */ void * -_cairo_skip_list_insert (cairo_skip_list_t *list, void *data, int unique) +_cairo_skip_list_insert (cairo_skip_list_t *list, void *data) { skip_elt_t **update[MAX_LEVEL]; skip_elt_t *prev[MAX_LEVEL]; @@ -209,7 +209,7 @@ _cairo_skip_list_insert (cairo_skip_list_t *list, void *data, int unique) for (; (elt = next[i]); next = elt->next) { int cmp = list->compare (list, ELT_DATA(elt), data); - if (unique && 0 == cmp) + if (0 == cmp) return ELT_DATA(elt); if (cmp > 0) break; @@ -369,7 +369,7 @@ typedef struct { } test_elt_t; static int -test_cmp (void *list, void *A, void *B) +test_cmp (void *list, const void *A, const void *B) { const test_elt_t *a = A, *b = B; return a->n - b->n; @@ -386,7 +386,7 @@ main (void) for (n = 0; n < 10000000; n++) { void *elt_and_data; elt.n = n; - elt_and_data = _cairo_skip_list_insert (&list, &elt, TRUE); + elt_and_data = _cairo_skip_list_insert (&list, &elt); assert (elt_and_data != NULL); } _cairo_skip_list_fini (&list); diff --git a/src/cairo-slope.c b/src/cairo-slope.c index 35c537221..15685b789 100644 --- a/src/cairo-slope.c +++ b/src/cairo-slope.c @@ -94,9 +94,7 @@ _cairo_slope_compare (const cairo_slope_t *a, const cairo_slope_t *b) * of b by an infinitesimally small amount, (that is, 'a' will * always be considered less than 'b'). */ - if (((a->dx > 0) != (b->dx > 0)) || - ((a->dy > 0) != (b->dy > 0))) - { + if ((a->dx ^ b->dx) < 0 || (a->dy ^ b->dy) < 0) { if (a->dx > 0 || (a->dx == 0 && a->dy > 0)) return +1; else diff --git a/src/cairo-spans-private.h b/src/cairo-spans-private.h index c706b22a7..9f6f11695 100644 --- a/src/cairo-spans-private.h +++ b/src/cairo-spans-private.h @@ -75,22 +75,15 @@ struct _cairo_scan_converter { /* Destroy this scan converter. */ cairo_destroy_func_t destroy; - /* Add an edge to the converter. */ - cairo_status_t - (*add_edge)( - void *abstract_converter, - cairo_fixed_t x1, - cairo_fixed_t y1, - cairo_fixed_t x2, - cairo_fixed_t y2); + /* Add a polygon (set of edges) to the converter. */ + cairo_status_t (*add_polygon) (void *abstract_converter, + const cairo_polygon_t *polygon); /* Generates coverage spans for rows for the added edges and calls * the renderer function for each row. After generating spans the * only valid thing to do with the converter is to destroy it. */ - cairo_status_t - (*generate)( - void *abstract_converter, - cairo_span_renderer_t *renderer); + cairo_status_t (*generate) (void *abstract_converter, + cairo_span_renderer_t *renderer); /* Private status. Read with _cairo_scan_converter_status(). */ cairo_status_t status; @@ -99,12 +92,11 @@ struct _cairo_scan_converter { /* Scan converter constructors. */ cairo_private cairo_scan_converter_t * -_cairo_tor_scan_converter_create( - int xmin, - int ymin, - int xmax, - int ymax, - cairo_fill_rule_t fill_rule); +_cairo_tor_scan_converter_create (int xmin, + int ymin, + int xmax, + int ymax, + cairo_fill_rule_t fill_rule); /* cairo-spans.c: */ @@ -132,14 +124,13 @@ _cairo_span_renderer_set_error (void *abstract_renderer, cairo_status_t error); cairo_private cairo_status_t -_cairo_path_fixed_fill_using_spans (cairo_operator_t op, - const cairo_pattern_t *pattern, - cairo_path_fixed_t *path, - cairo_surface_t *dst, - cairo_fill_rule_t fill_rule, - double tolerance, - cairo_antialias_t antialias, - const cairo_composite_rectangles_t *rects, - cairo_region_t *clip_region); +_cairo_surface_composite_polygon (cairo_surface_t *surface, + cairo_operator_t op, + const cairo_pattern_t *pattern, + cairo_fill_rule_t fill_rule, + cairo_antialias_t antialias, + const cairo_composite_rectangles_t *rects, + cairo_polygon_t *polygon, + cairo_region_t *clip_region); #endif /* CAIRO_SPANS_PRIVATE_H */ diff --git a/src/cairo-spans.c b/src/cairo-spans.c index 48396b54f..369cd5827 100644 --- a/src/cairo-spans.c +++ b/src/cairo-spans.c @@ -26,107 +26,7 @@ */ #include "cairoint.h" -typedef struct { - cairo_scan_converter_t *converter; - cairo_point_t current_point; - cairo_point_t first_point; - cairo_bool_t has_first_point; -} scan_converter_filler_t; - -static void -scan_converter_filler_init (scan_converter_filler_t *filler, - cairo_scan_converter_t *converter) -{ - filler->converter = converter; - filler->current_point.x = 0; - filler->current_point.y = 0; - filler->first_point = filler->current_point; - filler->has_first_point = FALSE; -} - -static cairo_status_t -scan_converter_filler_close_path (void *closure) -{ - scan_converter_filler_t *filler = closure; - cairo_status_t status; - - filler->has_first_point = FALSE; - - if (filler->first_point.x == filler->current_point.x && - filler->first_point.y == filler->current_point.y) - { - return CAIRO_STATUS_SUCCESS; - } - - status = filler->converter->add_edge ( - filler->converter, - filler->current_point.x, filler->current_point.y, - filler->first_point.x, filler->first_point.y); - - filler->current_point = filler->first_point; - return status; -} - -static cairo_status_t -scan_converter_filler_move_to (void *closure, - const cairo_point_t *p) -{ - scan_converter_filler_t *filler = closure; - if (filler->has_first_point) { - cairo_status_t status = scan_converter_filler_close_path (closure); - if (status) - return status; - } - filler->current_point.x = p->x; - filler->current_point.y = p->y; - filler->first_point = filler->current_point; - filler->has_first_point = TRUE; - return CAIRO_STATUS_SUCCESS; -} - -static cairo_status_t -scan_converter_filler_line_to (void *closure, - const cairo_point_t *p) -{ - scan_converter_filler_t *filler = closure; - cairo_status_t status; - cairo_point_t to; - - to.x = p->x; - to.y = p->y; - - status = filler->converter->add_edge ( - filler->converter, - filler->current_point.x, filler->current_point.y, - to.x, to.y); - - filler->current_point = to; - - return status; -} - -static cairo_status_t -_cairo_path_fixed_fill_to_scan_converter ( - cairo_path_fixed_t *path, - double tolerance, - cairo_scan_converter_t *converter) -{ - scan_converter_filler_t filler; - cairo_status_t status; - - scan_converter_filler_init (&filler, converter); - - status = _cairo_path_fixed_interpret_flat ( - path, CAIRO_DIRECTION_FORWARD, - scan_converter_filler_move_to, - scan_converter_filler_line_to, - scan_converter_filler_close_path, - &filler, tolerance); - if (status) - return status; - - return scan_converter_filler_close_path (&filler); -} +#include "cairo-fixed-private.h" static cairo_scan_converter_t * _create_scan_converter (cairo_fill_rule_t fill_rule, @@ -135,51 +35,50 @@ _create_scan_converter (cairo_fill_rule_t fill_rule, { if (antialias == CAIRO_ANTIALIAS_NONE) { ASSERT_NOT_REACHED; - return _cairo_scan_converter_create_in_error ( - CAIRO_INT_STATUS_UNSUPPORTED); - } - else { - return _cairo_tor_scan_converter_create ( - rects->mask.x, - rects->mask.y, - rects->mask.x + rects->width, - rects->mask.y + rects->height, - fill_rule); + return NULL; } + + return _cairo_tor_scan_converter_create (rects->mask.x, + rects->mask.y, + rects->mask.x + rects->width, + rects->mask.y + rects->height, + fill_rule); } +/* XXX Add me to the compositor interface. Ok, first create the compositor + * interface, and then add this with associated fallback! + */ cairo_status_t -_cairo_path_fixed_fill_using_spans (cairo_operator_t op, - const cairo_pattern_t *pattern, - cairo_path_fixed_t *path, - cairo_surface_t *dst, - cairo_fill_rule_t fill_rule, - double tolerance, - cairo_antialias_t antialias, - const cairo_composite_rectangles_t *rects, - cairo_region_t *clip_region) +_cairo_surface_composite_polygon (cairo_surface_t *surface, + cairo_operator_t op, + const cairo_pattern_t *pattern, + cairo_fill_rule_t fill_rule, + cairo_antialias_t antialias, + const cairo_composite_rectangles_t *rects, + cairo_polygon_t *polygon, + cairo_region_t *clip_region) { + cairo_span_renderer_t *renderer; + cairo_scan_converter_t *converter; cairo_status_t status; - cairo_span_renderer_t *renderer = _cairo_surface_create_span_renderer ( - op, pattern, dst, antialias, rects, clip_region); - cairo_scan_converter_t *converter = _create_scan_converter ( - fill_rule, antialias, rects); - status = _cairo_path_fixed_fill_to_scan_converter ( - path, tolerance, converter); - if (status) - goto BAIL; + converter = _create_scan_converter (fill_rule, antialias, rects); + status = converter->add_polygon (converter, polygon); + if (unlikely (status)) + goto CLEANUP_CONVERTER; + renderer = _cairo_surface_create_span_renderer (op, pattern, surface, + antialias, rects, + clip_region); status = converter->generate (converter, renderer); - if (status) - goto BAIL; + if (unlikely (status)) + goto CLEANUP_RENDERER; status = renderer->finish (renderer); - if (status) - goto BAIL; - BAIL: + CLEANUP_RENDERER: renderer->destroy (renderer); + CLEANUP_CONVERTER: converter->destroy (converter); return status; } @@ -191,17 +90,11 @@ _cairo_nil_destroy (void *abstract) } static cairo_status_t -_cairo_nil_scan_converter_add_edge (void *abstract_converter, - cairo_fixed_t x1, - cairo_fixed_t y1, - cairo_fixed_t x2, - cairo_fixed_t y2) +_cairo_nil_scan_converter_add_polygon (void *abstract_converter, + const cairo_polygon_t *polygon) { (void) abstract_converter; - (void) x1; - (void) y1; - (void) x2; - (void) y2; + (void) polygon; return _cairo_scan_converter_status (abstract_converter); } @@ -229,7 +122,7 @@ _cairo_scan_converter_set_error (void *abstract_converter, if (error == CAIRO_STATUS_SUCCESS) ASSERT_NOT_REACHED; if (converter->status == CAIRO_STATUS_SUCCESS) { - converter->add_edge = _cairo_nil_scan_converter_add_edge; + converter->add_polygon = _cairo_nil_scan_converter_add_polygon; converter->generate = _cairo_nil_scan_converter_generate; converter->status = error; } diff --git a/src/cairo-surface-fallback.c b/src/cairo-surface-fallback.c index 3bfb17dee..7ab12b4d1 100644 --- a/src/cairo-surface-fallback.c +++ b/src/cairo-surface-fallback.c @@ -34,6 +34,8 @@ * * Contributor(s): * Carl D. Worth + * Joonas Pihlaja + * Chris Wilson */ #include "cairoint.h" @@ -41,6 +43,7 @@ #include "cairo-surface-fallback-private.h" #include "cairo-clip-private.h" #include "cairo-region-private.h" +#include "cairo-spans-private.h" typedef struct { cairo_surface_t *dst; @@ -739,8 +742,15 @@ _clip_and_composite_trapezoids (const cairo_pattern_t *src, } } - /* Otherwise we need to render the trapezoids to a mask and composite - * in the usual fashion. + /* No fast path, exclude self-intersections and clip trapezoids. */ + if (traps->has_intersections) { + status = _cairo_bentley_ottmann_tessellate_traps (traps); + if (unlikely (status)) + return status; + } + + /* Otherwise render the trapezoids to a mask and composite in the usual + * fashion. */ if (_cairo_operator_bounded_by_mask (op)) { cairo_rectangle_int_t trap_extents; @@ -754,20 +764,20 @@ _clip_and_composite_trapezoids (const cairo_pattern_t *src, traps_info.traps = traps; traps_info.antialias = antialias; + return _clip_and_composite (clip, op, src, _composite_traps_draw_func, &traps_info, dst, extents); } typedef struct { - cairo_path_fixed_t *path; + cairo_polygon_t *polygon; cairo_fill_rule_t fill_rule; - double tolerance; cairo_antialias_t antialias; -} cairo_composite_spans_fill_info_t; +} cairo_composite_spans_info_t; static cairo_status_t -_composite_spans_fill_func (void *closure, +_composite_spans_draw_func (void *closure, cairo_operator_t op, const cairo_pattern_t *src, cairo_surface_t *dst, @@ -777,7 +787,7 @@ _composite_spans_fill_func (void *closure, cairo_region_t *clip_region) { cairo_composite_rectangles_t rects; - cairo_composite_spans_fill_info_t *info = closure; + cairo_composite_spans_info_t *info = closure; _cairo_composite_rectangles_init ( &rects, extents->x, extents->y, @@ -789,12 +799,12 @@ _composite_spans_fill_func (void *closure, rects.dst.x -= dst_x; rects.dst.y -= dst_y; - return _cairo_path_fixed_fill_using_spans (op, src, info->path, dst, - info->fill_rule, - info->tolerance, - info->antialias, - &rects, - clip_region); + return _cairo_surface_composite_polygon (dst, op, src, + info->fill_rule, + info->antialias, + &rects, + info->polygon, + clip_region); } static cairo_bool_t @@ -930,11 +940,12 @@ _cairo_surface_fallback_stroke (cairo_surface_t *surface, cairo_antialias_t antialias, cairo_clip_t *clip) { - cairo_status_t status; + cairo_polygon_t polygon; cairo_traps_t traps; cairo_box_t box; cairo_rectangle_int_t extents; cairo_bool_t is_bounded; + cairo_status_t status; is_bounded = _cairo_surface_get_extents (surface, &extents); assert (is_bounded || clip); @@ -952,22 +963,70 @@ _cairo_surface_fallback_stroke (cairo_surface_t *surface, _cairo_box_from_rectangle (&box, &extents); + _cairo_polygon_init (&polygon); + _cairo_polygon_limit (&polygon, &box); + _cairo_traps_init (&traps); _cairo_traps_limit (&traps, &box); - status = _cairo_path_fixed_stroke_to_traps (path, - stroke_style, - ctm, ctm_inverse, - tolerance, - &traps); + if (path->is_rectilinear) { + status = _cairo_path_fixed_stroke_rectilinear_to_traps (path, + stroke_style, + ctm, + &traps); + if (likely (status == CAIRO_STATUS_SUCCESS)) + goto DO_TRAPS; + + if (_cairo_status_is_error (status)) + goto CLEANUP; + } + + status = _cairo_path_fixed_stroke_to_polygon (path, + stroke_style, + ctm, ctm_inverse, + tolerance, + &polygon); if (unlikely (status)) - goto FAIL; + goto CLEANUP; + + if (_cairo_operator_bounded_by_mask (op)) { + cairo_rectangle_int_t polygon_extents; - status = _clip_and_composite_trapezoids (source, op, - surface, &traps, antialias, + _cairo_box_round_to_rectangle (&polygon.extents, &polygon_extents); + if (! _cairo_rectangle_intersect (&extents, &polygon_extents)) + goto CLEANUP; + } + + if (antialias != CAIRO_ANTIALIAS_NONE && + _cairo_surface_check_span_renderer (op, source, surface, + antialias, NULL)) + { + cairo_composite_spans_info_t info; + + info.polygon = &polygon; + info.fill_rule = CAIRO_FILL_RULE_WINDING; + info.antialias = antialias; + + status = _clip_and_composite (clip, op, source, + _composite_spans_draw_func, + &info, surface, &extents); + goto CLEANUP; + } + + /* Fall back to trapezoid fills. */ + status = _cairo_bentley_ottmann_tessellate_polygon (&traps, + &polygon, + CAIRO_FILL_RULE_WINDING); + if (unlikely (status)) + goto CLEANUP; + + DO_TRAPS: + status = _clip_and_composite_trapezoids (source, op, surface, + &traps, antialias, clip, &extents); - FAIL: + CLEANUP: _cairo_traps_fini (&traps); + _cairo_polygon_fini (&polygon); return status; } @@ -982,11 +1041,12 @@ _cairo_surface_fallback_fill (cairo_surface_t *surface, cairo_antialias_t antialias, cairo_clip_t *clip) { - cairo_status_t status; + cairo_polygon_t polygon; cairo_traps_t traps; cairo_box_t box; cairo_rectangle_int_t extents; cairo_bool_t is_bounded; + cairo_status_t status; is_bounded = _cairo_surface_get_extents (surface, &extents); assert (is_bounded || clip); @@ -1002,71 +1062,69 @@ _cairo_surface_fallback_fill (cairo_surface_t *surface, if (! _rectangle_intersect_clip (&extents, clip)) return CAIRO_STATUS_SUCCESS; - /* XXX future direction: - status = _cairo_path_fixed_fill_to_region (path, fill_rule, ®ion); - if (status != CAIRO_STATUS_INT_UNSUPPORTED) { - if (unlikely (status)) - return status; + _cairo_box_from_rectangle (&box, &extents); - status = _clip_and_composite_region (); - if (status != CAIRO_INT_STATUS_UNSUPPORTED) - return status; - } - */ - - /* Ask if the surface would like to render this combination of - * op/source/dst/antialias with spans or not, but don't actually - * make a renderer yet. We'll try to hit the region optimisations - * in _clip_and_composite_trapezoids() if it looks like the path - * is a region. */ - /* TODO: Until we have a mono scan converter we won't even try - * to use spans for CAIRO_ANTIALIAS_NONE. */ - /* TODO: The region filling code should be lifted from - * _clip_and_composite_trapezoids() and given first priority - * explicitly before deciding between spans and trapezoids. */ - if (antialias != CAIRO_ANTIALIAS_NONE && ! path->is_rectilinear && - _cairo_surface_check_span_renderer ( - op, source, surface, antialias, NULL)) + _cairo_polygon_init (&polygon); + _cairo_polygon_limit (&polygon, &box); + + _cairo_traps_init (&traps); + _cairo_traps_limit (&traps, &box); + + if (path->is_rectilinear) { + status = _cairo_path_fixed_fill_rectilinear_to_traps (path, + fill_rule, + &traps); + if (likely (status == CAIRO_STATUS_SUCCESS)) + goto DO_TRAPS; + + if (_cairo_status_is_error (status)) + goto CLEANUP; + } + + status = _cairo_path_fixed_fill_to_polygon (path, + tolerance, + &polygon); + if (unlikely (status)) + goto CLEANUP; + + if (_cairo_operator_bounded_by_mask (op)) { + cairo_rectangle_int_t polygon_extents; + + _cairo_box_round_to_rectangle (&polygon.extents, &polygon_extents); + if (! _cairo_rectangle_intersect (&extents, &polygon_extents)) + goto CLEANUP; + } + + if (antialias != CAIRO_ANTIALIAS_NONE && + _cairo_surface_check_span_renderer (op, source, surface, + antialias, NULL)) { - cairo_composite_spans_fill_info_t info; - info.path = path; + cairo_composite_spans_info_t info; + + info.polygon = &polygon; info.fill_rule = fill_rule; - info.tolerance = tolerance; info.antialias = antialias; - if (_cairo_operator_bounded_by_mask (op)) { - cairo_rectangle_int_t path_extents; - - _cairo_path_fixed_approximate_clip_extents (path, - &path_extents); - if (! _cairo_rectangle_intersect (&extents, &path_extents)) - return CAIRO_STATUS_SUCCESS; - } - - return _clip_and_composite (clip, op, source, - _composite_spans_fill_func, - &info, - surface, - &extents); + status = _clip_and_composite (clip, op, source, + _composite_spans_draw_func, + &info, surface, &extents); + goto CLEANUP; } /* Fall back to trapezoid fills. */ - _cairo_box_from_rectangle (&box, &extents); - _cairo_traps_init (&traps); - _cairo_traps_limit (&traps, &box); - - status = _cairo_path_fixed_fill_to_traps (path, - fill_rule, - tolerance, - &traps); + status = _cairo_bentley_ottmann_tessellate_polygon (&traps, + &polygon, + fill_rule); if (unlikely (status)) - goto FAIL; + goto CLEANUP; + DO_TRAPS: status = _clip_and_composite_trapezoids (source, op, surface, &traps, antialias, clip, &extents); - FAIL: + CLEANUP: _cairo_traps_fini (&traps); + _cairo_polygon_fini (&polygon); return status; } diff --git a/src/cairo-tor-scan-converter.c b/src/cairo-tor-scan-converter.c index f6b5b430a..75cda4fe4 100644 --- a/src/cairo-tor-scan-converter.c +++ b/src/cairo-tor-scan-converter.c @@ -199,11 +199,8 @@ glitter_scan_converter_reset( * converter should be reset or destroyed. Dir must be +1 or -1, * with the latter reversing the orientation of the edge. */ I glitter_status_t -glitter_scan_converter_add_edge( - glitter_scan_converter_t *converter, - glitter_input_scaled_t x1, glitter_input_scaled_t y1, - glitter_input_scaled_t x2, glitter_input_scaled_t y2, - int dir); +glitter_scan_converter_add_edge (glitter_scan_converter_t *converter, + const cairo_edge_t *edge); /* Render the polygon in the scan converter to the given A8 format * image raster. Only the pixels accessible as pixels[y*stride+x] for @@ -623,10 +620,8 @@ _pool_alloc_from_new_chunk( } if (NULL == chunk) { - chunk = _pool_chunk_create( - pool->current, - capacity); - if (NULL == chunk) + chunk = _pool_chunk_create (pool->current, capacity); + if (unlikely (NULL == chunk)) return NULL; } pool->current = chunk; @@ -643,9 +638,7 @@ _pool_alloc_from_new_chunk( * allocation failures. The pool retains ownership of the returned * memory. */ inline static void * -pool_alloc( - struct pool *pool, - size_t size) +pool_alloc (struct pool *pool, size_t size) { struct _pool_chunk *chunk = pool->current; @@ -653,15 +646,14 @@ pool_alloc( void *obj = ((unsigned char*)chunk + sizeof(*chunk) + chunk->size); chunk->size += size; return obj; - } - else { + } else { return _pool_alloc_from_new_chunk(pool, size); } } /* Relinquish all pool_alloced memory back to the pool. */ static void -pool_reset(struct pool *pool) +pool_reset (struct pool *pool) { /* Transfer all used chunks to the chunk free list. */ struct _pool_chunk *chunk = pool->current; @@ -680,19 +672,18 @@ pool_reset(struct pool *pool) /* Rewinds the cell list's cursor to the beginning. After rewinding * we're good to cell_list_find() the cell any x coordinate. */ inline static void -cell_list_rewind(struct cell_list *cells) +cell_list_rewind (struct cell_list *cells) { cells->cursor = &cells->head; } /* Rewind the cell list if its cursor has been advanced past x. */ inline static void -cell_list_maybe_rewind(struct cell_list *cells, int x) +cell_list_maybe_rewind (struct cell_list *cells, int x) { struct cell *tail = *cells->cursor; - if (tail->x > x) { - cell_list_rewind(cells); - } + if (tail->x > x) + cell_list_rewind (cells); } static void @@ -704,24 +695,24 @@ cell_list_init(struct cell_list *cells) cells->tail.next = NULL; cells->tail.x = INT_MAX; cells->head = &cells->tail; - cell_list_rewind(cells); + cell_list_rewind (cells); } static void cell_list_fini(struct cell_list *cells) { - pool_fini(cells->cell_pool.base); - cell_list_init(cells); + pool_fini (cells->cell_pool.base); + cell_list_init (cells); } /* Empty the cell list. This is called at the start of every pixel * row. */ inline static void -cell_list_reset(struct cell_list *cells) +cell_list_reset (struct cell_list *cells) { - cell_list_rewind(cells); + cell_list_rewind (cells); cells->head = &cells->tail; - pool_reset(cells->cell_pool.base); + pool_reset (cells->cell_pool.base); } /* Find a cell at the given x-coordinate. Returns %NULL if a new cell @@ -730,7 +721,7 @@ cell_list_reset(struct cell_list *cells) * cell_list_rewind(). Ownership of the returned cell is retained by * the cell list. */ inline static struct cell * -cell_list_find(struct cell_list *cells, int x) +cell_list_find (struct cell_list *cells, int x) { struct cell **cursor = cells->cursor; struct cell *tail; @@ -749,11 +740,12 @@ cell_list_find(struct cell_list *cells, int x) if (tail->x == x) { return tail; } else { - struct cell *cell = pool_alloc( - cells->cell_pool.base, - sizeof(struct cell)); - if (NULL == cell) + struct cell *cell; + + cell = pool_alloc (cells->cell_pool.base, sizeof (struct cell)); + if (unlikely (NULL == cell)) return NULL; + *cursor = cell; cell->next = tail; cell->x = x; @@ -785,17 +777,18 @@ cell_list_find_pair(struct cell_list *cells, int x1, int x2) cell1 = *cursor; if (cell1->x > x1) break; + if (cell1->x == x1) goto found_first; + cursor = &cell1->next; }); } /* New first cell at x1. */ - newcell = pool_alloc( - cells->cell_pool.base, - sizeof(struct cell)); - if (NULL != newcell) { + newcell = pool_alloc (cells->cell_pool.base, + sizeof (struct cell)); + if (likely (NULL != newcell)) { *cursor = newcell; newcell->next = cell1; newcell->x = x1; @@ -818,10 +811,9 @@ cell_list_find_pair(struct cell_list *cells, int x1, int x2) } /* New second cell at x2. */ - newcell = pool_alloc( - cells->cell_pool.base, - sizeof(struct cell)); - if (NULL != newcell) { + newcell = pool_alloc (cells->cell_pool.base, + sizeof (struct cell)); + if (likely (NULL != newcell)) { *cursor = newcell; newcell->next = cell2; newcell->x = x2; @@ -849,12 +841,13 @@ cell_list_add_unbounded_subspan( GRID_X_TO_INT_FRAC(x, ix, fx); - cell = cell_list_find(cells, ix); - if (cell) { + cell = cell_list_find (cells, ix); + if (likely (cell != NULL)) { cell->uncovered_area += 2*fx; cell->covered_height++; return GLITTER_STATUS_SUCCESS; } + return GLITTER_STATUS_NO_MEMORY; } @@ -874,17 +867,16 @@ cell_list_add_subspan( if (ix1 != ix2) { struct cell_pair p; p = cell_list_find_pair(cells, ix1, ix2); - if (p.cell1 && p.cell2) { + if (likely (p.cell1 != NULL && p.cell2 != NULL)) { p.cell1->uncovered_area += 2*fx1; ++p.cell1->covered_height; p.cell2->uncovered_area -= 2*fx2; --p.cell2->covered_height; return GLITTER_STATUS_SUCCESS; } - } - else { + } else { struct cell *cell = cell_list_find(cells, ix1); - if (cell) { + if (likely (cell != NULL)) { cell->uncovered_area += 2*(fx1-fx2); return GLITTER_STATUS_SUCCESS; } @@ -938,8 +930,9 @@ cell_list_render_edge( /* We always know that ix1 is >= the cell list cursor in this * case due to the no-intersections precondition. */ struct cell *cell = cell_list_find(cells, ix1); - if (NULL == cell) + if (unlikely (NULL == cell)) return GLITTER_STATUS_NO_MEMORY; + cell->covered_height += sign*GRID_Y; cell->uncovered_area += sign*(fx1 + fx2)*GRID_Y; return GLITTER_STATUS_SUCCESS; @@ -988,7 +981,7 @@ cell_list_render_edge( cell_list_maybe_rewind(cells, ix1); pair = cell_list_find_pair(cells, ix1, ix1+1); - if (!pair.cell1 || !pair.cell2) + if (unlikely (!pair.cell1 || !pair.cell2)) return GLITTER_STATUS_NO_MEMORY; pair.cell1->uncovered_area += sign*y.quo*(GRID_X + fx1); @@ -1016,7 +1009,7 @@ cell_list_render_edge( ++ix1; cell = cell_list_find(cells, ix1); - if (NULL == cell) + if (unlikely (NULL == cell)) return GLITTER_STATUS_NO_MEMORY; } while (ix1 != ix2); @@ -1030,22 +1023,22 @@ cell_list_render_edge( } static void -polygon_init(struct polygon *polygon) +polygon_init (struct polygon *polygon) { polygon->ymin = polygon->ymax = 0; polygon->y_buckets = polygon->y_buckets_embedded; - pool_init(polygon->edge_pool.base, - 8192 - sizeof(struct _pool_chunk), - sizeof(polygon->edge_pool.embedded)); + pool_init (polygon->edge_pool.base, + 8192 - sizeof (struct _pool_chunk), + sizeof (polygon->edge_pool.embedded)); } static void -polygon_fini(struct polygon *polygon) +polygon_fini (struct polygon *polygon) { if (polygon->y_buckets != polygon->y_buckets_embedded) - free(polygon->y_buckets); - pool_fini(polygon->edge_pool.base); - polygon_init(polygon); + free (polygon->y_buckets); + + pool_fini (polygon->edge_pool.base); } /* Empties the polygon of all edges. The polygon is then prepared to @@ -1063,11 +1056,12 @@ polygon_reset( pool_reset(polygon->edge_pool.base); - if (h > 0x7FFFFFFFU - EDGE_Y_BUCKET_HEIGHT) + if (unlikely (h > 0x7FFFFFFFU - EDGE_Y_BUCKET_HEIGHT)) goto bail_no_mem; /* even if you could, you wouldn't want to. */ if (polygon->y_buckets != polygon->y_buckets_embedded) free (polygon->y_buckets); + polygon->y_buckets = polygon->y_buckets_embedded; if (num_buckets > ARRAY_LENGTH (polygon->y_buckets_embedded)) { polygon->y_buckets = _cairo_malloc_ab (num_buckets, @@ -1099,11 +1093,8 @@ _polygon_insert_edge_into_its_y_bucket( } inline static glitter_status_t -polygon_add_edge( - struct polygon *polygon, - int x0, int y0, - int x1, int y1, - int dir) +polygon_add_edge (struct polygon *polygon, + const cairo_edge_t *edge) { struct edge *e; grid_scaled_x_t dx; @@ -1112,54 +1103,45 @@ polygon_add_edge( grid_scaled_y_t ymin = polygon->ymin; grid_scaled_y_t ymax = polygon->ymax; - if (y0 == y1) - return GLITTER_STATUS_SUCCESS; + assert (edge->bottom > edge->top); - if (y0 > y1) { - int tmp; - tmp = x0; x0 = x1; x1 = tmp; - tmp = y0; y0 = y1; y1 = tmp; - dir = -dir; - } - - if (y0 >= ymax || y1 <= ymin) + if (unlikely (edge->top >= ymax || edge->bottom <= ymin)) return GLITTER_STATUS_SUCCESS; - e = pool_alloc(polygon->edge_pool.base, - sizeof(struct edge)); - if (NULL == e) + e = pool_alloc (polygon->edge_pool.base, sizeof (struct edge)); + if (unlikely (NULL == e)) return GLITTER_STATUS_NO_MEMORY; - dx = x1 - x0; - dy = y1 - y0; + dx = edge->line.p2.x - edge->line.p1.x; + dy = edge->line.p2.y - edge->line.p1.y; e->dy = dy; - e->dxdy = floored_divrem(dx, dy); + e->dxdy = floored_divrem (dx, dy); - if (ymin <= y0) { - ytop = y0; - e->x.quo = x0; - e->x.rem = 0; - } - else { + if (ymin <= edge->top) + ytop = edge->top; + else ytop = ymin; - e->x = floored_muldivrem(ymin - y0, dx, dy); - e->x.quo += x0; + if (ytop == edge->line.p1.y) { + e->x.quo = edge->line.p1.x; + e->x.rem = 0; + } else { + e->x = floored_muldivrem (ytop - edge->line.p1.y, dx, dy); + e->x.quo += edge->line.p1.x; } - e->dir = dir; + e->dir = edge->dir; e->ytop = ytop; - ybot = y1 < ymax ? y1 : ymax; + ybot = edge->bottom < ymax ? edge->bottom : ymax; e->height_left = ybot - ytop; if (e->height_left >= GRID_Y) { - e->dxdy_full = floored_muldivrem(GRID_Y, dx, dy); - } - else { + e->dxdy_full = floored_muldivrem (GRID_Y, dx, dy); + } else { e->dxdy_full.quo = 0; e->dxdy_full.rem = 0; } - _polygon_insert_edge_into_its_y_bucket(polygon, e); + _polygon_insert_edge_into_its_y_bucket (polygon, e); e->x.rem -= dy; /* Bias the remainder for faster * edge advancement. */ @@ -1167,8 +1149,7 @@ polygon_add_edge( } static void -active_list_reset( - struct active_list *active) +active_list_reset (struct active_list *active) { active->head = NULL; active->min_height = 0; @@ -1292,8 +1273,7 @@ active_list_merge_edges_from_polygon( subrow_edges = tail; if (tail->height_left < min_height) min_height = tail->height_left; - } - else { + } else { ptail = &tail->next; } } @@ -1347,9 +1327,8 @@ active_list_substep_edges( } inline static glitter_status_t -apply_nonzero_fill_rule_for_subrow( - struct active_list *active, - struct cell_list *coverages) +apply_nonzero_fill_rule_for_subrow (struct active_list *active, + struct cell_list *coverages) { struct edge *edge = active->head; int winding = 0; @@ -1357,25 +1336,26 @@ apply_nonzero_fill_rule_for_subrow( int xend; int status; - cell_list_rewind(coverages); + cell_list_rewind (coverages); while (NULL != edge) { xstart = edge->x.quo; winding = edge->dir; while (1) { edge = edge->next; - if (NULL == edge) { - return cell_list_add_unbounded_subspan( - coverages, xstart); - } + if (NULL == edge) + return cell_list_add_unbounded_subspan (coverages, xstart); + winding += edge->dir; - if (0 == winding) - break; + if (0 == winding) { + if (edge->next == NULL || edge->next->x.quo != edge->x.quo) + break; + } } xend = edge->x.quo; - status = cell_list_add_subspan(coverages, xstart, xend); - if (status) + status = cell_list_add_subspan (coverages, xstart, xend); + if (unlikely (status)) return status; edge = edge->next; @@ -1385,29 +1365,33 @@ apply_nonzero_fill_rule_for_subrow( } static glitter_status_t -apply_evenodd_fill_rule_for_subrow( - struct active_list *active, - struct cell_list *coverages) +apply_evenodd_fill_rule_for_subrow (struct active_list *active, + struct cell_list *coverages) { struct edge *edge = active->head; int xstart; int xend; int status; - cell_list_rewind(coverages); + cell_list_rewind (coverages); while (NULL != edge) { xstart = edge->x.quo; - edge = edge->next; - if (NULL == edge) { - return cell_list_add_unbounded_subspan( - coverages, xstart); + while (1) { + edge = edge->next; + if (NULL == edge) + return cell_list_add_unbounded_subspan (coverages, xstart); + + if (edge->next == NULL || edge->next->x.quo != edge->x.quo) + break; + + edge = edge->next; } xend = edge->x.quo; - status = cell_list_add_subspan(coverages, xstart, xend); - if (status) + status = cell_list_add_subspan (coverages, xstart, xend); + if (unlikely (status)) return status; edge = edge->next; @@ -1417,9 +1401,8 @@ apply_evenodd_fill_rule_for_subrow( } static glitter_status_t -apply_nonzero_fill_rule_and_step_edges( - struct active_list *active, - struct cell_list *coverages) +apply_nonzero_fill_rule_and_step_edges (struct active_list *active, + struct cell_list *coverages) { struct edge **cursor = &active->head; struct edge *left_edge; @@ -1431,32 +1414,30 @@ apply_nonzero_fill_rule_and_step_edges( int winding = left_edge->dir; left_edge->height_left -= GRID_Y; - if (left_edge->height_left) { + if (left_edge->height_left) cursor = &left_edge->next; - } - else { + else *cursor = left_edge->next; - } while (1) { right_edge = *cursor; - - if (NULL == right_edge) { - return cell_list_render_edge( - coverages, left_edge, +1); - } + if (NULL == right_edge) + return cell_list_render_edge (coverages, left_edge, +1); right_edge->height_left -= GRID_Y; - if (right_edge->height_left) { + if (right_edge->height_left) cursor = &right_edge->next; - } - else { + else *cursor = right_edge->next; - } winding += right_edge->dir; - if (0 == winding) - break; + if (0 == winding) { + if (right_edge->next == NULL || + right_edge->next->x.quo != right_edge->x.quo) + { + break; + } + } right_edge->x.quo += right_edge->dxdy_full.quo; right_edge->x.rem += right_edge->dxdy_full.rem; @@ -1466,13 +1447,12 @@ apply_nonzero_fill_rule_and_step_edges( } } - status = cell_list_render_edge( - coverages, left_edge, +1); - if (status) + status = cell_list_render_edge (coverages, left_edge, +1); + if (unlikely (status)) return status; - status = cell_list_render_edge( - coverages, right_edge, -1); - if (status) + + status = cell_list_render_edge (coverages, right_edge, -1); + if (unlikely (status)) return status; left_edge = *cursor; @@ -1482,9 +1462,8 @@ apply_nonzero_fill_rule_and_step_edges( } static glitter_status_t -apply_evenodd_fill_rule_and_step_edges( - struct active_list *active, - struct cell_list *coverages) +apply_evenodd_fill_rule_and_step_edges (struct active_list *active, + struct cell_list *coverages) { struct edge **cursor = &active->head; struct edge *left_edge; @@ -1495,35 +1474,42 @@ apply_evenodd_fill_rule_and_step_edges( struct edge *right_edge; left_edge->height_left -= GRID_Y; - if (left_edge->height_left) { + if (left_edge->height_left) cursor = &left_edge->next; - } - else { + else *cursor = left_edge->next; - } - right_edge = *cursor; + while (1) { + right_edge = *cursor; + if (NULL == right_edge) + return cell_list_render_edge (coverages, left_edge, +1); - if (NULL == right_edge) { - return cell_list_render_edge( - coverages, left_edge, +1); - } + right_edge->height_left -= GRID_Y; + if (right_edge->height_left) + cursor = &right_edge->next; + else + *cursor = right_edge->next; - right_edge->height_left -= GRID_Y; - if (right_edge->height_left) { - cursor = &right_edge->next; - } - else { - *cursor = right_edge->next; + if (right_edge->next == NULL || + right_edge->next->x.quo != right_edge->x.quo) + { + break; + } + + right_edge->x.quo += right_edge->dxdy_full.quo; + right_edge->x.rem += right_edge->dxdy_full.rem; + if (right_edge->x.rem >= 0) { + ++right_edge->x.quo; + right_edge->x.rem -= right_edge->dy; + } } - status = cell_list_render_edge( - coverages, left_edge, +1); - if (status) + status = cell_list_render_edge (coverages, left_edge, +1); + if (unlikely (status)) return status; - status = cell_list_render_edge( - coverages, right_edge, -1); - if (status) + + status = cell_list_render_edge (coverages, right_edge, -1); + if (unlikely (status)) return status; left_edge = *cursor; @@ -1692,26 +1678,28 @@ glitter_scan_converter_reset( } while (0) I glitter_status_t -glitter_scan_converter_add_edge( - glitter_scan_converter_t *converter, - glitter_input_scaled_t x1, glitter_input_scaled_t y1, - glitter_input_scaled_t x2, glitter_input_scaled_t y2, - int dir) +glitter_scan_converter_add_edge (glitter_scan_converter_t *converter, + const cairo_edge_t *edge) { - /* XXX: possible overflows if GRID_X/Y > 2**GLITTER_INPUT_BITS */ - grid_scaled_y_t sx1, sy1; - grid_scaled_y_t sx2, sy2; + cairo_edge_t e; - INPUT_TO_GRID_Y(y1, sy1); - INPUT_TO_GRID_Y(y2, sy2); - if (sy1 == sy2) + INPUT_TO_GRID_Y (edge->top, e.top); + INPUT_TO_GRID_Y (edge->bottom, e.bottom); + if (e.top == e.bottom) + return GLITTER_STATUS_SUCCESS; + + /* XXX: possible overflows if GRID_X/Y > 2**GLITTER_INPUT_BITS */ + INPUT_TO_GRID_Y (edge->line.p1.y, e.line.p1.y); + INPUT_TO_GRID_Y (edge->line.p2.y, e.line.p2.y); + if (e.line.p1.y == e.line.p2.y) return GLITTER_STATUS_SUCCESS; - INPUT_TO_GRID_X(x1, sx1); - INPUT_TO_GRID_X(x2, sx2); + INPUT_TO_GRID_X (edge->line.p1.x, e.line.p1.x); + INPUT_TO_GRID_X (edge->line.p2.x, e.line.p2.x); - return polygon_add_edge( - converter->polygon, sx1, sy1, sx2, sy2, dir); + e.dir = edge->dir; + + return polygon_add_edge (converter->polygon, &e); } #ifndef GLITTER_BLIT_COVERAGES_BEGIN @@ -1756,58 +1744,54 @@ glitter_scan_converter_render( /* Determine if we can ignore this row or use the full pixel * stepper. */ - if (GRID_Y == EDGE_Y_BUCKET_HEIGHT - && !polygon->y_buckets[i]) - { - if (!active->head) { - GLITTER_BLIT_COVERAGES_EMPTY(i+ymin_i, xmin_i, xmax_i); + if (GRID_Y == EDGE_Y_BUCKET_HEIGHT && ! polygon->y_buckets[i]) { + if (! active->head) { + GLITTER_BLIT_COVERAGES_EMPTY (i+ymin_i, xmin_i, xmax_i); continue; } - do_full_step = active_list_can_step_full_row(active); + + do_full_step = active_list_can_step_full_row (active); } - cell_list_reset(coverages); + cell_list_reset (coverages); if (do_full_step) { /* Step by a full pixel row's worth. */ if (nonzero_fill) { - status = apply_nonzero_fill_rule_and_step_edges( - active, coverages); - } - else { - status = apply_evenodd_fill_rule_and_step_edges( - active, coverages); + status = apply_nonzero_fill_rule_and_step_edges (active, + coverages); + } else { + status = apply_evenodd_fill_rule_and_step_edges (active, + coverages); } - } - else { + } else { /* Subsample this row. */ grid_scaled_y_t suby; for (suby = 0; suby < GRID_Y; suby++) { grid_scaled_y_t y = (i+ymin_i)*GRID_Y + suby; - active_list_merge_edges_from_polygon( - active, y, polygon); + active_list_merge_edges_from_polygon (active, y, polygon); - if (nonzero_fill) - status |= apply_nonzero_fill_rule_for_subrow( - active, coverages); - else - status |= apply_evenodd_fill_rule_for_subrow( - active, coverages); + if (nonzero_fill) { + status |= apply_nonzero_fill_rule_for_subrow (active, + coverages); + } else { + status |= apply_evenodd_fill_rule_for_subrow (active, + coverages); + } active_list_substep_edges(active); } } - if (status) + if (unlikely (status)) return status; GLITTER_BLIT_COVERAGES(coverages, i+ymin_i, xmin_i, xmax_i); - if (!active->head) { + if (! active->head) { active->min_height = INT_MAX; - } - else { + } else { active->min_height -= GRID_Y; } } @@ -1860,7 +1844,7 @@ blit_with_span_renderer( /* Allocate enough spans for the row. */ pool_reset (span_pool); spans = pool_alloc (span_pool, sizeof(spans[0])*num_spans); - if (spans == NULL) + if (unlikely (spans == NULL)) return GLITTER_STATUS_NO_MEMORY; num_spans = 0; @@ -1906,6 +1890,7 @@ blit_empty_with_span_renderer (cairo_span_renderer_t *renderer, int y) struct _cairo_tor_scan_converter { cairo_scan_converter_t base; + glitter_scan_converter_t converter[1]; cairo_fill_rule_t fill_rule; @@ -1918,9 +1903,9 @@ struct _cairo_tor_scan_converter { typedef struct _cairo_tor_scan_converter cairo_tor_scan_converter_t; static void -_cairo_tor_scan_converter_destroy(void *abstract_converter) +_cairo_tor_scan_converter_destroy (void *converter) { - cairo_tor_scan_converter_t *self = abstract_converter; + cairo_tor_scan_converter_t *self = converter; if (self == NULL) { return; } @@ -1930,69 +1915,70 @@ _cairo_tor_scan_converter_destroy(void *abstract_converter) } static cairo_status_t -_cairo_tor_scan_converter_add_edge( - void *abstract_converter, - cairo_fixed_t x1, - cairo_fixed_t y1, - cairo_fixed_t x2, - cairo_fixed_t y2) +_cairo_tor_scan_converter_add_polygon (void *converter, + const cairo_polygon_t *polygon) { - cairo_tor_scan_converter_t *self = abstract_converter; + cairo_tor_scan_converter_t *self = converter; cairo_status_t status; - status = glitter_scan_converter_add_edge ( - self->converter, - x1, y1, x2, y2, +1); - if (status) { - return _cairo_scan_converter_set_error (self, - _cairo_error (status)); + int i; + + for (i = 0; i < polygon->num_edges; i++) { + status = glitter_scan_converter_add_edge (self->converter, + &polygon->edges[i]); + if (unlikely (status)) { + return _cairo_scan_converter_set_error (self, + _cairo_error (status)); + } } + return CAIRO_STATUS_SUCCESS; } static cairo_status_t -_cairo_tor_scan_converter_generate( - void *abstract_converter, - cairo_span_renderer_t *renderer) +_cairo_tor_scan_converter_generate (void *converter, + cairo_span_renderer_t *renderer) { - cairo_tor_scan_converter_t *self = abstract_converter; - cairo_status_t status = glitter_scan_converter_render ( - self->converter, - self->fill_rule == CAIRO_FILL_RULE_WINDING, - renderer, - self->span_pool.base); - if (status) { - return _cairo_scan_converter_set_error (self, - _cairo_error (status)); - } + cairo_tor_scan_converter_t *self = converter; + cairo_status_t status; + + status = glitter_scan_converter_render (self->converter, + self->fill_rule == CAIRO_FILL_RULE_WINDING, + renderer, + self->span_pool.base); + if (unlikely (status)) + return _cairo_scan_converter_set_error (self, _cairo_error (status)); + return CAIRO_STATUS_SUCCESS; } cairo_scan_converter_t * -_cairo_tor_scan_converter_create( - int xmin, - int ymin, - int xmax, - int ymax, - cairo_fill_rule_t fill_rule) +_cairo_tor_scan_converter_create (int xmin, + int ymin, + int xmax, + int ymax, + cairo_fill_rule_t fill_rule) { + cairo_tor_scan_converter_t *self; cairo_status_t status; - cairo_tor_scan_converter_t *self = - calloc (1, sizeof(struct _cairo_tor_scan_converter)); - if (self == NULL) + + self = calloc (1, sizeof(struct _cairo_tor_scan_converter)); + if (unlikely (self == NULL)) { + status = _cairo_error (CAIRO_STATUS_NO_MEMORY); goto bail_nomem; + } - self->base.destroy = &_cairo_tor_scan_converter_destroy; - self->base.add_edge = &_cairo_tor_scan_converter_add_edge; - self->base.generate = &_cairo_tor_scan_converter_generate; + self->base.destroy = _cairo_tor_scan_converter_destroy; + self->base.add_polygon = _cairo_tor_scan_converter_add_polygon; + self->base.generate = _cairo_tor_scan_converter_generate; pool_init (self->span_pool.base, 250 * sizeof(self->span_pool.embedded[0]), sizeof(self->span_pool.embedded)); _glitter_scan_converter_init (self->converter); - status = glitter_scan_converter_reset ( - self->converter, xmin, ymin, xmax, ymax); - if (status != CAIRO_STATUS_SUCCESS) + status = glitter_scan_converter_reset (self->converter, + xmin, ymin, xmax, ymax); + if (unlikely (status)) goto bail; self->fill_rule = fill_rule; @@ -2002,5 +1988,5 @@ _cairo_tor_scan_converter_create( bail: self->base.destroy(&self->base); bail_nomem: - return _cairo_scan_converter_create_in_error (CAIRO_STATUS_NO_MEMORY); + return _cairo_scan_converter_create_in_error (status); } diff --git a/src/cairo-toy-font-face.c b/src/cairo-toy-font-face.c index a9b600a5c..e7c841a9c 100644 --- a/src/cairo-toy-font-face.c +++ b/src/cairo-toy-font-face.c @@ -520,5 +520,6 @@ _cairo_toy_font_face_reset_static_data (void) cairo_toy_font_face_hash_table = NULL; CAIRO_MUTEX_UNLOCK (_cairo_toy_font_face_mutex); - _cairo_hash_table_destroy (hash_table); + if (hash_table != NULL) + _cairo_hash_table_destroy (hash_table); } diff --git a/src/cairo-traps.c b/src/cairo-traps.c index 343d77fde..057e95066 100644 --- a/src/cairo-traps.c +++ b/src/cairo-traps.c @@ -63,6 +63,7 @@ _cairo_traps_init (cairo_traps_t *traps) traps->extents.p2.x = traps->extents.p2.y = INT32_MIN; traps->has_limits = FALSE; + traps->has_intersections = FALSE; } void @@ -74,14 +75,6 @@ _cairo_traps_limit (cairo_traps_t *traps, traps->limits = *limits; } -cairo_bool_t -_cairo_traps_get_limit (cairo_traps_t *traps, - cairo_box_t *limits) -{ - *limits = traps->limits; - return traps->has_limits; -} - void _cairo_traps_clear (cairo_traps_t *traps) { @@ -90,6 +83,7 @@ _cairo_traps_clear (cairo_traps_t *traps) traps->maybe_region = 1; traps->num_traps = 0; + traps->has_intersections = FALSE; traps->extents.p1.x = traps->extents.p1.y = INT32_MAX; traps->extents.p2.x = traps->extents.p2.y = INT32_MIN; } @@ -165,6 +159,12 @@ _cairo_traps_grow (cairo_traps_t *traps) return TRUE; } +static cairo_fixed_t +_line_compute_intersection_x_for_y (const cairo_line_t *line, + cairo_fixed_t y) +{ + return _cairo_edge_compute_intersection_x_for_y (&line->p1, &line->p2, y); +} void _cairo_traps_add_trap (cairo_traps_t *traps, cairo_fixed_t top, cairo_fixed_t bottom, @@ -257,23 +257,44 @@ _cairo_traps_add_trap (cairo_traps_t *traps, traps->extents.p1.y = top; if (bottom > traps->extents.p2.y) traps->extents.p2.y = bottom; - /* - * This isn't generally accurate, but it is close enough for - * this purpose. Assuming that the left and right segments always - * contain the trapezoid vertical extents, these compares will - * yield a containing box. Assuming that the points all come from - * the same figure which will eventually be completely drawn, then - * the compares will yield the correct overall extents - */ - if (left->p1.x < traps->extents.p1.x) - traps->extents.p1.x = left->p1.x; - if (left->p2.x < traps->extents.p1.x) - traps->extents.p1.x = left->p2.x; - if (right->p1.x > traps->extents.p2.x) - traps->extents.p2.x = right->p1.x; - if (right->p2.x > traps->extents.p2.x) - traps->extents.p2.x = right->p2.x; + if (left->p1.x < traps->extents.p1.x) { + cairo_fixed_t x = left->p1.x; + if (top != left->p1.y) { + x = _line_compute_intersection_x_for_y (left, top); + if (x < traps->extents.p1.x) + traps->extents.p1.x = x; + } else + traps->extents.p1.x = x; + } + if (left->p2.x < traps->extents.p1.x) { + cairo_fixed_t x = left->p2.x; + if (bottom != left->p2.y) { + x = _line_compute_intersection_x_for_y (left, bottom); + if (x < traps->extents.p1.x) + traps->extents.p1.x = x; + } else + traps->extents.p1.x = x; + } + + if (right->p1.x > traps->extents.p2.x) { + cairo_fixed_t x = right->p1.x; + if (top != right->p1.y) { + x = _line_compute_intersection_x_for_y (right, top); + if (x > traps->extents.p2.x) + traps->extents.p2.x = x; + } else + traps->extents.p2.x = x; + } + if (right->p2.x > traps->extents.p2.x) { + cairo_fixed_t x = right->p2.x; + if (bottom != right->p2.y) { + x = _line_compute_intersection_x_for_y (right, bottom); + if (x > traps->extents.p2.x) + traps->extents.p2.x = x; + } else + traps->extents.p2.x = x; + } traps->num_traps++; } @@ -284,9 +305,8 @@ _compare_point_fixed_by_y (const void *av, const void *bv) const cairo_point_t *a = av, *b = bv; int ret = a->y - b->y; - if (ret == 0) { + if (ret == 0) ret = a->x - b->x; - } return ret; } diff --git a/src/cairo-types-private.h b/src/cairo-types-private.h index b55362092..fa7067852 100644 --- a/src/cairo-types-private.h +++ b/src/cairo-types-private.h @@ -177,13 +177,7 @@ typedef enum _cairo_internal_surface_type { #define CAIRO_HAS_TEST_NULL_SURFACE 1 #define CAIRO_HAS_TEST_WRAPPING_SURFACE 1 -typedef struct _cairo_point { - cairo_fixed_t x; - cairo_fixed_t y; -} cairo_point_t; - -typedef struct _cairo_slope -{ +typedef struct _cairo_slope { cairo_fixed_t dx; cairo_fixed_t dy; } cairo_slope_t, cairo_distance_t; @@ -244,7 +238,8 @@ typedef enum _cairo_direction { } cairo_direction_t; typedef struct _cairo_edge { - cairo_line_t edge; + cairo_line_t line; + int top, bottom; int dir; } cairo_edge_t; @@ -255,6 +250,10 @@ typedef struct _cairo_polygon { cairo_point_t current_point; cairo_bool_t has_current_point; + cairo_box_t extents; + cairo_box_t limits; + cairo_bool_t has_limits; + int num_edges; int edges_size; cairo_edge_t *edges; diff --git a/src/cairo-wideint-private.h b/src/cairo-wideint-private.h index f5aac2848..ec7fa1f6e 100644 --- a/src/cairo-wideint-private.h +++ b/src/cairo-wideint-private.h @@ -51,6 +51,9 @@ #if !HAVE_UINT64_T +cairo_uquorem64_t I +_cairo_uint64_divrem (cairo_uint64_t num, cairo_uint64_t den); + cairo_uint64_t I _cairo_uint32_to_uint64 (uint32_t i); #define _cairo_uint64_to_uint32(a) ((a).lo) cairo_uint64_t I _cairo_uint64_add (cairo_uint64_t a, cairo_uint64_t b); @@ -90,6 +93,16 @@ int I _cairo_int64_cmp (cairo_int64_t a, cairo_int64_t b); #else +static inline cairo_uquorem64_t +_cairo_uint64_divrem (cairo_uint64_t num, cairo_uint64_t den) +{ + cairo_uquorem64_t qr; + + qr.quo = num / den; + qr.rem = num % den; + return qr; +} + #define _cairo_uint32_to_uint64(i) ((uint64_t) (i)) #define _cairo_uint64_to_uint32(i) ((uint32_t) (i)) #define _cairo_uint64_add(a,b) ((a) + (b)) @@ -147,11 +160,35 @@ int I _cairo_int64_cmp (cairo_int64_t a, cairo_int64_t b); * a function which returns both for the 'native' type as well */ -cairo_uquorem64_t I -_cairo_uint64_divrem (cairo_uint64_t num, cairo_uint64_t den); - -cairo_quorem64_t I -_cairo_int64_divrem (cairo_int64_t num, cairo_int64_t den); +static inline cairo_quorem64_t +_cairo_int64_divrem (cairo_int64_t num, cairo_int64_t den) +{ + int num_neg = _cairo_int64_negative (num); + int den_neg = _cairo_int64_negative (den); + cairo_uquorem64_t uqr; + cairo_quorem64_t qr; + + if (num_neg) + num = _cairo_int64_negate (num); + if (den_neg) + den = _cairo_int64_negate (den); + uqr = _cairo_uint64_divrem (num, den); + if (num_neg) + qr.rem = _cairo_int64_negate (uqr.rem); + else + qr.rem = uqr.rem; + if (num_neg != den_neg) + qr.quo = (cairo_int64_t) _cairo_int64_negate (uqr.quo); + else + qr.quo = (cairo_int64_t) uqr.quo; + return qr; +} + +static inline int32_t +_cairo_int64_32_div (cairo_int64_t num, int32_t den) +{ + return num / den; +} /* * 128-bit datatypes. Again, provide two implementations in diff --git a/src/cairo-wideint.c b/src/cairo-wideint.c index 456559386..1843a6027 100644 --- a/src/cairo-wideint.c +++ b/src/cairo-wideint.c @@ -39,16 +39,6 @@ #define _cairo_uint32s_to_uint64(h,l) ((uint64_t) (h) << 32 | (l)) -cairo_uquorem64_t -_cairo_uint64_divrem (cairo_uint64_t num, cairo_uint64_t den) -{ - cairo_uquorem64_t qr; - - qr.quo = num / den; - qr.rem = num % den; - return qr; -} - #else cairo_uint64_t @@ -317,30 +307,6 @@ _cairo_uint64_divrem (cairo_uint64_t num, cairo_uint64_t den) #endif /* !HAVE_UINT64_T */ -cairo_quorem64_t -_cairo_int64_divrem (cairo_int64_t num, cairo_int64_t den) -{ - int num_neg = _cairo_int64_negative (num); - int den_neg = _cairo_int64_negative (den); - cairo_uquorem64_t uqr; - cairo_quorem64_t qr; - - if (num_neg) - num = _cairo_int64_negate (num); - if (den_neg) - den = _cairo_int64_negate (den); - uqr = _cairo_uint64_divrem (num, den); - if (num_neg) - qr.rem = _cairo_int64_negate (uqr.rem); - else - qr.rem = uqr.rem; - if (num_neg != den_neg) - qr.quo = (cairo_int64_t) _cairo_int64_negate (uqr.quo); - else - qr.quo = (cairo_int64_t) uqr.quo; - return qr; -} - #if HAVE_UINT128_T cairo_uquorem128_t diff --git a/src/cairoint.h b/src/cairoint.h index 12e40988a..30b0c4c0d 100644 --- a/src/cairoint.h +++ b/src/cairoint.h @@ -952,6 +952,7 @@ typedef struct _cairo_traps { cairo_status_t status; cairo_box_t extents; + cairo_box_t limits; unsigned int maybe_region : 1; /* hint: 0 implies that it cannot be */ @@ -962,7 +963,7 @@ typedef struct _cairo_traps { cairo_trapezoid_t traps_embedded[4]; cairo_bool_t has_limits; - cairo_box_t limits; + cairo_bool_t has_intersections; } cairo_traps_t; #define CAIRO_FONT_SLANT_DEFAULT CAIRO_FONT_SLANT_NORMAL @@ -1609,13 +1610,36 @@ _cairo_path_fixed_in_fill (const cairo_path_fixed_t *path, /* cairo-path-fill.c */ cairo_private cairo_status_t -_cairo_path_fixed_fill_to_traps (const cairo_path_fixed_t *path, - cairo_fill_rule_t fill_rule, - double tolerance, - cairo_traps_t *traps); +_cairo_path_fixed_fill_to_polygon (const cairo_path_fixed_t *path, + double tolerance, + cairo_polygon_t *polygon); + +cairo_private cairo_int_status_t +_cairo_path_fixed_fill_rectilinear_to_traps (const cairo_path_fixed_t *path, + cairo_fill_rule_t fill_rule, + cairo_traps_t *traps); + +cairo_private cairo_status_t +_cairo_path_fixed_fill_to_traps (const cairo_path_fixed_t *path, + cairo_fill_rule_t fill_rule, + double tolerance, + cairo_traps_t *traps); /* cairo-path-stroke.c */ cairo_private cairo_status_t +_cairo_path_fixed_stroke_to_polygon (const cairo_path_fixed_t *path, + cairo_stroke_style_t *stroke_style, + const cairo_matrix_t *ctm, + const cairo_matrix_t *ctm_inverse, + double tolerance, + cairo_polygon_t *polygon); + +cairo_private cairo_int_status_t +_cairo_path_fixed_stroke_rectilinear_to_traps (const cairo_path_fixed_t *path, + cairo_stroke_style_t *stroke_style, + const cairo_matrix_t *ctm, + cairo_traps_t *traps); +cairo_private cairo_status_t _cairo_path_fixed_stroke_to_traps (const cairo_path_fixed_t *path, cairo_stroke_style_t *stroke_style, const cairo_matrix_t *ctm, @@ -1623,6 +1647,22 @@ _cairo_path_fixed_stroke_to_traps (const cairo_path_fixed_t *path, double tolerance, cairo_traps_t *traps); +cairo_private cairo_status_t +_cairo_path_fixed_stroke_to_shaper (cairo_path_fixed_t *path, + cairo_stroke_style_t *stroke_style, + cairo_matrix_t *ctm, + cairo_matrix_t *ctm_inverse, + double tolerance, + cairo_status_t (*add_triangle) (void *closure, + const cairo_point_t triangle[3]), + cairo_status_t (*add_triangle_fan) (void *closure, + const cairo_point_t *midpt, + const cairo_point_t *points, + int npoints), + cairo_status_t (*add_quad) (void *closure, + const cairo_point_t quad[4]), + void *closure); + /* cairo-scaled-font.c */ cairo_private void @@ -2201,45 +2241,21 @@ cairo_private int _cairo_pen_find_active_ccw_vertex_index (const cairo_pen_t *pen, const cairo_slope_t *slope); -typedef struct _cairo_pen_stroke_spline { - cairo_pen_t pen; - cairo_spline_t spline; - cairo_polygon_t polygon; - cairo_point_t last_point; - cairo_point_t forward_hull_point; - cairo_point_t backward_hull_point; - int forward_vertex; - int backward_vertex; -} cairo_pen_stroke_spline_t; - -cairo_private cairo_int_status_t -_cairo_pen_stroke_spline_init (cairo_pen_stroke_spline_t *stroker, - const cairo_pen_t *pen, - const cairo_point_t *a, - const cairo_point_t *b, - const cairo_point_t *c, - const cairo_point_t *d); - -cairo_private cairo_status_t -_cairo_pen_stroke_spline (cairo_pen_stroke_spline_t *pen, - double tolerance, - cairo_traps_t *traps); - -cairo_private void -_cairo_pen_stroke_spline_fini (cairo_pen_stroke_spline_t *stroker); - /* cairo-polygon.c */ cairo_private void _cairo_polygon_init (cairo_polygon_t *polygon); cairo_private void -_cairo_polygon_fini (cairo_polygon_t *polygon); +_cairo_polygon_limit (cairo_polygon_t *polygon, + const cairo_box_t *limits); cairo_private void -_cairo_polygon_add_edge (cairo_polygon_t *polygon, - const cairo_point_t *p1, - const cairo_point_t *p2, - int dir); +_cairo_polygon_fini (cairo_polygon_t *polygon); + +cairo_private cairo_status_t +_cairo_polygon_add_external_edge (void *polygon, + const cairo_point_t *p1, + const cairo_point_t *p2); cairo_private void _cairo_polygon_move_to (cairo_polygon_t *polygon, @@ -2252,7 +2268,7 @@ _cairo_polygon_line_to (cairo_polygon_t *polygon, cairo_private void _cairo_polygon_close (cairo_polygon_t *polygon); -#define _cairo_polygon_status(P) (P)->status +#define _cairo_polygon_status(P) ((cairo_polygon_t *) (P))->status /* cairo-spline.c */ cairo_private cairo_bool_t @@ -2309,6 +2325,9 @@ cairo_private cairo_bool_t _cairo_matrix_is_integer_translation(const cairo_matrix_t *matrix, int *itx, int *ity); +cairo_private cairo_bool_t +_cairo_matrix_has_unity_scale (const cairo_matrix_t *matrix); + cairo_private cairo_bool_t _cairo_matrix_is_pixel_exact (const cairo_matrix_t *matrix) cairo_pure; @@ -2330,10 +2349,6 @@ cairo_private void _cairo_traps_limit (cairo_traps_t *traps, cairo_box_t *limits); -cairo_private cairo_bool_t -_cairo_traps_get_limit (cairo_traps_t *traps, - cairo_box_t *limits); - cairo_private void _cairo_traps_init_box (cairo_traps_t *traps, const cairo_box_t *box); @@ -2372,6 +2387,9 @@ _cairo_bentley_ottmann_tessellate_polygon (cairo_traps_t *traps, const cairo_polygon_t *polygon, cairo_fill_rule_t fill_rule); +cairo_private cairo_status_t +_cairo_bentley_ottmann_tessellate_traps (cairo_traps_t *traps); + cairo_private int _cairo_traps_contain (const cairo_traps_t *traps, double x, double y); diff --git a/test/Makefile.am b/test/Makefile.am index a05239320..9b5ee2a8b 100644 --- a/test/Makefile.am +++ b/test/Makefile.am @@ -4,8 +4,6 @@ include $(top_srcdir)/test/Makefile.sources SUBDIRS=pdiff . -CLEANFILES += have-similar.* - # Then we have a collection of tests that are only run if certain # features are compiled into cairo if HAVE_PTHREAD @@ -147,8 +145,10 @@ REFERENCE_IMAGES = \ bitmap-font.rgb24.ref.png \ caps-joins-alpha.quartz.ref.png \ caps-joins-alpha.ref.png \ + caps-joins-alpha.xlib.ref.png \ caps-joins-curve.ps.ref.png \ caps-joins-curve.ref.png \ + caps-joins-curve.xlib.ref.png \ caps-joins.ps.ref.png \ caps-joins.ref.png \ caps-sub-paths.ref.png \ @@ -156,6 +156,8 @@ REFERENCE_IMAGES = \ caps.ref.png \ clear.argb32.ref.png \ clear.rgb24.ref.png \ + clear.pdf.argb32.ref.png \ + clear.ps.argb32.ref.png \ clear.svg12.argb32.xfail.png \ clear.svg12.rgb24.xfail.png \ clip-all.ref.png \ @@ -237,6 +239,7 @@ REFERENCE_IMAGES = \ clipped-group.ps3.ref.png \ clipped-group.ref.png \ clipped-surface.ref.png \ + clipped-trapezoids.ref.png \ close-path-current-point.ps.ref.png \ close-path-current-point.ref.png \ close-path.ps2.ref.png \ @@ -275,6 +278,7 @@ REFERENCE_IMAGES = \ dash-curve.ps3.ref.png \ dash-curve.quartz.ref.png \ dash-curve.ref.png \ + dash-curve.xlib.ref.png \ dash-infinite-loop.ref.png \ dash-no-dash.ref.png \ dash-offset-negative.ref.png \ @@ -302,16 +306,18 @@ REFERENCE_IMAGES = \ degenerate-curve-to.ps.xfail.png \ degenerate-dash.ps.xfail.png \ degenerate-dash.ref.png \ + degenerate-dash.xlib.ref.png \ degenerate-path.ps.argb32.xfail.png \ degenerate-path.ps.rgb24.xfail.png \ degenerate-path.quartz.ref.png \ degenerate-path.quartz.rgb24.ref.png \ - degenerate-path.ref.png \ + degenerate-path.argb32.ref.png \ degenerate-path.rgb24.ref.png \ degenerate-pen.ps2.ref.png \ degenerate-pen.ps3.ref.png \ degenerate-pen.quartz.ref.png \ degenerate-pen.ref.png \ + degenerate-pen.xlib.ref.png \ degenerate-rel-curve-to.ref.png \ degenerate-rel-curve-to.ps.xfail.png \ device-offset-fractional.gl.xfail.png \ @@ -389,8 +395,10 @@ REFERENCE_IMAGES = \ fill-and-stroke.ps3.rgb24.ref.png \ fill-and-stroke.quartz.ref.png \ fill-and-stroke.quartz.rgb24.ref.png \ - fill-and-stroke.ref.png \ + fill-and-stroke.argb32.ref.png \ fill-and-stroke.rgb24.ref.png \ + fill-and-stroke.xlib.argb32.ref.png \ + fill-and-stroke.xlib.rgb24.ref.png \ fill-degenerate-sort-order.ps.argb32.xfail.png \ fill-degenerate-sort-order.ps.rgb24.xfail.png \ fill-degenerate-sort-order.quartz.ref.png \ @@ -469,14 +477,12 @@ REFERENCE_IMAGES = \ ft-text-antialias-none.ps3.argb32.ref.png \ ft-text-antialias-none.ref.png \ ft-text-vertical-layout-type1.pdf.ref.png \ - ft-text-vertical-layout-type1.ps2.ref.png \ - ft-text-vertical-layout-type1.ps3.ref.png \ + ft-text-vertical-layout-type1.ps.ref.png \ ft-text-vertical-layout-type1.ref.png \ ft-text-vertical-layout-type1.svg.ref.png \ ft-text-vertical-layout-type1.xlib.ref.png \ ft-text-vertical-layout-type3.pdf.ref.png \ - ft-text-vertical-layout-type3.ps2.ref.png \ - ft-text-vertical-layout-type3.ps3.ref.png \ + ft-text-vertical-layout-type3.ps.ref.png \ ft-text-vertical-layout-type3.ref.png \ ft-text-vertical-layout-type3.svg.ref.png \ ft-text-vertical-layout-type3.xlib.ref.png \ @@ -538,9 +544,11 @@ REFERENCE_IMAGES = \ leaky-dashed-rectangle.pdf.ref.png \ leaky-dashed-rectangle.ps.ref.png \ leaky-dashed-rectangle.ref.png \ + leaky-dashed-rectangle.xlib.ref.png \ leaky-dashed-stroke.ps2.ref.png \ leaky-dashed-stroke.ps3.ref.png \ leaky-dashed-stroke.ref.png \ + leaky-dashed-stroke.xlib.ref.png \ leaky-polygon.ps2.ref.png \ leaky-polygon.ps3.ref.png \ leaky-polygon.ref.png \ @@ -613,13 +621,14 @@ REFERENCE_IMAGES = \ miter-precision.ps3.ref.png \ miter-precision.ref.png \ move-to-show-surface.ref.png \ + new-sub-path.pdf.argb32.ref.png \ new-sub-path.ps2.argb32.ref.png \ new-sub-path.ps2.rgb24.ref.png \ new-sub-path.ps3.argb32.ref.png \ new-sub-path.ps3.rgb24.ref.png \ new-sub-path.quartz.ref.png \ new-sub-path.quartz.rgb24.ref.png \ - new-sub-path.ref.png \ + new-sub-path.argb32.ref.png \ new-sub-path.rgb24.ref.png \ nil-surface.ref.png \ nil-surface.rgb24.ref.png \ @@ -726,11 +735,13 @@ REFERENCE_IMAGES = \ radial-gradient.pdf.ref.png \ radial-gradient.quartz.ref.png \ radial-gradient.ref.png \ - random-intersections.ps2.ref.png \ - random-intersections.ps3.ref.png \ - random-intersections.quartz.ref.png \ - random-intersections.ref.png \ - random-intersections.xlib.ref.png \ + random-intersections-eo.ps.ref.png \ + random-intersections-eo.quartz.ref.png \ + random-intersections-eo.ref.png \ + random-intersections-eo.xlib.ref.png \ + random-intersections-nonzero.ref.png \ + random-intersections-nonzero.ps.ref.png \ + random-intersections-nonzero.xlib.ref.png \ rectangle-rounding-error.ref.png \ rectilinear-dash.ref.png \ rectilinear-fill.ref.png \ @@ -783,16 +794,9 @@ REFERENCE_IMAGES = \ self-copy.ps2.ref.png \ self-copy.ps3.ref.png \ self-copy.ref.png \ - self-intersecting.argb32.xfail.png \ - self-intersecting.pdf.argb32.xfail.png \ - self-intersecting.pdf.rgb24.xfail.png \ - self-intersecting.ps.argb32.xfail.png \ - self-intersecting.ps.rgb24.xfail.png \ + self-intersecting.ps.ref.png \ self-intersecting.ref.png \ - self-intersecting.rgb24.ref.png \ - self-intersecting.rgb24.xfail.png \ - self-intersecting.xlib.argb32.xfail.png \ - self-intersecting.xlib.rgb24.xfail.png \ + self-intersecting.xlib.ref.png \ set-source.ref.png \ set-source.rgb24.ref.png \ show-glyphs-many.ref.png \ @@ -815,6 +819,7 @@ REFERENCE_IMAGES = \ smask-paint.svg.ref.png \ smask-stroke.pdf.xfail.png \ smask-stroke.ref.png \ + smask-stroke.xlib.ref.png \ smask-text.pdf.ref.png \ smask-text.ps2.ref.png \ smask-text.ps3.ref.png \ @@ -822,8 +827,7 @@ REFERENCE_IMAGES = \ smask-text.svg.ref.png \ smask-text.xlib.ref.png \ smask.pdf.xfail.png \ - smask.ps2.ref.png \ - smask.ps3.ref.png \ + smask.ps.ref.png \ smask.ref.png \ smask.svg.ref.png \ smask.xlib.ref.png \ @@ -844,15 +848,16 @@ REFERENCE_IMAGES = \ spline-decomposition.ps.ref.png \ spline-decomposition.ref.png \ spline-decomposition.svg.ref.png \ + spline-decomposition.xlib.ref.png \ stroke-ctm-caps.ps2.ref.png \ stroke-ctm-caps.ps3.ref.png \ stroke-ctm-caps.quartz.ref.png \ stroke-ctm-caps.ref.png \ stroke-image.pdf.ref.png \ - stroke-image.ps2.ref.png \ - stroke-image.ps3.ref.png \ + stroke-image.ps.ref.png \ stroke-image.quartz.ref.png \ stroke-image.ref.png \ + stroke-image.xlib.ref.png \ surface-pattern-big-scale-down.ref.png \ surface-pattern-big-scale-down.ps.xfail.png \ surface-pattern-scale-down.pdf.ref.png \ @@ -900,6 +905,7 @@ REFERENCE_IMAGES = \ text-rotate.quartz.ref.png \ text-rotate.ref.png \ text-rotate.svg.ref.png \ + text-rotate.xlib.ref.png \ text-transform.pdf.ref.png \ text-transform.ps2.ref.png \ text-transform.ps3.ref.png \ @@ -923,6 +929,7 @@ REFERENCE_IMAGES = \ twin.ps.ref.png \ twin.ref.png \ twin.svg.ref.png \ + twin.xlib.ref.png \ unantialiased-shapes.quartz.ref.png \ unantialiased-shapes.ref.png \ unbounded-operator.gl.argb32.xfail.png \ @@ -934,7 +941,7 @@ REFERENCE_IMAGES = \ unbounded-operator.quartz.rgb24.ref.png \ unbounded-operator.ref.png \ unbounded-operator.rgb24.ref.png \ - unbounded-operator.svg12.argb32.xfail.png \ + unbounded-operator.svg12.argb32.ref.png \ unbounded-operator.svg12.rgb24.xfail.png \ unbounded-operator.xlib.rgb24.ref.png \ user-font-mask.pdf.ref.png \ @@ -953,8 +960,7 @@ REFERENCE_IMAGES = \ user-font-rescale.ps3.ref.png \ user-font-rescale.ref.png \ user-font-rescale.svg.ref.png \ - user-font.ps2.ref.png \ - user-font.ps3.ref.png \ + user-font.ps.ref.png \ user-font.ref.png \ user-font.svg.ref.png \ user-font.xlib.ref.png \ @@ -1132,14 +1138,22 @@ imagediff_LDADD = \ $(top_builddir)/src/libcairo.la png_flatten_SOURCES = png-flatten.c -png_flatten_LDADD = $(top_builddir)/src/libcairo.la $(CAIRO_LDADD) +png_flatten_LDADD = $(top_builddir)/src/libcairo.la \ + $(CAIRO_LDADD) if BUILD_ANY2PPM check_PROGRAMS += any2ppm any2ppm_CFLAGS = $(AM_CFLAGS) $(POPPLER_CFLAGS) $(LIBRSVG_CFLAGS) $(LIBSPECTRE_CFLAGS) # add LDADD, so poppler/librsvg uses "our" cairo any2ppm_LDFLAGS = $(AM_LDFLAGS) $(CAIRO_TEST_UNDEFINED_LDFLAGS) -any2ppm_LDADD = $(top_builddir)/util/cairo-script/libcairo-script-interpreter.la $(top_builddir)/src/libcairo.la $(CAIRO_LDADD) $(CAIROBOILERPLATE_LIBS) $(POPPLER_LIBS) $(LIBRSVG_LIBS) $(LIBSPECTRE_LIBS) +any2ppm_LDADD = \ + $(top_builddir)/util/cairo-script/libcairo-script-interpreter.la \ + $(top_builddir)/src/libcairo.la \ + $(CAIRO_LDADD) \ + $(CAIROBOILERPLATE_LIBS) \ + $(POPPLER_LIBS) \ + $(LIBRSVG_LIBS) \ + $(LIBSPECTRE_LIBS) endif if CAIRO_CAN_TEST_PDF_SURFACE @@ -1147,7 +1161,9 @@ check_PROGRAMS += pdf2png pdf2png_CFLAGS = $(AM_CFLAGS) $(POPPLER_CFLAGS) # add LDADD, so poppler uses "our" cairo pdf2png_LDFLAGS = $(AM_LDFLAGS) $(CAIRO_TEST_UNDEFINED_LDFLAGS) -pdf2png_LDADD = $(top_builddir)/src/libcairo.la $(CAIRO_LDADD) $(POPPLER_LIBS) +pdf2png_LDADD = $(top_builddir)/src/libcairo.la \ + $(CAIRO_LDADD) \ + $(POPPLER_LIBS) endif if CAIRO_CAN_TEST_SVG_SURFACE @@ -1155,7 +1171,9 @@ check_PROGRAMS += svg2png svg2png_CFLAGS = $(AM_CFLAGS) $(LIBRSVG_CFLAGS) # add LDADD, so librsvg uses "our" cairo svg2png_LDFLAGS = $(AM_LDFLAGS) $(CAIRO_TEST_UNDEFINED_LDFLAGS) -svg2png_LDADD = $(top_builddir)/src/libcairo.la $(CAIRO_LDADD) $(LIBRSVG_LIBS) +svg2png_LDADD = $(top_builddir)/src/libcairo.la \ + $(CAIRO_LDADD) \ + $(LIBRSVG_LIBS) endif if CAIRO_HAS_SPECTRE @@ -1163,7 +1181,9 @@ check_PROGRAMS += ps2png ps2png_CFLAGS = $(AM_CFLAGS) $(LIBSPECTRE_CFLAGS) # add LDADD, so ps2png uses "our" cairo ps2png_LDFLAGS = $(AM_LDFLAGS) $(CAIRO_TEST_UNDEFINED_LDFLAGS) -ps2png_LDADD = $(top_builddir)/src/libcairo.la $(CAIRO_LDADD) $(LIBSPECTRE_LIBS) +ps2png_LDADD = $(top_builddir)/src/libcairo.la \ + $(CAIRO_LDADD) \ + $(LIBSPECTRE_LIBS) endif EXTRA_PROGRAMS += $(TESTS) diff --git a/test/Makefile.sources b/test/Makefile.sources index 50b4d3eab..0a58ac077 100644 --- a/test/Makefile.sources +++ b/test/Makefile.sources @@ -150,7 +150,8 @@ test_sources = \ png.c \ push-group.c \ radial-gradient.c \ - random-intersections.c \ + random-intersections-eo.c \ + random-intersections-nonzero.c \ rectangle-rounding-error.c \ rectilinear-fill.c \ rectilinear-miter-limit.c \ diff --git a/test/caps-joins-alpha.ref.png b/test/caps-joins-alpha.ref.png index 1d34c73b6..b28d936e0 100644 Binary files a/test/caps-joins-alpha.ref.png and b/test/caps-joins-alpha.ref.png differ diff --git a/test/caps-joins-alpha.xlib.ref.png b/test/caps-joins-alpha.xlib.ref.png new file mode 100644 index 000000000..288a5005f Binary files /dev/null and b/test/caps-joins-alpha.xlib.ref.png differ diff --git a/test/caps-joins-curve.ref.png b/test/caps-joins-curve.ref.png index 9f7630130..cb4034b07 100644 Binary files a/test/caps-joins-curve.ref.png and b/test/caps-joins-curve.ref.png differ diff --git a/test/caps-joins-curve.xlib.ref.png b/test/caps-joins-curve.xlib.ref.png new file mode 100644 index 000000000..be7688d0b Binary files /dev/null and b/test/caps-joins-curve.xlib.ref.png differ diff --git a/test/clear.pdf.argb32.ref.png b/test/clear.pdf.argb32.ref.png new file mode 100644 index 000000000..0960f4851 Binary files /dev/null and b/test/clear.pdf.argb32.ref.png differ diff --git a/test/clear.ps.argb32.ref.png b/test/clear.ps.argb32.ref.png new file mode 100644 index 000000000..0960f4851 Binary files /dev/null and b/test/clear.ps.argb32.ref.png differ diff --git a/test/clip-operator.svg12.argb32.xfail.png b/test/clip-operator.svg12.argb32.xfail.png index be0696e0f..1c21d15f6 100644 Binary files a/test/clip-operator.svg12.argb32.xfail.png and b/test/clip-operator.svg12.argb32.xfail.png differ diff --git a/test/clip-operator.svg12.rgb24.xfail.png b/test/clip-operator.svg12.rgb24.xfail.png index 494852da4..f79de48eb 100644 Binary files a/test/clip-operator.svg12.rgb24.xfail.png and b/test/clip-operator.svg12.rgb24.xfail.png differ diff --git a/test/clipped-group.pdf.ref.png b/test/clipped-group.pdf.ref.png index 649586086..23db5a4fd 100644 Binary files a/test/clipped-group.pdf.ref.png and b/test/clipped-group.pdf.ref.png differ diff --git a/test/clipped-trapezoids-ref.png b/test/clipped-trapezoids-ref.png new file mode 100644 index 000000000..3fd300c04 Binary files /dev/null and b/test/clipped-trapezoids-ref.png differ diff --git a/test/clipped-trapezoids.c b/test/clipped-trapezoids.c new file mode 100644 index 000000000..1f96daa8c --- /dev/null +++ b/test/clipped-trapezoids.c @@ -0,0 +1,95 @@ +/* + * Copyright 2008 Chris Wilson + * + * Permission to use, copy, modify, distribute, and sell this software + * and its documentation for any purpose is hereby granted without + * fee, provided that the above copyright notice appear in all copies + * and that both that copyright notice and this permission notice + * appear in supporting documentation, and that the name of + * Chris Wilson not be used in advertising or publicity pertaining to + * distribution of the software without specific, written prior + * permission. Chris Wilson makes no representations about the + * suitability of this software for any purpose. It is provided "as + * is" without express or implied warranty. + * + * CHRIS WILSON DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS + * SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND + * FITNESS, IN NO EVENT SHALL CHRIS WILSON BE LIABLE FOR ANY SPECIAL, + * INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER + * RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION + * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR + * IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + * + * Author: Chris Wilson + */ + +#include "cairo-test.h" + +static cairo_test_status_t +draw (cairo_t *cr, int width, int height) +{ + double dash[2] = { 8, 4 }; + double radius; + + radius = width; + if (height > radius) + radius = height; + + /* fill the background using a big circle */ + cairo_arc (cr, 0, 0, 4 * radius, 0, 2 * M_PI); + cairo_fill (cr); + + /* a rotated square - overlapping the corners */ + cairo_save (cr); + cairo_save (cr); + cairo_translate (cr, width/2, height/2); + cairo_rotate (cr, M_PI/4); + cairo_scale (cr, M_SQRT2, M_SQRT2); + cairo_rectangle (cr, -width/2, -height/2, width, height); + cairo_restore (cr); + cairo_set_source_rgba (cr, 0, 1, 0, .5); + cairo_set_line_width (cr, radius/2); + cairo_stroke (cr); + cairo_restore (cr); + + /* and put some circles in the corners */ + cairo_set_source_rgb (cr, 1, 1, 1); + cairo_new_sub_path (cr); + cairo_arc (cr, 0, 0, radius/4, 0, 2 * M_PI); + cairo_new_sub_path (cr); + cairo_arc (cr, width, 0, radius/4, 0, 2 * M_PI); + cairo_new_sub_path (cr); + cairo_arc (cr, width, height, radius/4, 0, 2 * M_PI); + cairo_new_sub_path (cr); + cairo_arc (cr, 0, height, radius/4, 0, 2 * M_PI); + cairo_fill (cr); + + /* a couple of pixel-aligned lines */ + cairo_set_source_rgb (cr, 0, 0, 1); + cairo_move_to (cr, width/2, -height); + cairo_rel_line_to (cr, 0, 3*height); + cairo_move_to (cr, -width, height/2); + cairo_rel_line_to (cr, 3*width, 0); + cairo_stroke (cr); + + /* a couple of dashed diagonals */ + cairo_save (cr); + cairo_set_source_rgb (cr, 1, 0, 0); + cairo_set_dash (cr, dash, 2, 0); + cairo_set_line_width (cr, 4.); + cairo_move_to (cr, -width, -height); + cairo_line_to (cr, width+width, height+height); + cairo_move_to (cr, width+width, -height); + cairo_line_to (cr, -width, height+height); + cairo_stroke (cr); + cairo_restore (cr); + + return CAIRO_TEST_SUCCESS; +} + +CAIRO_TEST (clipped_trapezoids, + "Tests clipping of trapezoids larger than the surface", + "clip", /* keywords */ + NULL, /* requirements */ + 40, 40, + NULL, draw) diff --git a/test/clipped-trapezoids.ref.png b/test/clipped-trapezoids.ref.png new file mode 100644 index 000000000..975a692d8 Binary files /dev/null and b/test/clipped-trapezoids.ref.png differ diff --git a/test/close-path-current-point.ref.png b/test/close-path-current-point.ref.png index f30002c6b..70f9accc3 100644 Binary files a/test/close-path-current-point.ref.png and b/test/close-path-current-point.ref.png differ diff --git a/test/dash-caps-joins.ref.png b/test/dash-caps-joins.ref.png index 15a067988..bde369717 100644 Binary files a/test/dash-caps-joins.ref.png and b/test/dash-caps-joins.ref.png differ diff --git a/test/dash-curve.ref.png b/test/dash-curve.ref.png index a590fc433..b940c1b4f 100644 Binary files a/test/dash-curve.ref.png and b/test/dash-curve.ref.png differ diff --git a/test/dash-curve.xlib.ref.png b/test/dash-curve.xlib.ref.png new file mode 100644 index 000000000..76212601a Binary files /dev/null and b/test/dash-curve.xlib.ref.png differ diff --git a/test/dash-scale.ref.png b/test/dash-scale.ref.png index a0f004b38..cbfb6bd3e 100644 Binary files a/test/dash-scale.ref.png and b/test/dash-scale.ref.png differ diff --git a/test/degenerate-arc.ref.png b/test/degenerate-arc.ref.png index 1d131b225..d83e2c7b7 100644 Binary files a/test/degenerate-arc.ref.png and b/test/degenerate-arc.ref.png differ diff --git a/test/degenerate-dash.ref.png b/test/degenerate-dash.ref.png index ec51a3ce4..2ddfc8bbf 100644 Binary files a/test/degenerate-dash.ref.png and b/test/degenerate-dash.ref.png differ diff --git a/test/degenerate-dash.xlib.ref.png b/test/degenerate-dash.xlib.ref.png new file mode 100644 index 000000000..a1b2e830c Binary files /dev/null and b/test/degenerate-dash.xlib.ref.png differ diff --git a/test/degenerate-path.argb32.ref.png b/test/degenerate-path.argb32.ref.png new file mode 100644 index 000000000..e647677c7 Binary files /dev/null and b/test/degenerate-path.argb32.ref.png differ diff --git a/test/degenerate-path.ref.png b/test/degenerate-path.ref.png deleted file mode 100644 index 102e8905d..000000000 Binary files a/test/degenerate-path.ref.png and /dev/null differ diff --git a/test/degenerate-path.rgb24.ref.png b/test/degenerate-path.rgb24.ref.png index 881c0194e..d8210a54c 100644 Binary files a/test/degenerate-path.rgb24.ref.png and b/test/degenerate-path.rgb24.ref.png differ diff --git a/test/degenerate-pen.ref.png b/test/degenerate-pen.ref.png index 5961ddd4d..b7dcaadcc 100644 Binary files a/test/degenerate-pen.ref.png and b/test/degenerate-pen.ref.png differ diff --git a/test/degenerate-pen.xlib.ref.png b/test/degenerate-pen.xlib.ref.png new file mode 100644 index 000000000..b7dcaadcc Binary files /dev/null and b/test/degenerate-pen.xlib.ref.png differ diff --git a/test/device-offset-fractional.pdf.xfail.png b/test/device-offset-fractional.pdf.xfail.png index 77a496326..6248b4af9 100644 Binary files a/test/device-offset-fractional.pdf.xfail.png and b/test/device-offset-fractional.pdf.xfail.png differ diff --git a/test/fill-and-stroke-alpha-add.ref.png b/test/fill-and-stroke-alpha-add.ref.png index 412dd4f5a..c69b6bd3b 100644 Binary files a/test/fill-and-stroke-alpha-add.ref.png and b/test/fill-and-stroke-alpha-add.ref.png differ diff --git a/test/fill-and-stroke-alpha-add.svg12.xfail.png b/test/fill-and-stroke-alpha-add.svg12.xfail.png index 32962f7a7..c1d7d6fc7 100644 Binary files a/test/fill-and-stroke-alpha-add.svg12.xfail.png and b/test/fill-and-stroke-alpha-add.svg12.xfail.png differ diff --git a/test/fill-and-stroke-alpha.ref.png b/test/fill-and-stroke-alpha.ref.png index fd4b81bef..ff2e156c5 100644 Binary files a/test/fill-and-stroke-alpha.ref.png and b/test/fill-and-stroke-alpha.ref.png differ diff --git a/test/fill-and-stroke.argb32.ref.png b/test/fill-and-stroke.argb32.ref.png new file mode 100644 index 000000000..01d92c88c Binary files /dev/null and b/test/fill-and-stroke.argb32.ref.png differ diff --git a/test/fill-and-stroke.ref.png b/test/fill-and-stroke.ref.png deleted file mode 100644 index 298f6945f..000000000 Binary files a/test/fill-and-stroke.ref.png and /dev/null differ diff --git a/test/fill-and-stroke.rgb24.ref.png b/test/fill-and-stroke.rgb24.ref.png index ff886eb25..7228813b1 100644 Binary files a/test/fill-and-stroke.rgb24.ref.png and b/test/fill-and-stroke.rgb24.ref.png differ diff --git a/test/fill-and-stroke.xlib.argb32.ref.png b/test/fill-and-stroke.xlib.argb32.ref.png new file mode 100644 index 000000000..5f77c9263 Binary files /dev/null and b/test/fill-and-stroke.xlib.argb32.ref.png differ diff --git a/test/fill-and-stroke.xlib.rgb24.ref.png b/test/fill-and-stroke.xlib.rgb24.ref.png new file mode 100644 index 000000000..f4035ebea Binary files /dev/null and b/test/fill-and-stroke.xlib.rgb24.ref.png differ diff --git a/test/filter-nearest-offset.pdf.xfail.png b/test/filter-nearest-offset.pdf.xfail.png index ffe2df129..4d436aa17 100644 Binary files a/test/filter-nearest-offset.pdf.xfail.png and b/test/filter-nearest-offset.pdf.xfail.png differ diff --git a/test/filter-nearest-transformed.pdf.xfail.png b/test/filter-nearest-transformed.pdf.xfail.png index 7eb5988b7..5ad98a758 100644 Binary files a/test/filter-nearest-transformed.pdf.xfail.png and b/test/filter-nearest-transformed.pdf.xfail.png differ diff --git a/test/ft-text-vertical-layout-type1.ps.ref.png b/test/ft-text-vertical-layout-type1.ps.ref.png new file mode 100644 index 000000000..05cdf103d Binary files /dev/null and b/test/ft-text-vertical-layout-type1.ps.ref.png differ diff --git a/test/ft-text-vertical-layout-type1.ps2.ref.png b/test/ft-text-vertical-layout-type1.ps2.ref.png deleted file mode 100644 index 4523495bb..000000000 Binary files a/test/ft-text-vertical-layout-type1.ps2.ref.png and /dev/null differ diff --git a/test/ft-text-vertical-layout-type1.ps3.ref.png b/test/ft-text-vertical-layout-type1.ps3.ref.png deleted file mode 100644 index 4523495bb..000000000 Binary files a/test/ft-text-vertical-layout-type1.ps3.ref.png and /dev/null differ diff --git a/test/ft-text-vertical-layout-type1.ref.png b/test/ft-text-vertical-layout-type1.ref.png index 1accc0b3a..6f0df7b34 100644 Binary files a/test/ft-text-vertical-layout-type1.ref.png and b/test/ft-text-vertical-layout-type1.ref.png differ diff --git a/test/ft-text-vertical-layout-type1.svg.ref.png b/test/ft-text-vertical-layout-type1.svg.ref.png index 0be400c13..326a240d3 100644 Binary files a/test/ft-text-vertical-layout-type1.svg.ref.png and b/test/ft-text-vertical-layout-type1.svg.ref.png differ diff --git a/test/ft-text-vertical-layout-type1.xlib.ref.png b/test/ft-text-vertical-layout-type1.xlib.ref.png index 2b74aa608..44a1ec7a8 100644 Binary files a/test/ft-text-vertical-layout-type1.xlib.ref.png and b/test/ft-text-vertical-layout-type1.xlib.ref.png differ diff --git a/test/ft-text-vertical-layout-type3.ps.ref.png b/test/ft-text-vertical-layout-type3.ps.ref.png new file mode 100644 index 000000000..bcc208d8b Binary files /dev/null and b/test/ft-text-vertical-layout-type3.ps.ref.png differ diff --git a/test/ft-text-vertical-layout-type3.ps2.ref.png b/test/ft-text-vertical-layout-type3.ps2.ref.png deleted file mode 100644 index e6ad8fc0b..000000000 Binary files a/test/ft-text-vertical-layout-type3.ps2.ref.png and /dev/null differ diff --git a/test/ft-text-vertical-layout-type3.ps3.ref.png b/test/ft-text-vertical-layout-type3.ps3.ref.png deleted file mode 100644 index e6ad8fc0b..000000000 Binary files a/test/ft-text-vertical-layout-type3.ps3.ref.png and /dev/null differ diff --git a/test/ft-text-vertical-layout-type3.ref.png b/test/ft-text-vertical-layout-type3.ref.png index 1bda421c4..94048f1c4 100644 Binary files a/test/ft-text-vertical-layout-type3.ref.png and b/test/ft-text-vertical-layout-type3.ref.png differ diff --git a/test/ft-text-vertical-layout-type3.svg.ref.png b/test/ft-text-vertical-layout-type3.svg.ref.png index cddb955aa..985a8de65 100644 Binary files a/test/ft-text-vertical-layout-type3.svg.ref.png and b/test/ft-text-vertical-layout-type3.svg.ref.png differ diff --git a/test/ft-text-vertical-layout-type3.xlib.ref.png b/test/ft-text-vertical-layout-type3.xlib.ref.png index 8ec2ebec2..7a7f68f71 100644 Binary files a/test/ft-text-vertical-layout-type3.xlib.ref.png and b/test/ft-text-vertical-layout-type3.xlib.ref.png differ diff --git a/test/group-unaligned.svg.argb32.xfail.png b/test/group-unaligned.svg.argb32.xfail.png index 01c34bec4..38550376d 100644 Binary files a/test/group-unaligned.svg.argb32.xfail.png and b/test/group-unaligned.svg.argb32.xfail.png differ diff --git a/test/joins.ref.png b/test/joins.ref.png index eee7627e8..f8e33f8a8 100644 Binary files a/test/joins.ref.png and b/test/joins.ref.png differ diff --git a/test/leaky-dashed-rectangle.pdf.ref.png b/test/leaky-dashed-rectangle.pdf.ref.png index 690cb3633..c0ba7b2c0 100644 Binary files a/test/leaky-dashed-rectangle.pdf.ref.png and b/test/leaky-dashed-rectangle.pdf.ref.png differ diff --git a/test/leaky-dashed-rectangle.xlib.ref.png b/test/leaky-dashed-rectangle.xlib.ref.png new file mode 100644 index 000000000..690cb3633 Binary files /dev/null and b/test/leaky-dashed-rectangle.xlib.ref.png differ diff --git a/test/leaky-dashed-stroke.ref.png b/test/leaky-dashed-stroke.ref.png index e79d4d118..ae64dae4c 100644 Binary files a/test/leaky-dashed-stroke.ref.png and b/test/leaky-dashed-stroke.ref.png differ diff --git a/test/leaky-dashed-stroke.xlib.ref.png b/test/leaky-dashed-stroke.xlib.ref.png new file mode 100644 index 000000000..4ebf1a7fe Binary files /dev/null and b/test/leaky-dashed-stroke.xlib.ref.png differ diff --git a/test/line-width-scale.ref.png b/test/line-width-scale.ref.png index c40bce39a..e012b6e2d 100644 Binary files a/test/line-width-scale.ref.png and b/test/line-width-scale.ref.png differ diff --git a/test/long-dashed-lines.ref.png b/test/long-dashed-lines.ref.png index caf8b5e5f..09829b713 100644 Binary files a/test/long-dashed-lines.ref.png and b/test/long-dashed-lines.ref.png differ diff --git a/test/mask-glyphs.svg.ref.png b/test/mask-glyphs.svg.ref.png index 0058afc15..5d524ddc9 100644 Binary files a/test/mask-glyphs.svg.ref.png and b/test/mask-glyphs.svg.ref.png differ diff --git a/test/meta-surface-pattern.pdf.argb32.ref.png b/test/meta-surface-pattern.pdf.argb32.ref.png index 043322280..015f7445d 100644 Binary files a/test/meta-surface-pattern.pdf.argb32.ref.png and b/test/meta-surface-pattern.pdf.argb32.ref.png differ diff --git a/test/meta-surface-pattern.pdf.rgb24.ref.png b/test/meta-surface-pattern.pdf.rgb24.ref.png index b59a9caf8..1762e8ac8 100644 Binary files a/test/meta-surface-pattern.pdf.rgb24.ref.png and b/test/meta-surface-pattern.pdf.rgb24.ref.png differ diff --git a/test/meta-surface-pattern.svg.argb32.ref.png b/test/meta-surface-pattern.svg.argb32.ref.png index 86f6b6120..ff4154d61 100644 Binary files a/test/meta-surface-pattern.svg.argb32.ref.png and b/test/meta-surface-pattern.svg.argb32.ref.png differ diff --git a/test/meta-surface-pattern.svg.rgb24.ref.png b/test/meta-surface-pattern.svg.rgb24.ref.png index bbd89363e..d2d537241 100644 Binary files a/test/meta-surface-pattern.svg.rgb24.ref.png and b/test/meta-surface-pattern.svg.rgb24.ref.png differ diff --git a/test/new-sub-path.argb32.ref.png b/test/new-sub-path.argb32.ref.png new file mode 100644 index 000000000..4ecaa0f5c Binary files /dev/null and b/test/new-sub-path.argb32.ref.png differ diff --git a/test/new-sub-path.pdf.argb32.ref.png b/test/new-sub-path.pdf.argb32.ref.png new file mode 100644 index 000000000..41fe1314e Binary files /dev/null and b/test/new-sub-path.pdf.argb32.ref.png differ diff --git a/test/new-sub-path.ref.png b/test/new-sub-path.ref.png deleted file mode 100644 index 7319ab3fc..000000000 Binary files a/test/new-sub-path.ref.png and /dev/null differ diff --git a/test/new-sub-path.rgb24.ref.png b/test/new-sub-path.rgb24.ref.png index 8cbc73161..938344a55 100644 Binary files a/test/new-sub-path.rgb24.ref.png and b/test/new-sub-path.rgb24.ref.png differ diff --git a/test/operator-source.svg12.argb32.xfail.png b/test/operator-source.svg12.argb32.xfail.png index ccf431567..722e5ac4c 100644 Binary files a/test/operator-source.svg12.argb32.xfail.png and b/test/operator-source.svg12.argb32.xfail.png differ diff --git a/test/operator-source.svg12.rgb24.xfail.png b/test/operator-source.svg12.rgb24.xfail.png index 827521b8f..5f445fc54 100644 Binary files a/test/operator-source.svg12.rgb24.xfail.png and b/test/operator-source.svg12.rgb24.xfail.png differ diff --git a/test/over-around-source.pdf.argb32.ref.png b/test/over-around-source.pdf.argb32.ref.png index 02af76a91..da700af73 100644 Binary files a/test/over-around-source.pdf.argb32.ref.png and b/test/over-around-source.pdf.argb32.ref.png differ diff --git a/test/random-intersections-eo.c b/test/random-intersections-eo.c new file mode 100644 index 000000000..d35894f33 --- /dev/null +++ b/test/random-intersections-eo.c @@ -0,0 +1,78 @@ +/* + * Copyright © 2006 M Joonas Pihlaja + * + * Permission is hereby granted, free of charge, to any person + * obtaining a copy of this software and associated documentation + * files (the "Software"), to deal in the Software without + * restriction, including without limitation the rights to use, copy, + * modify, merge, publish, distribute, sublicense, and/or sell copies + * of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS + * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN + * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + * + * Author: M Joonas Pihlaja + */ +#include "cairo-test.h" + +#define SIZE 512 +#define NUM_SEGMENTS 128 + +static uint32_t state; + +static double +uniform_random (double minval, double maxval) +{ + static uint32_t const poly = 0x9a795537U; + uint32_t n = 32; + while (n-->0) + state = 2*state < state ? (2*state ^ poly) : 2*state; + return minval + state * (maxval - minval) / 4294967296.0; +} + +static cairo_test_status_t +draw (cairo_t *cr, int width, int height) +{ + int i; + + cairo_set_source_rgb (cr, 0, 0, 0); + cairo_paint (cr); + + state = 0x12345678; + cairo_translate (cr, 1, 1); + cairo_set_fill_rule (cr, CAIRO_FILL_RULE_EVEN_ODD); + + cairo_move_to (cr, 0, 0); + for (i = 0; i < NUM_SEGMENTS; i++) { + double x = uniform_random (0, width); + double y = uniform_random (0, height); + cairo_line_to (cr, x, y); + } + cairo_close_path (cr); + + cairo_set_source_rgb (cr, 1, 0, 0); + cairo_fill_preserve (cr); + cairo_set_source_rgb (cr, 0, 1, 0); + cairo_set_line_width (cr, 0.5); + cairo_stroke (cr); + + return CAIRO_TEST_SUCCESS; +} + +CAIRO_TEST (random_intersections_eo, + "Tests the tessellator trapezoid generation and intersection computation", + "trap", /* keywords */ + NULL, /* requirements */ + SIZE+3, SIZE+3, + NULL, draw) + diff --git a/test/random-intersections-eo.ps.ref.png b/test/random-intersections-eo.ps.ref.png new file mode 100644 index 000000000..4bb11d6fd Binary files /dev/null and b/test/random-intersections-eo.ps.ref.png differ diff --git a/test/random-intersections-eo.quartz.ref.png b/test/random-intersections-eo.quartz.ref.png new file mode 100644 index 000000000..ef76cba94 Binary files /dev/null and b/test/random-intersections-eo.quartz.ref.png differ diff --git a/test/random-intersections-eo.ref.png b/test/random-intersections-eo.ref.png new file mode 100644 index 000000000..ea23a8780 Binary files /dev/null and b/test/random-intersections-eo.ref.png differ diff --git a/test/random-intersections-eo.xlib.ref.png b/test/random-intersections-eo.xlib.ref.png new file mode 100644 index 000000000..942a5fc7a Binary files /dev/null and b/test/random-intersections-eo.xlib.ref.png differ diff --git a/test/random-intersections-nonzero.c b/test/random-intersections-nonzero.c new file mode 100644 index 000000000..cad047e04 --- /dev/null +++ b/test/random-intersections-nonzero.c @@ -0,0 +1,79 @@ +/* + * Copyright © 2006 M Joonas Pihlaja + * + * Permission is hereby granted, free of charge, to any person + * obtaining a copy of this software and associated documentation + * files (the "Software"), to deal in the Software without + * restriction, including without limitation the rights to use, copy, + * modify, merge, publish, distribute, sublicense, and/or sell copies + * of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS + * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN + * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + * + * Author: M Joonas Pihlaja + */ +#include "cairo-test.h" + +#define SIZE 512 +#define NUM_SEGMENTS 128 + +static uint32_t state; + +static double +uniform_random (double minval, double maxval) +{ + static uint32_t const poly = 0x9a795537U; + uint32_t n = 32; + while (n-->0) + state = 2*state < state ? (2*state ^ poly) : 2*state; + return minval + state * (maxval - minval) / 4294967296.0; +} + +static cairo_test_status_t +draw (cairo_t *cr, int width, int height) +{ + int i; + + cairo_set_source_rgb (cr, 0, 0, 0); + cairo_paint (cr); + + state = 0x12345678; + cairo_translate (cr, 1, 1); + cairo_set_fill_rule (cr, CAIRO_FILL_RULE_WINDING); + + cairo_move_to (cr, 0, 0); + for (i = 0; i < NUM_SEGMENTS; i++) { + double x = uniform_random (0, width); + double y = uniform_random (0, height); + cairo_line_to (cr, x, y); + } + cairo_close_path (cr); + + cairo_set_source_rgb (cr, 1, 0, 0); + cairo_fill_preserve (cr); + cairo_set_source_rgb (cr, 0, 1, 0); + cairo_set_line_width (cr, 0.5); + cairo_stroke (cr); + + return CAIRO_TEST_SUCCESS; +} + +CAIRO_TEST (random_intersections_nonzero, + "Tests the tessellator trapezoid generation and intersection computation", + "trap", /* keywords */ + NULL, /* requirements */ + SIZE+3, SIZE+3, + NULL, draw) + + diff --git a/test/random-intersections-nonzero.ps.ref.png b/test/random-intersections-nonzero.ps.ref.png new file mode 100644 index 000000000..043109109 Binary files /dev/null and b/test/random-intersections-nonzero.ps.ref.png differ diff --git a/test/random-intersections-nonzero.ref.png b/test/random-intersections-nonzero.ref.png new file mode 100644 index 000000000..3ea650c94 Binary files /dev/null and b/test/random-intersections-nonzero.ref.png differ diff --git a/test/random-intersections-nonzero.xlib.ref.png b/test/random-intersections-nonzero.xlib.ref.png new file mode 100644 index 000000000..69e06f8ce Binary files /dev/null and b/test/random-intersections-nonzero.xlib.ref.png differ diff --git a/test/random-intersections.c b/test/random-intersections.c deleted file mode 100644 index 75e6b6260..000000000 --- a/test/random-intersections.c +++ /dev/null @@ -1,78 +0,0 @@ -/* - * Copyright © 2006 M Joonas Pihlaja - * - * Permission is hereby granted, free of charge, to any person - * obtaining a copy of this software and associated documentation - * files (the "Software"), to deal in the Software without - * restriction, including without limitation the rights to use, copy, - * modify, merge, publish, distribute, sublicense, and/or sell copies - * of the Software, and to permit persons to whom the Software is - * furnished to do so, subject to the following conditions: - * - * The above copyright notice and this permission notice shall be - * included in all copies or substantial portions of the Software. - * - * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, - * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF - * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND - * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS - * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN - * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN - * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE - * SOFTWARE. - * - * Author: M Joonas Pihlaja - */ -#include "cairo-test.h" - -#define SIZE 512 -#define NUM_SEGMENTS 128 - -static uint32_t state; - -static double -uniform_random (double minval, double maxval) -{ - static uint32_t const poly = 0x9a795537U; - uint32_t n = 32; - while (n-->0) - state = 2*state < state ? (2*state ^ poly) : 2*state; - return minval + state * (maxval - minval) / 4294967296.0; -} - -static cairo_test_status_t -draw (cairo_t *cr, int width, int height) -{ - int i; - - cairo_set_source_rgb (cr, 0, 0, 0); - cairo_paint (cr); - - state = 0x12345678; - cairo_translate (cr, 1, 1); - cairo_set_fill_rule (cr, CAIRO_FILL_RULE_EVEN_ODD); - - cairo_move_to (cr, 0, 0); - for (i = 0; i < NUM_SEGMENTS; i++) { - double x = uniform_random (0, width); - double y = uniform_random (0, height); - cairo_line_to (cr, x, y); - } - cairo_close_path (cr); - - cairo_set_source_rgb (cr, 1, 0, 0); - cairo_fill_preserve (cr); - cairo_set_source_rgb (cr, 0, 1, 0); - cairo_set_line_width (cr, 0.5); - cairo_stroke (cr); - - return CAIRO_TEST_SUCCESS; -} - -CAIRO_TEST (random_intersections, - "Tests the tessellator trapezoid generation and intersection computation", - "trap", /* keywords */ - NULL, /* requirements */ - SIZE+3, SIZE+3, - NULL, draw) - diff --git a/test/random-intersections.ps2.ref.png b/test/random-intersections.ps2.ref.png deleted file mode 100644 index 590c83248..000000000 Binary files a/test/random-intersections.ps2.ref.png and /dev/null differ diff --git a/test/random-intersections.ps3.ref.png b/test/random-intersections.ps3.ref.png deleted file mode 100644 index 590c83248..000000000 Binary files a/test/random-intersections.ps3.ref.png and /dev/null differ diff --git a/test/random-intersections.quartz.ref.png b/test/random-intersections.quartz.ref.png deleted file mode 100644 index ef76cba94..000000000 Binary files a/test/random-intersections.quartz.ref.png and /dev/null differ diff --git a/test/random-intersections.ref.png b/test/random-intersections.ref.png deleted file mode 100644 index ace75a24e..000000000 Binary files a/test/random-intersections.ref.png and /dev/null differ diff --git a/test/random-intersections.xlib.ref.png b/test/random-intersections.xlib.ref.png deleted file mode 100644 index 3188edefc..000000000 Binary files a/test/random-intersections.xlib.ref.png and /dev/null differ diff --git a/test/reflected-stroke.ref.png b/test/reflected-stroke.ref.png index 20f89c841..2dd865ba5 100644 Binary files a/test/reflected-stroke.ref.png and b/test/reflected-stroke.ref.png differ diff --git a/test/rel-path.ref.png b/test/rel-path.ref.png index 7b7007f31..18e67ca3e 100644 Binary files a/test/rel-path.ref.png and b/test/rel-path.ref.png differ diff --git a/test/rel-path.rgb24.ref.png b/test/rel-path.rgb24.ref.png index 0a8a8732d..c317d11be 100644 Binary files a/test/rel-path.rgb24.ref.png and b/test/rel-path.rgb24.ref.png differ diff --git a/test/scale-offset-image.meta.xfail.png b/test/scale-offset-image.meta.xfail.png deleted file mode 100644 index 3e0191a1f..000000000 Binary files a/test/scale-offset-image.meta.xfail.png and /dev/null differ diff --git a/test/scale-offset-image.pdf.xfail.png b/test/scale-offset-image.pdf.xfail.png index 3eacbbc86..76e6fb76e 100644 Binary files a/test/scale-offset-image.pdf.xfail.png and b/test/scale-offset-image.pdf.xfail.png differ diff --git a/test/scale-offset-image.xfail.png b/test/scale-offset-image.xfail.png index 3e0191a1f..fef3a3995 100644 Binary files a/test/scale-offset-image.xfail.png and b/test/scale-offset-image.xfail.png differ diff --git a/test/scale-offset-image.xlib-fallback.xfail.png b/test/scale-offset-image.xlib-fallback.xfail.png index 1a286cdb6..0dd71002b 100644 Binary files a/test/scale-offset-image.xlib-fallback.xfail.png and b/test/scale-offset-image.xlib-fallback.xfail.png differ diff --git a/test/scale-offset-image.xlib.xfail.png b/test/scale-offset-image.xlib.xfail.png index efb009177..89611db5f 100644 Binary files a/test/scale-offset-image.xlib.xfail.png and b/test/scale-offset-image.xlib.xfail.png differ diff --git a/test/scale-offset-similar.meta.xfail.png b/test/scale-offset-similar.meta.xfail.png index 83d53e65a..0f2553e49 100644 Binary files a/test/scale-offset-similar.meta.xfail.png and b/test/scale-offset-similar.meta.xfail.png differ diff --git a/test/scale-offset-similar.pdf.xfail.png b/test/scale-offset-similar.pdf.xfail.png index 7808aeb9a..38b9a2096 100644 Binary files a/test/scale-offset-similar.pdf.xfail.png and b/test/scale-offset-similar.pdf.xfail.png differ diff --git a/test/scale-offset-similar.xfail.png b/test/scale-offset-similar.xfail.png index 3e0191a1f..fef3a3995 100644 Binary files a/test/scale-offset-similar.xfail.png and b/test/scale-offset-similar.xfail.png differ diff --git a/test/scale-offset-similar.xlib-fallback.xfail.png b/test/scale-offset-similar.xlib-fallback.xfail.png index 1a286cdb6..0dd71002b 100644 Binary files a/test/scale-offset-similar.xlib-fallback.xfail.png and b/test/scale-offset-similar.xlib-fallback.xfail.png differ diff --git a/test/scale-offset-similar.xlib.xfail.png b/test/scale-offset-similar.xlib.xfail.png index d58aebab3..09e17daa2 100644 Binary files a/test/scale-offset-similar.xlib.xfail.png and b/test/scale-offset-similar.xlib.xfail.png differ diff --git a/test/self-intersecting.argb32.xfail.png b/test/self-intersecting.argb32.xfail.png deleted file mode 100644 index f644ed46e..000000000 Binary files a/test/self-intersecting.argb32.xfail.png and /dev/null differ diff --git a/test/self-intersecting.c b/test/self-intersecting.c index 6719e93fe..8053235ac 100644 --- a/test/self-intersecting.c +++ b/test/self-intersecting.c @@ -47,6 +47,9 @@ static cairo_test_status_t draw (cairo_t *cr, int width, int height) { + cairo_set_source_rgb (cr, 1, 1, 1); + cairo_paint (cr); + cairo_translate (cr, 1.0, 1.0); cairo_set_source_rgb (cr, 1, 0, 0); /* red */ diff --git a/test/self-intersecting.pdf.argb32.xfail.png b/test/self-intersecting.pdf.argb32.xfail.png deleted file mode 100644 index eb38a893a..000000000 Binary files a/test/self-intersecting.pdf.argb32.xfail.png and /dev/null differ diff --git a/test/self-intersecting.pdf.rgb24.xfail.png b/test/self-intersecting.pdf.rgb24.xfail.png deleted file mode 100644 index a79a29759..000000000 Binary files a/test/self-intersecting.pdf.rgb24.xfail.png and /dev/null differ diff --git a/test/self-intersecting.ps.argb32.xfail.png b/test/self-intersecting.ps.argb32.xfail.png deleted file mode 100644 index 84fde0171..000000000 Binary files a/test/self-intersecting.ps.argb32.xfail.png and /dev/null differ diff --git a/test/self-intersecting.ps.ref.png b/test/self-intersecting.ps.ref.png new file mode 100644 index 000000000..84fde0171 Binary files /dev/null and b/test/self-intersecting.ps.ref.png differ diff --git a/test/self-intersecting.ps.rgb24.xfail.png b/test/self-intersecting.ps.rgb24.xfail.png deleted file mode 100644 index c81360704..000000000 Binary files a/test/self-intersecting.ps.rgb24.xfail.png and /dev/null differ diff --git a/test/self-intersecting.ref.png b/test/self-intersecting.ref.png index 384b0abc0..b2f425995 100644 Binary files a/test/self-intersecting.ref.png and b/test/self-intersecting.ref.png differ diff --git a/test/self-intersecting.rgb24.ref.png b/test/self-intersecting.rgb24.ref.png deleted file mode 100644 index 51217926f..000000000 Binary files a/test/self-intersecting.rgb24.ref.png and /dev/null differ diff --git a/test/self-intersecting.rgb24.xfail.png b/test/self-intersecting.rgb24.xfail.png deleted file mode 100644 index 958215c21..000000000 Binary files a/test/self-intersecting.rgb24.xfail.png and /dev/null differ diff --git a/test/self-intersecting.xlib.argb32.xfail.png b/test/self-intersecting.xlib.argb32.xfail.png deleted file mode 100644 index f644ed46e..000000000 Binary files a/test/self-intersecting.xlib.argb32.xfail.png and /dev/null differ diff --git a/test/self-intersecting.xlib.ref.png b/test/self-intersecting.xlib.ref.png new file mode 100644 index 000000000..f8fe0c03b Binary files /dev/null and b/test/self-intersecting.xlib.ref.png differ diff --git a/test/self-intersecting.xlib.rgb24.xfail.png b/test/self-intersecting.xlib.rgb24.xfail.png deleted file mode 100644 index 958215c21..000000000 Binary files a/test/self-intersecting.xlib.rgb24.xfail.png and /dev/null differ diff --git a/test/smask-stroke.ref.png b/test/smask-stroke.ref.png index 0d3f7feae..c94a09fce 100644 Binary files a/test/smask-stroke.ref.png and b/test/smask-stroke.ref.png differ diff --git a/test/smask-stroke.xlib.ref.png b/test/smask-stroke.xlib.ref.png new file mode 100644 index 000000000..71f427bbd Binary files /dev/null and b/test/smask-stroke.xlib.ref.png differ diff --git a/test/smask.ps.ref.png b/test/smask.ps.ref.png new file mode 100644 index 000000000..31ccc17b7 Binary files /dev/null and b/test/smask.ps.ref.png differ diff --git a/test/smask.ps2.ref.png b/test/smask.ps2.ref.png deleted file mode 100644 index c006bbdaa..000000000 Binary files a/test/smask.ps2.ref.png and /dev/null differ diff --git a/test/smask.ps3.ref.png b/test/smask.ps3.ref.png deleted file mode 100644 index c006bbdaa..000000000 Binary files a/test/smask.ps3.ref.png and /dev/null differ diff --git a/test/smask.ref.png b/test/smask.ref.png index e1904548f..b5919de37 100644 Binary files a/test/smask.ref.png and b/test/smask.ref.png differ diff --git a/test/smask.svg.ref.png b/test/smask.svg.ref.png index b4ad52703..b9c0308d2 100644 Binary files a/test/smask.svg.ref.png and b/test/smask.svg.ref.png differ diff --git a/test/smask.xlib.ref.png b/test/smask.xlib.ref.png index bb70abfe2..5ce0082c7 100644 Binary files a/test/smask.xlib.ref.png and b/test/smask.xlib.ref.png differ diff --git a/test/spline-decomposition.pdf.ref.png b/test/spline-decomposition.pdf.ref.png index 9ea094a72..5afa09498 100644 Binary files a/test/spline-decomposition.pdf.ref.png and b/test/spline-decomposition.pdf.ref.png differ diff --git a/test/spline-decomposition.ps.ref.png b/test/spline-decomposition.ps.ref.png index 2b3c07dcc..e6324041e 100644 Binary files a/test/spline-decomposition.ps.ref.png and b/test/spline-decomposition.ps.ref.png differ diff --git a/test/spline-decomposition.ref.png b/test/spline-decomposition.ref.png index bac35a9cd..426aefaa5 100644 Binary files a/test/spline-decomposition.ref.png and b/test/spline-decomposition.ref.png differ diff --git a/test/spline-decomposition.svg.ref.png b/test/spline-decomposition.svg.ref.png index 9ea094a72..5afa09498 100644 Binary files a/test/spline-decomposition.svg.ref.png and b/test/spline-decomposition.svg.ref.png differ diff --git a/test/spline-decomposition.xlib.ref.png b/test/spline-decomposition.xlib.ref.png new file mode 100644 index 000000000..30d05b3b3 Binary files /dev/null and b/test/spline-decomposition.xlib.ref.png differ diff --git a/test/stroke-ctm-caps.ref.png b/test/stroke-ctm-caps.ref.png index f36435760..799ff3920 100644 Binary files a/test/stroke-ctm-caps.ref.png and b/test/stroke-ctm-caps.ref.png differ diff --git a/test/stroke-image.pdf.ref.png b/test/stroke-image.pdf.ref.png index f3eb75d83..80df10040 100644 Binary files a/test/stroke-image.pdf.ref.png and b/test/stroke-image.pdf.ref.png differ diff --git a/test/stroke-image.ps.ref.png b/test/stroke-image.ps.ref.png new file mode 100644 index 000000000..208e008ba Binary files /dev/null and b/test/stroke-image.ps.ref.png differ diff --git a/test/stroke-image.ps2.ref.png b/test/stroke-image.ps2.ref.png deleted file mode 100644 index a18716742..000000000 Binary files a/test/stroke-image.ps2.ref.png and /dev/null differ diff --git a/test/stroke-image.ps3.ref.png b/test/stroke-image.ps3.ref.png deleted file mode 100644 index a18716742..000000000 Binary files a/test/stroke-image.ps3.ref.png and /dev/null differ diff --git a/test/stroke-image.ref.png b/test/stroke-image.ref.png index c8b9417df..a3c57aa1c 100644 Binary files a/test/stroke-image.ref.png and b/test/stroke-image.ref.png differ diff --git a/test/stroke-image.xlib.ref.png b/test/stroke-image.xlib.ref.png new file mode 100644 index 000000000..dbb5c5a17 Binary files /dev/null and b/test/stroke-image.xlib.ref.png differ diff --git a/test/surface-pattern.pdf.xfail.png b/test/surface-pattern.pdf.xfail.png index a43dc4d00..fadc2c240 100644 Binary files a/test/surface-pattern.pdf.xfail.png and b/test/surface-pattern.pdf.xfail.png differ diff --git a/test/text-rotate.pdf.ref.png b/test/text-rotate.pdf.ref.png index bdd64e6e9..ea82bfe4d 100644 Binary files a/test/text-rotate.pdf.ref.png and b/test/text-rotate.pdf.ref.png differ diff --git a/test/text-rotate.ref.png b/test/text-rotate.ref.png index b22739892..291c6c7d3 100644 Binary files a/test/text-rotate.ref.png and b/test/text-rotate.ref.png differ diff --git a/test/text-rotate.svg.ref.png b/test/text-rotate.svg.ref.png index 7ffd356b2..9d887a02f 100644 Binary files a/test/text-rotate.svg.ref.png and b/test/text-rotate.svg.ref.png differ diff --git a/test/text-rotate.xlib.ref.png b/test/text-rotate.xlib.ref.png new file mode 100644 index 000000000..3d359649b Binary files /dev/null and b/test/text-rotate.xlib.ref.png differ diff --git a/test/twin.ps.ref.png b/test/twin.ps.ref.png index e75062ca9..16b49ba62 100644 Binary files a/test/twin.ps.ref.png and b/test/twin.ps.ref.png differ diff --git a/test/twin.ref.png b/test/twin.ref.png index 3c46b02a0..f5d524fb7 100644 Binary files a/test/twin.ref.png and b/test/twin.ref.png differ diff --git a/test/twin.xlib.ref.png b/test/twin.xlib.ref.png new file mode 100644 index 000000000..044218670 Binary files /dev/null and b/test/twin.xlib.ref.png differ diff --git a/test/unantialiased-shapes.ref.png b/test/unantialiased-shapes.ref.png index 128a2a162..c909d3878 100644 Binary files a/test/unantialiased-shapes.ref.png and b/test/unantialiased-shapes.ref.png differ diff --git a/test/unbounded-operator.svg12.argb32.ref.png b/test/unbounded-operator.svg12.argb32.ref.png new file mode 100644 index 000000000..45b173fae Binary files /dev/null and b/test/unbounded-operator.svg12.argb32.ref.png differ diff --git a/test/unbounded-operator.svg12.argb32.xfail.png b/test/unbounded-operator.svg12.argb32.xfail.png deleted file mode 100644 index 15965c8e9..000000000 Binary files a/test/unbounded-operator.svg12.argb32.xfail.png and /dev/null differ diff --git a/test/unbounded-operator.svg12.rgb24.xfail.png b/test/unbounded-operator.svg12.rgb24.xfail.png index 828a9db97..c369fd263 100644 Binary files a/test/unbounded-operator.svg12.rgb24.xfail.png and b/test/unbounded-operator.svg12.rgb24.xfail.png differ diff --git a/test/user-font-proxy.svg.ref.png b/test/user-font-proxy.svg.ref.png index 6c458485d..747750a5d 100644 Binary files a/test/user-font-proxy.svg.ref.png and b/test/user-font-proxy.svg.ref.png differ diff --git a/test/user-font.ps.ref.png b/test/user-font.ps.ref.png new file mode 100644 index 000000000..63f289698 Binary files /dev/null and b/test/user-font.ps.ref.png differ diff --git a/test/user-font.ps2.ref.png b/test/user-font.ps2.ref.png deleted file mode 100644 index e1dd00abf..000000000 Binary files a/test/user-font.ps2.ref.png and /dev/null differ diff --git a/test/user-font.ps3.ref.png b/test/user-font.ps3.ref.png deleted file mode 100644 index e1dd00abf..000000000 Binary files a/test/user-font.ps3.ref.png and /dev/null differ diff --git a/test/user-font.ref.png b/test/user-font.ref.png index 753fc7bc2..ab18e1ce9 100644 Binary files a/test/user-font.ref.png and b/test/user-font.ref.png differ diff --git a/test/user-font.xlib.ref.png b/test/user-font.xlib.ref.png index abc31171a..d81ecf1db 100644 Binary files a/test/user-font.xlib.ref.png and b/test/user-font.xlib.ref.png differ diff --git a/util/.gitignore b/util/.gitignore index aa0e19b55..01eb637d4 100644 --- a/util/.gitignore +++ b/util/.gitignore @@ -2,6 +2,9 @@ .libs Makefile Makefile.in +show-edges +show-events +show-traps *.so *.la *.lo diff --git a/util/Makefile.am b/util/Makefile.am index d90d852f0..79bc3362e 100644 --- a/util/Makefile.am +++ b/util/Makefile.am @@ -6,6 +6,25 @@ if BUILD_TRACE SUBDIRS += cairo-trace endif +AM_CPPFLAGS = -I$(top_srcdir)/src + +EXTRA_PROGRAMS += show-traps show-edges show-events + +show_traps_SOURCES = show-traps.c +show_traps_CFLAGS = $(gtk_CFLAGS) +#show_traps_LDADD = $(top_builddir)/src/libcairo.la $(gtk_LIBS) +show_traps_LDADD = $(gtk_LIBS) + +show_edges_SOURCES = show-edges.c +show_edges_CFLAGS = $(gtk_CFLAGS) +#show_edges_LDADD = $(top_builddir)/src/libcairo.la $(gtk_LIBS) +show_edges_LDADD = $(gtk_LIBS) + +show_events_SOURCES = show-events.c +show_events_CFLAGS = $(gtk_CFLAGS) +#show_events_LDADD = $(top_builddir)/src/libcairo.la $(gtk_LIBS) +show_events_LDADD = $(gtk_LIBS) + util: malloc-stats.so backtrace-symbols.so .la.so: @@ -20,12 +39,10 @@ AM_LDFLAGS = -module -avoid-version -export-dynamic -rpath /dev/null EXTRA_LTLIBRARIES += malloc-stats.la backtrace-symbols.la -backtrace_symbols_la_LIBADD = -lbfd -liberty +backtrace_symbols_la_LIBADD = -lbfd -liberty #malloc_stats_la_LIBADD = $(backtrace_symbols_la_LIBADD) backtrace-symbols.lo -noinst_PROGRAMS = - if HAVE_GTK EXTRA_PROGRAMS += font-view font_view_CFLAGS = $(gtk_CFLAGS) diff --git a/util/show-edges.c b/util/show-edges.c new file mode 100644 index 000000000..d3b94bc01 --- /dev/null +++ b/util/show-edges.c @@ -0,0 +1,1189 @@ +#define _GNU_SOURCE +#include +#include +#include +#include +#include + +typedef struct _point { + gdouble x, y; +} point_t; +typedef struct _box { + point_t p1, p2; +} box_t; +typedef struct _line { + point_t p1, p2; +} line_t; +typedef struct _trapezoid { + gdouble top, bottom; + line_t left, right; +} trapezoid_t; +typedef struct _traps { + struct _traps *next, *prev; + box_t extents; + int num_traps; + int size; + trapezoid_t traps[0]; +} traps_t; + +typedef struct _edge { + line_t line; + gdouble top, bottom; + point_t p1, p2; + int dir; +} edge_t; +typedef struct _edges { + struct _edges *next, *prev; + box_t extents; + int num_edges; + int size; + edge_t edges[0]; +} edges_t; + +typedef struct _TrapView { + GtkWidget widget; + + struct _TrapView *group_head; + struct _TrapView *group_next; + struct _TrapView *group_prev; + + traps_t *traps_list; + traps_t *current_traps; + + edges_t *edges_list; + edges_t *current_edges; + + double px, py; + + gint mag_x, mag_y; + gint mag_size; + gdouble mag_zoom; + gboolean in_mag_drag; + gint mag_drag_x, mag_drag_y; +} TrapView; + +typedef struct _TrapViewClass { + GtkWidgetClass parent_class; +} TrapViewClass; + +G_DEFINE_TYPE (TrapView, trap_view, GTK_TYPE_WIDGET) + +static gdouble +_compute_intersection_x_for_y (const line_t *line, + gdouble y) +{ + gdouble dx = line->p2.x - line->p1.x; + gdouble dy = line->p2.y - line->p1.y; + gdouble x; + + if (y == line->p1.y) + return line->p1.x; + if (y == line->p2.y) + return line->p2.x; + + x = line->p1.x; + if (dy != 0) + x += (y - line->p1.y)*dx/dy; + return x; +} + +static void +_compute_intersection_point (const line_t *line, + gdouble y, + point_t *p) +{ + p->x = _compute_intersection_x_for_y (line, p->y = y); +} + +static void +trap_view_draw (TrapView *self, cairo_t *cr) +{ + traps_t *traps; + edges_t *edges; + gdouble sf_x, sf_y, sf; + gdouble mid, dim; + gdouble x0, x1, y0, y1; + double dash[2] = {8, 8}; + double dots[2] = {0., 1.}; + int n; + box_t extents; + point_t p; + + cairo_save (cr); + cairo_save (cr); + cairo_set_source_rgb (cr, 1, 1, 1); + cairo_paint (cr); + cairo_restore (cr); + + traps = self->current_traps; + edges = self->current_edges; + if (traps == NULL && edges == NULL) + return; + + if (traps != NULL) { + extents = traps->extents; + if (edges != NULL) { + if (edges->extents.p1.x < extents.p1.x) + extents.p1.x = edges->extents.p1.x; + if (edges->extents.p1.y < extents.p1.y) + extents.p1.y = edges->extents.p1.y; + if (edges->extents.p2.x > extents.p2.x) + extents.p2.x = edges->extents.p2.x; + if (edges->extents.p2.y > extents.p2.y) + extents.p2.y = edges->extents.p2.y; + } + } else + extents = edges->extents; + + mid = (extents.p2.x + extents.p1.x) / 2.; + dim = (extents.p2.x - extents.p1.x) / 2. * 1.25; + sf_x = self->widget.allocation.width / dim / 2; + + mid = (extents.p2.y + extents.p1.y) / 2.; + dim = (extents.p2.y - extents.p1.y) / 2. * 1.25; + sf_y = self->widget.allocation.height / dim / 2; + + sf = MIN (sf_x, sf_y); + + mid = (extents.p2.x + extents.p1.x) / 2.; + dim = sf_x / sf * (extents.p2.x - extents.p1.x) / 2. * 1.25; + x0 = mid - dim; + x1 = mid + dim; + mid = (extents.p2.y + extents.p1.y) / 2.; + dim = sf_y / sf * (extents.p2.y - extents.p1.y) / 2. * 1.25; + y0 = mid - dim; + y1 = mid + dim; + + if (traps != NULL) { + cairo_save (cr); + cairo_scale (cr, sf, sf); + cairo_translate (cr, -x0, -y0); + cairo_set_source_rgba (cr, 0, 1, 0, .2); + for (n = 0; n < traps->num_traps; n++) { + const trapezoid_t *t = &traps->traps[n]; + + _compute_intersection_point (&t->left, t->top, &p); + cairo_move_to (cr, p.x, p.y); + _compute_intersection_point (&t->right, t->top, &p); + cairo_line_to (cr, p.x, p.y); + _compute_intersection_point (&t->right, t->bottom, &p); + cairo_line_to (cr, p.x, p.y); + _compute_intersection_point (&t->left, t->bottom, &p); + cairo_line_to (cr, p.x, p.y); + cairo_close_path (cr); + cairo_fill (cr); + } + cairo_restore (cr); + } + + if (edges == NULL) { + cairo_save (cr); + + /* top, bottom */ + cairo_save (cr); { + cairo_matrix_t m; + cairo_matrix_init_scale (&m, sf, sf); + cairo_matrix_translate (&m, -x0, -y0); + + cairo_set_line_width (cr, 1.); + cairo_set_line_cap (cr, CAIRO_LINE_CAP_BUTT); + for (n = 0; n < traps->num_traps; n++) { + const trapezoid_t *t = &traps->traps[n]; + + _compute_intersection_point (&t->left, t->top, &p); + cairo_matrix_transform_point (&m, &p.x, &p.y); + cairo_move_to (cr, floor (p.x), floor (p.y) + .5); + cairo_set_dash (cr, dash, 2, fmod (floor (p.x), dash[0] + dash[1])); + + _compute_intersection_point (&t->right, t->top, &p); + cairo_matrix_transform_point (&m, &p.x, &p.y); + cairo_line_to (cr, ceil (p.x), floor (p.y) + .5); + cairo_stroke (cr); + + _compute_intersection_point (&t->left, t->bottom, &p); + cairo_matrix_transform_point (&m, &p.x, &p.y); + cairo_move_to (cr, floor (p.x), floor (p.y) + .5); + cairo_set_dash (cr, dash, 2, fmod (floor (p.x), dash[0] + dash[1])); + + _compute_intersection_point (&t->right, t->bottom, &p); + cairo_matrix_transform_point (&m, &p.x, &p.y); + cairo_line_to (cr, ceil (p.x), floor (p.y) + .5); + cairo_stroke (cr); + } + } cairo_restore (cr); + + /* left extents */ + cairo_save (cr); { + cairo_save (cr); { + cairo_scale (cr, sf, sf); + cairo_translate (cr, -x0, -y0); + + for (n = 0; n < traps->num_traps; n++) { + const trapezoid_t *t = &traps->traps[n]; + cairo_move_to (cr, t->left.p1.x, t->left.p1.y); + cairo_line_to (cr, t->left.p2.x, t->left.p2.y); + } + } cairo_restore (cr); + cairo_set_source_rgb (cr, 1, 0, 0); + cairo_set_line_width (cr, 1.); + cairo_set_dash (cr, dash, 2, 0.); + cairo_stroke (cr); + } cairo_restore (cr); + + /* left line */ + cairo_save (cr); { + cairo_save (cr); { + cairo_scale (cr, sf, sf); + cairo_translate (cr, -x0, -y0); + + for (n = 0; n < traps->num_traps; n++) { + const trapezoid_t *t = &traps->traps[n]; + _compute_intersection_point (&t->left, t->top, &p); + cairo_move_to (cr, p.x, p.y); + _compute_intersection_point (&t->left, t->bottom, &p); + cairo_line_to (cr, p.x, p.y); + } + } cairo_restore (cr); + cairo_set_source_rgb (cr, 1, 0, 0); + cairo_stroke (cr); + } cairo_restore (cr); + + /* right extents */ + cairo_save (cr); { + cairo_save (cr); { + cairo_scale (cr, sf, sf); + cairo_translate (cr, -x0, -y0); + + for (n = 0; n < traps->num_traps; n++) { + const trapezoid_t *t = &traps->traps[n]; + cairo_move_to (cr, t->right.p1.x, t->right.p1.y); + cairo_line_to (cr, t->right.p2.x, t->right.p2.y); + } + } cairo_restore (cr); + cairo_set_source_rgb (cr, 0, 0, 1); + cairo_set_line_width (cr, 1.); + cairo_set_dash (cr, dash, 2, 0.); + cairo_stroke (cr); + } cairo_restore (cr); + + /* right line */ + cairo_save (cr); { + cairo_save (cr); { + cairo_scale (cr, sf, sf); + cairo_translate (cr, -x0, -y0); + + for (n = 0; n < traps->num_traps; n++) { + const trapezoid_t *t = &traps->traps[n]; + _compute_intersection_point (&t->right, t->top, &p); + cairo_move_to (cr, p.x, p.y); + _compute_intersection_point (&t->right, t->bottom, &p); + cairo_line_to (cr, p.x, p.y); + } cairo_restore (cr); + cairo_set_source_rgb (cr, 0, 0, 1); + cairo_stroke (cr); + } cairo_restore (cr); + } + + /* end-points */ + cairo_save (cr); { + cairo_save (cr); { + cairo_scale (cr, sf, sf); + cairo_translate (cr, -x0, -y0); + + for (n = 0; n < traps->num_traps; n++) { + const trapezoid_t *t = &traps->traps[n]; + _compute_intersection_point (&t->left, t->top, &p); + cairo_move_to (cr, p.x, p.y); + cairo_close_path (cr); + _compute_intersection_point (&t->left, t->bottom, &p); + cairo_move_to (cr, p.x, p.y); + cairo_close_path (cr); + _compute_intersection_point (&t->right, t->top, &p); + cairo_move_to (cr, p.x, p.y); + cairo_close_path (cr); + _compute_intersection_point (&t->right, t->bottom, &p); + cairo_move_to (cr, p.x, p.y); + cairo_close_path (cr); + } + } cairo_restore (cr); + cairo_set_source_rgb (cr, 0, 0, 0); + cairo_set_dash (cr, dots, 2, 0.); + cairo_set_line_cap (cr, CAIRO_LINE_CAP_ROUND); + cairo_set_line_width (cr, 4.); + cairo_stroke (cr); + } cairo_restore (cr); + + cairo_restore (cr); + } else { + cairo_save (cr); + + for (n = 0; n < edges->num_edges; n++) { + const edge_t *e = &edges->edges[n]; + + cairo_save (cr); { + cairo_scale (cr, sf, sf); + cairo_translate (cr, -x0, -y0); + cairo_move_to (cr, e->p1.x, e->p1.y); + cairo_line_to (cr, e->p2.x, e->p2.y); + } cairo_restore (cr); + + if (e->dir < 0) { + cairo_set_source_rgb (cr, 0, 0, 1); + cairo_set_dash (cr, dash, 2, dash[0]); + } else { + cairo_set_source_rgb (cr, 1, 0, 0); + cairo_set_dash (cr, dash, 2, 0.); + } + + cairo_set_line_cap (cr, CAIRO_LINE_CAP_BUTT); + cairo_set_line_width (cr, 1.); + cairo_stroke (cr); + + cairo_save (cr); { + cairo_scale (cr, sf, sf); + cairo_translate (cr, -x0, -y0); + cairo_move_to (cr, e->p1.x, e->p1.y); + cairo_close_path (cr); + cairo_move_to (cr, e->p2.x, e->p2.y); + cairo_close_path (cr); + } cairo_restore (cr); + cairo_set_source_rgb (cr, 0, 0, 0); + cairo_set_dash (cr, dots, 2, 0.); + cairo_set_line_cap (cr, CAIRO_LINE_CAP_ROUND); + cairo_set_line_width (cr, 4.); + cairo_stroke (cr); + } + + cairo_restore (cr); + } + + /* draw a zoom view of the area around the mouse */ + { + cairo_save (cr); + double zoom = self->mag_zoom; + int size = self->mag_size; + + /* bottom right */ + cairo_rectangle (cr, self->mag_x, self->mag_y, size, size); + cairo_stroke_preserve (cr); + cairo_set_source_rgb (cr, 1, 1, 1); + cairo_fill_preserve (cr); + cairo_clip (cr); + + /* compute roi in extents */ + cairo_translate (cr, self->mag_x + size/2, self->mag_y + size/2); + + if (traps != NULL) { + cairo_save (cr); + cairo_scale (cr, zoom, zoom); + cairo_translate (cr, -(self->px / sf + x0), -(self->py /sf + y0)); + for (n = 0; n < traps->num_traps; n++) { + const trapezoid_t *t = &traps->traps[n]; + + _compute_intersection_point (&t->left, t->top, &p); + cairo_move_to (cr, p.x, p.y); + _compute_intersection_point (&t->right, t->top, &p); + cairo_line_to (cr, p.x, p.y); + _compute_intersection_point (&t->right, t->bottom, &p); + cairo_line_to (cr, p.x, p.y); + _compute_intersection_point (&t->left, t->bottom, &p); + cairo_line_to (cr, p.x, p.y); + cairo_close_path (cr); + cairo_set_source_rgba (cr, 0, 1, 0, .2); + cairo_fill (cr); + } + cairo_restore (cr); + } + + if (edges == NULL) { + cairo_save (cr); { + cairo_matrix_t m; + cairo_matrix_init_scale (&m, zoom, zoom); + cairo_matrix_translate (&m, -(self->px / sf + x0), -(self->py /sf + y0)); + + cairo_set_source_rgb (cr, 0, 0, 0); + cairo_set_line_width (cr, 1.); + cairo_set_line_cap (cr, CAIRO_LINE_CAP_BUTT); + for (n = 0; n < traps->num_traps; n++) { + const trapezoid_t *t = &traps->traps[n]; + + _compute_intersection_point (&t->left, t->top, &p); + cairo_matrix_transform_point (&m, &p.x, &p.y); + cairo_move_to (cr, floor (p.x), floor (p.y) + .5); + cairo_set_dash (cr, dash, 2, fmod (floor (p.x), dash[0] + dash[1])); + + _compute_intersection_point (&t->right, t->top, &p); + cairo_matrix_transform_point (&m, &p.x, &p.y); + cairo_line_to (cr, ceil (p.x), floor (p.y) + .5); + cairo_stroke (cr); + + _compute_intersection_point (&t->left, t->bottom, &p); + cairo_matrix_transform_point (&m, &p.x, &p.y); + cairo_move_to (cr, floor (p.x), floor (p.y) + .5); + cairo_set_dash (cr, dash, 2, fmod (floor (p.x), dash[0] + dash[1])); + + _compute_intersection_point (&t->right, t->bottom, &p); + cairo_matrix_transform_point (&m, &p.x, &p.y); + cairo_line_to (cr, ceil (p.x), floor (p.y) + .5); + cairo_stroke (cr); + } + } cairo_restore (cr); + + cairo_save (cr); { /* left extents */ + cairo_save (cr); { + cairo_scale (cr, zoom, zoom); + cairo_translate (cr, -(self->px / sf + x0), -(self->py /sf + y0)); + for (n = 0; n < traps->num_traps; n++) { + const trapezoid_t *t = &traps->traps[n]; + cairo_move_to (cr, t->left.p1.x, t->left.p1.y); + cairo_line_to (cr, t->left.p2.x, t->left.p2.y); + } + } cairo_restore (cr); + cairo_set_source_rgb (cr, 1, 0, 0); + cairo_set_line_width (cr, .5); + cairo_set_dash (cr, dash, 2, 0.); + cairo_stroke (cr); + } cairo_restore (cr); + cairo_save (cr); { /* right extents */ + cairo_save (cr); { + cairo_scale (cr, zoom, zoom); + cairo_translate (cr, -(self->px / sf + x0), -(self->py /sf + y0)); + + for (n = 0; n < traps->num_traps; n++) { + const trapezoid_t *t = &traps->traps[n]; + cairo_move_to (cr, t->right.p1.x, t->right.p1.y); + cairo_line_to (cr, t->right.p2.x, t->right.p2.y); + } + } cairo_restore (cr); + cairo_set_source_rgb (cr, 0, 0, 1); + cairo_set_line_width (cr, .5); + cairo_set_dash (cr, dash, 2, 0.); + cairo_stroke (cr); + } cairo_restore (cr); + + cairo_save (cr); { /* left lines */ + cairo_save (cr); + cairo_scale (cr, zoom, zoom); + cairo_translate (cr, -(self->px / sf + x0), -(self->py /sf + y0)); + for (n = 0; n < traps->num_traps; n++) { + const trapezoid_t *t = &traps->traps[n]; + _compute_intersection_point (&t->left, t->top, &p); + cairo_move_to (cr, p.x, p.y); + _compute_intersection_point (&t->left, t->bottom, &p); + cairo_line_to (cr, p.x, p.y); + } + cairo_restore (cr); + cairo_set_source_rgb (cr, 1, 0, 0); + cairo_stroke (cr); + } cairo_restore (cr); + cairo_save (cr); { /* right lines */ + cairo_save (cr); + cairo_scale (cr, zoom, zoom); + cairo_translate (cr, -(self->px / sf + x0), -(self->py /sf + y0)); + for (n = 0; n < traps->num_traps; n++) { + const trapezoid_t *t = &traps->traps[n]; + _compute_intersection_point (&t->right, t->top, &p); + cairo_move_to (cr, p.x, p.y); + _compute_intersection_point (&t->right, t->bottom, &p); + cairo_line_to (cr, p.x, p.y); + } + cairo_restore (cr); + cairo_set_source_rgb (cr, 0, 0, 1); + cairo_stroke (cr); + } cairo_restore (cr); + + /* end-points */ + cairo_save (cr); { + double dots[2] = {0., 1.}; + + cairo_save (cr); + cairo_scale (cr, zoom, zoom); + cairo_translate (cr, -(self->px / sf + x0), -(self->py /sf + y0)); + for (n = 0; n < traps->num_traps; n++) { + const trapezoid_t *t = &traps->traps[n]; + _compute_intersection_point (&t->left, t->top, &p); + cairo_move_to (cr, p.x, p.y); + cairo_close_path (cr); + _compute_intersection_point (&t->left, t->bottom, &p); + cairo_move_to (cr, p.x, p.y); + cairo_close_path (cr); + _compute_intersection_point (&t->right, t->top, &p); + cairo_move_to (cr, p.x, p.y); + cairo_close_path (cr); + _compute_intersection_point (&t->right, t->bottom, &p); + cairo_move_to (cr, p.x, p.y); + cairo_close_path (cr); + } + cairo_restore (cr); + cairo_set_source_rgb (cr, 0, 0, 0); + cairo_set_dash (cr, dots, 2, 0.); + cairo_set_line_cap (cr, CAIRO_LINE_CAP_ROUND); + cairo_set_line_width (cr, 4.); + cairo_stroke (cr); + } cairo_restore (cr); + } else { + cairo_save (cr); + + for (n = 0; n < edges->num_edges; n++) { + const edge_t *e = &edges->edges[n]; + + cairo_save (cr); { + cairo_scale (cr, zoom, zoom); + cairo_translate (cr, -(self->px / sf + x0), -(self->py /sf + y0)); + cairo_move_to (cr, e->p1.x, e->p1.y); + cairo_line_to (cr, e->p2.x, e->p2.y); + } cairo_restore (cr); + + if (e->dir < 0) { + cairo_set_source_rgb (cr, 0, 0, 1); + cairo_set_dash (cr, dash, 2, dash[0]); + } else { + cairo_set_source_rgb (cr, 1, 0, 0); + cairo_set_dash (cr, dash, 2, 0.); + } + + cairo_set_line_cap (cr, CAIRO_LINE_CAP_BUTT); + cairo_set_line_width (cr, 1.); + cairo_stroke (cr); + + cairo_save (cr); { + cairo_scale (cr, zoom, zoom); + cairo_translate (cr, -(self->px / sf + x0), -(self->py /sf + y0)); + cairo_move_to (cr, e->p1.x, e->p1.y); + cairo_close_path (cr); + cairo_move_to (cr, e->p2.x, e->p2.y); + cairo_close_path (cr); + } cairo_restore (cr); + cairo_set_source_rgb (cr, 0, 0, 0); + cairo_set_dash (cr, dots, 2, 0.); + cairo_set_line_cap (cr, CAIRO_LINE_CAP_ROUND); + cairo_set_line_width (cr, 4.); + cairo_stroke (cr); + } + + cairo_restore (cr); + } + + /* grid */ + cairo_save (cr); { + int i; + + cairo_translate (cr, + -zoom*fmod (self->px/sf + x0, 1.), + -zoom*fmod (self->py/sf + y0, 1.)); + for (i = -size/2/zoom - 1; i <= size/2/zoom + 1; i++) { + cairo_move_to (cr, zoom*i, -size/2); + cairo_line_to (cr, zoom*i, size/2 + zoom); + cairo_move_to (cr, -size/2, zoom*i); + cairo_line_to (cr, size/2 + zoom, zoom*i); + } + cairo_set_source_rgba (cr, .7, .7, .7, .5); + cairo_set_line_width (cr, 1.); + cairo_stroke (cr); + } cairo_restore (cr); + } + + cairo_restore (cr); +} + +static gdouble +trapezoid_area (const trapezoid_t *t) +{ + gdouble inner_left, inner_right; + gdouble outer_left, outer_right; + gdouble height; + gdouble area; + + /* split into 3 sections: a rectangle with a pair of triangular bookends */ + inner_left = _compute_intersection_x_for_y (&t->left, t->top); + outer_left = _compute_intersection_x_for_y (&t->left, t->bottom); + if (outer_left > inner_left) { + gdouble t = outer_left; + outer_left = inner_left; + inner_left = t; + } + + inner_right = _compute_intersection_x_for_y (&t->right, t->top); + outer_right = _compute_intersection_x_for_y (&t->right, t->bottom); + if (outer_right > inner_right) { + gdouble t = outer_right; + outer_right = inner_right; + inner_right = t; + } + + if (outer_left > outer_right) { /* reverse */ + gdouble t; + + t = outer_left; + outer_left = inner_right; + inner_right = t; + + t = inner_left; + inner_left = outer_right; + outer_right = t; + } + + height = t->bottom - t->top; + area = (inner_left - outer_left) * height / 2; + area += (outer_right - inner_right) * height / 2; + area += (inner_right - inner_left) * height; + + return area; +} + +static gdouble +traps_compute_total_area (const traps_t *traps) +{ + int n; + gdouble area = 0.; + for (n = 0; n < traps->num_traps; n++) + area += trapezoid_area (&traps->traps[n]); + return area; +} + +static void +trap_view_draw_labels (TrapView *self, cairo_t *cr) +{ + PangoLayout *layout; + gint width, height; + gdouble total_area; + gchar *str; + traps_t *traps; + + traps = self->current_traps; + if (traps == NULL) + return; + + /* convert total area from fixed-point (assuming 24.8) */ + total_area = traps_compute_total_area (traps) / (256. * 256.); + str = g_strdup_printf ("Number of trapezoids:\t%d\n" + "Total area of trapezoids:\t%.2f", + traps->num_traps, + total_area); + layout = gtk_widget_create_pango_layout (&self->widget, str); + g_free (str); + + pango_layout_get_pixel_size (layout, &width, &height); + + cairo_move_to (cr, 10, 10 + height); + pango_cairo_show_layout (cr, layout); + g_object_unref (layout); +} + +static gboolean +trap_view_expose (GtkWidget *w, GdkEventExpose *ev) +{ + TrapView *self = (TrapView *) w; + cairo_t *cr; + + cr = gdk_cairo_create (w->window); + gdk_cairo_region (cr, ev->region); + cairo_clip (cr); + + trap_view_draw (self, cr); + trap_view_draw_labels (self, cr); + + cairo_destroy (cr); + return FALSE; +} + +static void +trap_view_advance (TrapView *self) +{ + if (self->current_traps && self->current_traps->prev) + self->current_traps = self->current_traps->prev; + if (self->current_edges && self->current_edges->prev) + self->current_edges = self->current_edges->prev; + gtk_widget_queue_draw (&self->widget); +} + +static void +trap_view_back (TrapView *self) +{ + if (self->current_traps && self->current_traps->next) + self->current_traps = self->current_traps->next; + if (self->current_edges && self->current_edges->next) + self->current_edges = self->current_edges->next; + gtk_widget_queue_draw (&self->widget); +} + +static void +trap_view_group_foreach (TrapView *group, GFunc func, gpointer data) +{ + while (group) { + func (group, data); + group = group->group_next; + } +} + +static gboolean +trap_view_key_press (GtkWidget *w, GdkEventKey *ev) +{ + TrapView *self = (TrapView *) w; + + switch (ev->keyval) { + case GDK_BackSpace: + trap_view_group_foreach (self->group_head, + (GFunc) trap_view_back, + NULL); + break; + + case GDK_space: + trap_view_group_foreach (self->group_head, + (GFunc) trap_view_advance, + NULL); + break; + + case GDK_Return: + trap_view_group_foreach (self->group_head, + (GFunc) trap_view_advance, + NULL); + break; + + case GDK_Escape: + case GDK_Q: + gtk_main_quit (); + break; + } + + return FALSE; +} + +static gboolean +trap_view_button_press (GtkWidget *w, GdkEventButton *ev) +{ + TrapView *self = (TrapView *) w; + + if (ev->x < self->mag_x || + ev->y < self->mag_y || + ev->x > self->mag_x + self->mag_size || + ev->y > self->mag_y + self->mag_size) + { + if (ev->type == GDK_BUTTON_PRESS) { + if (self->current_traps == NULL) + return FALSE; + + if (ev->button == 1) { + trap_view_group_foreach (self->group_head, + (GFunc) trap_view_advance, + NULL); + } else if (ev->button == 3) { + trap_view_group_foreach (self->group_head, + (GFunc) trap_view_back, + NULL); + } + } + } + else + { + self->in_mag_drag = TRUE; + self->mag_drag_x = ev->x; + self->mag_drag_y = ev->y; + } + + return FALSE; +} + +static gboolean +trap_view_button_release (GtkWidget *w, GdkEventButton *ev) +{ + TrapView *self = (TrapView *) w; + + self->in_mag_drag = FALSE; + + return FALSE; +} + +static void +trap_view_update_mouse (TrapView *self, GdkEventMotion *ev) +{ + self->px = ev->x; + self->py = ev->y; + + gtk_widget_queue_draw (&self->widget); +} + +static void +trap_view_update_magnifier (TrapView *self, gint *xy) +{ + self->mag_x = xy[0]; + self->mag_y = xy[1]; + + gtk_widget_queue_draw (&self->widget); +} + +static gboolean +trap_view_motion (GtkWidget *w, GdkEventMotion *ev) +{ + TrapView *self = (TrapView *) w; + + if (self->in_mag_drag) { + int xy[2]; + + xy[0] = self->mag_x + ev->x - self->mag_drag_x; + xy[1] = self->mag_y + ev->y - self->mag_drag_y; + + trap_view_group_foreach (self->group_head, + (GFunc) trap_view_update_magnifier, + xy); + + self->mag_drag_x = ev->x; + self->mag_drag_y = ev->y; + } else if (ev->x < self->mag_x || + ev->y < self->mag_y || + ev->x > self->mag_x + self->mag_size || + ev->y > self->mag_y + self->mag_size) + { + trap_view_group_foreach (self->group_head, + (GFunc) trap_view_update_mouse, + ev); + } + + return FALSE; +} + +static void +trap_view_realize (GtkWidget *widget) +{ + GdkWindowAttr attributes; + + GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED); + + attributes.window_type = GDK_WINDOW_CHILD; + attributes.x = widget->allocation.x; + attributes.y = widget->allocation.y; + attributes.width = widget->allocation.width; + attributes.height = widget->allocation.height; + attributes.wclass = GDK_INPUT_OUTPUT; + attributes.visual = gtk_widget_get_visual (widget); + attributes.colormap = gtk_widget_get_colormap (widget); + attributes.event_mask = gtk_widget_get_events (widget) | + GDK_BUTTON_PRESS_MASK | + GDK_BUTTON_RELEASE_MASK | + GDK_KEY_PRESS_MASK | + GDK_KEY_RELEASE_MASK | + GDK_POINTER_MOTION_MASK | + GDK_BUTTON_MOTION_MASK | + GDK_EXPOSURE_MASK; + + widget->window = gdk_window_new (gtk_widget_get_parent_window (widget), + &attributes, + GDK_WA_X | GDK_WA_Y | + GDK_WA_VISUAL | GDK_WA_COLORMAP); + gdk_window_set_user_data (widget->window, widget); + + widget->style = gtk_style_attach (widget->style, widget->window); + gtk_style_set_background (widget->style, widget->window, GTK_STATE_NORMAL); +} + +static void +trap_view_size_allocate (GtkWidget *w, GdkRectangle *r) +{ + TrapView *self = (TrapView *) w; + + GTK_WIDGET_CLASS (trap_view_parent_class)->size_allocate (w, r); + + self->mag_x = w->allocation.width - self->mag_size - 10; + self->mag_y = w->allocation.height - self->mag_size - 10; +} + +static void +trap_view_finalize (GObject *obj) +{ + G_OBJECT_CLASS (trap_view_parent_class)->finalize (obj); +} + +static void +trap_view_class_init (TrapViewClass *klass) +{ + GObjectClass *object_class = (GObjectClass *) klass; + GtkWidgetClass *widget_class = (GtkWidgetClass *) klass; + + object_class->finalize = trap_view_finalize; + + widget_class->realize = trap_view_realize; + widget_class->size_allocate = trap_view_size_allocate; + widget_class->expose_event = trap_view_expose; + widget_class->key_press_event = trap_view_key_press; + widget_class->button_press_event = trap_view_button_press; + widget_class->button_release_event = trap_view_button_release; + widget_class->motion_notify_event = trap_view_motion; +} + +static void +trap_view_init (TrapView *self) +{ + self->mag_zoom = 10; + self->mag_size = 200; + + GTK_WIDGET_SET_FLAGS (self, GTK_CAN_FOCUS); +} + +static traps_t * +_traps_add_trapezoid (TrapView *tv, traps_t *traps, const trapezoid_t *trap) +{ + if (trap->top < traps->extents.p1.y) + traps->extents.p1.y = trap->top; + if (trap->bottom > traps->extents.p2.y) + traps->extents.p2.y = trap->bottom; + + if (trap->left.p1.x < traps->extents.p1.x) + traps->extents.p1.x = trap->left.p1.x; + if (trap->left.p2.x < traps->extents.p1.x) + traps->extents.p1.x = trap->left.p2.x; + + if (trap->right.p1.x > traps->extents.p2.x) + traps->extents.p2.x = trap->right.p1.x; + if (trap->right.p2.x > traps->extents.p2.x) + traps->extents.p2.x = trap->right.p2.x; + + if (traps->num_traps == traps->size) { + int newsize = 2 * traps->size; + void *newtraps; + + newtraps = g_realloc (traps, + sizeof (traps_t) + newsize * sizeof (trapezoid_t)); + if (newtraps == NULL) + return traps; + + if (tv->current_traps == traps) + tv->current_traps = newtraps; + + traps = newtraps; + traps->size = newsize; + + if (traps->next != NULL) + traps->next->prev = newtraps; + if (traps->prev != NULL) + traps->prev->next = newtraps; + else + tv->traps_list = newtraps; + } + + traps->traps[traps->num_traps++] = *trap; + + return traps; +} + +static traps_t * +traps_new (TrapView *tv) +{ + traps_t *t; + + t = g_malloc (sizeof (traps_t) + 16 * sizeof (trapezoid_t)); + t->prev = NULL; + t->next = tv->traps_list; + if (tv->traps_list) + tv->traps_list->prev = t; + tv->traps_list = t; + + if (tv->current_traps == NULL) + tv->current_traps = t; + + t->size = 16; + t->num_traps = 0; + t->extents.p1.x = G_MAXDOUBLE; + t->extents.p1.y = G_MAXDOUBLE; + t->extents.p2.x = -G_MAXDOUBLE; + t->extents.p2.y = -G_MAXDOUBLE; + + return t; +} + +static edges_t * +_edges_add_edge (TrapView *tv, edges_t *edges, edge_t *e) +{ + if (e->top < edges->extents.p1.y) + edges->extents.p1.y = e->top; + if (e->bottom > edges->extents.p2.y) + edges->extents.p2.y = e->bottom; + + _compute_intersection_point (&e->line, e->top, &e->p1); + _compute_intersection_point (&e->line, e->bottom, &e->p2); + + if (e->p1.x < edges->extents.p1.x) + edges->extents.p1.x = e->p1.x; + if (e->p2.x < edges->extents.p1.x) + edges->extents.p1.x = e->p2.x; + + if (e->p1.x > edges->extents.p2.x) + edges->extents.p2.x = e->p1.x; + if (e->p2.x > edges->extents.p2.x) + edges->extents.p2.x = e->p2.x; + + if (edges->num_edges == edges->size) { + int newsize = 2 * edges->size; + void *newedges; + + newedges = g_realloc (edges, + sizeof (edges_t) + newsize * sizeof (edge_t)); + if (newedges == NULL) + return edges; + + if (tv->current_edges == edges) + tv->current_edges = newedges; + + edges = newedges; + edges->size = newsize; + + if (edges->next != NULL) + edges->next->prev = newedges; + if (edges->prev != NULL) + edges->prev->next = newedges; + else + tv->edges_list = newedges; + } + + edges->edges[edges->num_edges++] = *e; + + return edges; +} + +static edges_t * +edges_new (TrapView *tv) +{ + edges_t *t; + + t = g_malloc (sizeof (edges_t) + 16 * sizeof (edge_t)); + t->prev = NULL; + t->next = tv->edges_list; + if (tv->edges_list) + tv->edges_list->prev = t; + tv->edges_list = t; + + if (tv->current_edges == NULL) + tv->current_edges = t; + + t->size = 16; + t->num_edges = 0; + t->extents.p1.x = G_MAXDOUBLE; + t->extents.p1.y = G_MAXDOUBLE; + t->extents.p2.x = -G_MAXDOUBLE; + t->extents.p2.y = -G_MAXDOUBLE; + + return t; +} + +int +main (int argc, char **argv) +{ + TrapView *tv, *tv2, *group_head = NULL, *group_prev = NULL; + traps_t *traps; + edges_t *edges; + GtkWidget *window, *hbox; + FILE *file; + char *line = NULL; + size_t len = 0; + + gtk_init (&argc, &argv); + + hbox = gtk_hbox_new (TRUE, 0); + + tv = g_object_new (trap_view_get_type (), NULL); + gtk_box_pack_start (GTK_BOX (hbox), &tv->widget, TRUE, TRUE, 0); + gtk_widget_show (&tv->widget); + + tv->group_prev = group_prev; + tv->group_next = NULL; + if (group_prev) + group_prev->group_next = tv; + group_prev = tv; + if (group_head == NULL) + group_head = tv; + tv->group_head = group_head; + + file = fopen (argv[1], "r"); + if (file != NULL) { + edges = edges_new (tv); + while (getline (&line, &len, file) != -1) { + edge_t e; + + if (sscanf (line, + "(%lf, %lf), (%lf, %lf) %lf %lf %d", + &e.line.p1.x, &e.line.p1.y, + &e.line.p2.x, &e.line.p2.y, + &e.top, &e.bottom, + &e.dir) == 7) { + edges = _edges_add_edge (tv, edges, &e); + } else { + if (edges->num_edges) { + g_print ("read %d edges\n", edges->num_edges); + g_print ("extents=(%lg, %lg), (%lg, %lg)\n", + edges->extents.p1.x, edges->extents.p1.y, + edges->extents.p2.x, edges->extents.p2.y); + edges = edges_new (tv); + } + } + } + + if (edges->num_edges) { + g_print ("read %d edges\n", edges->num_edges); + g_print ("extents=(%lg, %lg), (%lg, %lg)\n", + edges->extents.p1.x, edges->extents.p1.y, + edges->extents.p2.x, edges->extents.p2.y); + } + + fclose (file); + } + + file = fopen (argv[2], "r"); + if (file != NULL) { + traps = traps_new (tv); + while (getline (&line, &len, file) != -1) { + trapezoid_t t; + + if (sscanf (line, + "%lf %lf L:(%lf, %lf), (%lf, %lf) R:(%lf, %lf), (%lf, %lf)", + &t.top, &t.bottom, + &t.left.p1.x, &t.left.p1.y, + &t.left.p2.x, &t.left.p2.y, + &t.right.p1.x, &t.right.p1.y, + &t.right.p2.x, &t.right.p2.y) == 10) { + traps = _traps_add_trapezoid (tv, traps, &t); + } else { + if (traps->num_traps) { + g_print ("read %d trapezoids\n", traps->num_traps); + g_print ("extents=(%lg, %lg), (%lg, %lg)\n", + traps->extents.p1.x, traps->extents.p1.y, + traps->extents.p2.x, traps->extents.p2.y); + traps = traps_new (tv); + } + } + } + + if (traps->num_traps) { + g_print ("read %d trapezoids\n", traps->num_traps); + g_print ("extents=(%lg, %lg), (%lg, %lg)\n", + traps->extents.p1.x, traps->extents.p1.y, + traps->extents.p2.x, traps->extents.p2.y); + } + + fclose (file); + } + + free (line); + + tv2 = g_object_new (trap_view_get_type (), NULL); + gtk_box_pack_start (GTK_BOX (hbox), &tv2->widget, TRUE, TRUE, 0); + gtk_widget_show (&tv2->widget); + + tv2->traps_list = tv->traps_list; + tv2->current_traps = tv->current_traps; + + tv2->group_prev = group_prev; + tv2->group_next = NULL; + group_prev->group_next = tv2; + group_prev = tv2; + tv2->group_head = group_head; + + window = gtk_window_new (GTK_WINDOW_TOPLEVEL); + g_signal_connect (window, "delete-event", + G_CALLBACK (gtk_main_quit), NULL); + gtk_widget_set_size_request (window, 512, 512); + gtk_container_add (GTK_CONTAINER (window), hbox); + gtk_widget_show (hbox); + gtk_widget_show (window); + + gtk_main (); + return 0; +} diff --git a/util/show-events.c b/util/show-events.c new file mode 100644 index 000000000..8bff3efc4 --- /dev/null +++ b/util/show-events.c @@ -0,0 +1,845 @@ +#define _GNU_SOURCE +#include +#include +#include +#include +#include +#include + +typedef struct _point { + gdouble x, y; +} point_t; +typedef struct _box { + point_t p1, p2; +} box_t; +typedef struct _line { + point_t p1, p2; +} line_t; + +typedef struct _edge { + gulong id; + line_t line; + gdouble top, bottom; + point_t p1, p2; + int dir; +} edge_t; +typedef struct _trapezoid { + gdouble top, bottom; + const edge_t *left, *right; +} trapezoid_t; +typedef struct _traps { + int num_traps; + int size; + trapezoid_t traps[0]; +} traps_t; + +typedef struct _edges { + GHashTable *ht; + + int num_edges; + int size; + edge_t edges[0]; +} edges_t; + +typedef struct _event { + enum { + START_EDGE, + END_EDGE, + INTERSECTION, + START_TRAP, + END_TRAP, + } type; + + int x, y; /* (top, bottom) for trap */ + long e1, e2; +} event_t; + +typedef struct _events { + struct _events *prev, *next; + + box_t extents; + edges_t *edges; + traps_t *prototraps; + traps_t *traps; + + int current_event; + int num_events; + int size_events; + event_t *events; +} events_t; + +typedef struct _EventView { + GtkWidget widget; + + events_t *events_list; + events_t *current_events; + + double px, py; + + gint mag_x, mag_y; + gint mag_size; + gdouble mag_zoom; + gboolean in_mag_drag; + gint mag_drag_x, mag_drag_y; +} EventView; + +typedef struct _EventViewClass { + GtkWidgetClass parent_class; +} EventViewClass; + +G_DEFINE_TYPE (EventView, event_view, GTK_TYPE_WIDGET) + +static edge_t * +edges_lookup (edges_t *edges, gulong id) +{ + return &edges->edges[GPOINTER_TO_UINT(g_hash_table_lookup (edges->ht, + GUINT_TO_POINTER + (id)))]; +} + +static gdouble +_compute_intersection_x_for_y (const line_t *line, + gdouble y) +{ + gdouble dx = line->p2.x - line->p1.x; + gdouble dy = line->p2.y - line->p1.y; + gdouble x; + + if (y == line->p1.y) + return line->p1.x; + if (y == line->p2.y) + return line->p2.x; + + x = line->p1.x; + if (dy != 0) + x += (y - line->p1.y)*dx/dy; + return x; +} + +static void +_compute_intersection_point (const line_t *line, + gdouble y, + point_t *p) +{ + p->x = _compute_intersection_x_for_y (line, p->y = y); +} + +static void +_edge_path (cairo_t *cr, const cairo_matrix_t *m, const edge_t *e) +{ + double x, y; + + x = e->p1.x; y = e->p1.y; + cairo_matrix_transform_point (m, &x, &y); + cairo_move_to (cr, x, y); + + x = e->p2.x; y = e->p2.y; + cairo_matrix_transform_point (m, &x, &y); + cairo_line_to (cr, x, y); + + if (e->dir < 0) { + cairo_set_source_rgb (cr, 0, 0, 1); + } else { + cairo_set_source_rgb (cr, 1, 0, 0); + } +} + +static void +_events_draw (events_t *events, cairo_t *cr, cairo_matrix_t *m) +{ + double dash[2] = {8, 8}; + point_t p; + int n; + + /* first the existing and proto-traps */ + cairo_save (cr); { + cairo_set_matrix (cr, m); + + cairo_set_source_rgba (cr, 1, 0, 0, .15); + for (n = 0; n < events->prototraps->num_traps; n++) { + const trapezoid_t *t = &events->prototraps->traps[n]; + + _compute_intersection_point (&t->left->line, t->top, &p); + cairo_move_to (cr, p.x, p.y); + _compute_intersection_point (&t->right->line, t->top, &p); + cairo_line_to (cr, p.x, p.y); + _compute_intersection_point (&t->right->line, t->bottom, &p); + cairo_line_to (cr, p.x, p.y); + _compute_intersection_point (&t->left->line, t->bottom, &p); + cairo_line_to (cr, p.x, p.y); + cairo_close_path (cr); + cairo_fill (cr); + } + + cairo_set_source_rgba (cr, 0, 1, 0, .2); + for (n = 0; n < events->traps->num_traps; n++) { + const trapezoid_t *t = &events->traps->traps[n]; + + _compute_intersection_point (&t->left->line, t->top, &p); + cairo_move_to (cr, p.x, p.y); + _compute_intersection_point (&t->right->line, t->top, &p); + cairo_line_to (cr, p.x, p.y); + _compute_intersection_point (&t->right->line, t->bottom, &p); + cairo_line_to (cr, p.x, p.y); + _compute_intersection_point (&t->left->line, t->bottom, &p); + cairo_line_to (cr, p.x, p.y); + cairo_close_path (cr); + cairo_fill (cr); + } + } cairo_restore (cr); + + /* known edges */ + cairo_save (cr); + cairo_set_line_width (cr, 1.); + for (n = 0; n < events->edges->num_edges; n++) { + const edge_t *e = &events->edges->edges[n]; + double x, y; + + x = e->p1.x; y = e->p1.y; + cairo_matrix_transform_point (m, &x, &y); + cairo_move_to (cr, x, y); + + x = e->p2.x; y = e->p2.y; + cairo_matrix_transform_point (m, &x, &y); + cairo_line_to (cr, x, y); + + if (e->dir < 0) { + cairo_set_source_rgba (cr, 0, 0, 1., .4); + cairo_set_dash (cr, dash, 2, fmod (e->p1.x, dash[0]+dash[1]) + dash[0]); + } else { + cairo_set_source_rgba (cr, 1, 0, 0., 4); + cairo_set_dash (cr, dash, 2, fmod (e->p1.x, dash[0]+dash[1])); + } + + cairo_stroke (cr); + + x = e->p1.x; y = e->p1.y; + cairo_matrix_transform_point (m, &x, &y); + cairo_arc (cr, x, y, 2., 0, 2 * G_PI); + + x = e->p2.x; y = e->p2.y; + cairo_matrix_transform_point (m, &x, &y); + cairo_arc (cr, x, y, 2., 0, 2 * G_PI); + + cairo_fill (cr); + } + cairo_restore (cr); + + /* event time */ + cairo_save (cr); { + event_t *e; + double x, y; + + e = &events->events[events->current_event]; + + cairo_set_line_width (cr, 2.); + cairo_set_matrix (cr, m); + cairo_move_to (cr, + events->extents.p1.x, + e->y); + cairo_line_to (cr, + events->extents.p2.x, + e->y); + cairo_identity_matrix (cr); + cairo_stroke (cr); + + x = e->x; y = e->y; + cairo_matrix_transform_point (m, &x, &y); + switch (e->type) { + case START_EDGE: + case END_EDGE: + case INTERSECTION: + cairo_arc (cr, x, y, 4., 0, 2 * G_PI); + break; + case START_TRAP: + case END_TRAP: + break; + } + switch (e->type) { + case START_EDGE: + cairo_set_source_rgb (cr, 1, 0, 0); + break; + case END_EDGE: + cairo_set_source_rgb (cr, 0, 0, 1); + break; + case INTERSECTION: + cairo_set_source_rgb (cr, 1, 0, 1); + break; + case START_TRAP: + case END_TRAP: + break; + } + cairo_fill (cr); + + cairo_set_line_width (cr, 1.); + switch (e->type) { + case START_EDGE: + _edge_path (cr, m, edges_lookup (events->edges, e->e1)); + cairo_stroke (cr); + break; + case END_EDGE: + _edge_path (cr, m, edges_lookup (events->edges, e->e1)); + cairo_stroke (cr); + break; + case INTERSECTION: + _edge_path (cr, m, edges_lookup (events->edges, e->e1)); + cairo_stroke (cr); + _edge_path (cr, m, edges_lookup (events->edges, e->e2)); + cairo_stroke (cr); + break; + } + } cairo_restore (cr); +} + +static void +event_view_draw (EventView *self, cairo_t *cr) +{ + events_t *events; + gdouble sf_x, sf_y, sf; + gdouble mid, dim; + gdouble x0, x1, y0, y1; + cairo_matrix_t m; + + cairo_save (cr); + cairo_set_source_rgb (cr, 1, 1, 1); + cairo_paint (cr); + cairo_restore (cr); + + events = self->current_events; + if (events == NULL) + return; + + mid = (events->extents.p2.x + events->extents.p1.x) / 2.; + dim = (events->extents.p2.x - events->extents.p1.x) / 2. * 1.2; + sf_x = self->widget.allocation.width / dim / 2; + + mid = (events->extents.p2.y + events->extents.p1.y) / 2.; + dim = (events->extents.p2.y - events->extents.p1.y) / 2. * 1.2; + sf_y = self->widget.allocation.height / dim / 2; + + sf = MIN (sf_x, sf_y); + + mid = (events->extents.p2.x + events->extents.p1.x) / 2.; + dim = sf_x / sf * (events->extents.p2.x - events->extents.p1.x) / 2. * 1.2; + x0 = mid - dim; + x1 = mid + dim; + mid = (events->extents.p2.y + events->extents.p1.y) / 2.; + dim = sf_y / sf * (events->extents.p2.y - events->extents.p1.y) / 2. * 1.2; + y0 = mid - dim; + y1 = mid + dim; + + cairo_matrix_init_scale (&m, sf, sf); + cairo_matrix_translate (&m, -x0, -y0); + _events_draw (events, cr, &m); + + /* draw a zoom view of the area around the mouse */ + cairo_save (cr); { + double zoom = self->mag_zoom; + int size = self->mag_size; + + /* bottom right */ + cairo_rectangle (cr, self->mag_x, self->mag_y, size, size); + cairo_stroke_preserve (cr); + cairo_set_source_rgb (cr, 1, 1, 1); + cairo_fill_preserve (cr); + cairo_clip (cr); + + /* compute roi in extents */ + cairo_translate (cr, self->mag_x + size/2, self->mag_y + size/2); + + cairo_matrix_init_scale (&m, zoom, zoom); + cairo_matrix_translate (&m, -(self->px / sf + x0), -(self->py /sf + y0)); + _events_draw (events, cr, &m); + + /* grid */ + cairo_save (cr); { + int i; + + cairo_translate (cr, + -zoom*fmod (self->px/sf + x0, 1.), + -zoom*fmod (self->py/sf + y0, 1.)); + for (i = -size/2/zoom - 1; i <= size/2/zoom + 1; i++) { + cairo_move_to (cr, zoom*i, -size/2); + cairo_line_to (cr, zoom*i, size/2 + zoom); + cairo_move_to (cr, -size/2, zoom*i); + cairo_line_to (cr, size/2 + zoom, zoom*i); + } + cairo_set_source_rgba (cr, .7, .7, .7, .5); + cairo_set_line_width (cr, 1.); + cairo_stroke (cr); + } cairo_restore (cr); + } cairo_restore (cr); +} + +static void +event_view_draw_labels (EventView *self, cairo_t *cr) +{ + events_t *events; + + events = self->current_events; + if (events == NULL) + return; + +} + +static gboolean +event_view_expose (GtkWidget *w, GdkEventExpose *ev) +{ + EventView *self = (EventView *) w; + cairo_t *cr; + + cr = gdk_cairo_create (w->window); + gdk_cairo_region (cr, ev->region); + cairo_clip (cr); + + event_view_draw (self, cr); + event_view_draw_labels (self, cr); + + cairo_destroy (cr); + return FALSE; +} + +static void +traps_clear (traps_t *traps) +{ + traps->num_traps = 0; +} + +static traps_t * +traps_add (traps_t *traps, int top, int bot, const edge_t *e1, const edge_t *e2) +{ + trapezoid_t *t; + + if (traps->num_traps == traps->size) { + traps->size *= 2; + traps = g_realloc (traps, + sizeof (traps_t) + traps->size*sizeof (trapezoid_t)); + } + + t = &traps->traps[traps->num_traps++]; + t->top = top; + if (bot > e1->bottom) + bot = e1->bottom; + if (bot > e2->bottom) + bot = e2->bottom; + t->bottom = bot; + + t->left = e1; + t->right = e2; + + return traps; +} + +static void +traps_remove (traps_t *traps, int top, const edge_t *e1, const edge_t *e2) +{ + int n; + + for (n = 0; n < traps->num_traps; n++) { + trapezoid_t *t = &traps->traps[n]; + if (t->top == top && t->left == e1 && t->right == e2) + break; + } + if (n < traps->num_traps) { + g_memmove (&traps->traps[n], + &traps->traps[n+1], + (traps->num_traps-n+1) * sizeof (trapezoid_t)); + traps->num_traps--; + } +} + +static void +event_next (EventView *self) +{ + events_t *events; + event_t *e; + + events = self->current_events; + if (++events->current_event == events->num_events) { + return; + } else if (events->current_event >= events->num_events) { + traps_clear (events->prototraps); + traps_clear (events->traps); + events->current_event = 0; + + self->current_events = events->next; + if (self->current_events == NULL) + self->current_events = self->events_list; + events = self->current_events; + } + + e = &events->events[events->current_event]; + switch (e->type) { + case START_TRAP: + events->prototraps = traps_add (events->prototraps, + e->x, G_MAXINT, + edges_lookup (events->edges, e->e1), + edges_lookup (events->edges, e->e2)); + break; + case END_TRAP: + traps_remove (events->prototraps, + e->x, + edges_lookup (events->edges, e->e1), + edges_lookup (events->edges, e->e2)); + events->traps = traps_add (events->traps, + e->x, e->y, + edges_lookup (events->edges, e->e1), + edges_lookup (events->edges, e->e2)); + break; + } +} + +static gboolean +event_view_button_press (GtkWidget *w, GdkEventButton *ev) +{ + EventView *self = (EventView *) w; + + if (ev->x < self->mag_x || + ev->y < self->mag_y || + ev->x > self->mag_x + self->mag_size || + ev->y > self->mag_y + self->mag_size) + { + if (ev->type == GDK_BUTTON_PRESS) { + event_next (self); + gtk_widget_queue_draw (w); + } + } + else + { + self->in_mag_drag = TRUE; + self->mag_drag_x = ev->x; + self->mag_drag_y = ev->y; + } + + return FALSE; +} + +static gboolean +event_view_button_release (GtkWidget *w, GdkEventButton *ev) +{ + EventView *self = (EventView *) w; + + self->in_mag_drag = FALSE; + + return FALSE; +} + +static gboolean +event_view_motion (GtkWidget *w, GdkEventMotion *ev) +{ + EventView *self = (EventView *) w; + + if (self->in_mag_drag) { + self->mag_x += ev->x - self->mag_drag_x; + self->mag_y += ev->y - self->mag_drag_y; + + gtk_widget_queue_draw (&self->widget); + + self->mag_drag_x = ev->x; + self->mag_drag_y = ev->y; + } else if (ev->x < self->mag_x || + ev->y < self->mag_y || + ev->x > self->mag_x + self->mag_size || + ev->y > self->mag_y + self->mag_size) + { + self->px = ev->x; + self->py = ev->y; + + gtk_widget_queue_draw (&self->widget); + } + + return FALSE; +} + +static void +event_view_realize (GtkWidget *widget) +{ + GdkWindowAttr attributes; + + GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED); + + attributes.window_type = GDK_WINDOW_CHILD; + attributes.x = widget->allocation.x; + attributes.y = widget->allocation.y; + attributes.width = widget->allocation.width; + attributes.height = widget->allocation.height; + attributes.wclass = GDK_INPUT_OUTPUT; + attributes.visual = gtk_widget_get_visual (widget); + attributes.colormap = gtk_widget_get_colormap (widget); + attributes.event_mask = gtk_widget_get_events (widget) | + GDK_BUTTON_PRESS_MASK | + GDK_BUTTON_RELEASE_MASK | + GDK_KEY_PRESS_MASK | + GDK_KEY_RELEASE_MASK | + GDK_POINTER_MOTION_MASK | + GDK_BUTTON_MOTION_MASK | + GDK_EXPOSURE_MASK; + + widget->window = gdk_window_new (gtk_widget_get_parent_window (widget), + &attributes, + GDK_WA_X | GDK_WA_Y | + GDK_WA_VISUAL | GDK_WA_COLORMAP); + gdk_window_set_user_data (widget->window, widget); + + widget->style = gtk_style_attach (widget->style, widget->window); + gtk_style_set_background (widget->style, widget->window, GTK_STATE_NORMAL); +} + +static void +event_view_size_allocate (GtkWidget *w, GdkRectangle *r) +{ + EventView *self = (EventView *) w; + + GTK_WIDGET_CLASS (event_view_parent_class)->size_allocate (w, r); + + self->mag_x = w->allocation.width - self->mag_size - 10; + self->mag_y = w->allocation.height - self->mag_size - 10; +} + +static void +event_view_finalize (GObject *obj) +{ + G_OBJECT_CLASS (event_view_parent_class)->finalize (obj); +} + +static void +event_view_class_init (EventViewClass *klass) +{ + GObjectClass *object_class = (GObjectClass *) klass; + GtkWidgetClass *widget_class = (GtkWidgetClass *) klass; + + object_class->finalize = event_view_finalize; + + widget_class->realize = event_view_realize; + widget_class->size_allocate = event_view_size_allocate; + widget_class->expose_event = event_view_expose; + widget_class->button_press_event = event_view_button_press; + widget_class->button_release_event = event_view_button_release; + widget_class->motion_notify_event = event_view_motion; +} + +static void +event_view_init (EventView *self) +{ + self->mag_zoom = 10; + self->mag_size = 200; +} + +static traps_t * +traps_new (void) +{ + traps_t *t; + + t = g_malloc (sizeof (traps_t) + 16 * sizeof (trapezoid_t)); + + t->size = 16; + t->num_traps = 0; + + return t; +} + +static edges_t * +_edges_add_edge (edges_t *edges, edge_t *e, box_t *extents) +{ + if (e->top < extents->p1.y) + extents->p1.y = e->top; + if (e->bottom > extents->p2.y) + extents->p2.y = e->bottom; + + _compute_intersection_point (&e->line, e->top, &e->p1); + _compute_intersection_point (&e->line, e->bottom, &e->p2); + + if (e->p1.x < extents->p1.x) + extents->p1.x = e->p1.x; + if (e->p2.x < extents->p1.x) + extents->p1.x = e->p2.x; + + if (e->p1.x > extents->p2.x) + extents->p2.x = e->p1.x; + if (e->p2.x > extents->p2.x) + extents->p2.x = e->p2.x; + + if (edges->num_edges == edges->size) { + edges->size *= 2; + edges = g_realloc (edges, + sizeof (edges_t) + edges->size * sizeof (edge_t)); + } + + g_hash_table_insert (edges->ht, + GUINT_TO_POINTER (e->id), + GUINT_TO_POINTER (edges->num_edges)); + edges->edges[edges->num_edges++] = *e; + + return edges; +} + +static void +_events_add_event (events_t *events, + int type, + int x, int y, + gulong e1, gulong e2) +{ + event_t *e; + + if (events->num_events == events->size_events) { + int newsize = 2 * events->size_events; + void *newevents; + + newevents = g_renew (event_t, events->events, newsize); + events->events = newevents; + events->size_events = newsize; + } + + e = &events->events[events->num_events++]; + e->type = type; + e->x = x; + e->y = y; + e->e1 = e1; + e->e2 = e2; +} + +static edges_t * +edges_new (void) +{ + edges_t *t; + + t = g_malloc (sizeof (edges_t) + 16 * sizeof (edge_t)); + t->ht = g_hash_table_new (NULL, NULL); + t->size = 16; + t->num_edges = 0; + + return t; +} + +static events_t * +events_new (void) +{ + events_t *events; + + events = g_malloc (sizeof (events_t)); + + events->next = NULL; + events->prev = NULL; + + events->events = g_new (event_t, 16); + events->size_events = 16; + events->num_events = 0; + events->current_event = 0; + + events->edges = edges_new (); + events->prototraps = traps_new (); + events->traps = traps_new (); + + events->extents.p1.x = G_MAXDOUBLE; + events->extents.p1.y = G_MAXDOUBLE; + events->extents.p2.x = -G_MAXDOUBLE; + events->extents.p2.y = -G_MAXDOUBLE; + + return events; +} + +static void +events_read (EventView *ev, const char *filename) +{ + FILE *file; + + file = fopen (filename, "r"); + if (file != NULL) { + char *line = NULL; + size_t len = 0; + events_t *events; + + events = ev->events_list = events_new (); + while (getline (&line, &len, file) != -1) { + line = g_strstrip (line); + if (*line == '\0') { + events->next = events_new (); + events->next->prev = events; + events = events->next; + } else if (g_str_has_prefix (line, "edge:")) { + edge_t edge; + + sscanf (line, "edge: %lu (%lf, %lf) (%lf, %lf) (%lf, %lf) %d", + &edge.id, + &edge.line.p1.x, + &edge.line.p1.y, + &edge.line.p2.x, + &edge.line.p2.y, + &edge.top, + &edge.bottom, + &edge.dir); + + events->edges = _edges_add_edge (events->edges, + &edge, + &events->extents); + } else if (g_str_has_prefix (line, "event:")) { + int type; + int x,y; + gulong e1, e2; + + sscanf (line, "event: %d (%d, %d) %lu %lu", + &type, &x, &y, + &e1, &e2); + + _events_add_event (events, type, x, y, e1, e2); + } else if (g_str_has_prefix (line, "begin trap:")) { + int top; + gulong e1, e2; + + sscanf (line, "begin trap: %lu %lu %u", &e1, &e2, &top); + + _events_add_event (events, START_TRAP, top, 0, e1, e2); + } else if (g_str_has_prefix (line, "end trap:")) { + int top, bottom; + gulong e1, e2; + + sscanf (line, "end trap: %lu %lu %d %d", + &e1, &e2, &top, &bottom); + + _events_add_event (events, END_TRAP, top, bottom, e1, e2); + } + } + + ev->current_events = ev->events_list; + + free (line); + fclose (file); + } +} + +static gboolean +timeout_advance (EventView *self) +{ + event_next (self); + gtk_widget_queue_draw (&self->widget); + return TRUE; +} + +int +main (int argc, char **argv) +{ + EventView *ev; + GtkWidget *window, *hbox; + + gtk_init (&argc, &argv); + + hbox = gtk_hbox_new (TRUE, 0); + + ev = g_object_new (event_view_get_type (), NULL); + gtk_box_pack_start (GTK_BOX (hbox), &ev->widget, TRUE, TRUE, 0); + gtk_widget_show (&ev->widget); + + events_read (ev, argv[1]); + g_timeout_add (750, (GSourceFunc) timeout_advance, ev); + + window = gtk_window_new (GTK_WINDOW_TOPLEVEL); + gtk_widget_set_size_request (window, 800, 800); + g_signal_connect (window, "delete-event", + G_CALLBACK (gtk_main_quit), NULL); + gtk_container_add (GTK_CONTAINER (window), hbox); + gtk_widget_show (hbox); + gtk_widget_show (window); + + gtk_main (); + return 0; +} diff --git a/util/show-traps.c b/util/show-traps.c new file mode 100644 index 000000000..9a99aba44 --- /dev/null +++ b/util/show-traps.c @@ -0,0 +1,1239 @@ +#define _GNU_SOURCE +#include +#include +#include +#include +#include + +typedef struct _point { + gdouble x, y; +} point_t; +typedef struct _box { + point_t p1, p2; +} box_t; +typedef struct _line { + point_t p1, p2; +} line_t; +typedef struct _trapezoid { + gdouble top, bottom; + line_t left, right; +} trapezoid_t; +typedef struct _traps { + struct _traps *next, *prev; + box_t extents; + int num_traps; + int size; + trapezoid_t traps[0]; +} traps_t; + +typedef struct _edge { + line_t line; + gdouble top, bottom; + point_t p1, p2; + int dir; +} edge_t; +typedef struct _edges { + struct _edges *next, *prev; + box_t extents; + int num_edges; + int size; + edge_t edges[0]; +} edges_t; + +typedef struct _TrapView { + GtkWidget widget; + + struct _TrapView *group_head; + struct _TrapView *group_next; + struct _TrapView *group_prev; + + traps_t *traps_list; + traps_t *current_traps; + + edges_t *edges_list; + edges_t *current_edges; + + double px, py; + + gint mag_x, mag_y; + gint mag_size; + gdouble mag_zoom; + gboolean in_mag_drag; + gint mag_drag_x, mag_drag_y; +} TrapView; + +typedef struct _TrapViewClass { + GtkWidgetClass parent_class; +} TrapViewClass; + +G_DEFINE_TYPE (TrapView, trap_view, GTK_TYPE_WIDGET) + +static gdouble +_compute_intersection_x_for_y (const line_t *line, + gdouble y) +{ + gdouble dx = line->p2.x - line->p1.x; + gdouble dy = line->p2.y - line->p1.y; + gdouble x; + + if (y == line->p1.y) + return line->p1.x; + if (y == line->p2.y) + return line->p2.x; + + x = line->p1.x; + if (dy != 0) + x += (y - line->p1.y)*dx/dy; + return x; +} + +static void +_compute_intersection_point (const line_t *line, + gdouble y, + point_t *p) +{ + p->x = _compute_intersection_x_for_y (line, p->y = y); +} + +static void +trap_view_draw (TrapView *self, cairo_t *cr) +{ + traps_t *traps; + edges_t *edges; + gdouble sf_x, sf_y, sf; + gdouble mid, dim; + gdouble x0, x1, y0, y1; + double dash[2] = {8, 8}; + double dots[2] = {0., 1.}; + int n; + box_t extents; + point_t p; + + cairo_save (cr); + cairo_save (cr); + cairo_set_source_rgb (cr, 1, 1, 1); + cairo_paint (cr); + cairo_restore (cr); + + traps = self->current_traps; + if (traps == NULL) + return; + + edges = self->current_edges; + + extents = traps->extents; + if (edges != NULL) { + if (edges->extents.p1.x < extents.p1.x) + extents.p1.x = edges->extents.p1.x; + if (edges->extents.p1.y < extents.p1.y) + extents.p1.y = edges->extents.p1.y; + if (edges->extents.p2.x > extents.p2.x) + extents.p2.x = edges->extents.p2.x; + if (edges->extents.p2.y > extents.p2.y) + extents.p2.y = edges->extents.p2.y; + } + + mid = (extents.p2.x + extents.p1.x) / 2.; + dim = (extents.p2.x - extents.p1.x) / 2. * 1.25; + sf_x = self->widget.allocation.width / dim / 2; + + mid = (extents.p2.y + extents.p1.y) / 2.; + dim = (extents.p2.y - extents.p1.y) / 2. * 1.25; + sf_y = self->widget.allocation.height / dim / 2; + + sf = MIN (sf_x, sf_y); + + mid = (extents.p2.x + extents.p1.x) / 2.; + dim = sf_x / sf * (extents.p2.x - extents.p1.x) / 2. * 1.25; + x0 = mid - dim; + x1 = mid + dim; + mid = (extents.p2.y + extents.p1.y) / 2.; + dim = sf_y / sf * (extents.p2.y - extents.p1.y) / 2. * 1.25; + y0 = mid - dim; + y1 = mid + dim; + + cairo_save (cr); + cairo_scale (cr, sf, sf); + cairo_translate (cr, -x0, -y0); + cairo_set_source_rgba (cr, 0, 1, 0, .2); + for (n = 0; n < traps->num_traps; n++) { + const trapezoid_t *t = &traps->traps[n]; + + _compute_intersection_point (&t->left, t->top, &p); + cairo_move_to (cr, p.x, p.y); + _compute_intersection_point (&t->right, t->top, &p); + cairo_line_to (cr, p.x, p.y); + _compute_intersection_point (&t->right, t->bottom, &p); + cairo_line_to (cr, p.x, p.y); + _compute_intersection_point (&t->left, t->bottom, &p); + cairo_line_to (cr, p.x, p.y); + cairo_close_path (cr); + cairo_fill (cr); + } + cairo_restore (cr); + + if (edges == NULL) { + cairo_save (cr); + + /* top, bottom */ + cairo_save (cr); { + cairo_matrix_t m; + cairo_matrix_init_scale (&m, sf, sf); + cairo_matrix_translate (&m, -x0, -y0); + + cairo_set_line_width (cr, 1.); + cairo_set_line_cap (cr, CAIRO_LINE_CAP_BUTT); + for (n = 0; n < traps->num_traps; n++) { + const trapezoid_t *t = &traps->traps[n]; + + _compute_intersection_point (&t->left, t->top, &p); + cairo_matrix_transform_point (&m, &p.x, &p.y); + cairo_move_to (cr, floor (p.x), floor (p.y) + .5); + cairo_set_dash (cr, dash, 2, fmod (floor (p.x), dash[0] + dash[1])); + + _compute_intersection_point (&t->right, t->top, &p); + cairo_matrix_transform_point (&m, &p.x, &p.y); + cairo_line_to (cr, ceil (p.x), floor (p.y) + .5); + cairo_stroke (cr); + + _compute_intersection_point (&t->left, t->bottom, &p); + cairo_matrix_transform_point (&m, &p.x, &p.y); + cairo_move_to (cr, floor (p.x), floor (p.y) + .5); + cairo_set_dash (cr, dash, 2, fmod (floor (p.x), dash[0] + dash[1])); + + _compute_intersection_point (&t->right, t->bottom, &p); + cairo_matrix_transform_point (&m, &p.x, &p.y); + cairo_line_to (cr, ceil (p.x), floor (p.y) + .5); + cairo_stroke (cr); + } + } cairo_restore (cr); + + /* left extents */ + cairo_save (cr); { + cairo_save (cr); { + cairo_scale (cr, sf, sf); + cairo_translate (cr, -x0, -y0); + + for (n = 0; n < traps->num_traps; n++) { + const trapezoid_t *t = &traps->traps[n]; + cairo_move_to (cr, t->left.p1.x, t->left.p1.y); + cairo_line_to (cr, t->left.p2.x, t->left.p2.y); + } + } cairo_restore (cr); + cairo_set_source_rgb (cr, 1, 0, 0); + cairo_set_line_width (cr, 1.); + cairo_set_dash (cr, dash, 2, 0.); + cairo_stroke (cr); + } cairo_restore (cr); + + /* left line */ + cairo_save (cr); { + cairo_save (cr); { + cairo_scale (cr, sf, sf); + cairo_translate (cr, -x0, -y0); + + for (n = 0; n < traps->num_traps; n++) { + const trapezoid_t *t = &traps->traps[n]; + _compute_intersection_point (&t->left, t->top, &p); + cairo_move_to (cr, p.x, p.y); + _compute_intersection_point (&t->left, t->bottom, &p); + cairo_line_to (cr, p.x, p.y); + } + } cairo_restore (cr); + cairo_set_source_rgb (cr, 1, 0, 0); + cairo_stroke (cr); + } cairo_restore (cr); + + /* right extents */ + cairo_save (cr); { + cairo_save (cr); { + cairo_scale (cr, sf, sf); + cairo_translate (cr, -x0, -y0); + + for (n = 0; n < traps->num_traps; n++) { + const trapezoid_t *t = &traps->traps[n]; + cairo_move_to (cr, t->right.p1.x, t->right.p1.y); + cairo_line_to (cr, t->right.p2.x, t->right.p2.y); + } + } cairo_restore (cr); + cairo_set_source_rgb (cr, 0, 0, 1); + cairo_set_line_width (cr, 1.); + cairo_set_dash (cr, dash, 2, 0.); + cairo_stroke (cr); + } cairo_restore (cr); + + /* right line */ + cairo_save (cr); { + cairo_save (cr); { + cairo_scale (cr, sf, sf); + cairo_translate (cr, -x0, -y0); + + for (n = 0; n < traps->num_traps; n++) { + const trapezoid_t *t = &traps->traps[n]; + _compute_intersection_point (&t->right, t->top, &p); + cairo_move_to (cr, p.x, p.y); + _compute_intersection_point (&t->right, t->bottom, &p); + cairo_line_to (cr, p.x, p.y); + } cairo_restore (cr); + cairo_set_source_rgb (cr, 0, 0, 1); + cairo_stroke (cr); + } cairo_restore (cr); + } + + /* end-points */ + cairo_save (cr); { + cairo_save (cr); { + cairo_scale (cr, sf, sf); + cairo_translate (cr, -x0, -y0); + + for (n = 0; n < traps->num_traps; n++) { + const trapezoid_t *t = &traps->traps[n]; + _compute_intersection_point (&t->left, t->top, &p); + cairo_move_to (cr, p.x, p.y); + cairo_close_path (cr); + _compute_intersection_point (&t->left, t->bottom, &p); + cairo_move_to (cr, p.x, p.y); + cairo_close_path (cr); + _compute_intersection_point (&t->right, t->top, &p); + cairo_move_to (cr, p.x, p.y); + cairo_close_path (cr); + _compute_intersection_point (&t->right, t->bottom, &p); + cairo_move_to (cr, p.x, p.y); + cairo_close_path (cr); + } + } cairo_restore (cr); + cairo_set_source_rgb (cr, 0, 0, 0); + cairo_set_dash (cr, dots, 2, 0.); + cairo_set_line_cap (cr, CAIRO_LINE_CAP_ROUND); + cairo_set_line_width (cr, 4.); + cairo_stroke (cr); + } cairo_restore (cr); + + cairo_restore (cr); + } else { + cairo_save (cr); + + for (n = 0; n < edges->num_edges; n++) { + const edge_t *e = &edges->edges[n]; + + cairo_save (cr); { + cairo_scale (cr, sf, sf); + cairo_translate (cr, -x0, -y0); + cairo_move_to (cr, e->p1.x, e->p1.y); + cairo_line_to (cr, e->p2.x, e->p2.y); + } cairo_restore (cr); + + if (e->dir < 0) { + cairo_set_source_rgb (cr, 0, 0, 1); + cairo_set_dash (cr, dash, 2, dash[0]); + } else { + cairo_set_source_rgb (cr, 1, 0, 0); + cairo_set_dash (cr, dash, 2, 0.); + } + + cairo_set_line_cap (cr, CAIRO_LINE_CAP_BUTT); + cairo_set_line_width (cr, 1.); + cairo_stroke (cr); + + cairo_save (cr); { + cairo_scale (cr, sf, sf); + cairo_translate (cr, -x0, -y0); + cairo_move_to (cr, e->p1.x, e->p1.y); + cairo_close_path (cr); + cairo_move_to (cr, e->p2.x, e->p2.y); + cairo_close_path (cr); + } cairo_restore (cr); + cairo_set_source_rgb (cr, 0, 0, 0); + cairo_set_dash (cr, dots, 2, 0.); + cairo_set_line_cap (cr, CAIRO_LINE_CAP_ROUND); + cairo_set_line_width (cr, 4.); + cairo_stroke (cr); + } + + cairo_restore (cr); + } + + /* draw a zoom view of the area around the mouse */ + { + cairo_save (cr); + double zoom = self->mag_zoom; + int size = self->mag_size; + + /* bottom right */ + cairo_rectangle (cr, self->mag_x, self->mag_y, size, size); + cairo_stroke_preserve (cr); + cairo_set_source_rgb (cr, 1, 1, 1); + cairo_fill_preserve (cr); + cairo_clip (cr); + + /* compute roi in extents */ + cairo_translate (cr, self->mag_x + size/2, self->mag_y + size/2); + + cairo_save (cr); + cairo_scale (cr, zoom, zoom); + cairo_translate (cr, -(self->px / sf + x0), -(self->py /sf + y0)); + for (n = 0; n < traps->num_traps; n++) { + const trapezoid_t *t = &traps->traps[n]; + + _compute_intersection_point (&t->left, t->top, &p); + cairo_move_to (cr, p.x, p.y); + _compute_intersection_point (&t->right, t->top, &p); + cairo_line_to (cr, p.x, p.y); + _compute_intersection_point (&t->right, t->bottom, &p); + cairo_line_to (cr, p.x, p.y); + _compute_intersection_point (&t->left, t->bottom, &p); + cairo_line_to (cr, p.x, p.y); + cairo_close_path (cr); + cairo_set_source_rgba (cr, 0, 1, 0, .2); + cairo_fill (cr); + } + cairo_restore (cr); + + cairo_save (cr); { + cairo_matrix_t m; + cairo_matrix_init_scale (&m, zoom, zoom); + cairo_matrix_translate (&m, -(self->px / sf + x0), -(self->py /sf + y0)); + + cairo_set_source_rgb (cr, 0, 0, 0); + cairo_set_line_width (cr, 1.); + cairo_set_line_cap (cr, CAIRO_LINE_CAP_BUTT); + for (n = 0; n < traps->num_traps; n++) { + const trapezoid_t *t = &traps->traps[n]; + + _compute_intersection_point (&t->left, t->top, &p); + cairo_matrix_transform_point (&m, &p.x, &p.y); + cairo_move_to (cr, floor (p.x), floor (p.y) + .5); + cairo_set_dash (cr, dash, 2, fmod (floor (p.x), dash[0] + dash[1])); + + _compute_intersection_point (&t->right, t->top, &p); + cairo_matrix_transform_point (&m, &p.x, &p.y); + cairo_line_to (cr, ceil (p.x), floor (p.y) + .5); + cairo_stroke (cr); + + _compute_intersection_point (&t->left, t->bottom, &p); + cairo_matrix_transform_point (&m, &p.x, &p.y); + cairo_move_to (cr, floor (p.x), floor (p.y) + .5); + cairo_set_dash (cr, dash, 2, fmod (floor (p.x), dash[0] + dash[1])); + + _compute_intersection_point (&t->right, t->bottom, &p); + cairo_matrix_transform_point (&m, &p.x, &p.y); + cairo_line_to (cr, ceil (p.x), floor (p.y) + .5); + cairo_stroke (cr); + } + } cairo_restore (cr); + + cairo_save (cr); { /* left extents */ + cairo_save (cr); { + cairo_scale (cr, zoom, zoom); + cairo_translate (cr, -(self->px / sf + x0), -(self->py /sf + y0)); + for (n = 0; n < traps->num_traps; n++) { + const trapezoid_t *t = &traps->traps[n]; + cairo_move_to (cr, t->left.p1.x, t->left.p1.y); + cairo_line_to (cr, t->left.p2.x, t->left.p2.y); + } + } cairo_restore (cr); + cairo_set_source_rgb (cr, 1, 0, 0); + cairo_set_line_width (cr, .5); + cairo_set_dash (cr, dash, 2, 0.); + cairo_stroke (cr); + } cairo_restore (cr); + cairo_save (cr); { /* right extents */ + cairo_save (cr); { + cairo_scale (cr, zoom, zoom); + cairo_translate (cr, -(self->px / sf + x0), -(self->py /sf + y0)); + + for (n = 0; n < traps->num_traps; n++) { + const trapezoid_t *t = &traps->traps[n]; + cairo_move_to (cr, t->right.p1.x, t->right.p1.y); + cairo_line_to (cr, t->right.p2.x, t->right.p2.y); + } + } cairo_restore (cr); + cairo_set_source_rgb (cr, 0, 0, 1); + cairo_set_line_width (cr, .5); + cairo_set_dash (cr, dash, 2, 0.); + cairo_stroke (cr); + } cairo_restore (cr); + + cairo_save (cr); { /* left lines */ + cairo_save (cr); + cairo_scale (cr, zoom, zoom); + cairo_translate (cr, -(self->px / sf + x0), -(self->py /sf + y0)); + for (n = 0; n < traps->num_traps; n++) { + const trapezoid_t *t = &traps->traps[n]; + _compute_intersection_point (&t->left, t->top, &p); + cairo_move_to (cr, p.x, p.y); + _compute_intersection_point (&t->left, t->bottom, &p); + cairo_line_to (cr, p.x, p.y); + } + cairo_restore (cr); + cairo_set_source_rgb (cr, 1, 0, 0); + cairo_stroke (cr); + } cairo_restore (cr); + cairo_save (cr); { /* right lines */ + cairo_save (cr); + cairo_scale (cr, zoom, zoom); + cairo_translate (cr, -(self->px / sf + x0), -(self->py /sf + y0)); + for (n = 0; n < traps->num_traps; n++) { + const trapezoid_t *t = &traps->traps[n]; + _compute_intersection_point (&t->right, t->top, &p); + cairo_move_to (cr, p.x, p.y); + _compute_intersection_point (&t->right, t->bottom, &p); + cairo_line_to (cr, p.x, p.y); + } + cairo_restore (cr); + cairo_set_source_rgb (cr, 0, 0, 1); + cairo_stroke (cr); + } cairo_restore (cr); + + /* end-points */ + cairo_save (cr); { + double dots[2] = {0., 1.}; + + cairo_save (cr); + cairo_scale (cr, zoom, zoom); + cairo_translate (cr, -(self->px / sf + x0), -(self->py /sf + y0)); + for (n = 0; n < traps->num_traps; n++) { + const trapezoid_t *t = &traps->traps[n]; + _compute_intersection_point (&t->left, t->top, &p); + cairo_move_to (cr, p.x, p.y); + cairo_close_path (cr); + _compute_intersection_point (&t->left, t->bottom, &p); + cairo_move_to (cr, p.x, p.y); + cairo_close_path (cr); + _compute_intersection_point (&t->right, t->top, &p); + cairo_move_to (cr, p.x, p.y); + cairo_close_path (cr); + _compute_intersection_point (&t->right, t->bottom, &p); + cairo_move_to (cr, p.x, p.y); + cairo_close_path (cr); + } + cairo_restore (cr); + cairo_set_source_rgb (cr, 0, 0, 0); + cairo_set_dash (cr, dots, 2, 0.); + cairo_set_line_cap (cr, CAIRO_LINE_CAP_ROUND); + cairo_set_line_width (cr, 4.); + cairo_stroke (cr); + } cairo_restore (cr); + + /* grid */ + cairo_save (cr); { + int i; + + cairo_translate (cr, + -zoom*fmod (self->px/sf + x0, 1.), + -zoom*fmod (self->py/sf + y0, 1.)); + for (i = -size/2/zoom - 1; i <= size/2/zoom + 1; i++) { + cairo_move_to (cr, zoom*i, -size/2); + cairo_line_to (cr, zoom*i, size/2 + zoom); + cairo_move_to (cr, -size/2, zoom*i); + cairo_line_to (cr, size/2 + zoom, zoom*i); + } + cairo_set_source_rgba (cr, .7, .7, .7, .5); + cairo_set_line_width (cr, 1.); + cairo_stroke (cr); + } cairo_restore (cr); + } + + cairo_restore (cr); +} + +static gdouble +trapezoid_area (const trapezoid_t *t) +{ + gdouble inner_left, inner_right; + gdouble outer_left, outer_right; + gdouble height; + gdouble area; + + /* split into 3 sections: a rectangle with a pair of triangular bookends */ + inner_left = _compute_intersection_x_for_y (&t->left, t->top); + outer_left = _compute_intersection_x_for_y (&t->left, t->bottom); + if (outer_left > inner_left) { + gdouble t = outer_left; + outer_left = inner_left; + inner_left = t; + } + + inner_right = _compute_intersection_x_for_y (&t->right, t->top); + outer_right = _compute_intersection_x_for_y (&t->right, t->bottom); + if (outer_right > inner_right) { + gdouble t = outer_right; + outer_right = inner_right; + inner_right = t; + } + + if (outer_left > outer_right) { /* reverse */ + gdouble t; + + t = outer_left; + outer_left = inner_right; + inner_right = t; + + t = inner_left; + inner_left = outer_right; + outer_right = t; + } + + height = t->bottom - t->top; + area = (inner_left - outer_left) * height / 2; + area += (outer_right - inner_right) * height / 2; + area += (inner_right - inner_left) * height; + + return area; +} + +static gdouble +traps_compute_total_area (const traps_t *traps) +{ + int n; + gdouble area = 0.; + for (n = 0; n < traps->num_traps; n++) + area += trapezoid_area (&traps->traps[n]); + return area; +} + +static void +trap_view_draw_labels (TrapView *self, cairo_t *cr) +{ + PangoLayout *layout; + gint width, height; + gdouble total_area; + gchar *str; + traps_t *traps; + + traps = self->current_traps; + if (traps == NULL) + return; + + /* convert total area from fixed-point (assuming 24.8) */ + total_area = traps_compute_total_area (traps) / (256. * 256.); + str = g_strdup_printf ("Number of trapezoids:\t%d\n" + "Total area of trapezoids:\t%.2f", + traps->num_traps, + total_area); + layout = gtk_widget_create_pango_layout (&self->widget, str); + g_free (str); + + pango_layout_get_pixel_size (layout, &width, &height); + + cairo_move_to (cr, 10, 10 + height); + pango_cairo_show_layout (cr, layout); + g_object_unref (layout); +} + +static gboolean +trap_view_expose (GtkWidget *w, GdkEventExpose *ev) +{ + TrapView *self = (TrapView *) w; + cairo_t *cr; + + cr = gdk_cairo_create (w->window); + gdk_cairo_region (cr, ev->region); + cairo_clip (cr); + + trap_view_draw (self, cr); + trap_view_draw_labels (self, cr); + + cairo_destroy (cr); + return FALSE; +} + +static void +trap_view_advance (TrapView *self) +{ + if (self->current_traps && self->current_traps->prev) + self->current_traps = self->current_traps->prev; + if (self->current_edges && self->current_edges->prev) + self->current_edges = self->current_edges->prev; + gtk_widget_queue_draw (&self->widget); +} + +static void +trap_view_back (TrapView *self) +{ + if (self->current_traps && self->current_traps->next) + self->current_traps = self->current_traps->next; + if (self->current_edges && self->current_edges->next) + self->current_edges = self->current_edges->next; + gtk_widget_queue_draw (&self->widget); +} + +static void +trap_view_group_foreach (TrapView *group, GFunc func, gpointer data) +{ + while (group) { + func (group, data); + group = group->group_next; + } +} + +static gboolean +trap_view_key_press (GtkWidget *w, GdkEventKey *ev) +{ + TrapView *self = (TrapView *) w; + + switch (ev->keyval) { + case GDK_BackSpace: + trap_view_group_foreach (self->group_head, + (GFunc) trap_view_back, + NULL); + break; + + case GDK_space: + trap_view_group_foreach (self->group_head, + (GFunc) trap_view_advance, + NULL); + break; + + case GDK_Return: + trap_view_group_foreach (self->group_head, + (GFunc) trap_view_advance, + NULL); + break; + + case GDK_Escape: + case GDK_Q: + gtk_main_quit (); + break; + } + + return FALSE; +} + +static gboolean +trap_view_button_press (GtkWidget *w, GdkEventButton *ev) +{ + TrapView *self = (TrapView *) w; + + if (ev->x < self->mag_x || + ev->y < self->mag_y || + ev->x > self->mag_x + self->mag_size || + ev->y > self->mag_y + self->mag_size) + { + if (ev->type == GDK_BUTTON_PRESS) { + if (self->current_traps == NULL) + return FALSE; + + if (ev->button == 1) { + trap_view_group_foreach (self->group_head, + (GFunc) trap_view_advance, + NULL); + } else if (ev->button == 3) { + trap_view_group_foreach (self->group_head, + (GFunc) trap_view_back, + NULL); + } + } + } + else + { + self->in_mag_drag = TRUE; + self->mag_drag_x = ev->x; + self->mag_drag_y = ev->y; + } + + return FALSE; +} + +static gboolean +trap_view_button_release (GtkWidget *w, GdkEventButton *ev) +{ + TrapView *self = (TrapView *) w; + + self->in_mag_drag = FALSE; + + return FALSE; +} + +static void +trap_view_update_mouse (TrapView *self, GdkEventMotion *ev) +{ + self->px = ev->x; + self->py = ev->y; + + gtk_widget_queue_draw (&self->widget); +} + +static void +trap_view_update_magnifier (TrapView *self, gint *xy) +{ + self->mag_x = xy[0]; + self->mag_y = xy[1]; + + gtk_widget_queue_draw (&self->widget); +} + +static gboolean +trap_view_motion (GtkWidget *w, GdkEventMotion *ev) +{ + TrapView *self = (TrapView *) w; + + if (self->in_mag_drag) { + int xy[2]; + + xy[0] = self->mag_x + ev->x - self->mag_drag_x; + xy[1] = self->mag_y + ev->y - self->mag_drag_y; + + trap_view_group_foreach (self->group_head, + (GFunc) trap_view_update_magnifier, + xy); + + self->mag_drag_x = ev->x; + self->mag_drag_y = ev->y; + } else if (ev->x < self->mag_x || + ev->y < self->mag_y || + ev->x > self->mag_x + self->mag_size || + ev->y > self->mag_y + self->mag_size) + { + trap_view_group_foreach (self->group_head, + (GFunc) trap_view_update_mouse, + ev); + } + + return FALSE; +} + +static void +trap_view_realize (GtkWidget *widget) +{ + GdkWindowAttr attributes; + + GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED); + + attributes.window_type = GDK_WINDOW_CHILD; + attributes.x = widget->allocation.x; + attributes.y = widget->allocation.y; + attributes.width = widget->allocation.width; + attributes.height = widget->allocation.height; + attributes.wclass = GDK_INPUT_OUTPUT; + attributes.visual = gtk_widget_get_visual (widget); + attributes.colormap = gtk_widget_get_colormap (widget); + attributes.event_mask = gtk_widget_get_events (widget) | + GDK_BUTTON_PRESS_MASK | + GDK_BUTTON_RELEASE_MASK | + GDK_KEY_PRESS_MASK | + GDK_KEY_RELEASE_MASK | + GDK_POINTER_MOTION_MASK | + GDK_BUTTON_MOTION_MASK | + GDK_EXPOSURE_MASK; + + widget->window = gdk_window_new (gtk_widget_get_parent_window (widget), + &attributes, + GDK_WA_X | GDK_WA_Y | + GDK_WA_VISUAL | GDK_WA_COLORMAP); + gdk_window_set_user_data (widget->window, widget); + + widget->style = gtk_style_attach (widget->style, widget->window); + gtk_style_set_background (widget->style, widget->window, GTK_STATE_NORMAL); +} + +static void +trap_view_size_allocate (GtkWidget *w, GdkRectangle *r) +{ + TrapView *self = (TrapView *) w; + + GTK_WIDGET_CLASS (trap_view_parent_class)->size_allocate (w, r); + + self->mag_x = w->allocation.width - self->mag_size - 10; + self->mag_y = w->allocation.height - self->mag_size - 10; +} + +static void +trap_view_finalize (GObject *obj) +{ + G_OBJECT_CLASS (trap_view_parent_class)->finalize (obj); +} + +static void +trap_view_class_init (TrapViewClass *klass) +{ + GObjectClass *object_class = (GObjectClass *) klass; + GtkWidgetClass *widget_class = (GtkWidgetClass *) klass; + + object_class->finalize = trap_view_finalize; + + widget_class->realize = trap_view_realize; + widget_class->size_allocate = trap_view_size_allocate; + widget_class->expose_event = trap_view_expose; + widget_class->key_press_event = trap_view_key_press; + widget_class->button_press_event = trap_view_button_press; + widget_class->button_release_event = trap_view_button_release; + widget_class->motion_notify_event = trap_view_motion; +} + +static void +trap_view_init (TrapView *self) +{ + self->mag_zoom = 10; + self->mag_size = 200; + + GTK_WIDGET_SET_FLAGS (self, GTK_CAN_FOCUS); +} + +static traps_t * +_traps_add_trapezoid (TrapView *tv, traps_t *traps, const trapezoid_t *trap) +{ + if (trap->top < traps->extents.p1.y) + traps->extents.p1.y = trap->top; + if (trap->bottom > traps->extents.p2.y) + traps->extents.p2.y = trap->bottom; + + if (trap->left.p1.x < traps->extents.p1.x) + traps->extents.p1.x = trap->left.p1.x; + if (trap->left.p2.x < traps->extents.p1.x) + traps->extents.p1.x = trap->left.p2.x; + + if (trap->right.p1.x > traps->extents.p2.x) + traps->extents.p2.x = trap->right.p1.x; + if (trap->right.p2.x > traps->extents.p2.x) + traps->extents.p2.x = trap->right.p2.x; + + if (traps->num_traps == traps->size) { + int newsize = 2 * traps->size; + void *newtraps; + + newtraps = g_realloc (traps, + sizeof (traps_t) + newsize * sizeof (trapezoid_t)); + if (newtraps == NULL) + return traps; + + if (tv->current_traps == traps) + tv->current_traps = newtraps; + + traps = newtraps; + traps->size = newsize; + + if (traps->next != NULL) + traps->next->prev = newtraps; + if (traps->prev != NULL) + traps->prev->next = newtraps; + else + tv->traps_list = newtraps; + } + + traps->traps[traps->num_traps++] = *trap; + + return traps; +} + +static traps_t * +traps_new (TrapView *tv) +{ + traps_t *t; + + t = g_malloc (sizeof (traps_t) + 16 * sizeof (trapezoid_t)); + t->prev = NULL; + t->next = tv->traps_list; + if (tv->traps_list) + tv->traps_list->prev = t; + tv->traps_list = t; + + if (tv->current_traps == NULL) + tv->current_traps = t; + + t->size = 16; + t->num_traps = 0; + t->extents.p1.x = G_MAXDOUBLE; + t->extents.p1.y = G_MAXDOUBLE; + t->extents.p2.x = -G_MAXDOUBLE; + t->extents.p2.y = -G_MAXDOUBLE; + + return t; +} + +static edges_t * +_edges_add_edge (TrapView *tv, edges_t *edges, edge_t *e) +{ + if (e->top < edges->extents.p1.y) + edges->extents.p1.y = e->top; + if (e->bottom > edges->extents.p2.y) + edges->extents.p2.y = e->bottom; + + _compute_intersection_point (&e->line, e->top, &e->p1); + _compute_intersection_point (&e->line, e->bottom, &e->p2); + + if (e->p1.x < edges->extents.p1.x) + edges->extents.p1.x = e->p1.x; + if (e->p2.x < edges->extents.p1.x) + edges->extents.p1.x = e->p2.x; + + if (e->p1.x > edges->extents.p2.x) + edges->extents.p2.x = e->p1.x; + if (e->p2.x > edges->extents.p2.x) + edges->extents.p2.x = e->p2.x; + + if (edges->num_edges == edges->size) { + int newsize = 2 * edges->size; + void *newedges; + + newedges = g_realloc (edges, + sizeof (edges_t) + newsize * sizeof (edge_t)); + if (newedges == NULL) + return edges; + + if (tv->current_edges == edges) + tv->current_edges = newedges; + + edges = newedges; + edges->size = newsize; + + if (edges->next != NULL) + edges->next->prev = newedges; + if (edges->prev != NULL) + edges->prev->next = newedges; + else + tv->edges_list = newedges; + } + + edges->edges[edges->num_edges++] = *e; + + return edges; +} + +static edges_t * +edges_new (TrapView *tv) +{ + edges_t *t; + + t = g_malloc (sizeof (edges_t) + 16 * sizeof (edge_t)); + t->prev = NULL; + t->next = tv->edges_list; + if (tv->edges_list) + tv->edges_list->prev = t; + tv->edges_list = t; + + if (tv->current_edges == NULL) + tv->current_edges = t; + + t->size = 16; + t->num_edges = 0; + t->extents.p1.x = G_MAXDOUBLE; + t->extents.p1.y = G_MAXDOUBLE; + t->extents.p2.x = -G_MAXDOUBLE; + t->extents.p2.y = -G_MAXDOUBLE; + + return t; +} + +int +main (int argc, char **argv) +{ + TrapView *tv, *group_head = NULL, *group_prev = NULL; + GtkWidget *window, *hbox; + FILE *file; + + gtk_init (&argc, &argv); + + hbox = gtk_hbox_new (TRUE, 0); + + file = fopen (argv[1], "r"); + if (file != NULL) { + char *line = NULL; + size_t len = 0; + traps_t *traps; + + tv = g_object_new (trap_view_get_type (), NULL); + gtk_box_pack_start (GTK_BOX (hbox), &tv->widget, TRUE, TRUE, 0); + gtk_widget_show (&tv->widget); + + tv->group_prev = group_prev; + tv->group_next = NULL; + if (group_prev) + group_prev->group_next = tv; + group_prev = tv; + if (group_head == NULL) + group_head = tv; + tv->group_head = group_head; + + traps = traps_new (tv); + while (getline (&line, &len, file) != -1) { + trapezoid_t t; + + if (sscanf (line, + "%lf %lf L:(%lf, %lf), (%lf, %lf) R:(%lf, %lf), (%lf, %lf)", + &t.top, &t.bottom, + &t.left.p1.x, &t.left.p1.y, + &t.left.p2.x, &t.left.p2.y, + &t.right.p1.x, &t.right.p1.y, + &t.right.p2.x, &t.right.p2.y) == 10) { + traps = _traps_add_trapezoid (tv, traps, &t); + } else { + if (traps->num_traps) { + g_print ("read %d trapezoids\n", traps->num_traps); + g_print ("extents=(%lg, %lg), (%lg, %lg)\n", + traps->extents.p1.x, traps->extents.p1.y, + traps->extents.p2.x, traps->extents.p2.y); + traps = traps_new (tv); + } + } + } + free (line); + fclose (file); + + if (traps->num_traps) { + g_print ("read %d trapezoids\n", traps->num_traps); + g_print ("extents=(%lg, %lg), (%lg, %lg)\n", + traps->extents.p1.x, traps->extents.p1.y, + traps->extents.p2.x, traps->extents.p2.y); + } + } + + file = fopen (argv[2], "r"); + if (file != NULL) { + char *line = NULL; + size_t len = 0; + traps_t *traps; + + tv = g_object_new (trap_view_get_type (), NULL); + gtk_box_pack_start (GTK_BOX (hbox), &tv->widget, TRUE, TRUE, 0); + gtk_widget_show (&tv->widget); + + tv->group_prev = group_prev; + tv->group_next = NULL; + if (group_prev) + group_prev->group_next = tv; + group_prev = tv; + if (group_head == NULL) + group_head = tv; + tv->group_head = group_head; + + traps = traps_new (tv); + while (getline (&line, &len, file) != -1) { + trapezoid_t t; + + if (sscanf (line, + "%lf %lf L:(%lf, %lf), (%lf, %lf) R:(%lf, %lf), (%lf, %lf)", + &t.top, &t.bottom, + &t.left.p1.x, &t.left.p1.y, + &t.left.p2.x, &t.left.p2.y, + &t.right.p1.x, &t.right.p1.y, + &t.right.p2.x, &t.right.p2.y) == 10) { + traps = _traps_add_trapezoid (tv, traps, &t); + } else { + if (traps->num_traps) { + g_print ("read %d trapezoids\n", traps->num_traps); + g_print ("extents=(%lg, %lg), (%lg, %lg)\n", + traps->extents.p1.x, traps->extents.p1.y, + traps->extents.p2.x, traps->extents.p2.y); + traps = traps_new (tv); + } + } + } + free (line); + fclose (file); + + if (traps->num_traps) { + g_print ("read %d trapezoids\n", traps->num_traps); + g_print ("extents=(%lg, %lg), (%lg, %lg)\n", + traps->extents.p1.x, traps->extents.p1.y, + traps->extents.p2.x, traps->extents.p2.y); + } + } + +#if 1 + if (argc >=4) { + file = fopen (argv[3], "r"); + if (file != NULL) { + char *line = NULL; + size_t len = 0; + edges_t *edges; + + edges = edges_new (tv); + while (getline (&line, &len, file) != -1) { + edge_t e; + + if (sscanf (line, + "(%lf, %lf), (%lf, %lf) %lf %lf %d", + &e.line.p1.x, &e.line.p1.y, + &e.line.p2.x, &e.line.p2.y, + &e.top, &e.bottom, + &e.dir) == 7) { + edges = _edges_add_edge (tv, edges, &e); + } else { + if (edges->num_edges) { + g_print ("read %d edges\n", edges->num_edges); + g_print ("extents=(%lg, %lg), (%lg, %lg)\n", + edges->extents.p1.x, edges->extents.p1.y, + edges->extents.p2.x, edges->extents.p2.y); + edges = edges_new (tv); + } + } + } + free (line); + fclose (file); + + if (edges->num_edges) { + g_print ("read %d edges\n", edges->num_edges); + g_print ("extents=(%lg, %lg), (%lg, %lg)\n", + edges->extents.p1.x, edges->extents.p1.y, + edges->extents.p2.x, edges->extents.p2.y); + } + } + } +#else + if (argc >= 4) { + file = fopen (argv[3], "r"); + if (file != NULL) { + char *line = NULL; + size_t len = 0; + traps_t *traps; + + tv = g_object_new (trap_view_get_type (), NULL); + gtk_box_pack_start (GTK_BOX (hbox), &tv->widget, TRUE, TRUE, 0); + gtk_widget_show (&tv->widget); + + tv->group_prev = group_prev; + tv->group_next = NULL; + if (group_prev) + group_prev->group_next = tv; + group_prev = tv; + if (group_head == NULL) + group_head = tv; + tv->group_head = group_head; + + traps = traps_new (tv); + while (getline (&line, &len, file) != -1) { + trapezoid_t t; + + if (sscanf (line, + "%lf %lf L:(%lf, %lf), (%lf, %lf) R:(%lf, %lf), (%lf, %lf)", + &t.top, &t.bottom, + &t.left.p1.x, &t.left.p1.y, + &t.left.p2.x, &t.left.p2.y, + &t.right.p1.x, &t.right.p1.y, + &t.right.p2.x, &t.right.p2.y) == 10) { + traps = _traps_add_trapezoid (tv, traps, &t); + } else { + if (traps->num_traps) { + g_print ("read %d trapezoids\n", traps->num_traps); + g_print ("extents=(%lg, %lg), (%lg, %lg)\n", + traps->extents.p1.x, traps->extents.p1.y, + traps->extents.p2.x, traps->extents.p2.y); + traps = traps_new (tv); + } + } + } + free (line); + fclose (file); + + if (traps->num_traps) { + g_print ("read %d trapezoids\n", traps->num_traps); + g_print ("extents=(%lg, %lg), (%lg, %lg)\n", + traps->extents.p1.x, traps->extents.p1.y, + traps->extents.p2.x, traps->extents.p2.y); + } + } + } +#endif + + window = gtk_window_new (GTK_WINDOW_TOPLEVEL); + g_signal_connect (window, "delete-event", + G_CALLBACK (gtk_main_quit), NULL); + gtk_widget_set_size_request (window, 512, 512); + gtk_container_add (GTK_CONTAINER (window), hbox); + gtk_widget_show (hbox); + gtk_widget_show (window); + + gtk_main (); + return 0; +} -- cgit v1.2.3