Beispiel #1
0
        public void CaluclateCap(IVertexDest vc, VertexDistance v0, VertexDistance v1, double len)
        {
            vc.RemoveAll();

            double dx1 = (v1.y - v0.y) / len;
            double dy1 = (v1.x - v0.x) / len;
            double dx2 = 0;
            double dy2 = 0;

            dx1 *= m_width;
            dy1 *= m_width;

            if (m_line_cap != ELineCap.round_cap)
            {
                if (m_line_cap == ELineCap.square_cap)
                {
                    dx2 = dy1 * m_width_sign;
                    dy2 = dx1 * m_width_sign;
                }
                AddVertex(vc, v0.x - dx1 - dx2, v0.y + dy1 - dy2);
                AddVertex(vc, v0.x + dx1 - dx2, v0.y - dy1 - dy2);
            }
            else
            {
                double da = Math.Acos(m_width_abs / (m_width_abs + 0.125 / m_approx_scale)) * 2;
                double a1;
                int    i;
                int    n = (int)(Math.PI / da);

                da = Math.PI / (n + 1);
                AddVertex(vc, v0.x - dx1, v0.y + dy1);
                if (m_width_sign > 0)
                {
                    a1  = Math.Atan2(dy1, -dx1);
                    a1 += da;
                    for (i = 0; i < n; i++)
                    {
                        AddVertex(vc, v0.x + Math.Cos(a1) * m_width,
                                  v0.y + Math.Sin(a1) * m_width);
                        a1 += da;
                    }
                }
                else
                {
                    a1  = Math.Atan2(-dy1, dx1);
                    a1 -= da;
                    for (i = 0; i < n; i++)
                    {
                        AddVertex(vc, v0.x + Math.Cos(a1) * m_width,
                                  v0.y + Math.Sin(a1) * m_width);
                        a1 -= da;
                    }
                }
                AddVertex(vc, v0.x + dx1, v0.y - dy1);
            }
        }
Beispiel #2
0
        static public void ShortenPath(vertex_sequence vs, double s, uint closed)
        {
            //typedef typename VertexSequence::value_type vertex_type;

            if (s > 0.0 && vs.Size() > 1)
            {
                double d;
                int    n = (int)(vs.Size() - 2);
                while (n != 0)
                {
                    d = vs[n].dist;
                    if (d > s)
                    {
                        break;
                    }
                    vs.RemoveLast();
                    s -= d;
                    --n;
                }
                if (vs.Size() < 2)
                {
                    vs.RemoveAll();
                }
                else
                {
                    n = (int)vs.Size() - 1;
                    VertexDistance prev = vs[n - 1];
                    VertexDistance last = vs[n];
                    d = (prev.dist - s) / prev.dist;
                    double x = prev.x + (last.x - prev.x) * d;
                    double y = prev.y + (last.y - prev.y) * d;
                    last.x = x;
                    last.y = y;
                    if (!prev.IsEqual(last))
                    {
                        vs.RemoveLast();
                    }
                    vs.close(closed != 0);
                }
            }
        }
Beispiel #3
0
        void CalculateMiter(IVertexDest vc,
                            VertexDistance v0,
                            VertexDistance v1,
                            VertexDistance v2,
                            double dx1, double dy1,
                            double dx2, double dy2,
                            ELineJoin lj,
                            double mlimit,
                            double dbevel)
        {
            double xi  = v1.x;
            double yi  = v1.y;
            double di  = 1;
            double lim = m_width_abs * mlimit;
            bool   miter_limit_exceeded = true;          // Assume the worst
            bool   intersection_failed  = true;          // Assume the worst

            if (PictorMath.CalculateIntersection(v0.x + dx1, v0.y - dy1,
                                                 v1.x + dx1, v1.y - dy1,
                                                 v1.x + dx2, v1.y - dy2,
                                                 v2.x + dx2, v2.y - dy2,
                                                 out xi, out yi))
            {
                // Calculation of the intersection succeeded
                //---------------------
                di = PictorMath.CalculateDistance(v1.x, v1.y, xi, yi);
                if (di <= lim)
                {
                    // Inside the miter limit
                    //---------------------
                    AddVertex(vc, xi, yi);
                    miter_limit_exceeded = false;
                }
                intersection_failed = false;
            }
            else
            {
                // Calculation of the intersection failed, most probably
                // the three points lie one straight Line.
                // First check if v0 and v2 lie on the opposite sides of vector:
                // (v1.x, v1.y) -> (v1.x+dx1, v1.y-dy1), that is, the perpendicular
                // to the Line determined by vertices v0 and v1.
                // This condition determines whether the next Line segments continues
                // the previous one or goes back.
                //----------------
                double x2 = v1.x + dx1;
                double y2 = v1.y - dy1;
                if ((PictorMath.CrossProduct(v0.x, v0.y, v1.x, v1.y, x2, y2) < 0.0) ==
                    (PictorMath.CrossProduct(v1.x, v1.y, v2.x, v2.y, x2, y2) < 0.0))
                {
                    // This case means that the next segment continues
                    // the previous one (straight Line)
                    //-----------------
                    AddVertex(vc, v1.x + dx1, v1.y - dy1);
                    miter_limit_exceeded = false;
                }
            }

            if (miter_limit_exceeded)
            {
                // Miter limit exceeded
                //------------------------
                switch (lj)
                {
                case ELineJoin.miter_join_revert:
                    // For the compatibility with SVG, PDF, etc,
                    // we use a simple bevel join instead of
                    // "smart" bevel
                    //-------------------
                    AddVertex(vc, v1.x + dx1, v1.y - dy1);
                    AddVertex(vc, v1.x + dx2, v1.y - dy2);
                    break;

                case ELineJoin.miter_join_round:
                    CalculateArc(vc, v1.x, v1.y, dx1, -dy1, dx2, -dy2);
                    break;

                default:
                    // If no miter-revert, Calculate new dx1, dy1, dx2, dy2
                    //----------------
                    if (intersection_failed)
                    {
                        mlimit *= m_width_sign;
                        AddVertex(vc, v1.x + dx1 + dy1 * mlimit,
                                  v1.y - dy1 + dx1 * mlimit);
                        AddVertex(vc, v1.x + dx2 - dy2 * mlimit,
                                  v1.y - dy2 - dx2 * mlimit);
                    }
                    else
                    {
                        double x1 = v1.x + dx1;
                        double y1 = v1.y - dy1;
                        double x2 = v1.x + dx2;
                        double y2 = v1.y - dy2;
                        di = (lim - dbevel) / (di - dbevel);
                        AddVertex(vc, x1 + (xi - x1) * di,
                                  y1 + (yi - y1) * di);
                        AddVertex(vc, x2 + (xi - x2) * di,
                                  y2 + (yi - y2) * di);
                    }
                    break;
                }
            }
        }
Beispiel #4
0
        public void CalculateJoin(IVertexDest vc, VertexDistance v0,
                                  VertexDistance v1,
                                  VertexDistance v2,
                                  double len1,
                                  double len2)
        {
            double dx1 = m_width * (v1.y - v0.y) / len1;
            double dy1 = m_width * (v1.x - v0.x) / len1;
            double dx2 = m_width * (v2.y - v1.y) / len2;
            double dy2 = m_width * (v2.x - v1.x) / len2;

            vc.RemoveAll();

            double cp = PictorMath.CrossProduct(v0.x, v0.y, v1.x, v1.y, v2.x, v2.y);

            if (cp != 0 && (cp > 0) == (m_width > 0))
            {
                // Inner join
                //---------------
                double limit = ((len1 < len2) ? len1 : len2) / m_width_abs;
                if (limit < m_inner_miter_limit)
                {
                    limit = m_inner_miter_limit;
                }

                switch (m_inner_join)
                {
                default:                         // inner_bevel
                    AddVertex(vc, v1.x + dx1, v1.y - dy1);
                    AddVertex(vc, v1.x + dx2, v1.y - dy2);
                    break;

                case EInnerJoin.inner_miter:
                    CalculateMiter(vc,
                                   v0, v1, v2, dx1, dy1, dx2, dy2,
                                   ELineJoin.miter_join_revert,
                                   limit, 0);
                    break;

                case EInnerJoin.inner_jag:
                case EInnerJoin.inner_round:
                    cp = (dx1 - dx2) * (dx1 - dx2) + (dy1 - dy2) * (dy1 - dy2);
                    if (cp < len1 * len1 && cp < len2 * len2)
                    {
                        CalculateMiter(vc,
                                       v0, v1, v2, dx1, dy1, dx2, dy2,
                                       ELineJoin.miter_join_revert,
                                       limit, 0);
                    }
                    else
                    {
                        if (m_inner_join == EInnerJoin.inner_jag)
                        {
                            AddVertex(vc, v1.x + dx1, v1.y - dy1);
                            AddVertex(vc, v1.x, v1.y);
                            AddVertex(vc, v1.x + dx2, v1.y - dy2);
                        }
                        else
                        {
                            AddVertex(vc, v1.x + dx1, v1.y - dy1);
                            AddVertex(vc, v1.x, v1.y);
                            CalculateArc(vc, v1.x, v1.y, dx2, -dy2, dx1, -dy1);
                            AddVertex(vc, v1.x, v1.y);
                            AddVertex(vc, v1.x + dx2, v1.y - dy2);
                        }
                    }
                    break;
                }
            }
            else
            {
                // Outer join
                //---------------

                // Calculate the distance between v1 and
                // the central point of the bevel Line segment
                //---------------
                double dx     = (dx1 + dx2) / 2;
                double dy     = (dy1 + dy2) / 2;
                double dbevel = Math.Sqrt(dx * dx + dy * dy);

                if (m_line_join == ELineJoin.round_join || m_line_join == ELineJoin.bevel_join)
                {
                    // This is an optimization that reduces the number of points
                    // in cases of almost collinear segments. If there's no
                    // visible difference between bevel and miter joins we'd rather
                    // use miter join because it adds only one point instead of two.
                    //
                    // Here we Calculate the middle point between the bevel points
                    // and then, the distance between v1 and this middle point.
                    // At outer joins this distance always less than stroke Width,
                    // because it's actually the Height of an isosceles triangle of
                    // v1 and its two bevel points. If the difference between this
                    // Width and this Value is small (no visible bevel) we can
                    // Add just one point.
                    //
                    // The constant in the expression makes the result approximately
                    // the same as in round joins and caps. You can safely comment
                    // out this entire "if".
                    //-------------------
                    if (m_approx_scale * (m_width_abs - dbevel) < m_width_eps)
                    {
                        if (PictorMath.CalculateIntersection(v0.x + dx1, v0.y - dy1,
                                                             v1.x + dx1, v1.y - dy1,
                                                             v1.x + dx2, v1.y - dy2,
                                                             v2.x + dx2, v2.y - dy2,
                                                             out dx, out dy))
                        {
                            AddVertex(vc, dx, dy);
                        }
                        else
                        {
                            AddVertex(vc, v1.x + dx1, v1.y - dy1);
                        }
                        return;
                    }
                }

                switch (m_line_join)
                {
                case ELineJoin.miter_join:
                case ELineJoin.miter_join_revert:
                case ELineJoin.miter_join_round:
                    CalculateMiter(vc,
                                   v0, v1, v2, dx1, dy1, dx2, dy2,
                                   m_line_join,
                                   m_miter_limit,
                                   dbevel);
                    break;

                case ELineJoin.round_join:
                    CalculateArc(vc, v1.x, v1.y, dx1, -dy1, dx2, -dy2);
                    break;

                default:                         // Bevel join
                    AddVertex(vc, v1.x + dx1, v1.y - dy1);
                    AddVertex(vc, v1.x + dx2, v1.y - dy2);
                    break;
                }
            }
        }