Attachment 38879 Details for Bug 2807 – Implementation of dynamic axial pattern

[patch] Implementation of dynamic axial pattern

2807.patch (text/plain), 29.49 KB, created by Thomas Freitag on 2010-09-22 09:13:17 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Thomas Freitag

Created: 2010-09-22 09:13:17 UTC

Size: 29.49 KB

patch

obsolete

>diff --git a/poppler/Gfx.cc b/poppler/Gfx.cc
>index 50870cc..c13bb14 100644
>--- a/poppler/Gfx.cc
>+++ b/poppler/Gfx.cc
>@@ -487,7 +487,7 @@ GBool GfxResources::lookupGState(char *name, Object *obj) {
> 
>   if (!obj->isRef())
>     return gTrue;
>-  
>+
>   const Ref ref = obj->getRef();
>   if (!gStateCache.lookup(ref, obj)->isNull())
>     return gTrue;
>@@ -714,7 +714,7 @@ void Gfx::go(GBool topLevel) {
> 	    data_p = new ProfileData();
> 	    hash->add (cmd_g, data_p);
> 	  }
>-	  
>+
> 	  data_p->addElement(timer.getElapsed ());
> 	}
>       }
>@@ -2169,7 +2169,7 @@ void Gfx::doShadingPatternFill(GfxShadingPattern *sPat,
> 
> #if 1 //~tmp: turn off anti-aliasing temporarily
>   GBool vaa = out->getVectorAntialias();
>-  if (vaa) {
>+  if (vaa && !textHaveCSPattern ) {
>     out->setVectorAntialias(gFalse);
>   }
> #endif
>@@ -2379,14 +2379,14 @@ void Gfx::doFunctionShFill1(GfxFunctionShading *shading,
>     colors2[2] = colorM0;
>     colors2[3] = colorMM;
>     doFunctionShFill1(shading, x0, y0, xM, yM, colors2, depth + 1);
>-    
>+
>     // lower-left sub-rectangle
>     colors2[0] = color0M;
>     colors2[1] = colors[1];
>     colors2[2] = colorMM;
>     colors2[3] = colorM1;
>     doFunctionShFill1(shading, x0, yM, xM, y1, colors2, depth + 1);
>-    
>+
>     // upper-right sub-rectangle
>     colors2[0] = colorM0;
>     colors2[1] = colorMM;
>@@ -2584,10 +2584,10 @@ void Gfx::doAxialShFill(GfxAxialShading *shading) {
>       }
>       shading->getColor(tt, &color1);
>       if (isSameGfxColor(color1, color0, nComps, axialColorDelta)) {
>-         // in these two if what we guarantee is that if we are skipping lots of 
>+         // in these two if what we guarantee is that if we are skipping lots of
>          // positions because the colors are the same, we still create a region
>          // with vertexs passing by bboxIntersections[1] and bboxIntersections[2]
>-         // otherwise we can have empty regions that should really be painted 
>+         // otherwise we can have empty regions that should really be painted
>          // like happened in bug 19896
>          // What we do to ensure that we pass a line through this points
>          // is making sure use the exact bboxIntersections[] value as one of the used ta[] values
>@@ -3332,7 +3332,7 @@ void Gfx::opBeginText(Object args[], int numArgs) {
>   out->updateTextMat(state);
>   out->updateTextPos(state);
>   fontChanged = gTrue;
>-  if (out->supportTextCSPattern(state)) {
>+  if (!(state->getRender() & 4) && out->supportTextCSPattern(state)) {
>     textHaveCSPattern = gTrue;
>   }
> }
>@@ -3387,9 +3387,22 @@ void Gfx::opSetTextLeading(Object args[], int numArgs) {
> }
> 
> void Gfx::opSetTextRender(Object args[], int numArgs) {
>+  int rm = state->getRender();
>   state->setRender(args[0].getInt());
>-  if (args[0].getInt() == 7) {
>+  if ((args[0].getInt() & 4) && textHaveCSPattern && drawText) {
>+    GBool needFill = out->deviceHasTextClip(state);
>+    out->endTextObject(state);
>+    if (needFill) {
>+      doPatternFill(gTrue);
>+    }
>+    out->restoreState(state);
>+    out->beginTextObject(state);
>+    out->updateTextMat(state);
>+    out->updateTextPos(state);
>     textHaveCSPattern = gFalse;
>+  } else if ((rm & 4) && !(args[0].getInt() & 4) && out->supportTextCSPattern(state) && drawText) {
>+	out->beginTextObject(state);
>+    textHaveCSPattern = gTrue;
>   }
>   out->updateRender(state);
> }
>@@ -4350,7 +4363,7 @@ void Gfx::doForm1(Object *str, Dict *resDict, double *matrix, double *bbox,
> 
>   // draw the form
>   display(str, gFalse);
>-  
>+
>   if (stateBefore != state) {
>     if (state->isParentState(stateBefore)) {
>       error(-1, "There's a form with more q than Q, trying to fix");
>@@ -4403,7 +4416,7 @@ void Gfx::opBeginImage(Object args[], int numArgs) {
>   // display the image
>   if (str) {
>     doImage(NULL, str, gTrue);
>-  
>+
>     // skip 'EI' tag
>     c1 = str->getUndecodedStream()->getChar();
>     c2 = str->getUndecodedStream()->getChar();
>@@ -4525,7 +4538,7 @@ GBool Gfx::contentIsHidden() {
> void Gfx::opBeginMarkedContent(Object args[], int numArgs) {
>   // push a new stack entry
>   pushMarkedContent();
>-  
>+
>   OCGs *contentConfig = catalog->getOptContentConfig();
>   char* name0 = args[0].getName();
>   if ( strncmp( name0, "OC", 2) == 0 && contentConfig) {
>diff --git a/poppler/SplashOutputDev.cc b/poppler/SplashOutputDev.cc
>index 666ee18..4fcda00 100644
>--- a/poppler/SplashOutputDev.cc
>+++ b/poppler/SplashOutputDev.cc
>@@ -80,6 +80,86 @@ extern "C" int unlink(char *filename);
> #endif
> 
> //------------------------------------------------------------------------
>+// SplashSolidColor
>+//------------------------------------------------------------------------
>+
>+SplashAxialPattern::SplashAxialPattern(SplashColorMode colorModeA, GfxState *stateA, GfxAxialShading *shadingA) {
>+	Matrix ctm;
>+	
>+	shading = shadingA;
>+	state = stateA;
>+	colorMode = colorModeA;
>+	state->getCTM (&ctm);
>+	ctm.invertTo (&ictm);
>+
>+	shading->getCoords(&x0, &y0, &x1, &y1);
>+	dx = x1 - x0;
>+	dy = y1 - y0;
>+    mul = 1 / (dx * dx + dy * dy);
>+	
>+	// get the function domain
>+	t0 = shading->getDomain0();
>+	t1 = shading->getDomain1();
>+}
>+
>+SplashAxialPattern::~SplashAxialPattern() {
>+}
>+
>+void SplashAxialPattern::getColor(int x, int y, SplashColorPtr c) {
>+	SplashColor color;
>+	GfxColor gfxColor;
>+	GfxGray gray;
>+	GfxRGB rgb;
>+#if SPLASH_CMYK
>+	GfxCMYK cmyk;
>+#endif
>+	double tt;
>+
>+	double xc, yc, xaxis;
>+	ictm.transform(x, y, &xc, &yc);
>+	xaxis = ((xc - x0) * dx + (yc - y0) * dy) * mul;
>+	if (xaxis < 0) { // && !shading->getExtend0()) {
>+		tt = t0;
>+	} else if (xaxis > 1) { // && !shading->getExtend1()) {
>+		tt = t1;
>+    } else if (xaxis >= 0 && xaxis <= 1) {
>+		tt = t0 + (t1 -t0) * xaxis;
>+	} else
>+		return;
>+	shading->getColor(tt, &gfxColor);
>+    state->setFillColor(&gfxColor);
>+	state->getFillGray(&gray);
>+	state->getFillRGB(&rgb);
>+#if SPLASH_CMYK
>+	state->getFillCMYK(&cmyk);
>+#endif
>+  switch (colorMode) {
>+  case splashModeMono1:
>+  case splashModeMono8:
>+    color[0] = colToByte(gray);
>+    break;
>+  case splashModeXBGR8:
>+    color[3] = 255;
>+  case splashModeRGB8:
>+  case splashModeBGR8:
>+    color[0] = colToByte(rgb.r);
>+    color[1] = colToByte(rgb.g);
>+    color[2] = colToByte(rgb.b);
>+    break;
>+#if SPLASH_CMYK
>+  case splashModeCMYK8:
>+    color[0] = colToByte(cmyk.c);
>+    color[1] = colToByte(cmyk.m);
>+    color[2] = colToByte(cmyk.y);
>+    color[3] = colToByte(cmyk.k);
>+    break;
>+#endif
>+  }
>+
>+	splashColorCopy(c, color);
>+}
>+
>+//------------------------------------------------------------------------
> 
> // Divide a 16-bit value (in [0, 255*255]) by 255, returning an 8-bit result.
> static inline Guchar div255(int x) {
>@@ -1225,15 +1305,6 @@ void SplashOutputDev::updateFont(GfxState * /*state*/) {
>   needFontUpdate = gTrue;
> }
> 
>-void SplashOutputDev::updateRender(GfxState *state) {
>-  int rm;
>-  rm = state->getRender();
>-  if (rm == 7 && haveCSPattern) {
>-    haveCSPattern = gFalse;
>-    restoreState(state);
>-  }
>-}
>-
> void SplashOutputDev::doUpdateFont(GfxState *state) {
>   GfxFont *gfxFont;
>   GfxFontType fontType;
>@@ -1621,7 +1692,7 @@ void SplashOutputDev::drawChar(GfxState *state, double x, double y,
> 
>   // fill
>   if (!(render & 1)) {
>-    if (!state->getFillColorSpace()->isNonMarking()) {
>+    if (!haveCSPattern && !state->getFillColorSpace()->isNonMarking()) {
>       splash->fillChar((SplashCoord)x, (SplashCoord)y, code, font);
>     }
>   }
>@@ -1638,7 +1709,7 @@ void SplashOutputDev::drawChar(GfxState *state, double x, double y,
>   }
> 
>   // clip
>-  if (render & 4) {
>+  if (haveCSPattern || (render & 4)) {
>     if ((path = font->getGlyphPath(code))) {
>       path->offset((SplashCoord)x, (SplashCoord)y);
>       if (textClipPath) {
>@@ -1927,17 +1998,14 @@ void SplashOutputDev::drawType3Glyph(T3FontCache *t3Font,
> }
> 
> void SplashOutputDev::beginTextObject(GfxState *state) {
>-  if (state->getFillColorSpace()->getMode() == csPattern) {
>+  if (!(state->getRender() & 4) && state->getFillColorSpace()->getMode() == csPattern) {
>     haveCSPattern = gTrue;
>     saveState(state);
>-    savedRender = state->getRender();
>-    state->setRender(7);
>   }
> }
> 
> void SplashOutputDev::endTextObject(GfxState *state) {
>   if (haveCSPattern) {
>-    state->setRender(savedRender);
>     haveCSPattern = gFalse;
>     if (state->getFillColorSpace()->getMode() != csPattern) {
>       if (textClipPath) {
>@@ -3198,3 +3266,529 @@ void SplashOutputDev::setFreeTypeHinting(GBool enable)
> {
>   enableFreeTypeHinting = enable;
> }
>+
>+/* implement shading routines */
>+GBool SplashOutputDev::axialShadedFill(GfxState *state, GfxAxialShading *shading, double tMin, double tMax) {
>+  double xMin, yMin, xMax, yMax;
>+  SplashPath *path;
>+
>+  // get the clip region bbox
>+  state->getUserClipBBox(&xMin, &yMin, &xMax, &yMax);
>+  
>+  // fill the region
>+  state->moveTo(xMin, yMin);
>+  state->lineTo(xMax, yMin);
>+  state->lineTo(xMax, yMax);
>+  state->lineTo(xMin, yMax);
>+  state->closePath();
>+  path = convertPath(state, state->getPath());
>+	  
>+  SplashPattern *pattern = new SplashAxialPattern(colorMode, state, shading);
>+  splash->shadedFill(path, gFalse, pattern);
>+  state->clearPath();
>+  delete path;
>+
>+  return gFalse;
>+
>+}
>+
>+// copied from Gfx.cc
>+// TODO: implement SplashFunctionPattern
>+
>+// Max recursive depth for a function shading fill.
>+#define functionMaxDepth 6
>+
>+// Max delta allowed in any color component for a function shading fill.
>+#define functionColorDelta (dblToCol(1 / 256.0))
>+
>+GBool SplashOutputDev::functionShadedFill(GfxState *state,
>+				     GfxFunctionShading *shading) {
>+  double x0, y0, x1, y1;
>+  GfxColor colors[4];
>+
>+  shading->getDomain(&x0, &y0, &x1, &y1);
>+  shading->getColor(x0, y0, &colors[0]);
>+  shading->getColor(x0, y1, &colors[1]);
>+  shading->getColor(x1, y0, &colors[2]);
>+  shading->getColor(x1, y1, &colors[3]);
>+  doFunctionShFill1(shading, state, x0, y0, x1, y1, colors, 0);
>+  return gTrue;
>+}
>+
>+void SplashOutputDev::doFunctionShFill1(GfxFunctionShading *shading,
>+				GfxState *state,
>+			    double x0, double y0,
>+			    double x1, double y1,
>+			    GfxColor *colors, int depth) {
>+  GfxColor fillColor;
>+  GfxColor color0M, color1M, colorM0, colorM1, colorMM;
>+  GfxColor colors2[4];
>+  double *matrix;
>+  double xM, yM;
>+  int nComps, i, j;
>+
>+  nComps = shading->getColorSpace()->getNComps();
>+  matrix = shading->getMatrix();
>+
>+  // compare the four corner colors
>+  for (i = 0; i < 4; ++i) {
>+    for (j = 0; j < nComps; ++j) {
>+      if (abs(colors[i].c[j] - colors[(i+1)&3].c[j]) > functionColorDelta) {
>+	break;
>+      }
>+    }
>+    if (j < nComps) {
>+      break;
>+    }
>+  }
>+
>+  // center of the rectangle
>+  xM = 0.5 * (x0 + x1);
>+  yM = 0.5 * (y0 + y1);
>+
>+  // the four corner colors are close (or we hit the recursive limit)
>+  // -- fill the rectangle; but require at least one subdivision
>+  // (depth==0) to avoid problems when the four outer corners of the
>+  // shaded region are the same color
>+  if ((i == 4 && depth > 0) || depth == functionMaxDepth) {
>+
>+    // use the center color
>+    shading->getColor(xM, yM, &fillColor);
>+    state->setFillColor(&fillColor);
>+    updateFillColor(state);
>+
>+    // fill the rectangle
>+    state->moveTo(x0 * matrix[0] + y0 * matrix[2] + matrix[4],
>+		  x0 * matrix[1] + y0 * matrix[3] + matrix[5]);
>+    state->lineTo(x1 * matrix[0] + y0 * matrix[2] + matrix[4],
>+		  x1 * matrix[1] + y0 * matrix[3] + matrix[5]);
>+    state->lineTo(x1 * matrix[0] + y1 * matrix[2] + matrix[4],
>+		  x1 * matrix[1] + y1 * matrix[3] + matrix[5]);
>+    state->lineTo(x0 * matrix[0] + y1 * matrix[2] + matrix[4],
>+		  x0 * matrix[1] + y1 * matrix[3] + matrix[5]);
>+    state->closePath();
>+	fill(state);
>+    state->clearPath();
>+
>+  // the four corner colors are not close enough -- subdivide the
>+  // rectangle
>+  } else {
>+
>+    // colors[0]       colorM0       colors[2]
>+    //   (x0,y0)       (xM,y0)       (x1,y0)
>+    //         +----------+----------+
>+    //         |          |          |
>+    //         |    UL    |    UR    |
>+    // color0M |       colorMM       | color1M
>+    // (x0,yM) +----------+----------+ (x1,yM)
>+    //         |       (xM,yM)       |
>+    //         |    LL    |    LR    |
>+    //         |          |          |
>+    //         +----------+----------+
>+    // colors[1]       colorM1       colors[3]
>+    //   (x0,y1)       (xM,y1)       (x1,y1)
>+
>+    shading->getColor(x0, yM, &color0M);
>+    shading->getColor(x1, yM, &color1M);
>+    shading->getColor(xM, y0, &colorM0);
>+    shading->getColor(xM, y1, &colorM1);
>+    shading->getColor(xM, yM, &colorMM);
>+
>+    // upper-left sub-rectangle
>+    colors2[0] = colors[0];
>+    colors2[1] = color0M;
>+    colors2[2] = colorM0;
>+    colors2[3] = colorMM;
>+    doFunctionShFill1(shading, state, x0, y0, xM, yM, colors2, depth + 1);
>+    
>+    // lower-left sub-rectangle
>+    colors2[0] = color0M;
>+    colors2[1] = colors[1];
>+    colors2[2] = colorMM;
>+    colors2[3] = colorM1;
>+    doFunctionShFill1(shading, state, x0, yM, xM, y1, colors2, depth + 1);
>+    
>+    // upper-right sub-rectangle
>+    colors2[0] = colorM0;
>+    colors2[1] = colorMM;
>+    colors2[2] = colors[2];
>+    colors2[3] = color1M;
>+    doFunctionShFill1(shading, state, xM, y0, x1, yM, colors2, depth + 1);
>+
>+    // lower-right sub-rectangle
>+    colors2[0] = colorMM;
>+    colors2[1] = colorM1;
>+    colors2[2] = color1M;
>+    colors2[3] = colors[3];
>+    doFunctionShFill1(shading, state, xM, yM, x1, y1, colors2, depth + 1);
>+  }
>+}
>+
>+// copied from Gfx.cc
>+// TODO: implement SplashRadialPattern
>+
>+// the MSVC math.h doesn't define this
>+#ifndef M_PI
>+#define M_PI 3.14159265358979323846
>+#endif
>+
>+// Max number of splits along the t axis for a radial shading fill.
>+#define radialMaxSplits 256
>+
>+// Max delta allowed in any color component for a radial shading fill.
>+#define radialColorDelta (dblToCol(1 / 256.0))
>+
>+static inline GBool isSameGfxColor(const GfxColor &colorA, const GfxColor &colorB, Guint nComps, double delta) {
>+  for (Guint k = 0; k < nComps; ++k) {
>+    if (abs(colorA.c[k] - colorB.c[k]) > delta) {
>+      return false;
>+    }
>+  }
>+  return true;
>+}
>+
>+GBool SplashOutputDev::radialShadedFill(GfxState *state, GfxRadialShading *shading, double /*sMin*/, double /*sMax*/) {
>+  double xMin, yMin, xMax, yMax;
>+  double x0, y0, r0, x1, y1, r1, t0, t1;
>+  int nComps;
>+  GfxColor colorA, colorB;
>+  double xa, ya, xb, yb, ra, rb;
>+  double ta, tb, sa, sb;
>+  double sz, xz, yz, sMin, sMax;
>+  GBool enclosed;
>+  int ia, ib, k, n;
>+  double *ctm;
>+  double theta, alpha, angle, t;
>+  GBool needExtend = gTrue;
>+
>+  // get the shading info
>+  shading->getCoords(&x0, &y0, &r0, &x1, &y1, &r1);
>+  t0 = shading->getDomain0();
>+  t1 = shading->getDomain1();
>+  nComps = shading->getColorSpace()->getNComps();
>+
>+  // Compute the point at which r(s) = 0; check for the enclosed
>+  // circles case; and compute the angles for the tangent lines.
>+  if (x0 == x1 && y0 == y1) {
>+    enclosed = gTrue;
>+    theta = 0; // make gcc happy
>+    sz = 0; // make gcc happy
>+  } else if (r0 == r1) {
>+    enclosed = gFalse;
>+    theta = 0;
>+    sz = 0; // make gcc happy
>+  } else {
>+    sz = -r0 / (r1 - r0);
>+    xz = x0 + sz * (x1 - x0);
>+    yz = y0 + sz * (y1 - y0);
>+    enclosed = (xz - x0) * (xz - x0) + (yz - y0) * (yz - y0) <= r0 * r0;
>+    theta = asin(r0 / sqrt((x0 - xz) * (x0 - xz) + (y0 - yz) * (y0 - yz)));
>+    if (r0 > r1) {
>+      theta = -theta;
>+    }
>+  }
>+  if (enclosed) {
>+    alpha = 0;
>+  } else {
>+    alpha = atan2(y1 - y0, x1 - x0);
>+  }
>+
>+  // compute the (possibly extended) s range
>+  state->getUserClipBBox(&xMin, &yMin, &xMax, &yMax);
>+  if (enclosed) {
>+    sMin = 0;
>+    sMax = 1;
>+  } else {
>+    sMin = 1;
>+    sMax = 0;
>+    // solve for x(s) + r(s) = xMin
>+    if ((x1 + r1) - (x0 + r0) != 0) {
>+      sa = (xMin - (x0 + r0)) / ((x1 + r1) - (x0 + r0));
>+      if (sa < sMin) {
>+	sMin = sa;
>+      } else if (sa > sMax) {
>+	sMax = sa;
>+      }
>+    }
>+    // solve for x(s) - r(s) = xMax
>+    if ((x1 - r1) - (x0 - r0) != 0) {
>+      sa = (xMax - (x0 - r0)) / ((x1 - r1) - (x0 - r0));
>+      if (sa < sMin) {
>+	sMin = sa;
>+      } else if (sa > sMax) {
>+	sMax = sa;
>+      }
>+    }
>+    // solve for y(s) + r(s) = yMin
>+    if ((y1 + r1) - (y0 + r0) != 0) {
>+      sa = (yMin - (y0 + r0)) / ((y1 + r1) - (y0 + r0));
>+      if (sa < sMin) {
>+	sMin = sa;
>+      } else if (sa > sMax) {
>+	sMax = sa;
>+      }
>+    }
>+    // solve for y(s) - r(s) = yMax
>+    if ((y1 - r1) - (y0 - r0) != 0) {
>+      sa = (yMax - (y0 - r0)) / ((y1 - r1) - (y0 - r0));
>+      if (sa < sMin) {
>+	sMin = sa;
>+      } else if (sa > sMax) {
>+	sMax = sa;
>+      }
>+    }
>+    // check against sz
>+    if (r0 < r1) {
>+      if (sMin < sz) {
>+	sMin = sz;
>+      }
>+    } else if (r0 > r1) {
>+      if (sMax > sz) {
>+	sMax = sz;
>+      }
>+    }
>+    // check the 'extend' flags
>+    if (!shading->getExtend0() && sMin < 0) {
>+      sMin = 0;
>+    }
>+    if (!shading->getExtend1() && sMax > 1) {
>+      sMax = 1;
>+    }
>+  }
>+
>+  // compute the number of steps into which circles must be divided to
>+  // achieve a curve flatness of 0.1 pixel in device space for the
>+  // largest circle (note that "device space" is 72 dpi when generating
>+  // PostScript, hence the relatively small 0.1 pixel accuracy)
>+  ctm = state->getCTM();
>+  t = fabs(ctm[0]);
>+  if (fabs(ctm[1]) > t) {
>+    t = fabs(ctm[1]);
>+  }
>+  if (fabs(ctm[2]) > t) {
>+    t = fabs(ctm[2]);
>+  }
>+  if (fabs(ctm[3]) > t) {
>+    t = fabs(ctm[3]);
>+  }
>+  if (r0 > r1) {
>+    t *= r0;
>+  } else {
>+    t *= r1;
>+  }
>+  if (t < 1) {
>+    n = 3;
>+  } else {
>+    n = (int)(M_PI / acos(1 - 0.1 / t));
>+    if (n < 3) {
>+      n = 3;
>+    } else if (n > 200) {
>+      n = 200;
>+    }
>+  }
>+
>+  // setup for the start circle
>+  ia = 0;
>+  sa = sMin;
>+  ta = t0 + sa * (t1 - t0);
>+  xa = x0 + sa * (x1 - x0);
>+  ya = y0 + sa * (y1 - y0);
>+  ra = r0 + sa * (r1 - r0);
>+  if (ta < t0) {
>+    shading->getColor(t0, &colorA);
>+  } else if (ta > t1) {
>+    shading->getColor(t1, &colorA);
>+  } else {
>+    shading->getColor(ta, &colorA);
>+  }
>+
>+  // fill the circles
>+  while (ia < radialMaxSplits) {
>+
>+    // go as far along the t axis (toward t1) as we can, such that the
>+    // color difference is within the tolerance (radialColorDelta) --
>+    // this uses bisection (between the current value, t, and t1),
>+    // limited to radialMaxSplits points along the t axis; require at
>+    // least one split to avoid problems when the innermost and
>+    // outermost colors are the same
>+    ib = radialMaxSplits;
>+    sb = sMax;
>+    tb = t0 + sb * (t1 - t0);
>+    if (tb < t0) {
>+      shading->getColor(t0, &colorB);
>+    } else if (tb > t1) {
>+      shading->getColor(t1, &colorB);
>+    } else {
>+      shading->getColor(tb, &colorB);
>+    }
>+    while (ib - ia > 1) {
>+      if (isSameGfxColor(colorB, colorA, nComps, radialColorDelta) && ib < radialMaxSplits) {
>+	// The shading is not necessarily lineal so having two points with the
>+	// same color does not mean all the areas in between have the same color too
>+	// Do another bisection to be a bit more sure we are not doing something wrong
>+	GfxColor colorC;
>+	int ic = (ia + ib) / 2;
>+	double sc = sMin + ((double)ic / (double)radialMaxSplits) * (sMax - sMin);
>+	double tc = t0 + sc * (t1 - t0);
>+	if (tc < t0) {
>+	  shading->getColor(t0, &colorC);
>+	} else if (tc > t1) {
>+	  shading->getColor(t1, &colorC);
>+	} else {
>+	  shading->getColor(tc, &colorC);
>+	}
>+	if (isSameGfxColor(colorC, colorA, nComps, radialColorDelta))
>+	  break;
>+      }
>+      ib = (ia + ib) / 2;
>+      sb = sMin + ((double)ib / (double)radialMaxSplits) * (sMax - sMin);
>+      tb = t0 + sb * (t1 - t0);
>+      if (tb < t0) {
>+	shading->getColor(t0, &colorB);
>+      } else if (tb > t1) {
>+	shading->getColor(t1, &colorB);
>+      } else {
>+	shading->getColor(tb, &colorB);
>+      }
>+    }
>+
>+    // compute center and radius of the circle
>+    xb = x0 + sb * (x1 - x0);
>+    yb = y0 + sb * (y1 - y0);
>+    rb = r0 + sb * (r1 - r0);
>+
>+    // use the average of the colors at the two circles
>+    for (k = 0; k < nComps; ++k) {
>+      colorA.c[k] = (colorA.c[k] + colorB.c[k]) / 2;
>+    }
>+    state->setFillColor(&colorA);
>+	updateFillColor(state);
>+
>+    if (needExtend) {
>+      if (enclosed) {
>+        // construct path for first circle (counterclockwise)
>+        state->moveTo(xa + ra, ya);
>+        for (k = 1; k < n; ++k) {
>+	  angle = ((double)k / (double)n) * 2 * M_PI;
>+	  state->lineTo(xa + ra * cos(angle), ya + ra * sin(angle));
>+        }
>+        state->closePath();
>+
>+        // construct and append path for second circle (clockwise)
>+        state->moveTo(xb + rb, yb);
>+        for (k = 1; k < n; ++k) {
>+	  angle = -((double)k / (double)n) * 2 * M_PI;
>+	  state->lineTo(xb + rb * cos(angle), yb + rb * sin(angle));
>+        }
>+        state->closePath();
>+      } else {
>+        // construct the first subpath (clockwise)
>+        state->moveTo(xa + ra * cos(alpha + theta + 0.5 * M_PI),
>+		      ya + ra * sin(alpha + theta + 0.5 * M_PI));
>+        for (k = 0; k < n; ++k) {
>+	  angle = alpha + theta + 0.5 * M_PI
>+		  - ((double)k / (double)n) * (2 * theta + M_PI);
>+	  state->lineTo(xb + rb * cos(angle), yb + rb * sin(angle));
>+        }
>+	for (k = 0; k < n; ++k) {
>+	  angle = alpha - theta - 0.5 * M_PI
>+		  + ((double)k / (double)n) * (2 * theta - M_PI);
>+	  state->lineTo(xa + ra * cos(angle), ya + ra * sin(angle));
>+	}
>+	state->closePath();
>+
>+        // construct the second subpath (counterclockwise)
>+	state->moveTo(xa + ra * cos(alpha + theta + 0.5 * M_PI),
>+		      ya + ra * sin(alpha + theta + 0.5 * M_PI));
>+	for (k = 0; k < n; ++k) {
>+	  angle = alpha + theta + 0.5 * M_PI
>+		  + ((double)k / (double)n) * (-2 * theta + M_PI);
>+	  state->lineTo(xb + rb * cos(angle), yb + rb * sin(angle));
>+	}
>+	for (k = 0; k < n; ++k) {
>+	  angle = alpha - theta - 0.5 * M_PI
>+		  + ((double)k / (double)n) * (2 * theta + M_PI);
>+	  state->lineTo(xa + ra * cos(angle), ya + ra * sin(angle));
>+	}
>+	state->closePath();
>+      }
>+    }
>+
>+	fill(state);
>+	state->clearPath();
>+
>+    // step to the next value of t
>+    ia = ib;
>+    sa = sb;
>+    ta = tb;
>+    xa = xb;
>+    ya = yb;
>+    ra = rb;
>+    colorA = colorB;
>+  }
>+
>+  if (!needExtend)
>+    return gTrue;
>+
>+  if (enclosed) {
>+    // extend the smaller circle
>+    if ((shading->getExtend0() && r0 <= r1) ||
>+	(shading->getExtend1() && r1 < r0)) {
>+      if (r0 <= r1) {
>+	ta = t0;
>+	ra = r0;
>+	xa = x0;
>+	ya = y0;
>+      } else {
>+	ta = t1;
>+	ra = r1;
>+	xa = x1;
>+	ya = y1;
>+      }
>+      shading->getColor(ta, &colorA);
>+      state->setFillColor(&colorA);
>+      updateFillColor(state);
>+      state->moveTo(xa + ra, ya);
>+      for (k = 1; k < n; ++k) {
>+	angle = ((double)k / (double)n) * 2 * M_PI;
>+	state->lineTo(xa + ra * cos(angle), ya + ra * sin(angle));
>+      }
>+      state->closePath();
>+      fill(state);
>+      state->clearPath();
>+    }
>+
>+    // extend the larger circle
>+    if ((shading->getExtend0() && r0 > r1) ||
>+	(shading->getExtend1() && r1 >= r0)) {
>+      if (r0 > r1) {
>+	ta = t0;
>+	ra = r0;
>+	xa = x0;
>+	ya = y0;
>+      } else {
>+	ta = t1;
>+	ra = r1;
>+	xa = x1;
>+	ya = y1;
>+      }
>+      shading->getColor(ta, &colorA);
>+      state->setFillColor(&colorA);
>+      updateFillColor(state);
>+      state->moveTo(xMin, yMin);
>+      state->lineTo(xMin, yMax);
>+      state->lineTo(xMax, yMax);
>+      state->lineTo(xMax, yMin);
>+      state->closePath();
>+      state->moveTo(xa + ra, ya);
>+      for (k = 1; k < n; ++k) {
>+	angle = ((double)k / (double)n) * 2 * M_PI;
>+	state->lineTo(xa + ra * cos(angle), ya + ra * sin(angle));
>+      }
>+      state->closePath();
>+      fill(state);
>+      state->clearPath();
>+    }
>+  }
>+  return gTrue;
>+}
>diff --git a/poppler/SplashOutputDev.h b/poppler/SplashOutputDev.h
>index 37b771a..b77170b 100644
>--- a/poppler/SplashOutputDev.h
>+++ b/poppler/SplashOutputDev.h
>@@ -31,6 +31,7 @@
> 
> #include "goo/gtypes.h"
> #include "splash/SplashTypes.h"
>+#include "splash/SplashPattern.h"
> #include "poppler-config.h"
> #include "OutputDev.h"
> #include "GfxState.h"
>@@ -39,7 +40,6 @@ class Gfx8BitFont;
> class SplashBitmap;
> class Splash;
> class SplashPath;
>-class SplashPattern;
> class SplashFontEngine;
> class SplashFont;
> class T3FontCache;
>@@ -53,6 +53,35 @@ struct SplashTransparencyGroup;
> #define splashOutT3FontCacheSize 8
> 
> //------------------------------------------------------------------------
>+// SplashShadingColor
>+//------------------------------------------------------------------------
>+
>+class SplashAxialPattern: public SplashPattern {
>+public:
>+
>+  SplashAxialPattern(SplashColorMode colorMode, GfxState *state, GfxAxialShading *shading);
>+
>+  virtual SplashPattern *copy() { return new SplashAxialPattern(colorMode, state, shading); }
>+
>+  virtual ~SplashAxialPattern();
>+
>+  virtual void getColor(int x, int y, SplashColorPtr c);
>+
>+  virtual GBool isStatic() { return gFalse; }
>+
>+private:
>+
>+  Matrix ictm;
>+  double x0, y0, x1, y1;
>+  double dx, dy, mul;
>+  double t0, t1;
>+  GfxAxialShading *shading;
>+  GfxState *state;
>+  SplashColorMode colorMode;
>+  double *bbox;
>+};
>+
>+//------------------------------------------------------------------------
> // SplashOutputDev
> //------------------------------------------------------------------------
> 
>@@ -70,6 +99,11 @@ public:
> 
>   //----- get info about output device
> 
>+  // Does this device use functionShadedFill(), axialShadedFill(), and
>+  // radialShadedFill()?  If this returns false, these shaded fills
>+  // will be reduced to a series of other drawing operations.
>+  virtual GBool useShadedFills() { return gTrue; }
>+
>   // Does this device use upside-down coordinates?
>   // (Upside-down means (0,0) is the top left corner of the page.)
>   virtual GBool upsideDown() { return gTrue; }
>@@ -116,12 +150,19 @@ public:
> 
>   //----- update text state
>   virtual void updateFont(GfxState *state);
>-  virtual void updateRender(GfxState *state);
> 
>   //----- path painting
>   virtual void stroke(GfxState *state);
>   virtual void fill(GfxState *state);
>   virtual void eoFill(GfxState *state);
>+  virtual GBool axialShadedFill(GfxState *state, GfxAxialShading *shading, double tMin, double tMax);
>+  virtual GBool functionShadedFill(GfxState *state,
>+				   GfxFunctionShading *shading);
>+  virtual GBool radialShadedFill(GfxState *state, GfxRadialShading *shading, double /*sMin*/, double /*sMax*/);
>+  virtual void doFunctionShFill1(GfxFunctionShading *shading, GfxState *state,
>+			 double x0, double y0,
>+			 double x1, double y1,
>+			 GfxColor *colors, int depth);
> 
>   //----- path clipping
>   virtual void clip(GfxState *state);
>@@ -246,8 +287,7 @@ private:
> 			      Guchar *alphaLine);
> 
>   GBool haveCSPattern;		// set if text has been drawn with a
>-				//   clipping render mode because of pattern colorspace
>-  int savedRender;		// use if pattern colorspace
>+							//   clipping render mode because of pattern colorspace
>   GBool keepAlphaChannel;	// don't fill with paper color, keep alpha channel
> 
>   SplashColorMode colorMode;
>diff --git a/splash/Splash.cc b/splash/Splash.cc
>index 5e27d42..f117477 100644
>--- a/splash/Splash.cc
>+++ b/splash/Splash.cc
>@@ -3592,3 +3592,59 @@ void Splash::dumpXPath(SplashXPath *path) {
> 	   (path->segs[i].flags	& splashXPathFlip) ? "P" : " ");
>   }
> }
>+
>+SplashError Splash::shadedFill(SplashPath *path, GBool eo,
>+									SplashPattern *pattern) {
>+  SplashPipe pipe;
>+  SplashXPath *xPath;
>+  SplashXPathScanner *scanner;
>+  int xMinI, yMinI, xMaxI, yMaxI, x0, x1, y;
>+  SplashClipResult clipRes;
>+
>+  if (path->length == 0) {
>+    return splashErrEmptyPath;
>+  }
>+  xPath = new SplashXPath(path, state->matrix, state->flatness, gTrue);
>+  xPath->aaScale();
>+  xPath->sort();
>+  scanner = new SplashXPathScanner(xPath, eo);
>+
>+  // get the min and max x and y values
>+  scanner->getBBoxAA(&xMinI, &yMinI, &xMaxI, &yMaxI);
>+
>+  // check clipping
>+  if ((clipRes = state->clip->testRect(xMinI, yMinI, xMaxI, yMaxI))
>+      != splashClipAllOutside) {
>+
>+    // limit the y range
>+    if (yMinI < state->clip->getYMinI()) {
>+      yMinI = state->clip->getYMinI();
>+    }
>+    if (yMaxI > state->clip->getYMaxI()) {
>+      yMaxI = state->clip->getYMaxI();
>+    }
>+
>+	pipeInit(&pipe, 0, yMinI, pattern, NULL, state->fillAlpha, vectorAntialias, gFalse);
>+    drawAAPixelInit();
>+
>+    // draw the spans
>+	for (y = yMinI; y <= yMaxI; ++y) {
>+		scanner->renderAALine(aaBuf, &x0, &x1, y);
>+		if (clipRes != splashClipAllInside) {
>+			state->clip->clipAALine(aaBuf, &x0, &x1, y);
>+		}
>+		drawAALine(&pipe, x0, x1, y);
>+/*
>+		for (x = x0; x <= x1; ++x) {
>+			pipeSetXY(&pipe, x, y);			
>+			drawAAPixel(&pipe, x, y);
>+		}
>+*/
>+	}
>+  }
>+  opClipRes = clipRes;
>+
>+  delete scanner;
>+  delete xPath;
>+  return splashOk;
>+}
>diff --git a/splash/Splash.h b/splash/Splash.h
>index c9d57cc..3dd93e1 100644
>--- a/splash/Splash.h
>+++ b/splash/Splash.h
>@@ -248,6 +248,8 @@ public:
>   GBool getVectorAntialias() { return vectorAntialias; }
>   void setVectorAntialias(GBool vaa) { vectorAntialias = vaa; }
> #endif
>+  SplashError shadedFill(SplashPath *path, GBool eo,
>+				    SplashPattern *pattern);
> 
> private:
> 
>@@ -301,6 +303,7 @@ private:
>   SplashClipResult opClipRes;
>   GBool vectorAntialias;
>   GBool debugMode;
>+
> };
> 
> #endif

Actions: View | Splinter Review

Attachments on bug 2807: 2496 | 2730 | 36253 | 36512 | 36513 | 36528 | 36989 | 37347 | 37416 | 37504 | 38596 | 38797 | 38879 | 38894

Use of freedesktop.org services, including Bugzilla, is subject to our Code of Conduct. How we collect and use information is described in our Privacy Policy.