void BendPolyline(Point3d origin, Point3d fromp, Point3d to, ref Polyline pl)
{
Matrix3d M = BendMatrix(origin, fromp, to);
bool forward = true;
int segment = CheckSegment(origin, fromp, ref pl, out forward);
int start, end;
Point3d temp_p; //временная точка для чтения вершины и преобразования ее
if (forward)
{
start = segment + 1; end = pl.NumberOfVertices - 1; //номера изменяемых вершин включительно
}
else
{
start = 0; end = segment;
}
for (int i = start; i <= end; i++)
{
temp_p = pl.GetPoint3dAt(i);
temp_p = temp_p.TransformBy(M);
pl.SetPointAt(i, UT.from3dto2d(temp_p));
}
pl.AddVertexAt(segment + 1, UT.from3dto2d(origin), pl.GetBulgeAt(segment), pl.GetStartWidthAt(segment), pl.GetEndWidthAt(segment));
}
public override void Input(List <Entity> objects)
{
base.Input(objects);
double sum = 0;
foreach (Entity ent in objects)
{
sum += UT.EntityLength(ent);
}
while (iio.SumCountInput)
{
var sset = Inp.Objects("Введите дополнительный набор стержней");
if (Inp.StatusBad)
{
break;
}
using (TransactionHelper th = new TransactionHelper())
{
objects = th.ReadObjects(sset);
foreach (Entity ent in objects)
{
sum += UT.EntityLength(ent);
}
}
}
segments.Add(new StraitItemSegment(sum));
count = 1;
status = true;
}
static public void CommandResult() //(Entity A, Point2d place)
{
Point2d location = Input.Point("Enter loction").to2d(); if (Input.StatusBad)
{
return;
}
Point2d user_direction = Input.Point("Enter direction").to2d(); if (Input.StatusBad)
{
return;
}
Vector2d dir = user_direction - location;
Vector2d perp = dir.GetPerpendicularVector();
using (var th = new TransactionHelper())
{
var anno_scale = UT.GetAnnoScale("CANNOSCALE");
var left = Tail(dir, anno_scale, location + dir, LeftRight.Left);
var right = Tail(dir, anno_scale, location, LeftRight.Right);
th.WriteObject(left);
th.WriteObject(right);
}
}
void InputTail()
{
asc = UT.GetAnnoScale("CANNOSCALE");
var sset_poly = Input.Objects("Выберите полилинию-хвост. Прикрепление будет к начальной точке");
if (Input.StatusOK)
{
using (var th = new TransactionHelper())
{
try
{
var pl = th.EditObjects(sset_poly)[0] as Polyline;
tail_default = pl.Clone() as Polyline;
}
catch (System.Exception)
{
InputTail();
return;
}
var p1 = Input.Point("Укажите базовую точку");
var p2 = Input.Point("Укажите направление Х");
var p1p2v = p1.Subtract(p2.GetAsVector()).GetAsVector();
tail_default.TransformBy(Matrix3d.AlignCoordinateSystem(p1, p1p2v.DivideBy(p1p2v.Length), p1p2v.GetPerpendicularVector(), Vector3d.ZAxis,
Point3d.Origin, Vector3d.XAxis, Vector3d.YAxis, Vector3d.ZAxis));
tail_default.TransformBy(Matrix3d.Scaling(asc.Scale, Point3d.Origin));
}
}
}
void Init()
{
acDoc = App.DocumentManager.MdiActiveDocument;
acCurDb = acDoc.Database;
acEd = acDoc.Editor;
mLeader = new MLeader();
asc = UT.GetAnnoScale("CANNOSCALE");
}
public RebarDrawing()
{
Tweet("Начинаем распознавать слои");
if (!InitLayers())
{
Tweet("Не хватает слоев! Программа не будет продолжена. Для корректной работы необходим полный шаблон ПК");
return;
}
if (!InitLinetype())
{
return;
}
Tweet("Пробуем нарисовать плиту");
using (var th = new TransactionHelper())
{
var sset_line1 = Input.Objects("Выберите линию сечения нижней арматуры", new string[]
{ "SEttings", "ПАраметры", "LAyers", "cЛОи" },
SetParams
); if (Input.StatusBad)
{
return;
}
var sset_lines1 = Input.Objects("Выберите нижние арматурные стержни"); if (Input.StatusBad)
{
return;
}
var sset_line2 = Input.Objects("Выберите линию сечения верхней арматуры"); if (Input.StatusBad)
{
return;
}
var sset_lines2 = Input.Objects("Выберите верхние арматурные стержни"); if (Input.StatusBad)
{
return;
}
var ln1 = th.ReadObject(sset_line1[0].ObjectId) as Line;
var ln2 = th.ReadObject(sset_line2[0].ObjectId) as Line;
var lines1 = th.ReadObjects(sset_lines1);
var lines2 = th.ReadObjects(sset_lines2);
var colors1 = lines1.Select((ln) => ln.Color).ToList();
var colors2 = lines2.Select((ln) => ln.Color).ToList();
dot_data1 = lines1.Select((ln) => {
return(new Tuple <double, Color>(UT.IntersectWith(ln, ln1)[0].X, ln.Color));
}
).ToList();
dot_data2 = lines2.Select((ln) => {
return(new Tuple <double, Color>(UT.IntersectWith(ln, ln2)[0].X, ln.Color));
}
).ToList();
th.WriteObjects(Slab(thickness, ln1.StartPoint.X, ln1.EndPoint.X, offset_up, offset_down, dots_up, dots_down));
}
}
void FindPoints()
{
for (int i = 0; i < lines_first_ent.Count; i++)
{
List <Point3d> lineintersections = new List <Point3d>();
for (int j = 0; j < lines_second_ent.Count; j++)
{
var pts = UT.IntersectWith(lines_first_ent[i], lines_second_ent[j], extend);
foreach (Point3d pt in pts)
{
lineintersections.Add(pt);
}
}
if (lines_first_ent[i] is Curve)
{
var crv = lines_first_ent[i] as Curve;
try
{
lineintersections.Sort((x, y) => crv.GetParameterAtPoint(x).CompareTo(crv.GetParameterAtPoint(y)));
}
catch (Exception)
{
Tweet("Не удалась сортировка исходя из параметров");
try
{
lineintersections.Sort((x, y) => crv.StartPoint.DistanceTo(x).CompareTo(crv.StartPoint.DistanceTo(y)));
}
catch (Exception)
{
Tweet("Сортировка по дистанции от начала кривой не удалась");
}
}
}
for (int j = 0; j < lineintersections.Count; j++)
{
if (copy_chess)
{
if (ChessOrder(i, j))
{
points.Add(lineintersections[j]);
}
else
{
points_alternative.Add(lineintersections[j]);
}
}
else
{
points.Add(lineintersections[j]);
}
}
}
}
/// <summary>
/// Создание сегмента-загиба по радиусу
/// </summary>
/// <param name="arc"></param>
public ItemSegment(Arc arc)
{
length_data = new double[1];
length_data[0] = UT.EntityLength(arc);
i_s_type = ItemSegmentType.Radius;
radius = arc.Radius;
start = arc.StartPoint;
end = arc.EndPoint;
}
public RadiusItemSegment(Arc arc)
{
length_data = new double[1] {
UT.EntityLength(arc)
};
radius = arc.Radius;
start = arc.StartPoint;
end = arc.EndPoint;
}
Polyline BendSingleLine(Point3d origin, Point3d fromp, Point3d to, Line ln)
{
Polyline result = new Polyline();
result.SetPropertiesFrom(ln);
result.AddVertexAt(0, UT.from3dto2d(ln.StartPoint), 0, 0, 0);
result.AddVertexAt(1, UT.from3dto2d(ln.EndPoint), 0, 0, 0);
BendPolyline(origin, fromp, to, ref result);
return(result);
}
void FindCenters()
{
//находим центры
for (int i = 0; i < objects.Count; i++)
{
Point3d cen = UT.GetCenter(objects[i], Dim_line, dim_line_point, out hascenter);
if (hascenter)
{
centers.Add(cen);
}
}
}
/// <summary>
/// Суммарная длина
/// </summary>
/// <param name="ent"></param>
/// <param name="alllength"></param>
public Item(List <Entity> data, bool alllength)
{
segments = new List <ItemSegment>();
double sum = 0;
foreach (Entity ent in data)
{
sum += UT.EntityLength(ent);
}
segments.Add(new ItemSegment(sum, true));
}
void InputConstant()
{
iim = ItemInputMode.Constant;
pos.segments.Add(new ItemSegment(UT.EntityLength(objects[0])));
if (objects.Count == 1)
{
pos.count = ItemCount();
}
else
{
pos.count = Convert.ToUInt32(objects.Count);
}
}
void FindDirection()
{
//автоопределение направления (горизонтально/вертикально)
if (Auto_direction)
{
double minx = double.PositiveInfinity;
double maxx = double.NegativeInfinity;
double miny = double.PositiveInfinity;
double maxy = double.NegativeInfinity;
//надо найти центры по дефолтному направлению и вычислить границы
for (int i = 0; i < objects.Count; i++)
{
Point3d cen = UT.GetCenter(objects[i], DimDirection, dim_line_point, out hascenter);
if (hascenter)
{
if (cen.X < minx)
{
minx = cen.X;
}
if (cen.X > maxx)
{
maxx = cen.X;
}
if (cen.Y < miny)
{
miny = cen.Y;
}
if (cen.Y > maxy)
{
maxy = cen.Y;
}
}
}
Point3d dd = dim_line_point; //простое название
if ((dd.X < minx || dd.X > maxx) && (dd.Y < maxy) && (dd.Y > miny))
{
DimDirection = new Line(Point3d.Origin, new Point3d(0, 1000, 0));
}
else
{
DimDirection = new Line(Point3d.Origin, new Point3d(1000, 0, 0));
}
}
Auto_direction = true; //обнуляем чтоб на следующий раз можно было авто
}
public override void Input(List <Entity> firstinput)
{
base.Input(firstinput);
segments.Add(new StraitItemSegment(UT.EntityLength(firstinput[0])));
if (firstinput.Count == 1)
{
count = ItemInput.ItemCount();
}
else
{
count = Convert.ToUInt32(firstinput.Count);
}
status = true;
}
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();
}
public void LengthList()
{
base.Execute();
if (delimiter == "\n")
{
Tweet("Вертикальная группировка");
}
else if (delimiter == "\t")
{
Tweet("Горизонтальная группировка");
}
var list = new List <string>();
var sset = Input.Objects("Выберите объекты", new [] { "Mode", "РЕжим" }, (s, e) =>
{
if (delimiter == "\t")
{
delimiter = "\n";
Tweet("Вертикальная группировка");
}
else if (delimiter == "\n")
{
delimiter = "\t";
Tweet("Горизонтальная группировка");
}
}
); if (Input.StatusBad)
{
return;
}
using (var th = new TransactionHelper())
{
objects = th.ReadObjects(sset);
foreach (var o in objects)
{
list.Add(String.Format("{0:F0}", UT.EntityLength(o)));
}
}
Clipboard.SetText(list.Aggregate((s1, s2) => s1 + delimiter + s2));
}
void InputBend()
{
iim = ItemInputMode.Bend;
if (objects.Count == 2)
{
pos.segments.Add(new ItemSegment(UT.EntityLength(objects[0]), UT.EntityLength(objects[1])));
}
else
{
double[] lengthdata = new double[objects.Count];
for (int i = 0; i < objects.Count; i++)
{
lengthdata[i] = UT.EntityLength(objects[i]);
}
pos.segments.Add(new ItemSegment(lengthdata));
}
}
static public void DrawRodTwoPoints()
{
var keywords = new string[] {
"LEft", "ЛЕво",
"RIght", "ПРаво",
"Diameter", "Диаметр",
"ANchorage", "АНкеровка"
};
Point3d p1 = Input.Point("Выберите первую точку", keywords, SetSides); if (Input.StatusCancel)
{
return;
}
Point3d p2 = Input.Point("Выберите вторую точку", keywords, SetSides); if (Input.StatusCancel)
{
return;
}
Point3d p3 = Input.Point("Выберите сторону смещения"); if (Input.StatusCancel)
{
return;
}
double anchorage = Math.Round(base_anchorage * diameter / round) * round;
double offset = Math.Round((min_layer + diameter / 2) / round_5, MidpointRounding.AwayFromZero) * round_5;
var vp1p2 = UT.GetUniteVector(p1, p2);
var pl = new Plane(p1, vp1p2.GetPerpendicularVector());
Point3d p4 = p3.OrthoProject(pl);
var vp4p3 = UT.GetUniteVector(p4, p3);
var A = p1.Add(vp4p3.MultiplyBy(offset)).Add(vp1p2.MultiplyBy(left_anchorage?-anchorage:0));
var B = p2.Add(vp4p3.MultiplyBy(offset)).Add(vp1p2.MultiplyBy(right_anchorage?anchorage:0));
using (var th = new TransactionHelper())
{
var AB = new Line(A, B);
AB.SetDatabaseDefaults();
th.WriteObject(AB);
}
}
public double GetLengthSum()
{
double sum = 0;
var sset = Input.Objects("Выберите объекты для подсчета");
if (Input.StatusBad)
{
return(0);
}
using (TransactionHelper th = new TransactionHelper())
{
objects = th.ReadObjects(sset);
foreach (Entity ent in objects)
{
sum += UT.EntityLength(ent);
}
}
return(sum);
}
public override void Input(List <Entity> firstinput)
{
base.Input(firstinput);
if (firstinput.Count == 2)
{
segments.Add(new VariableItemSegment(UT.EntityLength(firstinput[0]), UT.EntityLength(firstinput[1])));
}
else
{
double[] lengthdata = new double[firstinput.Count];
for (int i = 0; i < firstinput.Count; i++)
{
lengthdata[i] = UT.EntityLength(firstinput[i]);
}
segments.Add(new VariableItemSegment(lengthdata));
}
base.count = ItemInput.ItemCount();
status = true;
}
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);
}
}
}
static void PropertyMLeader(string name, int pow)
{
var acDoc = App.DocumentManager.MdiActiveDocument;
var acCurDb = acDoc.Database;
var acEd = acDoc.Editor;
var sset = Input.Objects("Выберите объект"); if (Input.StatusBad)
{
return;
}
asc = UT.GetAnnoScale("CANNOSCALE");
Vector3d offset = new Vector3d(2, 3.6, 0);
var areas = new List <double>();
using (var th = new TransactionHelper())
{
var ents = th.EditObjects(sset);
foreach (var e in ents)
{
var p = PropertyWorker.GetProperty(e, name);
if (p == null)
{
Messaging.Tweet("Skip");
continue;
}
areas.Add((double)p.pValue);
}
}
foreach (var d in areas)
{
double measured_d = PKUserTools.Measurings.UnitsForm.measuringUnits.Value(PKUserTools.Measurings.UnitsForm.modelUnits, d, pow);
using (var th = new TransactionHelper())
{
var pt1 = Input.Point("Первая точка выноски"); if (Input.StatusBad)
{
return;
}
var pt2 = Input.Point("Вторая точка выноски"); if (Input.StatusBad)
{
return;
}
//TODO сделать общий класс создания мультивыносок
var mleader = new MLeader();
MText mt;
PrepareMtext(0, out mt, acCurDb, pt2);
mleader.SetDatabaseDefaults();
mleader.ContentType = ContentType.MTextContent;
mt.TransformBy(Matrix3d.Displacement(offset.DivideBy(asc.Scale)));
mt.Contents = string.Format("{0:F3}", measured_d);
mleader.MText = mt;
int idx = mleader.AddLeaderLine(pt1);
mleader.SetFirstVertex(idx, pt1);
th.WriteObject(mleader);
}
}
}
void Initialise()
{
geometry = new List <Entity>();
asc = UT.GetAnnoScale("CANNOSCALE");
}
public DrawTails()
{
var sset_lines = Input.Objects("Выберите отрезки, на которых нужно нарисовать хвосты ", new string[] { "TAil", "ХВост", "SIde", "СТорона", "OFfset", "смеЩЕние" },
(s, e) =>
{
if (e.Input == "TAil")
{
InputTail();
}
if (e.Input == "SIde")
{
side *= -1;
}
if (e.Input == "OFfset")
{
offsetMode ^= 1; //switching 0 and 1
}
});
if (Input.StatusBad)
{
return;
}
if (tail_default == null)
{
InputTail();
if (Input.StatusBad)
{
return;
}
}
using (var th = new TransactionHelper())
{
//забираем линии из выбора
var lines = th.EditObjects(sset_lines).OfType <Line>().ToList();
//в новой версии хотим добавить обработку полилиний
var polylines = th.EditObjects(sset_lines).OfType <Polyline>().ToList();
foreach (var ln in lines)
{
Point3d p1, p2;
if (ln.Angle >= 0 && ln.Angle <= 3 * Math.PI / 4 || ln.Angle > 7 * Math.PI / 4)
{
p1 = ln.EndPoint; p2 = ln.StartPoint;
}
else
{
p2 = ln.EndPoint; p1 = ln.StartPoint;
}
var tail_scaled = tail_default.Clone() as Polyline;
asc = UT.GetAnnoScale("CANNOSCALE");
tail_scaled.TransformBy(Matrix3d.Scaling(1 / asc.Scale, Point3d.Origin));
var pl_new = DrawTwoTails(p1, p2, tail_scaled);
pl_new.SetPropertiesFrom(ln);
th.WriteObject(pl_new);
ln.Erase();
}
foreach (var pl in polylines)
{
var tail_scaled = tail_default.Clone() as Polyline;
asc = UT.GetAnnoScale("CANNOSCALE");
tail_scaled.TransformBy(Matrix3d.Scaling(1 / asc.Scale, Point3d.Origin));
var pl_new = TailsFromPolyline(pl, tail_scaled);
pl_new.SetPropertiesFrom(pl);
th.WriteObject(pl_new);
pl.Erase();
}
}
}
/// <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();
}
/// <summary>
/// Мультивыноска из объектов со стрелками на одной линии
/// </summary>
public void MakeArrowsInline()
{
base.Execute();
asc = UT.GetAnnoScale("CANNOSCALE");
var objects = new List <Entity>();
var points = new List <Point3d>();
Point3d p1, p2;
Line p1p2;
Vector3d offset = new Vector3d(2, 3.6, 0);
var sset = Input.Objects("Выберите объекты"); if (Input.StatusBad)
{
return;
}
p1 = Input.Point("Выберите точку мультивыноски"); if (Input.StatusBad)
{
return;
}
p2 = Input.Point("Выберите точку для задания направления"); if (Input.StatusBad)
{
return;
}
p1p2 = new Line(p1, p2);
Tweet("\nНачинаем транзакцию");
using (var th = new TransactionHelper())
{
objects = th.ReadObjects(sset);
Tweet("\nНачинаем поиск точек");
foreach (Entity ent in objects)
{
var pt_arr = UT.IntersectWith(p1p2, ent);
if (pt_arr.Count > 0)
{
points.Add(pt_arr[0]);
}
}
Tweet("\nНачинаем подготовку текста");
mtp = p1;
text = "хх";
PrepareMtext(0);
Tweet("\nНачинаем подготовку выноски");
MLeader mleader = new MLeader();
mleader.SetDatabaseDefaults();
mleader.ContentType = ContentType.MTextContent;
mt.TransformBy(Matrix3d.Displacement(offset.DivideBy(asc.Scale)));
mleader.MText = mt;
Tweet("\nДобавляем линии");
foreach (Point3d ptt in points)
{
int idx = mleader.AddLeaderLine(p1);
mleader.SetFirstVertex(idx, ptt);
}
Tweet("\nЗаписываем объекты");
th.WriteObject(mleader);
}
}
public override void Execute()
{
base.Execute();
var sset = Input.Objects("Выберите объекты для нанесения выносок или ",
new string[]
{
"Angle", "Уклон",
"oFFset", "cМЕщение",
"Text", "ТТекст"
},
new SelectionTextInputEventHandler(KeywordInput));
if (Input.StatusBad)
{
return;
}
string[] Keywords = null;
if (sset.Count == 1)
{
Keywords = new string[]
{
"LEft", "ЛЕво",
"RIght", "ПРаво",
"INside", "внуТРи",
"OUtside", "сНАружи"
};
}
leader_point = Input.Point("\nУкажите точку, через которую пройдет выносная линия", Keywords);
if (Input.StatusKeyword)
{
SideInput(Input.StringResult);
leader_point = Input.Point("\nУкажите точку, через которую пройдет выносная линия");
}
if (Input.StatusBad)
{
return;
}
//достаем объекты
using (Utilities.TransactionHelper th = new Utilities.TransactionHelper())
{
objects = th.ReadObjects(sset);
Line dir = new Line(Point3d.Origin, new Point3d(1000, 0, 0)); //для работы функции нахождения центра
bool hascenter;
for (int i = 0; i < objects.Count; i++)
{
Point3d cen = UT.GetCenter(objects[i], dir, Point3d.Origin, out hascenter);
if (hascenter)
{
centers.Add(cen);
}
}
if (centers.Count > 1) //если больше 1 объекта
{
dir = new Line(centers[0], centers[centers.Count - 1]);
//сортируем
PointSorter ps = new PointSorter();
ps.direction = dir;
//сортируем по направлению
centers.Sort(ps);
}
//создаем объекты
if (centers.Count > 1)
{
GroupLeader(centers[0], centers[centers.Count - 1], leader_point);
}
else if (centers.Count == 1)
{
GroupLeader(centers[0], leader_point, group_leader_side);
}
else
{
return; //если объектов 0 то нам здесь нечего делать
}
cline = s_cline;
}
Make();
Line p1p2 = new Line(p1, p2);
bool subleader = false;
if (p1p2.Angle > Math.PI * 1 / 4 && p1p2.Angle < Math.PI * 3 / 4 || p1p2.Angle > Math.PI * 5 / 4 && p1p2.Angle < Math.PI * 7 / 4)
{
subleader = true;
}
else
{
geometry.Add(mt);
}
using (TransactionHelper th = new TransactionHelper())
{
th.WriteObjects(geometry);
}
//нужно 2 разных транзакции чтобы видеть результат работы предыдущей части
if (subleader)
{
using (TransactionHelper th = new TransactionHelper())
{
PrepareSubLeader();
th.WriteObject(geometry.Last());
}
}
}
public override void Input(List <Entity> objects)
{
base.Input(objects);
bool doinput = true;
while (doinput)
{
Entity base_ent;
//ввод базы
var Ssetbase = Inp.Objects("Выберите объект на проекции, представляющий базу");
if (Inp.StatusBad)
{
continue;
}
if (Ssetbase.Count != 1)
{
Alert("Введите один объект!");
continue;
}
using (TransactionHelper th = new TransactionHelper())
{
base_ent = th.ReadObject(Ssetbase[0].ObjectId) as Entity;
}
var Ssetvar = Inp.Objects("nВыберите переменные длины");
if (Inp.StatusBad)
{
return;
}
using (TransactionHelper th = new TransactionHelper())
{
objects_var = th.ReadObjects(Ssetvar);
}
double baselength = UT.EntityLength(base_ent) - UT.EntityLength(objects_var[0]);
double[] lengthdata = new double[objects_var.Count];
for (int i = 0; i < objects_var.Count; i++)
{
lengthdata[i] = UT.EntityLength(objects_var[i]) + baselength;
}
segments.Add(new VariableItemSegment(lengthdata));
doinput = false;
}
//добавляем остальные сегменты
foreach (Entity ent in objects)
{
if (ent is Line)
{
segments.Add(new StraitItemSegment(((Line)ent).Length));
}
else if (ent is Arc)
{
segments.Add(new RadiusItemSegment(ent as Arc));
}
else if (ent is Polyline)
{
Polyline pl = ent as Polyline;
int count;
if (pl.Closed)
{
count = pl.NumberOfVertices;
}
else
{
count = pl.NumberOfVertices - 1;
}
for (int j = 0; j < count; j++)
{
SegmentType st = pl.GetSegmentType(j);
if (st == SegmentType.Line)
{
LineSegment2d lsd = pl.GetLineSegment2dAt(j);
segments.Add(new StraitItemSegment(lsd.Length));
}
else if (st == SegmentType.Arc)
{
CircularArc2d arc_s = pl.GetArcSegment2dAt(j);
Plane pn = new Plane(Point3d.Origin, Vector3d.XAxis, Vector3d.YAxis);
Arc arc = new Arc(new Point3d(pn, arc_s.Center), Vector3d.ZAxis, arc_s.Radius, arc_s.StartAngle, arc_s.EndAngle);
segments.Add(new RadiusItemSegment(arc));
}
}
}
}
base.count = ItemInput.ItemCount();
status = true;
}
void InputBendVar()
{
iim = ItemInputMode.BendVar;
bool doinput = true;
while (doinput)
{
Entity base_ent;
//ввод базы
ObjectsInput OIbase = new ObjectsInput()
{
Message = "\nВыберите объект на проекции, представляющий базу",
};
OIbase.Input();
if (OIbase.StatusBad)
{
continue;
}
if (OIbase.SSet.Count != 1)
{
Alert("Введите один объект!");
continue;
}
using (TransactionHelper th = new TransactionHelper())
{
base_ent = th.ReadObject(OIbase.SSet[0].ObjectId) as Entity;
}
ObjectsInput OIvar = new ObjectsInput()
{
Message = "\nВыберите переменные длины",
};
OIvar.Input();
if (OIvar.StatusBad)
{
return;
}
using (TransactionHelper th = new TransactionHelper())
{
objects_var = th.ReadObjects(OIvar.SSet);
}
double baselength = UT.EntityLength(base_ent) - UT.EntityLength(objects_var[0]);
double[] lengthdata = new double[objects_var.Count];
for (int i = 0; i < objects_var.Count; i++)
{
lengthdata[i] = UT.EntityLength(objects_var[i]) + baselength;
}
pos.segments.Add(new ItemSegment(lengthdata));
doinput = false;
}
//добавляем остальные сегменты
foreach (Entity ent in objects)
{
if (ent is Line)
{
pos.segments.Add(new ItemSegment(((Line)ent).Length));
}
else if (ent is Arc)
{
pos.segments.Add(new ItemSegment(ent as Arc));
}
else if (ent is Polyline)
{
Polyline pl = ent as Polyline;
int count;
if (pl.Closed)
{
count = pl.NumberOfVertices;
}
else
{
count = pl.NumberOfVertices - 1;
}
for (int j = 0; j < count; j++)
{
SegmentType st = pl.GetSegmentType(j);
if (st == SegmentType.Line)
{
LineSegment2d lsd = pl.GetLineSegment2dAt(j);
pos.segments.Add(new ItemSegment(lsd.Length));
}
else if (st == SegmentType.Arc)
{
CircularArc2d arc_s = pl.GetArcSegment2dAt(j);
Plane pn = new Plane(Point3d.Origin, Vector3d.XAxis, Vector3d.YAxis);
Arc arc = new Arc(new Point3d(pn, arc_s.Center), Vector3d.ZAxis, arc_s.Radius, arc_s.StartAngle, arc_s.EndAngle);
pos.segments.Add(new ItemSegment(arc));
}
}
}
}
pos.count = ItemCount();
}
