X-Git-Url: http://git.asbjorn.biz/?a=blobdiff_plain;f=lib%2Fdevices%2Farts.c;h=510df3e5bf5ac883b73513593f6ea954e53959cf;hb=70c85e8a814e75b29883fc347a65f83af370249b;hp=0b624fc6ce171fdfd0e8969bd58a4b4fd828d20f;hpb=b358cfe04e66551a533c7db6506d0d7bd1f20433;p=swftools.git

diff --git a/lib/devices/arts.c b/lib/devices/arts.c
index 0b624fc..510df3e 100644
--- a/lib/devices/arts.c
+++ b/lib/devices/arts.c
@@ -37,9 +37,10 @@ typedef struct _clip {
 typedef struct _internal {
     gfxdevice_t*out;
     clip_t*clip;
+    ArtSVP*svpunion;
 } internal_t;
 
-static int verbose = 1;
+static int verbose = 0;
 static void dbg(char*format, ...)
 {
     if(!verbose)
@@ -63,14 +64,15 @@ int arts_setparameter(struct _gfxdevice*dev, const char*key, const char*value)
 {
     dbg("arts_setparameter");
     internal_t*i = (internal_t*)dev->internal;
-    return i->out->setparameter(i->out,key,value);
+    if(i->out) return i->out->setparameter(i->out,key,value);
+    else return 0;
 }
 
 void arts_startpage(struct _gfxdevice*dev, int width, int height)
 {
     dbg("arts_startpage");
     internal_t*i = (internal_t*)dev->internal;
-    i->out->startpage(i->out,width,height);
+    if(i->out) i->out->startpage(i->out,width,height);
 }
 
 void arts_startclip(struct _gfxdevice*dev, gfxline_t*line)
@@ -89,7 +91,7 @@ void arts_startclip(struct _gfxdevice*dev, gfxline_t*line)
 	i->clip->svp = art_svp_intersect(svp, old);
 	art_svp_free(svp);
     } else {
-	i->clip = rfx_calloc(sizeof(clip_t));
+	i->clip = (clip_t*)rfx_calloc(sizeof(clip_t));
 	i->clip->svp = svp;
     }
 }
@@ -109,6 +111,16 @@ void arts_endclip(struct _gfxdevice*dev)
     }
 }
 
+void addtounion(struct _gfxdevice*dev, ArtSVP*svp)
+{
+    internal_t*i = (internal_t*)dev->internal;
+    if(i->svpunion) {
+	ArtSVP*old = i->svpunion;
+	i->svpunion = art_svp_union(svp,i->svpunion);
+	art_svp_free(old);
+    }
+}
+
 void arts_stroke(struct _gfxdevice*dev, gfxline_t*line, gfxcoord_t width, gfxcolor_t*color, gfx_capType cap_style, gfx_joinType joint_style, gfxcoord_t miterLimit)
 {
     dbg("arts_stroke");
@@ -120,8 +132,9 @@ void arts_stroke(struct _gfxdevice*dev, gfxline_t*line, gfxcoord_t width, gfxcol
 	svp = art_svp_intersect(svp, i->clip->svp);
 	art_svp_free(old);
     }
+    addtounion(dev,svp);
     gfxline_t*gfxline = SVPtogfxline(svp);
-    i->out->fill(i->out, gfxline, color);
+    if(i->out) i->out->fill(i->out, gfxline, color);
     free(gfxline);
     art_svp_free(svp);
 }
@@ -132,6 +145,20 @@ void arts_fill(struct _gfxdevice*dev, gfxline_t*line, gfxcolor_t*color)
     internal_t*i = (internal_t*)dev->internal;
     ArtSVP* svp = gfxfillToSVP(line, 1);
     
+    if (svp->n_segs > 500)
+    {
+	int lineParts = 0;
+	gfxline_t* lineCursor = line;
+	while(lineCursor != NULL)
+	{
+	    if(lineCursor->type != gfx_moveTo) ++lineParts;
+	    lineCursor = lineCursor->next;
+	}
+	fprintf(stderr, "arts_fill abandonning shape with %d segments (%d line parts)\n", svp->n_segs, lineParts);
+	art_svp_free(svp);
+	return;
+    }
+
     svp = art_svp_rewind_uncrossed(art_svp_uncross(svp),ART_WIND_RULE_ODDEVEN); /*FIXME*/
 
     if(i->clip) {
@@ -139,8 +166,9 @@ void arts_fill(struct _gfxdevice*dev, gfxline_t*line, gfxcolor_t*color)
 	svp = art_svp_intersect(svp, i->clip->svp);
 	art_svp_free(old);
     }
+    addtounion(dev,svp);
     gfxline_t*gfxline = SVPtogfxline(svp);
-    i->out->fill(i->out, gfxline, color);
+    if(i->out) i->out->fill(i->out, gfxline, color);
     free(gfxline);
     art_svp_free(svp);
 }
@@ -150,13 +178,77 @@ void arts_fillbitmap(struct _gfxdevice*dev, gfxline_t*line, gfximage_t*img, gfxm
     dbg("arts_fillbitmap");
     internal_t*i = (internal_t*)dev->internal;
     ArtSVP* svp = gfxfillToSVP(line, 1);
+
+    // We need to make sure that the SVP we now have bounds an area (i.e. the
+    // source line wound anticlockwise) rather than excludes an area (i.e. the
+    // line wound clockwise). It seems that PDF (or xpdf) is less strict about
+    // this for bitmaps than it is for fill areas.
+    //
+    // To check this, we'll sum the cross products of all pairs of adjacent
+    // lines. If the result is positive, the direction is correct; if not, we
+    // need to reverse the sense of the SVP generated. The easiest way to do
+    // this is to flip the up/down flags of all the segments.
+    //
+    // This is approximate; since the gfxline_t structure can contain any
+    // combination of moveTo, lineTo and splineTo in any order, not all pairs
+    // of lines in the shape that share a point need be described next to each
+    // other in the sequence. For ease, we'll consider only pairs of lines
+    // stored as lineTos and splineTos without intervening moveTos.
+    //
+    // TODO is this a valid algorithm? My vector maths is rusty.
+    //
+    // It may be more correct to instead reverse the line before we feed it
+    // into gfxfilltoSVP. However, this seems equivalent and is easier to
+    // implement!
+    double total_cross_product = 0.0;
+    gfxline_t* cursor = line;
+    if (cursor != NULL)
+    {
+	double x_last = cursor->x;
+	double y_last = cursor->y;
+	cursor = cursor->next;
+
+	while((cursor != NULL) && (cursor->next != NULL))
+	{
+	    if (((cursor->type == gfx_lineTo) || (cursor->type == gfx_splineTo))
+		&& ((cursor->next->type == gfx_lineTo) || (cursor->next->type == gfx_splineTo)))
+	    {
+		// Process these lines
+		//
+		// In this space (x right, y down) the cross-product is
+		// (x1 * y0) - (x0 * y1)
+		double x0 = cursor->x - x_last;
+		double y0 = cursor->y - y_last;
+		double x1 = cursor->next->x - cursor->x;
+		double y1 = cursor->next->y - cursor->y;
+		total_cross_product += (x1 * y0) - (x0 * y1);
+	    }
+
+	    x_last = cursor->x;
+	    y_last = cursor->y;
+	    cursor = cursor->next;
+	}
+    }
+    if (total_cross_product < 0.0)
+    {
+	int i = 0;
+	for(; i < svp->n_segs; ++i)
+	{
+	    if (svp->segs[i].dir != 0)
+		svp->segs[i].dir = 0;
+	    else
+		svp->segs[i].dir = 1;
+	}
+    }
+
     if(i->clip) {
 	ArtSVP*old = svp;
 	svp = art_svp_intersect(svp, i->clip->svp);
 	art_svp_free(old);
     }
+    addtounion(dev,svp);
     gfxline_t*gfxline = SVPtogfxline(svp);
-    i->out->fillbitmap(i->out, gfxline, img, matrix, cxform);
+    if(i->out) i->out->fillbitmap(i->out, gfxline, img, matrix, cxform);
     free(gfxline);
     art_svp_free(svp);
 }
@@ -171,8 +263,9 @@ void arts_fillgradient(struct _gfxdevice*dev, gfxline_t*line, gfxgradient_t*grad
 	svp = art_svp_intersect(svp, i->clip->svp);
 	art_svp_free(old);
     }
+    addtounion(dev,svp);
     gfxline_t*gfxline = SVPtogfxline(svp);
-    i->out->fillgradient(i->out, gfxline, gradient, type, matrix);
+    if(i->out) i->out->fillgradient(i->out, gfxline, gradient, type, matrix);
     free(gfxline);
     art_svp_free(svp);
 }
@@ -181,7 +274,7 @@ void arts_addfont(struct _gfxdevice*dev, gfxfont_t*font)
 {
     dbg("arts_addfont");
     internal_t*i = (internal_t*)dev->internal;
-    i->out->addfont(i->out, font);
+    if(i->out) i->out->addfont(i->out, font);
 }
 
 void arts_drawchar(struct _gfxdevice*dev, gfxfont_t*font, int glyphnr, gfxcolor_t*color, gfxmatrix_t*matrix)
@@ -199,6 +292,9 @@ void arts_drawchar(struct _gfxdevice*dev, gfxfont_t*font, int glyphnr, gfxcolor_
 	gfxbbox_t bbox2 = gfxline_getbbox(gfxline);
 	double w = bbox2.xmax - bbox2.xmin;
 	double h = bbox2.ymax - bbox2.ymin;
+	
+	addtounion(dev, svp); // TODO: use the whole char, not just the bbox
+
 	if(w < 0.001 || h < 0.001) /* character was clipped completely */ {
 	} else if(fabs((bbox.xmax - bbox.xmin) - w) > 0.05 ||
                   fabs((bbox.ymax - bbox.ymin) - h) > 0.05) {
@@ -207,10 +303,10 @@ void arts_drawchar(struct _gfxdevice*dev, gfxfont_t*font, int glyphnr, gfxcolor_
 	     */
 	    arts_fill(dev, glyph, color);
 	} else {
-	    i->out->drawchar(i->out, font, glyphnr, color, matrix);
+	    if(i->out) i->out->drawchar(i->out, font, glyphnr, color, matrix);
 	}
     } else {
-	i->out->drawchar(i->out, font, glyphnr, color, matrix);
+	if(i->out) i->out->drawchar(i->out, font, glyphnr, color, matrix);
     }
     
     gfxline_free(glyph);
@@ -220,28 +316,69 @@ void arts_drawlink(struct _gfxdevice*dev, gfxline_t*line, char*action)
 {
     dbg("arts_drawlink");
     internal_t*i = (internal_t*)dev->internal;
-    i->out->drawlink(i->out, line, action);
+    if(i->out) i->out->drawlink(i->out, line, action);
 }
 
 void arts_endpage(struct _gfxdevice*dev)
 {
     dbg("arts_endpage");
     internal_t*i = (internal_t*)dev->internal;
-    i->out->endpage(i->out);
+    if(i->out) i->out->endpage(i->out);
 }
 
 gfxresult_t* arts_finish(struct _gfxdevice*dev)
 {
     dbg("arts_finish");
     internal_t*i = (internal_t*)dev->internal;
-    return i->out->finish(i->out);
+    if(i->out) {
+	return i->out->finish(i->out);
+    } else {
+	return 0;
+    }
+}
+
+gfxline_t*gfxdevice_union_getunion(struct _gfxdevice*dev)
+{
+    internal_t*i = (internal_t*)dev->internal;
+    return SVPtogfxline(i->svpunion);
+}
+
+void gfxdevice_removeclippings_init(gfxdevice_t*dev, gfxdevice_t*out)
+{
+    dbg("gfxdevice_removeclippings_init");
+    internal_t*i = (internal_t*)rfx_calloc(sizeof(internal_t));
+    memset(dev, 0, sizeof(gfxdevice_t));
+    
+    dev->name = "removeclippings";
+
+    dev->internal = i;
+
+    dev->setparameter = arts_setparameter;
+    dev->startpage = arts_startpage;
+    dev->startclip = arts_startclip;
+    dev->endclip = arts_endclip;
+    dev->stroke = arts_stroke;
+    dev->fill = arts_fill;
+    dev->fillbitmap = arts_fillbitmap;
+    dev->fillgradient = arts_fillgradient;
+    dev->addfont = arts_addfont;
+    dev->drawchar = arts_drawchar;
+    dev->drawlink = arts_drawlink;
+    dev->endpage = arts_endpage;
+    dev->finish = arts_finish;
+
+    i->out = out;
+    i->svpunion = 0;
 }
 
-void gfxdevice_arts_init(gfxdevice_t*dev, gfxdevice_t*out)
+void gfxdevice_union_init(gfxdevice_t*dev,gfxdevice_t*out)
 {
-    dbg("gfxdevice_arts_init");
-    internal_t*i = rfx_calloc(sizeof(internal_t));
+    dbg("gfxdevice_getunion_init");
+    internal_t*i = (internal_t*)rfx_calloc(sizeof(internal_t));
     memset(dev, 0, sizeof(gfxdevice_t));
+    
+    dev->name = "union";
+
     dev->internal = i;
 
     dev->setparameter = arts_setparameter;
@@ -259,5 +396,6 @@ void gfxdevice_arts_init(gfxdevice_t*dev, gfxdevice_t*out)
     dev->finish = arts_finish;
 
     i->out = out;
+    i->svpunion = gfxstrokeToSVP(0, 0, 0, 0, 0);
 }