+
+ /* fix "dotted" lines */
+ int t;
+ char linepending=0;
+ for(t=0;vec[t].code!=ART_END;t++) {
+ if(t>0 && vec[t-1].code==ART_MOVETO && vec[t].code==ART_LINETO
+ && vec[t+1].code!=ART_LINETO
+ && vec[t-1].x == vec[t].x
+ && vec[t-1].y == vec[t].y) {
+ vec[t].x += 0.01;
+ }
+ if(vec[t].code==ART_MOVETO)
+ linepending=0;
+ x = vec[t].x;
+ y = vec[t].y;
+ }
+
+ // Spot adjacent identical points
+ t = 1;
+ while(t < pos)
+ {
+ if ((vec[t-1].x == vec[t].x) && (vec[t-1].y == vec[t].y)) {
+ // adjacent identical points; remove one
+ memcpy(&(vec[t]), &(vec[t + 1]), sizeof(vec[t]) * (pos - t));
+ pos--;
+ } else {
+ t++;
+ }
+ }
+
+ /* adjacency remover disabled for now, pending code inspection */
+ return vec;
+
+ // Check for further non-adjacent identical points. We don't want any
+ // points other than the first and last points to exactly match.
+ //
+ // If we do find matching points, move the second point slightly. This
+ // currently moves the duplicate 2% towards the midpoint of its neighbours
+ // (easier to calculate than 2% down the perpendicular to the line joining
+ // the neighbours) but limiting the change to 0.1 twips to avoid visual
+ // problems when the shapes are large. Note that there is no minimum
+ // change: if the neighbouring points are colinear and equally spaced,
+ // e.g. they were generated as part of a straight spline, then the
+ // duplicate point may not actually move.
+ //
+ // The scan for duplicates algorithm is quadratic in the number of points:
+ // there's probably a better method but the numbers of points is generally
+ // small so this will do for now.
+ {
+ int i = 1, j;
+ for(; i < (pos - 1); ++i)
+ {
+ for (j = 0; j < i; ++j)
+ {
+ if ((vec[i].x == vec[j].x)
+ && (vec[i].y == vec[j].y))
+ {
+ // points match; shuffle point
+ double dx = (vec[i-1].x + vec[i+1].x - (vec[i].x * 2.0)) / 100.0;
+ double dy = (vec[i-1].y + vec[i+1].y - (vec[i].y * 2.0)) / 100.0;
+ double dxxyy = (dx*dx) + (dy*dy);
+ if (dxxyy > 0.01)
+ {
+ // This is more than 0.1 twip's distance; scale down
+ double dscale = sqrt(dxxyy) * 10.0;
+ dx /= dscale;
+ dy /= dscale;
+ };
+ vec[i].x += dx;
+ vec[i].y += dy;
+ break;
+ }
+ }
+ }
+ }