Esempio n. 1
0
        void MakeSingle()
        {
            double   Offset4 = 5 / asc.Scale;
            Vector3d vp1_l   = leader_point.GetAsVector().Subtract(p1.GetAsVector());
            Point3d  p3;

            switch (gls)
            {
            case GroupLeaderSide.Right:
            {
                p3 = leader_point.Add(Vector3d.XAxis.MultiplyBy(Offset4));
                break;
            }

            case GroupLeaderSide.Left:
            {
                p3 = leader_point.Add(Vector3d.XAxis.MultiplyBy(Offset4 * -1));
                break;
            }

            case GroupLeaderSide.Inside:
            {
                double dx = p1.X - leader_point.X;
                p3 = leader_point.Add(Vector3d.XAxis.MultiplyBy(Offset4 * Math.Sign(dx)));
                break;
            }

            case GroupLeaderSide.Outside:
            {
                double dx = leader_point.X - p1.X;
                p3 = leader_point.Add(Vector3d.XAxis.MultiplyBy(Offset4 * Math.Sign(dx)));
                break;
            }

            default:
            {
                return;
            }
            }
            mtp    = UT.GetMiddle(p3, leader_point);
            points = new Point3d[3] {
                p1, leader_point, p3
            };

            PrepareMtext(0);
            PreparePolyline();
        }
Esempio n. 2
0
        public void MakeBreakLine()
        {
            using (var lm = new PKLayerManager())
            {
                //находим текущий масштаб аннотаций. Не забываем что в аннотативном масштабе 1:25 масштаб равен 0,04, но нам нужно именно обратное число
                scale = 1 / (UT.GetAnnoScale("CANNOSCALE").Scale);

                size       *= scale;
                overlength *= scale;

                lm.CommandLayer = "ПК_С_ЛинииРазрыва";

                var sset = Input.Implied();
                if (Input.StatusBad) //нет предварительно выбранных объектов. Используем старый механизм.
                {
                    p1 = Input.Point("\nВведите первую точку"); if (Input.StatusBad)
                    {
                        return;
                    }
                    p2 = Input.Point("\nВведите вторую точку"); if (Input.StatusBad)
                    {
                        return;
                    }


                    p1p2  = new Line(p1, p2);
                    p1p2v = p1p2.Delta.MultiplyBy(1 / p1p2.Length);

                    Plane pl = new Plane(p1, p1p2.Delta.GetPerpendicularVector());

                    p11 = p1.Add(p1p2v.MultiplyBy(overlength * -1));
                    p21 = p2.Add(p1p2v.MultiplyBy(overlength));

                    //заполняем точки пока ввод корректный. Если не введено ни одной точки, ставим единственную в середину
                    data = new List <Point2d>();

                    var pt = Input.Point("\nУкажите точку вставки символа или по умолчанию в середине");

                    int cnt = 0;
                    if (Input.StatusBad)
                    {
                        if (int.TryParse(Input.StringResult, out cnt) && cnt > 0)
                        {
                            data = Divide(cnt);
                        }
                        else
                        {
                            data.Add(UT.GetMiddle(p1, p2).to2d());
                        }
                    }

                    while (Input.StatusOK)
                    {
                        data.Add(pt.OrthoProject(pl).to2d());
                        pt = Input.Point("\nУкажите следующую точку вставки символа");
                    }
                    results.Add(Prepare());
                }
                else
                {
                    using (var th = new TransactionHelper())
                    {
                        var ents      = th.EditObjects(sset);
                        var lines     = ents.OfType <Line>();
                        var polylines = ents.OfType <Polyline>();

                        foreach (var l in lines)
                        {
                            th.WriteObject(MakeFromLine(l));
                            l.Erase();
                        }
                        foreach (var pl in polylines)
                        {
                            th.WriteObject(MakeFromPolyLine(pl));
                            pl.Erase();
                        }
                    }
                }
                using (var th = new TransactionHelper())
                {
                    th.WriteObjects(results);
                }
            }
        }
Esempio n. 3
0
        /// <summary>
        /// самая первая реализация групповой выноски, в виде трапеции
        /// </summary>
        void MakeTaper()
        {
            double leader_offset2;


            leader_offset2 = leader_offset + offset / asc.Scale;            //выносим за 6мм за объект по умолчанию (переменная offset теперь задается)
            //TODO уровни

            Vector3d vp1p2 = p2.GetAsVector().Subtract(p1.GetAsVector());
            Vector3d norm  = vp1p2.GetPerpendicularVector();

            Vector3d vp2o = leader_point.GetAsVector().Subtract(p2.GetAsVector());
            Vector3d vp1o = leader_point.GetAsVector().Subtract(p1.GetAsVector());

            //корректируем нормаль в сторону выбранной точки выноски
            double ang = norm.GetAngleTo(vp1o, Vector3d.ZAxis);

            if (ang > Math.PI / 2 && ang < Math.PI * 3 / 2)
            {
                norm = norm.Negate();
            }

            Plane pl = new Plane(p1, norm);

            Point3d o = leader_point.OrthoProject(pl);

            Vector3d p2o = o.GetAsVector().Subtract(p2.GetAsVector());
            Vector3d p1o = o.GetAsVector().Subtract(p1.GetAsVector());

            double leader_offset3 = leader_offset2 * cline;

            Vector3d p1h = p1o.MultiplyBy(leader_offset3 / p1o.Length);
            Vector3d p2h = p2o.MultiplyBy(leader_offset3 / p2o.Length);



            //смещение точек привязки - получаем верхние углы выноски
            Vector3d vp1p3 = norm.MultiplyBy(leader_offset2).Add(p1h);
            Vector3d vp2p4 = norm.MultiplyBy(leader_offset2).Add(p2h);


            Point3d p3 = p1.Add(vp1p3);
            Point3d p4 = p2.Add(vp2p4);



            //случаи с подавлением
            double Offset4 = 6 / asc.Scale;            //сделаем ширину выноски 6мм TODO настроить под текст

            if (SingleLeft)
            {
                Point3d p3_2 = p3.Add(vp1p2.MultiplyBy(Offset4 / vp1p2.Length));
                points = new Point3d[3] {
                    p1, p3, p3_2
                };
                mtp = UT.GetMiddle(p3_2, p4);
            }
            else if (SingleRight)
            {
                Point3d p4_2 = p4.Subtract(vp1p2.MultiplyBy(Offset4 / vp1p2.Length));
                points = new Point3d[3] {
                    p4_2, p4, p2
                };
                mtp = UT.GetMiddle(p3, p4_2);
            }
            else            //общий случай
            {
                points = new Point3d[4] {
                    p1, p3, p4, p2
                };
                //средняя точка выноски - привязываем к ней мультитекст

                mtp = UT.GetMiddle(p3, p4);
            }
            //коррекция угла поворота текста
            if (p1.X > p2.X)
            {
                vp1p2 = vp1p2.Negate();
            }
            PrepareMtext(-1 * vp1p2.GetAngleTo(Vector3d.XAxis, Vector3d.ZAxis));

            PreparePolyline();
        }