Пример #1
0
        /* ---------------------------------------------------------------------- */
        /* Stage 4: smoothing and corner analysis (Sec. 2.3.3) */
        static void reverse(Path path)
        {
            privcurve curve = path.curve;
            int       m     = curve.n;

            dPoint[] v = curve.vertex;
            int      i, j;
            dPoint   tmp;

            for (i = 0, j = m - 1; i < j; i++, j--)
            {
                tmp  = v[i];
                v[i] = v[j];
                v[j] = tmp;
            }
        }
Пример #2
0
        /* ---------------------------------------------------------------------- */
        /* Stage 5: Curve optimization (Sec. 2.4) */

        /* calculate best fit from i+.5 to j+.5.  Assume i<j (cyclically).
         *              Return 0 and set badness and parameters (alpha, beta), if
         *              possible. Return 1 if impossible. */
        static int opti_penalty(Path path, int i, int j, Opti res, double opttolerance,
                                int[] convc, double[] areac)
        {
            int       m     = path.curve.n;
            privcurve curve = path.curve;

            dPoint[] vertex = curve.vertex;
            int      k, k1, k2, conv, i1;
            double   area, alpha, d, d1, d2;
            dPoint   p0, p1, p2, p3, pt;
            double   A, R, A1, A2, A3, A4,
                     s, t;

            /* check convexity, corner-freeness, and maximum bend < 179 degrees */
            if (i == j)
            {             /* sanity - a full loop can never be an opticurve */
                return(1);
            }

            k    = i;
            i1   = mod(i + 1, m);
            k1   = mod(k + 1, m);
            conv = convc[k1];
            if (conv == 0)
            {
                return(1);
            }
            d = ddist(vertex[i], vertex[i1]);
            for (k = k1; k != j; k = k1)
            {
                k1 = mod(k + 1, m);
                k2 = mod(k + 2, m);
                if (convc[k1] != conv)
                {
                    return(1);
                }
                if (sign(cprod(vertex[i], vertex[i1], vertex[k1], vertex[k2])) !=
                    conv)
                {
                    return(1);
                }
                if (iprod1(vertex[i], vertex[i1], vertex[k1], vertex[k2]) <
                    d * ddist(vertex[k1], vertex[k2]) * -0.999847695156)
                {
                    return(1);
                }
            }
            /* the curve we're working in: */
            p0 = curve.c[mod(i, m) * 3 + 2].copy();
            p1 = vertex[mod(i + 1, m)].copy();
            p2 = vertex[mod(j, m)].copy();
            p3 = curve.c[mod(j, m) * 3 + 2].copy();
            /* determine its area */
            area  = areac[j] - areac[i];
            area -= dpara(vertex[0], curve.c[i * 3 + 2], curve.c[j * 3 + 2]) / 2;
            if (i >= j)
            {
                area += areac[m];
            }

            /* find intersection o of p0p1 and p2p3. Let t,s such that o =
             *               interval(t,p0,p1) = interval(s,p3,p2). Let A be the area of the
             *               triangle (p0,o,p3). */
            A1 = dpara(p0, p1, p2);
            A2 = dpara(p0, p1, p3);
            A3 = dpara(p0, p2, p3);

            A4 = A1 + A3 - A2;

            if (A2 == A1)
            {            /* this should never happen */
                return(1);
            }

            t = A3 / (A3 - A4);
            s = A2 / (A2 - A1);
            A = A2 * t / 2.0;

            if (A == 0.0)
            {
                /* this should never happen */
                return(1);
            }

            R     = area / A;                   /* relative area */
            alpha = 2 - Math.Sqrt(4 - R / 0.3); /* overall alpha for p0-o-p3 curve */

            res.c[0]  = interval(t * alpha, p0, p1);
            res.c[1]  = interval(s * alpha, p3, p2);
            res.alpha = alpha;
            res.t     = t;
            res.s     = s;

            p1 = res.c[0].copy();
            p2 = res.c[1].copy();             /* the proposed curve is now (p0,p1,p2,p3) */

            res.pen = 0;
            /* calculate penalty */
            /* check tangency with edges */
            for (k = mod(i + 1, m); k != j; k = k1)
            {
                k1 = mod(k + 1, m);
                t  = tangent(p0, p1, p2, p3, vertex[k], vertex[k1]);
                if (t < -0.5)
                {
                    return(1);
                }
                pt = bezier(t, p0, p1, p2, p3);
                d  = ddist(vertex[k], vertex[k1]);
                if (d == 0.0)
                {
                    /* this should never happen */
                    return(1);
                }
                d1 = dpara(vertex[k], vertex[k1], pt) / d;
                if (Math.Abs(d1) > opttolerance)
                {
                    return(1);
                }
                if (iprod(vertex[k], vertex[k1], pt) < 0 ||
                    iprod(vertex[k1], vertex[k], pt) < 0)
                {
                    return(1);
                }
                res.pen += d1 * d1;
            }
            /* check corners */
            for (k = i; k != j; k = k1)
            {
                k1 = mod(k + 1, m);
                t  = tangent(p0, p1, p2, p3, curve.c[k * 3 + 2], curve.c[k1 * 3 + 2]);
                if (t < -0.5)
                {
                    return(1);
                }
                pt = bezier(t, p0, p1, p2, p3);
                d  = ddist(curve.c[k * 3 + 2], curve.c[k1 * 3 + 2]);
                if (d == 0.0)
                {
                    /* this should never happen */
                    return(1);
                }
                d1  = dpara(curve.c[k * 3 + 2], curve.c[k1 * 3 + 2], pt) / d;
                d2  = dpara(curve.c[k * 3 + 2], curve.c[k1 * 3 + 2], vertex[k1]) / d;
                d2 *= 0.75 * curve.alpha[k1];
                if (d2 < 0)
                {
                    d1 = -d1;
                    d2 = -d2;
                }
                if (d1 < d2 - opttolerance)
                {
                    return(1);
                }
                if (d1 < d2)
                {
                    res.pen += (d1 - d2) * (d1 - d2);
                }
            }

            return(0);
        }
Пример #3
0
        /* Always succeeds and returns 0 */
        static void smooth(Path path, double alphamax)
        {
            int       m     = path.curve.n;
            privcurve curve = path.curve;

            if (path.sign == "-")
            {
                reverse(path);
            }
            int    i, j, k;
            double dd, denom, alpha;
            dPoint p2, p3, p4;

            /* examine each vertex and find its best fit */
            for (i = 0; i < m; i++)
            {
                j  = mod(i + 1, m);
                k  = mod(i + 2, m);
                p4 = interval(1 / 2.0, curve.vertex[k], curve.vertex[j]);

                denom = ddenom(curve.vertex[i], curve.vertex[k]);
                if (denom != 0.0)
                {
                    dd    = dpara(curve.vertex[i], curve.vertex[j], curve.vertex[k]) / denom;
                    dd    = Math.Abs(dd);
                    alpha = dd > 1 ? (1 - 1.0 / dd) : 0;
                    alpha = alpha / 0.75;
                }
                else
                {
                    alpha = 4 / 3.0;
                }
                curve.alpha0[j] = alpha;                   /* remember "original" value of alpha */

                if (alpha >= alphamax)
                {
                    curve.tag[j]       = POTRACE_CORNER;
                    curve.c[3 * j + 1] = curve.vertex[j];
                    curve.c[3 * j + 2] = p4;
                }
                else
                {
                    if (alpha < 0.55)
                    {
                        alpha = 0.55;
                    }
                    else if (alpha > 1)
                    {
                        alpha = 1;
                    }
                    p2                 = interval(0.5 + 0.5 * alpha, curve.vertex[i], curve.vertex[j]);
                    p3                 = interval(0.5 + 0.5 * alpha, curve.vertex[k], curve.vertex[j]);
                    curve.tag[j]       = POTRACE_CURVETO;
                    curve.c[3 * j + 0] = p2;
                    curve.c[3 * j + 1] = p3;
                    curve.c[3 * j + 2] = p4;
                }
                curve.alpha[j] = alpha;                  /* store the "cropped" value of alpha */
                curve.beta[j]  = 0.5;
            }
            curve.alphacurve = 1;
        }
Пример #4
0
        /* optimize the path p, replacing sequences of Bezier segments by a
         * single segment when possible. Return 0 on success, 1 with errno set
         * on failure. */
        static void optiCurve(Path path, double opttolerance)
        {
            privcurve curve = path.curve;
            int       m     = curve.n;

            dPoint[]  vert = curve.vertex;
            int[]     pt = new int[m + 1];
            double[]  pen = new double[m + 1];
            int[]     len = new int[m + 1];
            Opti[]    opt = new Opti[m + 1];
            Opti      o = new Opti();
            int       om, i, j, r;
            dPoint    p0;
            int       i1;
            double    area, alpha;
            privcurve ocurve;

            int[]    convc = new int[m];           /* conv[m]: pre-computed convexities */
            double[] areac = new double[m + 1];
            /* pre-calculate convexity: +1 = right turn, -1 = left turn, 0 = corner */
            for (i = 0; i < m; i++)
            {
                if (curve.tag[i] == POTRACE_CURVETO)
                {
                    convc[i] = sign(dpara(vert[mod(i - 1, m)], vert[i], vert[mod(i + 1, m)]));
                }
                else
                {
                    convc[i] = 0;
                }
            }
            /* pre-calculate areas */
            area     = 0.0;
            areac[0] = 0.0;
            p0       = curve.vertex[0];
            for (i = 0; i < m; i++)
            {
                i1 = mod(i + 1, m);
                if (curve.tag[i1] == POTRACE_CURVETO)
                {
                    alpha = curve.alpha[i1];
                    area += 0.3 * alpha * (4 - alpha) *
                            dpara(curve.c[i * 3 + 2], vert[i1], curve.c[i1 * 3 + 2]) / 2;
                    area += dpara(p0, curve.c[i * 3 + 2], curve.c[i1 * 3 + 2]) / 2;
                }
                areac[i + 1] = area;
            }

            pt[0]  = -1;
            pen[0] = 0;
            len[0] = 0;

            /* Fixme: we always start from a fixed point -- should find the best
             *                curve cyclically ### */
            for (j = 1; j <= m; j++)
            {
                /* calculate best path from 0 to j */
                pt[j]  = j - 1;
                pen[j] = pen[j - 1];
                len[j] = len[j - 1] + 1;

                for (i = j - 2; i >= 0; i--)
                {
                    r = opti_penalty(path, i, mod(j, m), o, opttolerance, convc,
                                     areac);
                    if (r == 1)
                    {
                        break;
                    }
                    if (len[j] > len[i] + 1 ||
                        (len[j] == len[i] + 1 && pen[j] > pen[i] + o.pen))
                    {
                        pt[j]  = i;
                        pen[j] = pen[i] + o.pen;
                        len[j] = len[i] + 1;
                        opt[j] = o;
                        o      = new Opti();
                    }
                }
            }
            om     = len[m];
            ocurve = new privcurve(om);
            double[] s = new double[om];
            double[] t = new double[om];

            j = m;
            for (i = om - 1; i >= 0; i--)
            {
                if (pt[j] == j - 1)
                {
                    ocurve.tag[i]       = curve.tag[mod(j, m)];
                    ocurve.c[i * 3 + 0] = curve.c[mod(j, m) * 3 + 0];
                    ocurve.c[i * 3 + 1] = curve.c[mod(j, m) * 3 + 1];
                    ocurve.c[i * 3 + 2] = curve.c[mod(j, m) * 3 + 2];
                    ocurve.vertex[i]    = curve.vertex[mod(j, m)];
                    ocurve.alpha[i]     = curve.alpha[mod(j, m)];
                    ocurve.alpha0[i]    = curve.alpha0[mod(j, m)];
                    ocurve.beta[i]      = curve.beta[mod(j, m)];
                    s[i] = t[i] = 1.0;
                }
                else
                {
                    ocurve.tag[i]       = POTRACE_CURVETO;
                    ocurve.c[i * 3 + 0] = opt[j].c[0];
                    ocurve.c[i * 3 + 1] = opt[j].c[1];
                    ocurve.c[i * 3 + 2] = curve.c[mod(j, m) * 3 + 2];
                    ocurve.vertex[i]    = interval(opt[j].s, curve.c[mod(j, m) * 3 + 2],
                                                   vert[mod(j, m)]);
                    ocurve.alpha[i]  = opt[j].alpha;
                    ocurve.alpha0[i] = opt[j].alpha;
                    s[i]             = opt[j].s;
                    t[i]             = opt[j].t;
                }
                j = pt[j];
            }
            /* calculate beta parameters */
            for (i = 0; i < om; i++)
            {
                i1             = mod(i + 1, om);
                ocurve.beta[i] = s[i] / (s[i] + t[i1]);
            }
            ocurve.alphacurve = 1;
            path.curve        = ocurve;
        }