summaryrefslogtreecommitdiff
path: root/Build/source/libs/poppler/poppler-0.28.0/splash/SplashXPath.cc
diff options
context:
space:
mode:
authorPeter Breitenlohner <peb@mppmu.mpg.de>2014-12-05 09:04:57 +0000
committerPeter Breitenlohner <peb@mppmu.mpg.de>2014-12-05 09:04:57 +0000
commitcf7e21cca95784d0744759e2a05f2700fe45778d (patch)
tree17ba2512f5bad060985a878aea765b3f464d62c1 /Build/source/libs/poppler/poppler-0.28.0/splash/SplashXPath.cc
parentcf4b7e8c43521a9301aaf1cd3f745eef8c0399d6 (diff)
poppler 0.29.0
git-svn-id: svn://tug.org/texlive/trunk@35749 c570f23f-e606-0410-a88d-b1316a301751
Diffstat (limited to 'Build/source/libs/poppler/poppler-0.28.0/splash/SplashXPath.cc')
-rw-r--r--Build/source/libs/poppler/poppler-0.28.0/splash/SplashXPath.cc472
1 files changed, 0 insertions, 472 deletions
diff --git a/Build/source/libs/poppler/poppler-0.28.0/splash/SplashXPath.cc b/Build/source/libs/poppler/poppler-0.28.0/splash/SplashXPath.cc
deleted file mode 100644
index 27106ee3d14..00000000000
--- a/Build/source/libs/poppler/poppler-0.28.0/splash/SplashXPath.cc
+++ /dev/null
@@ -1,472 +0,0 @@
-//========================================================================
-//
-// SplashXPath.cc
-//
-//========================================================================
-
-//========================================================================
-//
-// Modified under the Poppler project - http://poppler.freedesktop.org
-//
-// All changes made under the Poppler project to this file are licensed
-// under GPL version 2 or later
-//
-// Copyright (C) 2010 Paweł Wiejacha <pawel.wiejacha@gmail.com>
-// Copyright (C) 2010, 2011 Albert Astals Cid <aacid@kde.org>
-// Copyright (C) 2013 Thomas Freitag <Thomas.Freitag@alfa.de>
-//
-// To see a description of the changes please see the Changelog file that
-// came with your tarball or type make ChangeLog if you are building from git
-//
-//========================================================================
-
-#include <config.h>
-
-#ifdef USE_GCC_PRAGMAS
-#pragma implementation
-#endif
-
-#include <stdlib.h>
-#include <string.h>
-#include <algorithm>
-#include "goo/gmem.h"
-#include "SplashMath.h"
-#include "SplashPath.h"
-#include "SplashXPath.h"
-
-//------------------------------------------------------------------------
-
-struct SplashXPathPoint {
- SplashCoord x, y;
-};
-
-struct SplashXPathAdjust {
- int firstPt, lastPt; // range of points
- GBool vert; // vertical or horizontal hint
- SplashCoord x0a, x0b, // hint boundaries
- xma, xmb,
- x1a, x1b;
- SplashCoord x0, x1, xm; // adjusted coordinates
-};
-
-//------------------------------------------------------------------------
-
-// Transform a point from user space to device space.
-inline void SplashXPath::transform(SplashCoord *matrix,
- SplashCoord xi, SplashCoord yi,
- SplashCoord *xo, SplashCoord *yo) {
- // [ m[0] m[1] 0 ]
- // [xo yo 1] = [xi yi 1] * [ m[2] m[3] 0 ]
- // [ m[4] m[5] 1 ]
- *xo = xi * matrix[0] + yi * matrix[2] + matrix[4];
- *yo = xi * matrix[1] + yi * matrix[3] + matrix[5];
-}
-
-//------------------------------------------------------------------------
-// SplashXPath
-//------------------------------------------------------------------------
-
-SplashXPath::SplashXPath(SplashPath *path, SplashCoord *matrix,
- SplashCoord flatness, GBool closeSubpaths,
- GBool adjustLines, int linePosI) {
- SplashPathHint *hint;
- SplashXPathPoint *pts;
- SplashXPathAdjust *adjusts, *adjust;
- SplashCoord x0, y0, x1, y1, x2, y2, x3, y3, xsp, ysp;
- SplashCoord adj0, adj1;
- int curSubpath, i, j;
-
- // transform the points
- pts = (SplashXPathPoint *)gmallocn(path->length, sizeof(SplashXPathPoint));
- for (i = 0; i < path->length; ++i) {
- transform(matrix, path->pts[i].x, path->pts[i].y, &pts[i].x, &pts[i].y);
- }
-
- // set up the stroke adjustment hints
- if (path->hints) {
- adjusts = (SplashXPathAdjust *)gmallocn(path->hintsLength,
- sizeof(SplashXPathAdjust));
- for (i = 0; i < path->hintsLength; ++i) {
- hint = &path->hints[i];
- if (hint->ctrl0 + 1 >= path->length || hint->ctrl1 + 1 >= path->length) {
- gfree(adjusts);
- adjusts = NULL;
- break;
- }
- x0 = pts[hint->ctrl0 ].x; y0 = pts[hint->ctrl0 ].y;
- x1 = pts[hint->ctrl0 + 1].x; y1 = pts[hint->ctrl0 + 1].y;
- x2 = pts[hint->ctrl1 ].x; y2 = pts[hint->ctrl1 ].y;
- x3 = pts[hint->ctrl1 + 1].x; y3 = pts[hint->ctrl1 + 1].y;
- if (x0 == x1 && x2 == x3) {
- adjusts[i].vert = gTrue;
- adj0 = x0;
- adj1 = x2;
- } else if (y0 == y1 && y2 == y3) {
- adjusts[i].vert = gFalse;
- adj0 = y0;
- adj1 = y2;
- } else {
- gfree(adjusts);
- adjusts = NULL;
- break;
- }
- if (adj0 > adj1) {
- x0 = adj0;
- adj0 = adj1;
- adj1 = x0;
- }
- adjusts[i].x0a = adj0 - 0.01;
- adjusts[i].x0b = adj0 + 0.01;
- adjusts[i].xma = (SplashCoord)0.5 * (adj0 + adj1) - 0.01;
- adjusts[i].xmb = (SplashCoord)0.5 * (adj0 + adj1) + 0.01;
- adjusts[i].x1a = adj1 - 0.01;
- adjusts[i].x1b = adj1 + 0.01;
- // rounding both edge coordinates can result in lines of
- // different widths (e.g., adj=10.1, adj1=11.3 --> x0=10, x1=11;
- // adj0=10.4, adj1=11.6 --> x0=10, x1=12), but it has the
- // benefit of making adjacent strokes/fills line up without any
- // gaps between them
- x0 = splashRound(adj0);
- x1 = splashRound(adj1);
- if (x1 == x0) {
- if (adjustLines) {
- // the adjustment moves thin lines (clip rectangle with
- // empty width or height) out of clip area, here we need
- // a special adjustment:
- x0 = linePosI;
- x1 = x0 + 1;
- } else {
- x1 = x1 + 1;
- }
- }
- adjusts[i].x0 = (SplashCoord)x0;
- adjusts[i].x1 = (SplashCoord)x1 - 0.01;
- adjusts[i].xm = (SplashCoord)0.5 * (adjusts[i].x0 + adjusts[i].x1);
- adjusts[i].firstPt = hint->firstPt;
- adjusts[i].lastPt = hint->lastPt;
- }
-
- } else {
- adjusts = NULL;
- }
-
- // perform stroke adjustment
- if (adjusts) {
- for (i = 0, adjust = adjusts; i < path->hintsLength; ++i, ++adjust) {
- for (j = adjust->firstPt; j <= adjust->lastPt; ++j) {
- strokeAdjust(adjust, &pts[j].x, &pts[j].y);
- }
- }
- gfree(adjusts);
- }
-
- segs = NULL;
- length = size = 0;
-
- x0 = y0 = xsp = ysp = 0; // make gcc happy
- adj0 = adj1 = 0; // make gcc happy
- curSubpath = 0;
- i = 0;
- while (i < path->length) {
-
- // first point in subpath - skip it
- if (path->flags[i] & splashPathFirst) {
- x0 = pts[i].x;
- y0 = pts[i].y;
- xsp = x0;
- ysp = y0;
- curSubpath = i;
- ++i;
-
- } else {
-
- // curve segment
- if (path->flags[i] & splashPathCurve) {
- x1 = pts[i].x;
- y1 = pts[i].y;
- x2 = pts[i+1].x;
- y2 = pts[i+1].y;
- x3 = pts[i+2].x;
- y3 = pts[i+2].y;
- addCurve(x0, y0, x1, y1, x2, y2, x3, y3,
- flatness,
- (path->flags[i-1] & splashPathFirst),
- (path->flags[i+2] & splashPathLast),
- !closeSubpaths &&
- (path->flags[i-1] & splashPathFirst) &&
- !(path->flags[i-1] & splashPathClosed),
- !closeSubpaths &&
- (path->flags[i+2] & splashPathLast) &&
- !(path->flags[i+2] & splashPathClosed));
- x0 = x3;
- y0 = y3;
- i += 3;
-
- // line segment
- } else {
- x1 = pts[i].x;
- y1 = pts[i].y;
- addSegment(x0, y0, x1, y1);
- x0 = x1;
- y0 = y1;
- ++i;
- }
-
- // close a subpath
- if (closeSubpaths &&
- (path->flags[i-1] & splashPathLast) &&
- (pts[i-1].x != pts[curSubpath].x ||
- pts[i-1].y != pts[curSubpath].y)) {
- addSegment(x0, y0, xsp, ysp);
- }
- }
- }
-
- gfree(pts);
-}
-
-// Apply the stroke adjust hints to point <pt>: (*<xp>, *<yp>).
-void SplashXPath::strokeAdjust(SplashXPathAdjust *adjust,
- SplashCoord *xp, SplashCoord *yp) {
- SplashCoord x, y;
-
- if (adjust->vert) {
- x = *xp;
- if (x > adjust->x0a && x < adjust->x0b) {
- *xp = adjust->x0;
- } else if (x > adjust->xma && x < adjust->xmb) {
- *xp = adjust->xm;
- } else if (x > adjust->x1a && x < adjust->x1b) {
- *xp = adjust->x1;
- }
- } else {
- y = *yp;
- if (y > adjust->x0a && y < adjust->x0b) {
- *yp = adjust->x0;
- } else if (y > adjust->xma && y < adjust->xmb) {
- *yp = adjust->xm;
- } else if (y > adjust->x1a && y < adjust->x1b) {
- *yp = adjust->x1;
- }
- }
-}
-
-SplashXPath::SplashXPath(SplashXPath *xPath) {
- length = xPath->length;
- size = xPath->size;
- segs = (SplashXPathSeg *)gmallocn(size, sizeof(SplashXPathSeg));
- memcpy(segs, xPath->segs, length * sizeof(SplashXPathSeg));
-}
-
-SplashXPath::~SplashXPath() {
- gfree(segs);
-}
-
-// Add space for <nSegs> more segments
-void SplashXPath::grow(int nSegs) {
- if (length + nSegs > size) {
- if (size == 0) {
- size = 32;
- }
- while (size < length + nSegs) {
- size *= 2;
- }
- segs = (SplashXPathSeg *)greallocn(segs, size, sizeof(SplashXPathSeg));
- }
-}
-
-void SplashXPath::addCurve(SplashCoord x0, SplashCoord y0,
- SplashCoord x1, SplashCoord y1,
- SplashCoord x2, SplashCoord y2,
- SplashCoord x3, SplashCoord y3,
- SplashCoord flatness,
- GBool first, GBool last, GBool end0, GBool end1) {
- SplashCoord *cx = new SplashCoord[(splashMaxCurveSplits + 1) * 3];
- SplashCoord *cy = new SplashCoord[(splashMaxCurveSplits + 1) * 3];
- int *cNext = new int[splashMaxCurveSplits + 1];
- SplashCoord xl0, xl1, xl2, xr0, xr1, xr2, xr3, xx1, xx2, xh;
- SplashCoord yl0, yl1, yl2, yr0, yr1, yr2, yr3, yy1, yy2, yh;
- SplashCoord dx, dy, mx, my, d1, d2, flatness2;
- int p1, p2, p3;
-
-#if USE_FIXEDPOINT
- flatness2 = flatness;
-#else
- flatness2 = flatness * flatness;
-#endif
-
- // initial segment
- p1 = 0;
- p2 = splashMaxCurveSplits;
-
- *(cx + p1 * 3 + 0) = x0;
- *(cx + p1 * 3 + 1) = x1;
- *(cx + p1 * 3 + 2) = x2;
- *(cx + p2 * 3 + 0) = x3;
-
- *(cy + p1 * 3 + 0) = y0;
- *(cy + p1 * 3 + 1) = y1;
- *(cy + p1 * 3 + 2) = y2;
- *(cy + p2 * 3 + 0) = y3;
-
- *(cNext + p1) = p2;
-
- while (p1 < splashMaxCurveSplits) {
-
- // get the next segment
- xl0 = *(cx + p1 * 3 + 0);
- xx1 = *(cx + p1 * 3 + 1);
- xx2 = *(cx + p1 * 3 + 2);
-
- yl0 = *(cy + p1 * 3 + 0);
- yy1 = *(cy + p1 * 3 + 1);
- yy2 = *(cy + p1 * 3 + 2);
-
- p2 = *(cNext + p1);
-
- xr3 = *(cx + p2 * 3 + 0);
- yr3 = *(cy + p2 * 3 + 0);
-
- // compute the distances from the control points to the
- // midpoint of the straight line (this is a bit of a hack, but
- // it's much faster than computing the actual distances to the
- // line)
- mx = (xl0 + xr3) * 0.5;
- my = (yl0 + yr3) * 0.5;
-#if USE_FIXEDPOINT
- d1 = splashDist(xx1, yy1, mx, my);
- d2 = splashDist(xx2, yy2, mx, my);
-#else
- dx = xx1 - mx;
- dy = yy1 - my;
- d1 = dx*dx + dy*dy;
- dx = xx2 - mx;
- dy = yy2 - my;
- d2 = dx*dx + dy*dy;
-#endif
-
- // if the curve is flat enough, or no more subdivisions are
- // allowed, add the straight line segment
- if (p2 - p1 == 1 || (d1 <= flatness2 && d2 <= flatness2)) {
- addSegment(xl0, yl0, xr3, yr3);
- p1 = p2;
-
- // otherwise, subdivide the curve
- } else {
- xl1 = (xl0 + xx1) * 0.5;
- yl1 = (yl0 + yy1) * 0.5;
- xh = (xx1 + xx2) * 0.5;
- yh = (yy1 + yy2) * 0.5;
- xl2 = (xl1 + xh) * 0.5;
- yl2 = (yl1 + yh) * 0.5;
- xr2 = (xx2 + xr3) * 0.5;
- yr2 = (yy2 + yr3) * 0.5;
- xr1 = (xh + xr2) * 0.5;
- yr1 = (yh + yr2) * 0.5;
- xr0 = (xl2 + xr1) * 0.5;
- yr0 = (yl2 + yr1) * 0.5;
- // add the new subdivision points
- p3 = (p1 + p2) / 2;
-
- *(cx + p1 * 3 + 1) = xl1;
- *(cx + p1 * 3 + 2) = xl2;
-
- *(cy + p1 * 3 + 1) = yl1;
- *(cy + p1 * 3 + 2) = yl2;
-
- *(cNext + p1) = p3;
-
- *(cx + p3 * 3 + 0) = xr0;
- *(cx + p3 * 3 + 1) = xr1;
- *(cx + p3 * 3 + 2) = xr2;
-
- *(cy + p3 * 3 + 0) = yr0;
- *(cy + p3 * 3 + 1) = yr1;
- *(cy + p3 * 3 + 2) = yr2;
-
- *(cNext + p3) = p2;
- }
- }
-
- delete [] cx;
- delete [] cy;
- delete [] cNext;
-}
-
-void SplashXPath::addSegment(SplashCoord x0, SplashCoord y0,
- SplashCoord x1, SplashCoord y1) {
- grow(1);
- segs[length].x0 = x0;
- segs[length].y0 = y0;
- segs[length].x1 = x1;
- segs[length].y1 = y1;
- segs[length].flags = 0;
- if (y1 == y0) {
- segs[length].dxdy = segs[length].dydx = 0;
- segs[length].flags |= splashXPathHoriz;
- if (x1 == x0) {
- segs[length].flags |= splashXPathVert;
- }
- } else if (x1 == x0) {
- segs[length].dxdy = segs[length].dydx = 0;
- segs[length].flags |= splashXPathVert;
- } else {
-#if USE_FIXEDPOINT
- if (FixedPoint::divCheck(x1 - x0, y1 - y0, &segs[length].dxdy)) {
- segs[length].dydx = (SplashCoord)1 / segs[length].dxdy;
- } else {
- segs[length].dxdy = segs[length].dydx = 0;
- if (splashAbs(x1 - x0) > splashAbs(y1 - y0)) {
- segs[length].flags |= splashXPathHoriz;
- } else {
- segs[length].flags |= splashXPathVert;
- }
- }
-#else
- segs[length].dxdy = (x1 - x0) / (y1 - y0);
- segs[length].dydx = (SplashCoord)1 / segs[length].dxdy;
-#endif
- }
- if (y0 > y1) {
- segs[length].flags |= splashXPathFlip;
- }
- ++length;
-}
-
-struct cmpXPathSegsFunctor {
- bool operator()(const SplashXPathSeg &seg0, const SplashXPathSeg &seg1) {
- SplashCoord x0, y0, x1, y1;
-
- if (seg0.flags & splashXPathFlip) {
- x0 = seg0.x1;
- y0 = seg0.y1;
- } else {
- x0 = seg0.x0;
- y0 = seg0.y0;
- }
- if (seg1.flags & splashXPathFlip) {
- x1 = seg1.x1;
- y1 = seg1.y1;
- } else {
- x1 = seg1.x0;
- y1 = seg1.y0;
- }
- return (y0 != y1) ? (y0 < y1) : (x0 < x1);
- }
-};
-
-void SplashXPath::aaScale() {
- SplashXPathSeg *seg;
- int i;
-
- for (i = 0, seg = segs; i < length; ++i, ++seg) {
- seg->x0 *= splashAASize;
- seg->y0 *= splashAASize;
- seg->x1 *= splashAASize;
- seg->y1 *= splashAASize;
- }
-}
-
-void SplashXPath::sort() {
- std::sort(segs, segs + length, cmpXPathSegsFunctor());
-}