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 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);
}
}
}
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>
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);
}
}
void Initialise()
{
geometry = new List <Entity>();
asc = UT.GetAnnoScale("CANNOSCALE");
}
/// <summary>
/// Создание линий на основе двух отрезков со смещением центральной вершины
/// </summary>
/// <param name="InputFirst">первый отрезок</param>
/// <param name="InputSecond">второй отрезок</param>
void Make(Line InputFirst, Line InputSecond)
{
Tweet("Делаем два отрезка из двух отрезков");
Point3d S1;
Point3d S2;
Point3d E1;
Point3d E2;
Point3d middle;
Point3d p1;
Point3d p2;
//выделяем 3 точки
S1 = InputFirst.StartPoint;
E1 = InputFirst.EndPoint;
S2 = InputSecond.StartPoint;
E2 = InputSecond.EndPoint;
if (S1 == S2)
{
middle = S1;
p1 = E1;
p2 = E2;
}
else if (S1 == E2)
{
middle = S1;
p1 = E1;
p2 = S2;
}
else if (E1 == E2)
{
middle = E1;
p1 = S1;
p2 = S2;
}
else if (E1 == S2)
{
middle = E1;
p1 = S1;
p2 = E2;
}
else
{
p1 = Point3d.Origin;
p2 = Point3d.Origin;
middle = Point3d.Origin;
Alert("Не совпадают концы отрезков");
status_ok = false;
return;
}
AnnotationScale asc = UT.GetAnnoScale("CANNOSCALE");
Vector3d v1 = p1 - middle;
Vector3d v2 = p2 - middle;
if ((v1.Length == 0) || (v2.Length == 0))
{
Alert("Нулевая длина отрезков");
return;
}
v1 = v1.MultiplyBy(1 / v1.Length);
v2 = v2.MultiplyBy(1 / v2.Length);
Vector3d v3 = v1.Add(v2);
if (v3.Length == 0)
{
Alert("Отрезки параллельны");
return;
}
v3 = v3.MultiplyBy(currscale / (asc.Scale * v3.Length));
//находим длину биссектрисы
double a, b, c, lb, p;
Line p1p2 = new Line(p1, p2);
a = InputFirst.Length;
c = InputSecond.Length;
b = p1p2.Length;
p = (a + b + c) / 2;
lb = 2 * Math.Sqrt(a * c * p * (p - b)) / (a + c);
//приводим длину вектора к половине этой длины
if (v3.Length >= lb * 0.5)
{
v3 = v3.MultiplyBy(lb * 0.5 / v3.Length);
}
middle = middle.Add(v3);
//создаем 2 новые линии
first = new Line(p1, middle);
second = new Line(p2, middle);
}
void CreateDimms()
{
asc = UT.GetAnnoScale("CANNOSCALE");
for (int i = 1; i < centers_projected.Count; i++)
{
RotatedDimension dim = new RotatedDimension();
if (i == 1)
{
current_dimm = centers_projected[i].DistanceTo(centers_projected[i - 1]);
}
if (i < centers_projected.Count - 1)
{
next_dim = centers_projected[i].DistanceTo(centers_projected[i + 1]);
}
else
{
next_dim = 0;
}
if (Math.Abs(next_dim - current_dimm) < Dim_tolerance && UniteDimms) //точность определения размеров
{
continue; //пропускаем выносные линии одинаковых размеров, если выбран режим объединения
}
//создние размера
if (i - start_dim > 2)
{
//делаем корректировку, чтобы цифры шага и общего размера соответствовали,
//потому что из-за низкой точности чертежа
//может возникнуть ситуация типа 5х199=1000
int count = i - start_dim;
double dim_max = centers_projected[i].DistanceTo(centers_projected[start_dim]);
double dim_corrected = dim_max / count;
dim.DimensionText = string.Format("{0}х{1:0}=<>", count, dim_corrected);
}
if (i - start_dim == 2)
{
//случай когда 2 одинаковых
i--;
}
if (i == 1)
{
dim.XLine2Point = centers[start_dim];
dim.XLine1Point = centers[i];
if (tails)
{
dim.Dimtmove = 0;
}
else
{
dim.Dimtmove = 1;
}
}
else if (i == centers_projected.Count - 1)
{
dim.XLine1Point = centers[start_dim];
dim.XLine2Point = centers[i];
if (tails)
{
dim.Dimtmove = 0;
}
else
{
dim.Dimtmove = 1;
}
}
else
{
dim.XLine2Point = centers[start_dim];
dim.XLine1Point = centers[i];
dim.Dimtmove = 1;
}
dim.DimLinePoint = centers_projected[i];
dim.Rotation = DimDirection.Angle;
dim.DimensionStyle = acCurDb.Dimstyle;
dim.Annotative = AnnotativeStates.True;
//сужаем тексты
if (dim.Measurement < (asc.DrawingUnits / asc.PaperUnits) * 9 && dim.Measurement > (asc.DrawingUnits / asc.PaperUnits) * 4)
{
if (dim.DimensionText == null | dim.DimensionText == "")
{
dim.DimensionText = @"{\W0.6;<>}";
}
else
{
dim.DimensionText = @"{\W0.6;" + dim.DimensionText + @"}";
}
}
//если размер маленький, сужаем
dimensions.Add(dim);
if (i < centers_projected.Count - 1)
{
current_dimm = centers_projected[i + 1].DistanceTo(centers_projected[i]);
}
start_dim = i;
}
}