public static void ConfigureParamsView(ParamsView view)
{
Label sizeLabel = null;
void refreshSize() => sizeLabel.Text = Acad.GetSize(view.GetParams <Disk3DTechProcess>().ProcessingArea);
view.BindingSource.DataSourceChanged += (s, e) => refreshSize();
view.AddMachine(CAM.MachineType.Donatoni, CAM.MachineType.ScemaLogic)
.AddMaterial()
.AddParam(nameof(Thickness))
.AddIndent()
.AddTool()
.AddParam(nameof(Frequency))
.AddParam(nameof(PenetrationFeed))
.AddIndent()
.AddAcadObject(allowedTypes: $"{AcadObjectNames.Surface},{AcadObjectNames.Region}", afterSelect: (ids) => refreshSize())
.AddText("Размеры", p => sizeLabel = p)
.AddParam(nameof(Angle), "Угол")
.AddParam(nameof(IsExactlyBegin), "Начало точно")
.AddParam(nameof(IsExactlyEnd), "Конец точно")
.AddParam(nameof(ZSafety))
.AddParam(nameof(IsA90), "Угол A = 90")
.AddParam(nameof(OriginCellNumber), "Ячейка начала координат");
}
public void CalcPassList()
{
if (TechProcess.Tool.Thickness == null)
{
Acad.Alert("Не указана толщина инструмента");
return;
}
var toolThickness = TechProcess.Tool.Thickness.Value;
if (MaxCrestWidth == 0 || MaxCrestWidth > toolThickness)
{
MaxCrestWidth = toolThickness;
}
var periodAll = BandWidth - toolThickness;
var periodWidth = toolThickness + MaxCrestWidth;
var count = Math.Ceiling(periodAll / periodWidth);
periodWidth = periodAll / count;
var x = (toolThickness - (periodWidth - toolThickness)) / 2;
var shift = TechProcess.MachineType == MachineType.ScemaLogic ^ ProcessingAngle == 45? toolThickness : 0;
PassList = new List <Pass> {
new Pass(shift, CuttingType.Roughing)
};
for (int i = 1; i <= count; i++)
{
PassList.Add(new Pass(i * periodWidth + shift, CuttingType.Roughing));
PassList.Add(new Pass(i * periodWidth + x + shift - toolThickness, CuttingType.Finishing));
}
}
public void BindData(Disk3DTechProcess data)
{
disk3DTechProcessBindingSource.DataSource = _techProcess = data;
tbTool.Text = _techProcess.Tool?.ToString();
tbObjects.Text = _techProcess.ProcessingArea?.GetDesc();
lbSize.Text = Acad.GetSize(_techProcess.ProcessingArea);
}
public override bool Validate()
{
if (StepPass == 0)
{
Acad.Alert("Не заполнено поле \"Шаг межстрочный\"");
}
return(StepPass != 0);
}
public override bool Validate()
{
if (Angle2 >= 90)
{
Acad.Alert("Угол2 должен быть меньше 90");
}
return(Angle2 < 90);
}
public override bool Validate()
{
if (LongStep == 0 || ProfileStep == 0)
{
Acad.Alert("Не заполнено поле \"Шаг\"");
}
return(!(LongStep == 0 || ProfileStep == 0));
}
public void Clear()
{
PointsX.Clear();
PointsY.Clear();
if (PointObjectIds.Any())
{
Acad.DeleteObjects(PointObjectIds);
}
}
public void Clear()
{
PointsX.Clear();
PointsY.Clear();
if (PointObjectIds.Any())
{
Acad.DeleteObjects(PointObjectIds);
}
PointObjectIds = Array.Empty <ObjectId>();
}
private void bObjects_Click(object sender, EventArgs e)
{
Acad.SelectObjectIds();
Interaction.SetActiveDocFocus();
var ids = Interaction.GetSelection("\nВыберите объекты распиловки", $"{AcadObjectNames.Line},{AcadObjectNames.Arc},{AcadObjectNames.Lwpolyline}");
if (ids.Length == 0)
{
return;
}
Acad.DeleteExtraObjects();
_techProcess.CreateExtraObjects(ids);
tbObjects.Text = _techProcess.ProcessingArea.GetDesc();
}
private void bObjects_Click(object sender, EventArgs e)
{
Interaction.SetActiveDocFocus();
Acad.SelectObjectIds();
var ids = Interaction.GetSelection("\nВыберите окружности", AcadObjectNames.Circle);
if (ids.Length == 0)
{
return;
}
_techProcess.ProcessingArea = AcadObject.CreateList(ids);
tbObjects.Text = _techProcess.ProcessingArea.GetDesc();
Acad.SelectObjectIds(ids);
}
private void bObjects_Click(object sender, EventArgs e)
{
Acad.SelectObjectIds();
Interaction.SetActiveDocFocus();
var ids = Interaction.GetSelection("\nВыберите объекты", $"{AcadObjectNames.Surface},{AcadObjectNames.Region}");
if (ids.Length == 0)
{
return;
}
_techProcess.ProcessingArea = AcadObject.CreateList(ids);
tbObjects.Text = _techProcess.ProcessingArea.GetDesc();
lbSize.Text = Acad.GetSize(_techProcess.ProcessingArea);
}
private void bObjects_Click(object sender, System.EventArgs e)
{
Interaction.SetActiveDocFocus();
Acad.SelectObjectIds();
var ids = Interaction.GetSelection("\nВыберите объекты контура");
if (ids.Length == 0)
{
return;
}
_techProcess.ProcessingArea = AcadObject.CreateList(ids);
tbObjects.Text = _techProcess.ProcessingArea.GetDesc();
Acad.SelectObjectIds(ids);
}
private void bObjects_Click(object sender, EventArgs e)
{
Interaction.SetActiveDocFocus();
Acad.SelectObjectIds();
var ids = Interaction.GetSelection("\nВыберите профиль [Отрезок], [Дуга], [Полилиния]", $"{AcadObjectNames.Line},{AcadObjectNames.Arc},{AcadObjectNames.Lwpolyline}");
if (ids.Length == 0)
{
return;
}
ids = new ObjectId[] { ids[0] };
_techProcess.ProcessingArea = AcadObject.CreateList(ids);
tbObjects.Text = _techProcess.ProcessingArea.GetDesc();
Acad.SelectObjectIds(ids);
}
private void bProcessingArea_Click(object sender, EventArgs e)
{
Interaction.SetActiveDocFocus();
Acad.SelectObjectIds();
var ids = Interaction.GetSelection("\nВыберите объекты контура плитки", "LINE");
if (ids.Length == 0)
{
return;
}
_techProcess.ProcessingArea = AcadObject.CreateList(ids);
tbContour.Text = _techProcess.ProcessingArea.GetDesc();
Acad.SelectObjectIds(ids);
SetParamsEnabled();
}
public virtual void SerializeInit()
{
if (OriginX != 0 || OriginY != 0)
{
OriginObject = Acad.CreateOriginObject(new Point3d(OriginX, OriginY, 0));
}
AcadObject.LoadAcadProps(this);
TechOperations.ForEach(p =>
{
AcadObject.LoadAcadProps(p);
p.TechProcessBase = this;
p.SerializeInit();
});
}
private double?[,] GetZArray(Point2dCollection[] collections, double sizeX)
{
var distance = TechProcess.Tool.Diameter / 2;
var countX = (int)(sizeX / StepX2) + 1;
var zArray = new double?[collections.Length, countX];
var intersector = new CurveCurveIntersector2d();
Acad.SetLimitProgressor(collections.Length);
var rays = Enumerable.Range(0, countX).Select(p => new Ray2d(new Point2d(p * StepX2, 0), Vector2d.YAxis)).ToList();
for (int i = 0; i < collections.Length; i++)
{
Acad.ReportProgressor();
if (collections[i] == null)
{
continue;
}
var polylene = new PolylineCurve2d(collections[i]);
var offsetCurve = polylene.GetTrimmedOffset(distance, OffsetCurveExtensionType.Fillet)[0];
for (int j = 0; j < countX; j++)
{
intersector.Set(offsetCurve, rays[j]);
if (intersector.NumberOfIntersectionPoints == 1)
{
zArray[i, j] = intersector.GetIntersectionPoint(0).Y - distance;
}
}
//if (i < 50)
//{
// Draw.Pline(polylene.GetSamplePoints(10).Select(p => new Point3d(p.X + i * 100, p.Y + 1000, 0)));
// Draw.Pline(offsetCurve.GetSamplePoints(10).Select(p => new Point3d(p.X + i * 100, p.Y + 1000, 0)));
//}
//else
//{
polylene.Dispose();
offsetCurve.Dispose();
//}
}
rays.ForEach(p => p.Dispose());
intersector.Dispose();
return(zArray);
}
private void bOrigin_Click(object sender, EventArgs e)
{
Interaction.SetActiveDocFocus();
var point = Interaction.GetPoint("\nВыберите точку начала координат");
if (!point.IsNull())
{
_techProcess.OriginX = point.X.Round(3);
_techProcess.OriginY = point.Y.Round(3);
tbOrigin.Text = $"{{{_techProcess.OriginX}, {_techProcess.OriginY}}}";
if (_techProcess.OriginObject != null)
{
Acad.DeleteObjects(_techProcess.OriginObject);
}
_techProcess.OriginObject = Acad.CreateOriginObject(point);
}
}
private void bRail_Click(object sender, EventArgs e)
{
Interaction.SetActiveDocFocus();
Acad.SelectObjectIds();
var ids = Interaction.GetSelection("\nВыберите направляющую [Отрезок]", AcadObjectNames.Line);
if (ids.Length == 1)
{
_techProcess.Rail = AcadObject.Create(ids[0]);
tbRail.Text = _techProcess.Rail.GetDesc();
Acad.SelectObjectIds(ids);
}
else
{
_techProcess.Rail = null;
tbRail.Text = "";
}
}
private void bObject_Click(object sender, System.EventArgs e)
{
Acad.SelectObjectIds();
Interaction.SetActiveDocFocus();
var ids = Interaction.GetSelection("\nВыберите объект", $"{AcadObjectNames.Line},{AcadObjectNames.Arc},{AcadObjectNames.Lwpolyline}");
if (ids.Length == 0)
{
return;
}
Acad.DeleteExtraObjects();
_techOperation.ProcessingArea = null;
var border = ((SawingTechProcess)_techOperation.TechProcess).CreateExtraObjects(ids[0])[0];
_techOperation.SetFromBorder(border);
tbObject.Text = _techOperation.ProcessingArea.GetDesc();
sawingTechOperationBindingSource.ResetBindings(false);
sawingModesView.sawingModesBindingSource.DataSource = _techOperation.SawingModes;
}
private static void ConfigurePointsSelector(TextBox textBox, Button button, BindingSource bindingSource)
{
textBox.Enter += (s, e) => Acad.SelectObjectIds(bindingSource.GetSource <MeasurementTechOperation>().PointObjectIds);
button.Click += (s, e) =>
{
var operation = bindingSource.GetSource <MeasurementTechOperation>();
operation.Clear();
Interaction.SetActiveDocFocus();
Point3d point;
while (!(point = Interaction.GetPoint("\nВыберите точку измерения")).IsNull())
{
operation.CreatePoint(point);
textBox.Text = operation.PointsX.Count.ToString();
}
};
bindingSource.DataSourceChanged += (s, e) => textBox.Text = bindingSource.GetSource <MeasurementTechOperation>().PointsX.Count.ToString();
}
private void bObjects_Click(object sender, EventArgs e)
{
if (_techProcess.ProcessingArea == null)
{
Acad.Alert("Укажите контур плитки");
return;
}
Interaction.SetActiveDocFocus();
Acad.SelectObjectIds();
var ids = Interaction.GetSelection("\nВыберите 2 элемента плитки");
if (ids.Length > 0)
{
_techProcess.CalcType(ids);
_techProcess.Objects = AcadObject.CreateList(ids);
tbObjects.Text = _techProcess.Objects.GetDesc();
tactileTechProcessBindingSource.ResetBindings(false);
SetParamsEnabled();
}
}
private Point2dCollection[] GetPointCollections(DbSurface offsetSurface, Point3d minPoint, Point3d maxPoint)
{
var countY = (int)((maxPoint.Y - minPoint.Y) / StepY) + 1;
var countX = (int)((maxPoint.X - minPoint.X) / StepX1) + 1;
var collections = new Point2dCollection[countY];
Acad.SetLimitProgressor(countY);
for (var i = 0; i < countY; i++)
{
Acad.ReportProgressor();
var collection = new Point2dCollection();
var dy = i * StepY;
for (var j = 0; j < countX; j++)
{
var dx = j * StepX1;
offsetSurface.RayTest(minPoint + new Vector3d(dx, dy, 0), Vector3d.ZAxis, 0.0001, out SubentityId[] col, out DoubleCollection par);
if (par.Count == 1)
{
var point = new Point2d(dx, Math.Round(par[0], 2));
var ind = collection.Count - 1;
if (ind > 0 && collection[ind - 1].GetVectorTo(collection[ind]).IsCodirectionalTo(collection[ind].GetVectorTo(point)))
{
collection[ind] = point;
}
else
{
collection.Add(point);
}
}
}
if (collection.Count > 1)
{
collections[i] = collection;
}
}
return(collections);
}
private void tbRail_Enter(object sender, EventArgs e)
{
Acad.SelectAcadObjects(new List <AcadObject> {
_techProcess.Rail
});
}
public void CalcType(ObjectId[] ids)
{
Type = null;
BandSpacing = null;
BandWidth = null;
BandStart1 = null;
BandStart2 = null;
ProcessingAngle1 = null;
ProcessingAngle2 = null;
if (ids.Length < 2)
{
Acad.Alert("Выберите 2 элемента");
return;
}
var contourPoints = GetContour().GetPolyPoints().ToArray();
var curves = ids.QOpenForRead <Curve>();
var circles = curves.OfType <Circle>().ToArray();
if (circles.Any())
{
var radius = circles.Max(p => p.Radius);
circles = circles.Where(p => p.Radius == radius).ToArray();
const double Delta = 1;
radius += Delta;
var vector = circles[1].Center - circles[0].Center;
var center = (circles[1].Center.X < circles[0].Center.X ? circles[1] : circles[0]).Center;
BandSpacing = radius * 2;
BandWidth = vector.Length - BandSpacing.Value;
if (vector.IsParallelTo(Vector3d.XAxis) || vector.IsPerpendicularTo(Vector3d.XAxis))
{
Type = "Конусы прямые";
ProcessingAngle1 = 0;
ProcessingAngle2 = 90;
BandStart1 = center.Y + radius - contourPoints[0].Y;
BandStart2 = center.X + radius - contourPoints[0].X;
}
else
{
Type = "Конусы диагональные";
var ray = new Ray {
BasePoint = center
};
ProcessingAngle1 = 135;
ray.UnitDir = Vector3d.XAxis.RotateBy(Graph.ToRad(ProcessingAngle1.Value), Vector3d.ZAxis);
BandStart1 = ray.GetDistToPoint(contourPoints[0], true) + radius;
ProcessingAngle2 = 45;
ray.UnitDir = Vector3d.XAxis.RotateBy(Graph.ToRad(ProcessingAngle2.Value), Vector3d.ZAxis);
BandStart2 = ray.GetDistToPoint(contourPoints[3], true) % vector.Length + radius;
}
RoundParams();
return;
}
var lines = curves.OfType <Line>().ToArray();
if (lines.Length == 8)
{
Type = "Квадраты";
ProcessingAngle1 = 0;
ProcessingAngle2 = 90;
BandSpacing = lines.First().Length;
var points = lines.SelectMany(p => Graph.GetStartEndPoints(p));
var point1 = new Point3d(points.Min(p => p.X), points.Min(p => p.Y), 0);
BandStart1 = point1.Y + BandSpacing - contourPoints[0].Y;
BandStart2 = point1.X + BandSpacing - contourPoints[0].X;
var point2 = new Point3d(points.Max(p => p.X), points.Max(p => p.Y), 0);
var vector = point2 - point1;
BandWidth = (vector.X > vector.Y ? point2.X - point1.X : point2.Y - point1.Y) - BandSpacing * 2;
RoundParams();
return;
}
if (lines.Length == 3 || lines.Length == 4)
{
var vector = lines[0].Delta;
if (vector.IsParallelTo(Vector3d.XAxis, Tolerance.Global))
{
ProcessingAngle1 = 0;
}
if (vector.IsParallelTo(Vector3d.XAxis.RotateBy(Math.PI / 4, Vector3d.ZAxis)))
{
ProcessingAngle1 = 45;
}
if (vector.IsParallelTo(Vector3d.YAxis, Tolerance.Global))
{
ProcessingAngle1 = 90;
}
if (vector.IsParallelTo(Vector3d.XAxis.RotateBy(Math.PI * 3 / 4, Vector3d.ZAxis)))
{
ProcessingAngle1 = 45;
}
if (ProcessingAngle1.HasValue)
{
Type = $"Полосы {ProcessingAngle1}";
var point = ProcessingAngle1 == 45 ? contourPoints[3] : contourPoints[0];
var dist = lines.Select(p => p.GetDistToPoint(point)).OrderBy(p => p).ToArray();
var s1 = dist[1] - dist[0];
var s2 = dist[2] - dist[1];
BandWidth = Math.Max(s1, s2);
BandSpacing = Math.Min(s1, s2);
BandStart1 = (s1 > s2 ? dist[0] : dist[1]) % (BandWidth + BandSpacing);
RoundParams();
return;
}
}
Acad.Alert("Тип плитки не распознан");
void RoundParams()
{
BandSpacing = BandSpacing?.Round(3);
BandWidth = BandWidth?.Round(3);
BandStart1 = BandStart1?.Round(3);
BandStart2 = BandStart2?.Round(3);
}
}
public List <Border> CreateExtraObjects(params ObjectId[] ids)
{
ExtraObjectsGroup?.DeleteGroup();
ExtraObjectsGroup = null;
var techOperations = TechOperations.FindAll(p => p.ProcessingArea != null);
techOperations.FindAll(p => ids.Contains(p.ProcessingArea.ObjectId)).ForEach(p => ((SawingTechOperation)p).OuterSide = Side.None);
_borders = ids.Except(techOperations.Select(p => p.ProcessingArea.ObjectId)).Select(p => new Border(p)).ToList();
var borders = _borders.Concat(techOperations.Select(p => new Border((SawingTechOperation)p))).ToList();
borders.ForEach(p => p.Curve = Acad.OpenForRead(p.ObjectId));
ProcessingArea = AcadObject.CreateList(borders.Select(p => p.ObjectId));
while ((borders.Find(p => p.OuterSide != Side.None) ?? borders.FirstOrDefault()) is Border startBorder)
{
if (startBorder.OuterSide == Side.None)
{
startBorder.OuterSide = GetOuterSide(startBorder.Curve);
}
var contour = CalcBordersChain(startBorder, Corner.End);
if (borders.Contains(startBorder))
{
var contourBack = CalcBordersChain(startBorder, Corner.Start);
contourBack.Reverse();
contourBack.Add(startBorder.Curve);
contourBack.AddRange(contour);
contour = contourBack;
borders.Remove(startBorder);
}
var sign = startBorder.OuterSide == Side.Left ? 1 : -1;
var hatchId = Graph.CreateHatch(contour, sign);
if (hatchId.HasValue)
{
ExtraObjectsGroup = ExtraObjectsGroup.AppendToGroup(hatchId.Value);
}
}
return(_borders);
List <Curve> CalcBordersChain(Border border, Corner corner)
{
var point = border.Curve.GetPoint(corner);
var contour = new List <Curve>();
while (borders.SingleOrDefault(p => p != border && p.Curve.HasPoint(point)) is Border nextBorder)
{
contour.Add(nextBorder.Curve);
borders.Remove(nextBorder);
var nextCorner = nextBorder.Curve.GetCorner(point);
nextBorder.OuterSide = nextCorner != corner ? border.OuterSide : border.OuterSide.Opposite();
if (border.MustCalc || nextBorder.MustCalc)
{
var isExactly = CalcIsExactly(border, corner, nextBorder, nextCorner, point);
border.SetIsExactly(corner, isExactly);
nextBorder.SetIsExactly(nextCorner, isExactly);
}
border = nextBorder;
corner = nextCorner.Swap();
point = border.Curve.GetPoint(corner);
}
return(contour);
}
bool CalcIsExactly(Border border, Corner corner, Border nextBorder, Corner nextCorner, Point3d point)
{
var v1 = border.Curve.GetTangent(corner);
var v2 = nextBorder.Curve.GetTangent(nextCorner);
var isLeftTurn = v1.MinusPiToPiAngleTo(v2) > Consts.Epsilon;
var isLeftOuterSide = border.OuterSide == Side.Left;
var isNextStartPoint = nextCorner == Corner.Start;
return(isLeftTurn ^ isLeftOuterSide ^ isNextStartPoint);
}
Side GetOuterSide(Curve curve)
{
var startPoint = curve.GetPointAtParameter((curve.EndParam + curve.StartParam) / 2);
var point = Interaction.GetLineEndPoint("Выберите направление внешней нормали к объекту", startPoint);
var vector = curve.GetTangent(startPoint);
return(vector.IsTurnRight((point - startPoint).ToVector2d()) ? Side.Right : Side.Left);
}
}
public override void BuildProcessing(ICommandGenerator generator)
{
const int CornerIndentIncrease = 5;
var techProcess = (SawingTechProcess)TechProcess;
var curve = ProcessingArea.GetCurve();
var thickness = techProcess.Thickness.Value;
var toolDiameter = techProcess.Tool.Diameter;
var engineSide = Side.None;
double offsetArc = 0;
double angleA = 0;
if (techProcess.MachineType == MachineType.ScemaLogic)
{
AngleA = 0;
}
switch (curve)
{
case Arc arc:
CalcArc(arc);
break;
case Line line:
CalcLine(line);
break;
case Polyline polyline:
CalcPolyline(polyline);
break;
default:
throw new InvalidOperationException($"Кривая типа {curve.GetType()} не может быть обработана.");
}
var outerSideSign = OuterSide == Side.Left ^ curve is Line ? -1 : 1;
var offsetCoeff = Math.Tan(angleA) * outerSideSign;
var depthCoeff = 1 / Math.Cos(angleA);
var toolThickness = techProcess.Tool.Thickness.Value * depthCoeff;
var compensation = (offsetArc + (engineSide == OuterSide ^ techProcess.MachineType == MachineType.Donatoni ? toolThickness : 0)) * outerSideSign;
var shift = angleA > 0 ? -thickness * offsetCoeff : 0;
var sumIndent = CalcIndent(thickness) * (Convert.ToInt32(IsExactlyBegin) + Convert.ToInt32(IsExactlyEnd));
if (sumIndent >= curve.Length())
{
if (AngleA != 0)
{
throw new InvalidOperationException("Расчет намечания выполняется только при нулевом вертикальном угле.");
}
var point = Scheduling();
var angle = BuilderUtils.CalcToolAngle((curve.EndPoint - curve.StartPoint).ToVector2d().Angle, engineSide);
generator.Move(point.X, point.Y, angleC: angle);
generator.Cutting(point.X, point.Y, point.Z, techProcess.PenetrationFeed);
return;
}
var modes = SawingModes.ConvertAll(p => new CuttingMode {
Depth = p.Depth, DepthStep = p.DepthStep, Feed = p.Feed
});
var passList = BuilderUtils.GetPassList(modes, thickness, !ProcessingArea.ObjectId.IsLine()).ToList();
Curve toolpathCurve = null;
foreach (var item in passList)
{
CreateToolpath(item.Key, compensation + shift + item.Key * offsetCoeff);
if (generator.IsUpperTool)
{
var point = engineSide == Side.Right ^ (passList.Count() % 2 == 1) ? toolpathCurve.EndPoint : toolpathCurve.StartPoint;
var vector = Vector3d.ZAxis * (item.Key + generator.ZSafety);
if (angleA != 0)
{
vector = vector.RotateBy(outerSideSign * angleA, ((Line)toolpathCurve).Delta) * depthCoeff;
}
var p0 = point + vector;
var angleC = BuilderUtils.CalcToolAngle(toolpathCurve, point, engineSide);
generator.Move(p0.X, p0.Y, angleC: angleC, angleA: Math.Abs(AngleA));
if (techProcess.MachineType == MachineType.ScemaLogic)
{
generator.Command("28;;XYCZ;;;;;;", "Цикл");
}
}
generator.Cutting(toolpathCurve, item.Value, techProcess.PenetrationFeed, engineSide);
}
generator.Uplifting(Vector3d.ZAxis.RotateBy(outerSideSign * angleA, toolpathCurve.EndPoint - toolpathCurve.StartPoint) * (thickness + generator.ZSafety) * depthCoeff);
if (!IsExactlyBegin || !IsExactlyEnd)
{
var gashCurve = curve.GetOffsetCurves(shift)[0] as Curve;
if (!IsExactlyBegin)
{
Acad.CreateGash(gashCurve, gashCurve.StartPoint, OuterSide, thickness * depthCoeff, toolDiameter, toolThickness);
}
if (!IsExactlyEnd)
{
Acad.CreateGash(gashCurve, gashCurve.EndPoint, OuterSide, thickness * depthCoeff, toolDiameter, toolThickness);
}
gashCurve.Dispose();
}
// Local func ------------------------
void CalcArc(Arc arc)
{
AngleA = 0;
var startSide = Math.Sign(Math.Cos(arc.StartAngle.Round(3)));
var endSide = Math.Sign(Math.Cos(arc.EndAngle.Round(3)));
var cornersOneSide = Math.Sign(startSide * endSide);
if (arc.TotalAngle.Round(3) > Math.PI && cornersOneSide > 0)
{
throw new InvalidOperationException("Обработка дуги невозможна - дуга пересекает углы 90 и 270 градусов.");
}
if (cornersOneSide < 0) // дуга пересекает углы 90 или 270 градусов
{
if (techProcess.MachineType == MachineType.ScemaLogic)
{
throw new InvalidOperationException("Обработка дуги невозможна - дуга пересекает угол 90 или 270 градусов.");
}
engineSide = startSide > 0 ? Side.Left : Side.Right;
}
if (OuterSide == Side.Left) // внутренний рез дуги
{
if (techProcess.MachineType == MachineType.Donatoni && engineSide != Side.Left) // подворот диска при вн. резе дуги
{
engineSide = Side.Right;
//var comp = arc.Radius - Math.Sqrt(arc.Radius * arc.Radius - thickness * (toolDiameter - thickness));
//AngleA = Math.Atan2(comp, thickness).ToDeg();
var R = arc.Radius;
var t = thickness;
var d = toolDiameter;
var comp = (2 * R * t * t - Math.Sqrt(-d * d * d * d * t * t + 4 * d * d * R * R * t * t + d * d * t * t * t * t)) / (d * d - 4 * R * R);
AngleA = -Math.Atan2(comp, thickness).ToDeg();
}
else
{
offsetArc = arc.Radius - Math.Sqrt(arc.Radius * arc.Radius - thickness * (toolDiameter - thickness));
}
}
if (engineSide == Side.None)
{
engineSide = (startSide + endSide) > 0 ? Side.Right : Side.Left;
}
}
void CalcLine(Line line)
{
angleA = AngleA.ToRad();
engineSide = AngleA == 0 ? BuilderUtils.CalcEngineSide(line.Angle) : AngleA > 0 ? OuterSide : OuterSide.Opposite();
}
void CalcPolyline(Polyline polyline)
{
int sign = 0;
for (int i = 0; i < polyline.NumberOfVertices; i++)
{
var point = polyline.GetPoint3dAt(i);
var s = Math.Sign(Math.Sin(polyline.GetTangent(point).Angle.Round(6)));
if (s == 0)
{
continue;
}
if (sign == 0)
{
sign = s;
continue;
}
var bulge = polyline.GetBulgeAt(i - 1);
if (bulge == 0)
{
bulge = polyline.GetBulgeAt(i);
}
if (s != sign)
{
if (techProcess.MachineType == MachineType.ScemaLogic)
{
throw new InvalidOperationException("Обработка полилинии невозможна - кривая пересекает углы 90 или 270 градусов.");
}
var side = sign > 0 ^ bulge < 0 ? Side.Left : Side.Right;
if (engineSide != Side.None)
{
if (engineSide != side)
{
throw new InvalidOperationException("Обработка полилинии невозможна.");
}
}
else
{
engineSide = side;
}
sign = s;
}
else
if (Math.Abs(bulge) > 1)
{
throw new InvalidOperationException("Обработка невозможна - дуга полилинии пересекает углы 90 и 270 градусов.");
}
}
if (engineSide == Side.None)
{
engineSide = BuilderUtils.CalcEngineSide(polyline.GetTangent(polyline.StartPoint).Angle);
}
}
void CreateToolpath(double depth, double offset)
{
toolpathCurve = curve.GetOffsetCurves(offset)[0] as Curve;
toolpathCurve.TransformBy(Matrix3d.Displacement(-Vector3d.ZAxis * depth));
if (!IsExactlyBegin && !IsExactlyEnd)
{
return;
}
var indent = CalcIndent(depth * depthCoeff);
switch (toolpathCurve)
{
case Line l:
if (IsExactlyBegin)
{
l.StartPoint = l.GetPointAtDist(indent);
}
if (IsExactlyEnd)
{
l.EndPoint = l.GetPointAtDist(l.Length - indent);
}
break;
case Arc a:
var indentAngle = indent / ((Arc)curve).Radius;
if (IsExactlyBegin)
{
a.StartAngle = a.StartAngle + indentAngle;
}
if (IsExactlyEnd)
{
a.EndAngle = a.EndAngle - indentAngle;
}
break;
case Polyline p:
if (IsExactlyBegin)
{
p.SetPointAt(0, p.GetPointAtDist(indent).ToPoint2d());
}
//p.StartPoint = p.GetPointAtDist(indent);
if (IsExactlyEnd)
{
//p.EndPoint = p.GetPointAtDist(p.Length - indent);
p.SetPointAt(p.NumberOfVertices - 1, p.GetPointAtDist(p.Length - indent).ToPoint2d());
}
break;
}
;
}
double CalcIndent(double depth) => Math.Sqrt(depth * (toolDiameter - depth)) + CornerIndentIncrease;
/// <summary>
/// Расчет точки намечания
/// </summary>
Point3d Scheduling()
{
var vector = curve.EndPoint - curve.StartPoint;
var depth = thickness;
var point = Point3d.Origin;
if (IsExactlyBegin && IsExactlyEnd)
{
var l = vector.Length - 2 * CornerIndentIncrease;
depth = (toolDiameter - Math.Sqrt(toolDiameter * toolDiameter - l * l)) / 2;
point = curve.StartPoint + vector / 2;
}
else
{
var indentVector = vector.GetNormal() * (Math.Sqrt(depth * (toolDiameter - depth)) + CornerIndentIncrease);
point = IsExactlyBegin ? curve.StartPoint + indentVector : curve.EndPoint - indentVector;
Acad.CreateGash(curve, IsExactlyBegin ? curve.EndPoint : curve.StartPoint, OuterSide, depth, toolDiameter, toolThickness, point);
}
return(point + vector.GetPerpendicularVector().GetNormal() * compensation - Vector3d.ZAxis * depth);
}
}
public override void Teardown()
{
Acad.DeleteObjects(PointObjectIds);
base.Teardown();
}
public void CreatePoint(Point3d point)
{
PointsX.Add(point.X);
PointsY.Add(point.Y);
PointObjectIds = PointObjectIds.Concat(Acad.CreateMeasurementPoint(point)).ToArray();
}
private void tbObjects_Enter(object sender, EventArgs e)
{
Acad.SelectAcadObjects(_techProcess.ProcessingArea);
}
public override void Setup(ITechProcess techProcess)
{
base.Setup(techProcess);
PointObjectIds = PointsX.SelectMany((p, i) => Acad.CreateMeasurementPoint(new Point3d(PointsX[i], PointsY[i], 0))).ToArray();
}
