Esempio n. 1
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;
                }
            }
        }
Esempio n. 2
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;
                }
            }
        }