private void Cutting(MillingCommandGenerator generator, double x, double y) { generator.Move(x, y); generator.Move(z: ZEntry); var zMin = -Depth; double z = 0; int counter = 0; while (z >= zMin) { var feed = (int)((FeedMax - FeedMin) / zMin * (z * z / zMin - 2 * z) + FeedMax); generator.Cutting(x, y, z, feed); if (z <= -2) { if (++counter == 5) // Подъем на 1мм для охлаждения { counter = 0; generator.Pause(0.2); generator.Uplifting(z + 1); generator.Cutting(x, y, z + 0.2, (int)(FeedMax * 1.5)); generator.Cutting(x, y, z, feed); } } z -= 0.2; } generator.Pause(0.2); generator.Uplifting(); }
private Point3d BuildPass(MillingCommandGenerator generator, List <Point3d> points) { var z = generator.ZSafety - TechProcess.ZSafety; bool isComplete; var point = Algorithms.NullPoint3d; do { isComplete = true; z -= Penetration; var point0 = Algorithms.NullPoint3d; foreach (var pt in points) { var p = pt; if (z > p.Z) { p = new Point3d(p.X, p.Y, z); isComplete = false; } if (generator.IsUpperTool) { generator.Move(p.X, p.Y, angleC: ((Disk3DTechProcess)TechProcess).Angle); generator.Cycle(); } if (point.IsNull()) { if (generator.ToolPosition.Point != p) { generator.GCommand(CommandNames.Penetration, 1, point: p, feed: TechProcess.PenetrationFeed); } else { generator.Move(p.X, p.Y); generator.Cycle(); } } else if (point0 != point && point != p && !point0.GetVectorTo(point).IsCodirectionalTo(point.GetVectorTo(p))) { generator.GCommand(CommandNames.Cutting, 1, point: point, feed: CuttingFeed); point0 = point; } if (point0.IsNull()) { point0 = p; } point = p; } generator.GCommand(CommandNames.Cutting, 1, point: point, feed: CuttingFeed); points.Reverse(); }while (!isComplete); if (IsUplifting) { generator.Uplifting(); } return(point); }
public override void BuildProcessing(MillingCommandGenerator generator) { _disk3DTechProcess = (Disk3DTechProcess)TechProcess; var offsetSurface = CreateOffsetSurface(); var matrix = Matrix3d.Rotation(_disk3DTechProcess.Angle.ToRad(), Vector3d.ZAxis, Point3d.Origin); if (_disk3DTechProcess.Angle != 0) { offsetSurface.TransformBy(matrix); } var minPoint = offsetSurface.GeometricExtents.MinPoint; var maxPoint = offsetSurface.GeometricExtents.MaxPoint; var collections = GetPointCollections(offsetSurface, minPoint, maxPoint); offsetSurface.Dispose(); var zArray = GetZArray(collections, (maxPoint - minPoint).X); var passList = CalcPassList(zArray, minPoint); matrix = matrix.Inverse(); passList.ForEach(p => { var points = p; if (Departure > 0) { points.Insert(0, new Point3d((IsDepartureOnBorderSection ? points.First().X : minPoint.X) - Departure, points.First().Y, points.First().Z)); points.Add(new Point3d((IsDepartureOnBorderSection ? points.Last().X : maxPoint.X) + Departure, points.Last().Y, points.Last().Z)); } if (TechProcess.MachineType == MachineType.Donatoni) //Settongs.IsFrontPlaneZero { points = points.ConvertAll(x => new Point3d(x.X, x.Y - TechProcess.Tool.Thickness.Value, x.Z)); } if (_disk3DTechProcess.Angle != 0) { points = points.ConvertAll(x => x.TransformBy(matrix)); } var loc = generator.ToolPosition; if (loc.IsDefined && loc.Point.DistanceTo(points.First()) > loc.Point.DistanceTo(points.Last())) { points.Reverse(); } BuildPass(generator, points); if (IsUplifting) { generator.Uplifting(); } }); }
public override void BuildProcessing(MillingCommandGenerator generator) { const int AngleA = 45; var tactileTechProcess = (TactileTechProcess)TechProcess; var contour = tactileTechProcess.GetContour(); var contourPoints = contour.GetPolyPoints().ToArray(); var ray = new Ray { BasePoint = ProcessingAngle == 45 ? contourPoints.Last() : contourPoints.First(), UnitDir = Vector3d.XAxis.RotateBy(Graph.ToRad(ProcessingAngle), Vector3d.ZAxis) }; var passDir = ray.UnitDir.GetPerpendicularVector(); if (ProcessingAngle >= 90) { passDir = passDir.Negate(); } ray.BasePoint += passDir * (tactileTechProcess.BandStart1.Value - tactileTechProcess.BandSpacing.Value); var step = tactileTechProcess.BandWidth.Value + tactileTechProcess.BandSpacing.Value; var engineSide = ProcessingAngle < 90 ? Side.Right : Side.Left; while (true) { var points = new Point3dCollection(); ray.IntersectWith(contour, Intersect.ExtendThis, new Plane(), points, IntPtr.Zero, IntPtr.Zero); if (points.Count == 2 && !points[0].IsEqualTo(points[1])) { var vector = (points[1] - points[0]).GetNormal() * tactileTechProcess.Departure; var startPoint = points[0] - vector - Vector3d.ZAxis * tactileTechProcess.Depth; var endPoint = points[1] + vector - Vector3d.ZAxis * tactileTechProcess.Depth; if (generator.IsUpperTool) { generator.Move(startPoint.X, startPoint.Y, angleC: BuilderUtils.CalcToolAngle(ProcessingAngle.ToRad(), engineSide), angleA: AngleA); } generator.Cutting(startPoint, endPoint, CuttingFeed, tactileTechProcess.TransitionFeed); } else if (step > 0) { ray.BasePoint += passDir * tactileTechProcess.BandSpacing.Value; step = -step; generator.Uplifting(); engineSide = engineSide.Opposite(); } else { break; } ray.BasePoint += passDir * step; } }
public override void BuildProcessing(MillingCommandGenerator generator) { //var progressMeter = new ProgressMeter(); //progressMeter.Start($"test"); //progressMeter.SetLimit(100); //for (int i = 0; i < 100; i++) //{ // progressMeter.MeterProgress(); // Thread.Sleep(100); //} ////progressMeter.Start($"test111"); //progressMeter.SetLimit(100); //for (int i = 0; i < 100; i++) //{ // progressMeter.MeterProgress(); // Thread.Sleep(100); //} //progressMeter.Stop(); //return; //Draw.Pline(new Point3d(0, 1000, 0), new Point3d(1000, 1000, 0), new Point3d(1000, 1200, 0), new Point3d(2000, 1200, 0)); //var points1 = new Point3dCollection(new Point3d[] { new Point3d(0, 1000, 0), new Point3d(1000, 1000, 0), new Point3d(1000, 1200, 0), new Point3d(2000, 1200, 0) }); //var pline = new PolylineCurve3d(points1); // var distance = TechProcess.Tool.Diameter / 2; // var offsetCurves = pline.GetTrimmedOffset(100, Vector3d.ZAxis, OffsetCurveExtensionType.Fillet); //var cInt = new CurveCurveIntersector3d(offsetCurves[0], new Line3d(new Point3d(0, 0, 0), new Point3d(0, 3000, 0)), Vector3d.ZAxis); //var dbp = new List<DBPoint>(); //for (int i = 0; i < 2000; i++) //{ // cInt.Set(offsetCurves[0], new Line3d(new Point3d(i, 0, 0), new Point3d(i, 3000, 0)), Vector3d.ZAxis); // Point3d pnt3d = cInt.GetIntersectionPoint(0); // dbp.Add(new DBPoint(pnt3d - Vector3d.YAxis * 100)); //} //cInt.Dispose(); //dbp.AddToCurrentSpace(); _disk3DTechProcess = (Disk3DTechProcess)TechProcess; var offsetSurface = CreateOffsetSurface(); var matrix = Matrix3d.Rotation(_disk3DTechProcess.Angle.ToRad(), Vector3d.ZAxis, Point3d.Origin); if (_disk3DTechProcess.Angle != 0) { offsetSurface.TransformBy(matrix); } var minPoint = offsetSurface.GeometricExtents.MinPoint; if (StartPass != 0) { minPoint = new Point3d(minPoint.X, StartPass, minPoint.Z); } var maxPoint = offsetSurface.GeometricExtents.MaxPoint; // - Vector3d.XAxis * 1000; if (EndPass != 0) { maxPoint = new Point3d(maxPoint.X, EndPass, maxPoint.Z); } var collections = GetPointCollections(offsetSurface, minPoint, maxPoint); offsetSurface.Dispose(); var zArray = GetZArray(collections, (maxPoint - minPoint).X); //var pointsArray = CalcOffsetPoints(polylines, minPoint, maxPoint); var passList = CalcPassList(zArray, minPoint); matrix = matrix.Inverse(); if (IsReverse) { passList.Reverse(); } passList.ForEach(p => { var points = p; if (!points.Any()) { return; } if (Departure > 0) { points.Insert(0, new Point3d((IsDepartureOnBorderSection ? points.First().X : minPoint.X) - Departure, points.First().Y, points.First().Z)); points.Add(new Point3d((IsDepartureOnBorderSection ? points.Last().X : maxPoint.X) + Departure, points.Last().Y, points.Last().Z)); } if (TechProcess.MachineType == MachineType.Donatoni) //Settongs.IsFrontPlaneZero { points = points.ConvertAll(x => new Point3d(x.X, x.Y - TechProcess.Tool.Thickness.Value, x.Z)); } if (_disk3DTechProcess.Angle != 0) { points = points.ConvertAll(x => x.TransformBy(matrix)); } var loc = generator.ToolPosition; if (loc.IsDefined && loc.Point.DistanceTo(points.First()) > loc.Point.DistanceTo(points.Last())) { points.Reverse(); } BuildPass(generator, points); if (IsUplifting) { generator.Uplifting(); } }); }
public override void BuildProcessing(MillingCommandGenerator generator) { var tactileTechProcess = (TactileTechProcess)TechProcess; var isDiag = tactileTechProcess.ProcessingAngle1 != 0; var contour = tactileTechProcess.GetContour(); var contourPoints = contour.GetPolyPoints().ToArray(); var point = tactileTechProcess.Objects.Select(p => p.GetCurve()).OfType <Circle>().Select(p => p.Center).OrderBy(p => (int)p.Y).ThenBy(p => p.X).First(); var x = point.X; var y = point.Y; var stepX = tactileTechProcess.BandSpacing.Value + tactileTechProcess.BandWidth.Value; var stepY = stepX; if (isDiag) { stepY /= Math.Sqrt(2); stepX = stepY * 2; } generator.SetTool(2, Frequency, 90, false); generator.ZSafety = ZSafety; while (y < contourPoints[1].Y) { Cutting(); x += stepX; if (x > contourPoints[3].X) { y += stepY; x -= stepY; stepX = -stepX; if (x > contourPoints[3].X) { x += stepX; } } if (x < contourPoints[1].X) { y += stepY; x += stepY; stepX = -stepX; if (x < contourPoints[1].X) { x += stepX; } } } void Cutting() { generator.Move(x, y); generator.Move(z: ZEntry); var zMin = -Depth; double z = 0.2; int counter = 0; while (z > zMin) { z -= 0.2; if (z < zMin) { z = zMin; } var feed = (int)((FeedMax - FeedMin) / zMin * (z * z / zMin - 2 * z) + FeedMax); generator.Cutting(x, y, z, feed); if (z <= -2) { if (++counter == 5) // Подъем на 1мм для охлаждения { counter = 0; Pause(); generator.Uplifting(z + 1); generator.Cutting(x, y, z + 0.2, (int)(FeedMax * 1.5)); generator.Cutting(x, y, z, feed); } } } Pause(); generator.Uplifting(); void Pause() => generator.Command("G4 F0.2", "Пауза"); } contour.Dispose(); }
public override void BuildProcessing(MillingCommandGenerator generator) { var railBase = TechProcess.Rail?.GetCurve() ?? new Line(Point3d.Origin, Point3d.Origin + Vector3d.XAxis * TechProcess.Length.Value); var profile = (Profile ?? TechProcess.ProcessingArea[0]).GetCurve(); var processSide = ChangeEngineSide ? -1 : 1; CreateProfile3D(profile, railBase, 1); //var processSide = ChangeProcessSide ? -1 : 1; //CreateProfile3D(profile, railBase, processSide); var rail = CreateDepartureRail(railBase, Departure); if (Delta != 0) { var profileOffset = (Curve)profile.GetOffsetCurves(Delta)[0]; profile = profileOffset.EndPoint.GetAsVector().Length < profile.EndPoint.GetAsVector().Length ? (Curve)profile.GetOffsetCurves(-Delta)[0] : profileOffset; CreateProfile3D(profile, railBase, processSide); } if (!(railBase is Line)) { processSide *= -1; } if (railBase.IsNewObject) { railBase.Dispose(); } var side = BuilderUtils.CalcEngineSide(rail.GetFirstDerivative(0).GetAngleTo(Vector3d.XAxis)); if (ChangeEngineSide) { side = SideExt.Opposite(side); } var isMinToolCoord = IsA90 ? TechProcess.MachineType.Value != MachineType.ScemaLogic : side == Side.Right ^ TechProcess.MachineType.Value == MachineType.ScemaLogic ^ ChangeProcessSide; generator.CuttingFeed = CuttingFeed; generator.SmallFeed = TechProcess.PenetrationFeed; generator.EngineSide = side; Curve outletCurve = null; if (IsA90 && IsOutlet) { outletCurve = rail.GetOffsetCurves(TechProcess.ZSafety * processSide)[0] as Curve; var angleC = BuilderUtils.CalcToolAngle(outletCurve, outletCurve.StartPoint, side); generator.Move(outletCurve.StartPoint.X, outletCurve.StartPoint.Y, angleC: angleC, angleA: 90); } var angleA = IsA90 ? 90 : 0; var index = IsA90 ? 1 : 0; var points = BuilderUtils.GetProcessPoints(profile, index, StepPass, TechProcess.Tool.Thickness.Value, isMinToolCoord, FirstPass, LasttPass, IsExactlyBegin, IsExactlyEnd, IsProfileStep); foreach (var point in points) { var end = Math.Max(point[1 - index], PenetrationEnd ?? double.MinValue); var count = 1; var penetrationStepCalc = 0D; if (PenetrationStep.GetValueOrDefault() > 0 && PenetrationBegin.GetValueOrDefault() > end) { var allPenetration = PenetrationBegin.Value - end; count = (int)Math.Ceiling(allPenetration / PenetrationStep.Value); penetrationStepCalc = allPenetration / count; } if (IsA90 && IsOutlet && generator._isEngineStarted) { generator.Transition(z: point[index]); } var coords = Enumerable.Range(1, count).Select(p => end + (count - p) * penetrationStepCalc).ToList(); if (IsA90) { coords.ForEach(p => generator.Cutting(rail, processSide * p, point[index], angleA: angleA)); } else { coords.ForEach(p => generator.Cutting(rail, processSide * point[index], p, angleA: angleA)); } if (IsOutlet) { if (IsA90) { var pt = outletCurve.GetClosestPoint(generator.ToolPosition.Point); generator.Move(pt.X, pt.Y); } else { generator.Uplifting(); } } } rail.Dispose(); }
public override void BuildProcessing(MillingCommandGenerator generator) { var railBase = TechProcess.Rail?.GetCurve() ?? new Line(Point3d.Origin, Point3d.Origin + Vector3d.XAxis * TechProcess.Length.Value); var profile = (Profile ?? TechProcess.ProcessingArea[0]).GetCurve(); var processSide = ChangeProcessSide ? 1 : -1; CreateProfile3D(profile, railBase, processSide); var rail = CreateDepartureRail(railBase, Departure); if (Delta != 0) { var profileOffset = (Curve)profile.GetOffsetCurves(Delta)[0]; profile = profileOffset.EndPoint.GetAsVector().Length < profile.EndPoint.GetAsVector().Length ? (Curve)profile.GetOffsetCurves(-Delta)[0] : profileOffset; CreateProfile3D(profile, railBase, processSide); } var offsetSign = processSide * (railBase is Line ? 1 : -1); if (railBase.IsNewObject) { railBase.Dispose(); } var side = BuilderUtils.CalcEngineSide(rail.GetFirstDerivative(0).GetAngleTo(Vector3d.XAxis)); if (ChangeEngineSide) { side = SideExt.Opposite(side); } var isMinToolCoord = IsA90 ? TechProcess.MachineType.Value != MachineType.ScemaLogic : side == Side.Right ^ TechProcess.MachineType.Value == MachineType.ScemaLogic ^ ChangeProcessSide; generator.CuttingFeed = CuttingFeed; generator.SmallFeed = TechProcess.PenetrationFeed; generator.EngineSide = side; Curve outletCurve = null; if (IsA90 && IsOutlet) { outletCurve = rail.GetOffsetCurves(TechProcess.ZSafety * offsetSign)[0] as Curve; var angleC = BuilderUtils.CalcToolAngle(outletCurve, outletCurve.StartPoint, side); generator.Move(outletCurve.StartPoint.X, outletCurve.StartPoint.Y, angleC: angleC, angleA: 90); } var angleA = IsA90 ? 90 : 0; var index = IsA90 ? 1 : 0; var profilePoints = BuilderUtils.GetProcessPoints(profile, index, ProfileStep, TechProcess.Tool.Thickness.Value, isMinToolCoord, ProfileBegin, ProfileEnd, IsExactlyBegin, IsExactlyEnd, true); var profilePline = new Polyline(); Enumerable.Range(0, profilePoints.Count).ForEach(i => profilePline.AddVertexAt(i, profilePoints[i], 0, 0, 0)); var railLength = rail.Length(); Acad.SetLimitProgressor((int)(railLength / LongStep)); for (double dist = 0; dist < railLength; dist += LongStep) { Acad.ReportProgressor(); var point = rail.GetPointAtDist(dist); var angleC = BuilderUtils.CalcToolAngle(rail, point, side); var passPline = CalcPassPline(rail, point, profilePline, processSide); generator.Cutting(passPline, CuttingFeed, TechProcess.PenetrationFeed, angleC: angleC, angleA: angleA); if (IsOutlet) { if (IsA90) { var pt = outletCurve.GetClosestPoint(generator.ToolPosition.Point); generator.Move(pt.X, pt.Y); } else { generator.Uplifting(); } } } rail.Dispose(); }
protected override void BuildProcessing(MillingCommandGenerator generator) { var toolThickness = Tool.Thickness.Value; var profile = ProcessingArea[0].GetCurve(); if (Delta != 0) { profile = (Curve)profile.GetOffsetCurves(Delta)[0]; } var zMax = profile.GetStartEndPoints().Max(p => p.Y); generator.SetZSafety(ZSafety, zMax); var xMax = 0D; using (var curve = profile.ToCompositeCurve2d()) using (var ray = new Ray2d()) using (var intersector = new CurveCurveIntersector2d()) { var angleC = 360; var gCode = 2; for (var z = StartZ; z > 0; z -= StepZ) { var xMin = RadiusMin; for (int i = 0; i < 3; i++) { ray.Set(new Point2d(0, z + i * toolThickness / 2), Vector2d.XAxis); intersector.Set(curve, ray); if (intersector.NumberOfIntersectionPoints == 1) { xMin = Math.Max(xMin, intersector.GetIntersectionPoint(0).X); } } if (xMin == 0) { throw new Exception("Нет точек пересечения с профилем"); } var x = Math.Max(xMin, RadiusMax - Penetration); var s = x - xMin; int passCount = (int)Math.Ceiling(s / Penetration); var dx = s > Consts.Epsilon ? s / passCount : 1; if (generator.IsUpperTool) { generator.Move(0, -x - ZSafety, angleC: 0, angleA: 90); } else { generator.Transition(y: -x - ZSafety, feed: CuttingFeed); } generator.Transition(z: z); do { var arc = new Arc(new Point3d(0, 0, z), x, Math.PI * 1.5, Math.PI * 1.5 - Consts.Epsilon); generator.Cutting(0, -x, z, PenetrationFeed); generator.GCommand(CommandNames.Cutting, gCode, angleC: angleC, curve: arc, center: arc.Center.To2d(), feed: CuttingFeed); angleC = 360 - angleC; gCode = 5 - gCode; x -= dx; }while (x >= xMin - Consts.Epsilon); xMax = Math.Max(xMin, RadiusMax); } generator.Transition(y: -xMax - ZSafety, feed: PenetrationFeed); generator.Uplifting(); } }
public override void BuildProcessing(MillingCommandGenerator generator) { const int CornerIndentIncrease = 5; var curve = ProcessingArea.GetCurve(); var thickness = TechProcess.Thickness.Value + 2; // запил на 2мм ниже нижнего края 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) && Departure == 0) { var gashCurve = curve.GetOffsetCurves(shift)[0] as Curve; var gashList = new List <ObjectId>(); if (!IsExactlyBegin) { gashList.Add(Acad.CreateGash(gashCurve, gashCurve.StartPoint, OuterSide, thickness * depthCoeff, toolDiameter, toolThickness)); } if (!IsExactlyEnd) { gashList.Add(Acad.CreateGash(gashCurve, gashCurve.EndPoint, OuterSide, thickness * depthCoeff, toolDiameter, toolThickness)); } if (gashList.Count > 0) { Modify.AppendToGroup(base.TechProcess.ExtraObjectsGroup.Value, gashList.ToArray()); } 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 (Departure > 0 && toolpathCurve is Line line) { if (!IsExactlyBegin) { toolpathCurve.StartPoint = line.ExpandStart(Departure); } if (!IsExactlyEnd) { toolpathCurve.EndPoint = line.ExpandEnd(Departure); } } 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); } }
protected override void BuildProcessing(MillingCommandGenerator generator) { //чистка диском под углом А return; var rail = Rail != null?Rail.GetCurve() as Line : new Line(Point3d.Origin, new Point3d(Length.Value, 0, 0)); var startRail = rail.StartPoint; var railVector = rail.Delta.GetNormal(); if (rail.Angle >= Math.PI) { startRail = rail.EndPoint; railVector = railVector.Negate(); } var startPass = startRail - railVector * Departure; var passVector = railVector * (rail.Length + 2 * Departure); var railAngle = railVector.GetAngleTo(Vector3d.XAxis); if (Rail == null) { rail.Dispose(); } var profile = ProcessingArea[0].GetCurve(); var profileLength = profile.Length(); startPass = new Point3d(startPass.X, startPass.Y - profile.StartPoint.X, profile.StartPoint.Y); generator.ZSafety += profile.StartPoint.Y; double dist = 0; var engineSide = Side.None; double angleC; do { var point = profile.GetPointAtDist(dist); var distAvg = dist + Tool.Thickness.Value / 2; if (distAvg > profileLength) { distAvg = profileLength; } var pointAvg = profile.GetPointAtDist(distAvg); var tangent = profile.GetFirstDerivative(pointAvg); var angleA = Math.Abs(tangent.GetAngleTo(Vector3d.XAxis).ToDeg()); var side = tangent.Y < 0 ? Side.Left : Side.Right; if (engineSide != side) { engineSide = side; angleC = BuilderUtils.CalcToolAngle(railAngle, side); if (!generator.IsUpperTool) { generator.Uplifting(); } var sp = GetStartPoint(point, tangent); generator.Move(sp.X, sp.Y, angleC: angleC, angleA: angleA); } var startPoint = GetStartPoint(point, tangent); generator.Cutting(startPoint, startPoint + passVector, CuttingFeed, PenetrationFeed, angleA: angleA); dist += Step; }while (dist < profileLength); generator.Uplifting(); Point3d GetStartPoint(Point3d point, Vector3d tangent) { if (engineSide == Side.Left) { point += tangent.GetNormal() * Tool.Thickness.Value; } var profileVector = point - profile.StartPoint; return(startPass + railVector.RotateBy(Math.PI / 2, -Vector3d.ZAxis).RotateBy(profileVector.GetAngleTo(Vector3d.XAxis), railVector) * profileVector.Length); } }