mirror of
https://github.com/ajisaacs/OpenNest.git
synced 2026-11-16 17:15:33 -05:00
fix(cutting): leave out a tabbed outside's lead-out that would cut its tab free
A tab stops the outside cut short of its entry, and the lead-out leaves from there. On a counterclockwise outside a line lead-out angles forward, toward the tab: a 0.1 lead-out at 60 degrees runs 0.05 along the edge, past a 0.03 tab, and crosses the lead-in, so the two cuts sever the tab. The released- contour check rightly refused every such part, so a plate of support-tabbed strips found no cut plan at all. The emitter now drops a tabbed outside's lead-out that touches the lead-in or passes within a kerf of it, as tabbed cutouts and breakoffs already end at their tabs. Lead-outs that stay clear and untabbed contours are unchanged. The tests that expected the crossing leads now expect them left out, and a new test keeps the check's refusal of a crossing lead-out covered. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
1 parent
6b48a986fd
commit
5776fa80c9
5 files changed
+192
-47
No files matched your search
@@ -1,6 +1,7 @@
|
|||||||
using System;
|
using System;
|
||||||
using System.Collections.Generic;
|
using System.Collections.Generic;
|
||||||
using System.Linq;
|
using System.Linq;
|
||||||
|
using OpenNest.Converters;
|
||||||
using OpenNest.Geometry;
|
using OpenNest.Geometry;
|
||||||
using OpenNest.Math;
|
using OpenNest.Math;
|
||||||
|
|
||||||
@@ -630,9 +631,15 @@ namespace OpenNest.CNC.CuttingStrategy
|
|||||||
Parameters.GetEffectivePierceClearance(), out leadOutNormal);
|
Parameters.GetEffectivePierceClearance(), out leadOutNormal);
|
||||||
}
|
}
|
||||||
|
|
||||||
program.Codes.AddRange(leadIn.Generate(point, leadInNormal, turn));
|
var leadInCodes = leadIn.Generate(point, leadInNormal, turn);
|
||||||
|
program.Codes.AddRange(leadInCodes);
|
||||||
program.Codes.AddRange(ConvertShapeToMoves(reindexedShape, point));
|
program.Codes.AddRange(ConvertShapeToMoves(reindexedShape, point));
|
||||||
var leadOutCodes = leadOut.Generate(leadOutPoint, leadOutNormal, turn);
|
var leadOutCodes = leadOut.Generate(leadOutPoint, leadOutNormal, turn);
|
||||||
|
// A run-out angled toward the tab can reach the lead-in on the tab's far side, and the
|
||||||
|
// two cuts then sever the tab: the cut stops at its tab instead.
|
||||||
|
if (tabbed && Parameters.TabConfig.Size > Tolerance.Epsilon
|
||||||
|
&& LeadsMeet(leadInCodes, point, leadOutCodes, leadOutPoint, Parameters.Kerf))
|
||||||
|
leadOutCodes = [];
|
||||||
program.Codes.AddRange(leadOutCodes);
|
program.Codes.AddRange(leadOutCodes);
|
||||||
return contourType != ContourType.External && leadOutCodes.Count > 0;
|
return contourType != ContourType.External && leadOutCodes.Count > 0;
|
||||||
}
|
}
|
||||||
@@ -1050,6 +1057,60 @@ namespace OpenNest.CNC.CuttingStrategy
|
|||||||
return true;
|
return true;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Whether a tabbed outside's lead-out, leaving from <paramref name="leadOutStart"/>,
|
||||||
|
/// touches its lead-in, which enters at <paramref name="entry"/>, or passes within
|
||||||
|
/// <paramref name="kerf"/> of it. Either way the two cuts close across the tab gap
|
||||||
|
/// and cut the part free.
|
||||||
|
/// </summary>
|
||||||
|
private static bool LeadsMeet(List<ICode> leadInCodes, Vector entry, List<ICode> leadOutCodes,
|
||||||
|
Vector leadOutStart, double kerf)
|
||||||
|
{
|
||||||
|
var leadIn = LeadEntities(leadInCodes, entry);
|
||||||
|
var leadOut = LeadEntities(leadOutCodes, leadOutStart);
|
||||||
|
if (leadIn.Count == 0 || leadOut.Count == 0)
|
||||||
|
return false;
|
||||||
|
var reach = double.IsFinite(kerf) && kerf > 0 ? kerf : 0;
|
||||||
|
foreach (var cut in leadOut)
|
||||||
|
{
|
||||||
|
foreach (var lead in leadIn)
|
||||||
|
{
|
||||||
|
if (Crosses(cut, lead) || reach > 0 && (Near(cut, lead) || Near(lead, cut)))
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return false;
|
||||||
|
|
||||||
|
static bool Crosses(Entity a, Entity b) => b switch
|
||||||
|
{
|
||||||
|
Line line => a.Intersects(line),
|
||||||
|
Arc arc => a.Intersects(arc),
|
||||||
|
_ => false,
|
||||||
|
};
|
||||||
|
|
||||||
|
bool Near(Entity a, Entity b) =>
|
||||||
|
Ends(a).Any(end => b.ClosestPointTo(end).DistanceTo(end) < reach - Tolerance.Epsilon);
|
||||||
|
}
|
||||||
|
|
||||||
|
// A lead's cutting motions as entities; a lead-in starts at its own rapid to the pierce.
|
||||||
|
private static List<Entity> LeadEntities(List<ICode> codes, Vector start)
|
||||||
|
{
|
||||||
|
var program = new Program(Mode.Absolute);
|
||||||
|
if (codes.Count == 0 || codes[0] is not RapidMove)
|
||||||
|
program.Codes.Add(new RapidMove(start));
|
||||||
|
program.Codes.AddRange(codes);
|
||||||
|
return ConvertProgram.ToGeometry(program)
|
||||||
|
.Where(e => e.Layer != SpecialLayers.Rapid && e is Line or Arc)
|
||||||
|
.ToList();
|
||||||
|
}
|
||||||
|
|
||||||
|
private static IEnumerable<Vector> Ends(Entity entity) => entity switch
|
||||||
|
{
|
||||||
|
Line line => [line.StartPoint, line.EndPoint],
|
||||||
|
Arc arc => [arc.StartPoint(), arc.EndPoint()],
|
||||||
|
_ => [],
|
||||||
|
};
|
||||||
|
|
||||||
private static Vector EntityEndPoint(Entity entity)
|
private static Vector EntityEndPoint(Entity entity)
|
||||||
{
|
{
|
||||||
if (entity is Line line)
|
if (entity is Line line)
|
||||||
|
|||||||
@@ -156,7 +156,7 @@ public class HoleLookAheadTests
|
|||||||
[Theory]
|
[Theory]
|
||||||
[InlineData(false)]
|
[InlineData(false)]
|
||||||
[InlineData(true)]
|
[InlineData(true)]
|
||||||
public void HoleProgramsRetainScribesOnceAndNeverInstallOnFailure(bool tabs)
|
public void HoleProgramsRetainScribesOnceAndNeverInstall(bool tabs)
|
||||||
{
|
{
|
||||||
var clean = MixedHoles();
|
var clean = MixedHoles();
|
||||||
clean.MoveTo(-2, -2);
|
clean.MoveTo(-2, -2);
|
||||||
@@ -169,21 +169,14 @@ public class HoleLookAheadTests
|
|||||||
var fingerprint = ExplicitContourTests.Fingerprint(part.Program);
|
var fingerprint = ExplicitContourTests.Fingerprint(part.Program);
|
||||||
var result = CuttingPlanService.Plan(new CuttingPlanRequest([part], Start,
|
var result = CuttingPlanService.Plan(new CuttingPlanRequest([part], Start,
|
||||||
confirmedParameters: parameters, preservePartOrder: true));
|
confirmedParameters: parameters, preservePartOrder: true));
|
||||||
if (tabs)
|
Assert.True(result.Status == CuttingPlanStatus.Ready, Describe(result));
|
||||||
{
|
Assert.True(result.IndependentlyReplayed);
|
||||||
Assert.NotEqual(CuttingPlanStatus.Ready, result.Status);
|
var actual = result.ProposedOrder[0];
|
||||||
Assert.Empty(result.ProposedOrder);
|
Assert.Equal(2, actual.ContourChoices[^1].ContourOrdinal);
|
||||||
Assert.Contains(result.Findings, f => f.Kind == PostVerificationKind.Incomplete);
|
Assert.Equal(3, actual.ContourChoices.Select(c => c.ContourOrdinal).Distinct().Count());
|
||||||
}
|
Assert.Single(actual.Execution.Motions.Where(m => !m.Rapid && m.Layer == LayerType.Scribe));
|
||||||
else
|
// The arc lead-out would cut through the tab into the lead-in, so a tabbed outside has none.
|
||||||
{
|
Assert.Equal(!tabs, actual.Execution.Motions.Any(m => m.Layer == LayerType.Leadout));
|
||||||
Assert.True(result.Status == CuttingPlanStatus.Ready, Describe(result));
|
|
||||||
Assert.True(result.IndependentlyReplayed);
|
|
||||||
var actual = result.ProposedOrder[0];
|
|
||||||
Assert.Equal(2, actual.ContourChoices[^1].ContourOrdinal);
|
|
||||||
Assert.Equal(3, actual.ContourChoices.Select(c => c.ContourOrdinal).Distinct().Count());
|
|
||||||
Assert.Single(actual.Execution.Motions.Where(m => !m.Rapid && m.Layer == LayerType.Scribe));
|
|
||||||
}
|
|
||||||
Assert.Equal(fingerprint, ExplicitContourTests.Fingerprint(part.Program));
|
Assert.Equal(fingerprint, ExplicitContourTests.Fingerprint(part.Program));
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|||||||
@@ -315,18 +315,31 @@ public class JointCuttingPlanTests
|
|||||||
}
|
}
|
||||||
|
|
||||||
[Fact]
|
[Fact]
|
||||||
public void TabbedArcCandidate_UncertifiedTabGap_IsRefusedWithoutRepairOrException()
|
public void TabbedArcCandidate_LeadOutThatWouldCutTheTab_IsLeftOutAndPlanned()
|
||||||
{
|
{
|
||||||
// The arc lead-out is now well formed; the open tab gap is still not certified.
|
// The arc lead-out would run over the tab gap into the lead-in, so the cut stops at its tab.
|
||||||
var parameters = ExplicitContourTests.Parameters();
|
var parameters = ExplicitContourTests.Parameters();
|
||||||
parameters.TabsEnabled = true; parameters.TabConfig = new NormalTab { Size = 0.2 };
|
parameters.TabsEnabled = true; parameters.TabConfig = new NormalTab { Size = 0.2 };
|
||||||
parameters.ExternalLeadOut = new ArcLeadOut { Radius = 0.2 };
|
parameters.ExternalLeadOut = new ArcLeadOut { Radius = 0.2 };
|
||||||
var part = new Part(new Drawing("tabbed", LeadPathValidationTests.Rectangle(0, 0, 10, 10)));
|
var part = new Part(new Drawing("tabbed", LeadPathValidationTests.Rectangle(0, 0, 10, 10)));
|
||||||
var result = CuttingPlanService.Plan(new CuttingPlanRequest([part], new Vector(-2, 5), confirmedParameters: parameters));
|
var result = CuttingPlanService.Plan(new CuttingPlanRequest([part], new Vector(-2, 5), confirmedParameters: parameters));
|
||||||
Assert.Equal(CuttingPlanStatus.NoSolutionWithinBudget, result.Status);
|
Assert.Equal(CuttingPlanStatus.Ready, result.Status);
|
||||||
Assert.Empty(result.ProposedOrder); Assert.True(result.Expansions > 0);
|
Assert.True(result.IndependentlyReplayed);
|
||||||
Assert.Contains(result.Findings, f => f.Kind == PostVerificationKind.Incomplete);
|
Assert.DoesNotContain(Assert.Single(result.ProposedOrder).Execution.Motions, m => m.Layer == LayerType.Leadout);
|
||||||
Assert.Contains(result.Findings, f => f.Message.Contains("retention gap"));
|
}
|
||||||
|
|
||||||
|
[Fact]
|
||||||
|
public void TabbedPerimeter_LeadOutCrossingItsLeadIn_IsRefusedAsCuttingTheRetentionGap()
|
||||||
|
{
|
||||||
|
// Wound counterclockwise, entered at (0, 5) and stopped 0.2 short of it: the lead-out runs
|
||||||
|
// forward over the tab gap and crosses the lead-in, cutting the tab free.
|
||||||
|
var program = new Program(Mode.Absolute);
|
||||||
|
program.Codes.Add(new RapidMove(-0.3, 5.5));
|
||||||
|
program.Codes.Add(new LinearMove(0, 5) { Layer = LayerType.Leadin });
|
||||||
|
program.LineTo(0, 0); program.LineTo(10, 0); program.LineTo(10, 10); program.LineTo(0, 10); program.LineTo(0, 5.2);
|
||||||
|
program.Codes.Add(new LinearMove(-0.3, 4.9) { Layer = LayerType.Leadout });
|
||||||
|
var findings = new ReleasedContourState().Check(Read(program, Vector.Zero), Vector.Zero, 1);
|
||||||
|
Assert.Contains(findings, f => f.Kind == PostVerificationKind.Incomplete && f.Message.Contains("retention gap"));
|
||||||
}
|
}
|
||||||
|
|
||||||
[Fact]
|
[Fact]
|
||||||
|
|||||||
@@ -9,19 +9,18 @@ namespace OpenNest.Tests.CuttingStrategy;
|
|||||||
/// <summary>
|
/// <summary>
|
||||||
/// A tab trims the perimeter short of its entry, so the lead-out leaves from where the
|
/// A tab trims the perimeter short of its entry, so the lead-out leaves from where the
|
||||||
/// trimmed cut actually ends. Generating it from the nominal entry emitted an arc whose
|
/// trimmed cut actually ends. Generating it from the nominal entry emitted an arc whose
|
||||||
/// start was off its own radius.
|
/// start was off its own radius. A lead-out that would reach the lead-in across the tab gap
|
||||||
|
/// would cut the tab free, so the cut then stops at its tab with no lead-out.
|
||||||
/// </summary>
|
/// </summary>
|
||||||
public class TabbedLeadOutTests
|
public class TabbedLeadOutTests
|
||||||
{
|
{
|
||||||
private const double TabSize = 0.2;
|
private const double TabSize = 0.2;
|
||||||
private const double LeadRadius = 0.2;
|
private const double LeadRadius = 0.2;
|
||||||
|
|
||||||
[Theory]
|
[Fact]
|
||||||
[InlineData(false)]
|
public void ArcLeadOut_LeavesTangentlyFromTheTrimmedCutEnd()
|
||||||
[InlineData(true)]
|
|
||||||
public void ArcLeadOut_LeavesTangentlyFromTheTrimmedCutEnd(bool reversed)
|
|
||||||
{
|
{
|
||||||
var execution = Emit(ExplicitContourTests.Square(reversed), new Vector(-2, 5),
|
var execution = Emit(ExplicitContourTests.Square(false), new Vector(-2, 5),
|
||||||
new ArcLeadOut { Radius = LeadRadius }, tabs: true);
|
new ArcLeadOut { Radius = LeadRadius }, tabs: true);
|
||||||
var (cuts, leadout) = Split(execution);
|
var (cuts, leadout) = Split(execution);
|
||||||
|
|
||||||
@@ -31,11 +30,65 @@ public class TabbedLeadOutTests
|
|||||||
Assert.Equal(end, leadout.Start!.Value);
|
Assert.Equal(end, leadout.Start!.Value);
|
||||||
var arc = Assert.IsType<Arc>(leadout.Curve.ToEntity());
|
var arc = Assert.IsType<Arc>(leadout.Curve.ToEntity());
|
||||||
Assert.Equal(LeadRadius, arc.Radius, 9);
|
Assert.Equal(LeadRadius, arc.Radius, 9);
|
||||||
// Centerd on the actual end's outward normal, so it touches the edge only where it starts.
|
// Centered on the actual end's outward normal, so it touches the edge only where it starts.
|
||||||
Assert.Equal(-LeadRadius, arc.Center.X, 9);
|
Assert.Equal(-LeadRadius, arc.Center.X, 9);
|
||||||
Assert.Equal(end.Y, arc.Center.Y, 9);
|
Assert.Equal(end.Y, arc.Center.Y, 9);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
[Fact]
|
||||||
|
public void ArcLeadOut_ThatWouldCrossTheLeadIn_IsLeftOut()
|
||||||
|
{
|
||||||
|
// Wound the other way, the arc runs forward over the tab gap and through the lead-in.
|
||||||
|
var execution = Emit(ExplicitContourTests.Square(true), new Vector(-2, 5),
|
||||||
|
new ArcLeadOut { Radius = LeadRadius }, tabs: true);
|
||||||
|
|
||||||
|
var cuts = execution.Motions.Where(m => m.Layer == LayerType.Display && !m.Rapid).ToArray();
|
||||||
|
Assert.Equal(TabSize, System.Math.Abs(cuts[^1].End.Y - 5), 9);
|
||||||
|
Assert.DoesNotContain(execution.Motions, m => m.Layer == LayerType.Leadout);
|
||||||
|
}
|
||||||
|
|
||||||
|
[Theory]
|
||||||
|
[InlineData(false)]
|
||||||
|
[InlineData(true)]
|
||||||
|
public void LineLeadOut_AngledIntoASmallTab_IsLeftOutOnlyWhenItWouldCrossTheLeadIn(bool reversed)
|
||||||
|
{
|
||||||
|
// A strip tabbed for support with 60 degree leads and a tab shorter than the lead-out's
|
||||||
|
// forward run: wound one way the lead-out angles away from the tab, the other way it
|
||||||
|
// crosses the lead-in and would cut the tab free.
|
||||||
|
var clean = new Program(Mode.Absolute);
|
||||||
|
if (reversed)
|
||||||
|
{
|
||||||
|
clean.MoveTo(0, 0); clean.LineTo(11.8, 0); clean.LineTo(11.8, 3.8); clean.LineTo(0, 3.8); clean.LineTo(0, 0);
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
clean.MoveTo(0, 0); clean.LineTo(0, 3.8); clean.LineTo(11.8, 3.8); clean.LineTo(11.8, 0); clean.LineTo(0, 0);
|
||||||
|
}
|
||||||
|
var parameters = new CuttingParameters
|
||||||
|
{
|
||||||
|
Kerf = 0.014,
|
||||||
|
ExternalLeadIn = new LineLeadIn { Length = 0.15, ApproachAngle = 60 },
|
||||||
|
ExternalLeadOut = new LineLeadOut { Length = 0.1, ApproachAngle = 60 },
|
||||||
|
InternalLeadIn = new LineLeadIn { Length = 0.15, ApproachAngle = 60 },
|
||||||
|
InternalLeadOut = new NoLeadOut(),
|
||||||
|
TabsEnabled = true,
|
||||||
|
TabConfig = new NormalTab { Size = 0.03 },
|
||||||
|
};
|
||||||
|
var emitted = new ContourCuttingStrategy { Parameters = parameters }.Apply(clean, new Vector(5, -2));
|
||||||
|
var execution = ExecutionMotionReader.Read(emitted.Program, Vector.Zero, null, default);
|
||||||
|
|
||||||
|
var leadIn = Assert.Single(execution.Motions.Where(m => m.Layer == LayerType.Leadin));
|
||||||
|
var leadOuts = execution.Motions.Where(m => m.Layer == LayerType.Leadout).ToArray();
|
||||||
|
if (reversed)
|
||||||
|
Assert.Empty(leadOuts);
|
||||||
|
else
|
||||||
|
{
|
||||||
|
var leadOut = Assert.Single(leadOuts);
|
||||||
|
Assert.False(new Line(leadIn.Start!.Value, leadIn.End).Intersects(new Line(leadOut.Start!.Value, leadOut.End)));
|
||||||
|
}
|
||||||
|
Assert.Empty(new ReleasedContourState().Check(execution, new Vector(5, -2), 1));
|
||||||
|
}
|
||||||
|
|
||||||
[Fact]
|
[Fact]
|
||||||
public void ArcLeadOut_OnCurvedPerimeter_IsTangentAtTheTrimmedEnd()
|
public void ArcLeadOut_OnCurvedPerimeter_IsTangentAtTheTrimmedEnd()
|
||||||
{
|
{
|
||||||
@@ -84,30 +137,20 @@ public class TabbedLeadOutTests
|
|||||||
Assert.Equal(5, arc.Center.Y, 9);
|
Assert.Equal(5, arc.Center.Y, 9);
|
||||||
}
|
}
|
||||||
|
|
||||||
[Theory]
|
[Fact]
|
||||||
[InlineData(false)]
|
public void LineLeads_TabWrappingAFilletedCorner_ShareTheCornerBisector()
|
||||||
[InlineData(true)]
|
|
||||||
public void LineLeads_TabWrappingAFilletedCorner_ShareTheCornerBisector(bool reversed)
|
|
||||||
{
|
{
|
||||||
// Entered at the fillet joint the tab trims back around: on its own edge's normal the
|
// Entered at the fillet joint the tab trims back around: on its own edge's normal the
|
||||||
// lead-in and lead-out would sit 150 degrees apart, not the 60 degree V of a straight edge.
|
// lead-in and lead-out would sit 150 degrees apart, not the 60 degree V of a straight edge.
|
||||||
const double fillet = 0.015;
|
const double fillet = 0.015;
|
||||||
const double tab = 0.03;
|
const double tab = 0.03;
|
||||||
var clean = new Program(Mode.Absolute);
|
var clean = new Program(Mode.Absolute);
|
||||||
if (reversed)
|
clean.MoveTo(0, 0); clean.LineTo(0, 10 - fillet);
|
||||||
{
|
clean.ArcTo(fillet, 10, fillet, 10 - fillet, RotationType.CW);
|
||||||
clean.MoveTo(fillet, 10); clean.ArcTo(0, 10 - fillet, fillet, 10 - fillet, RotationType.CCW);
|
clean.LineTo(10, 10); clean.LineTo(10, 0); clean.LineTo(0, 0);
|
||||||
clean.LineTo(0, 0); clean.LineTo(10, 0); clean.LineTo(10, 10); clean.LineTo(fillet, 10);
|
|
||||||
}
|
|
||||||
else
|
|
||||||
{
|
|
||||||
clean.MoveTo(0, 0); clean.LineTo(0, 10 - fillet);
|
|
||||||
clean.ArcTo(fillet, 10, fillet, 10 - fillet, RotationType.CW);
|
|
||||||
clean.LineTo(10, 10); clean.LineTo(10, 0); clean.LineTo(0, 0);
|
|
||||||
}
|
|
||||||
var part = new Part(new Drawing("tabbed-fillet", clean));
|
var part = new Part(new Drawing("tabbed-fillet", clean));
|
||||||
var perimeter = LeadInTestHelpers.Profile(part).Perimeter;
|
var perimeter = LeadInTestHelpers.Profile(part).Perimeter;
|
||||||
var entry = reversed ? new Vector(0, 10 - fillet) : new Vector(fillet, 10);
|
var entry = new Vector(fillet, 10);
|
||||||
var entity = perimeter.Entities.OfType<Line>().First(l => l.StartPoint.DistanceTo(entry) < 1e-9);
|
var entity = perimeter.Entities.OfType<Line>().First(l => l.StartPoint.DistanceTo(entry) < 1e-9);
|
||||||
var parameters = new CuttingParameters
|
var parameters = new CuttingParameters
|
||||||
{
|
{
|
||||||
@@ -125,7 +168,7 @@ public class TabbedLeadOutTests
|
|||||||
LeadInTestHelpers.AssertPoint(entry, leadIn.EndPoint);
|
LeadInTestHelpers.AssertPoint(entry, leadIn.EndPoint);
|
||||||
Assert.Equal(tab, leadOut.StartPoint.DistanceTo(entry), 9);
|
Assert.Equal(tab, leadOut.StartPoint.DistanceTo(entry), 9);
|
||||||
// The cut stops on the other edge, past the corner.
|
// The cut stops on the other edge, past the corner.
|
||||||
Assert.Equal(0, reversed ? 10 - leadOut.StartPoint.Y : leadOut.StartPoint.X, 9);
|
Assert.Equal(0, leadOut.StartPoint.X, 9);
|
||||||
|
|
||||||
const double bisector = 3 * System.Math.PI / 4;
|
const double bisector = 3 * System.Math.PI / 4;
|
||||||
var spread = OpenNest.Math.Angle.ToRadians(30);
|
var spread = OpenNest.Math.Angle.ToRadians(30);
|
||||||
@@ -133,6 +176,36 @@ public class TabbedLeadOutTests
|
|||||||
LeadInTestHelpers.AssertPoint(leadOut.StartPoint + Polar(0.1, bisector + spread), leadOut.EndPoint);
|
LeadInTestHelpers.AssertPoint(leadOut.StartPoint + Polar(0.1, bisector + spread), leadOut.EndPoint);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
[Fact]
|
||||||
|
public void LineLeads_TabWrappingAFilletedCornerTheOtherWay_LeaveOutTheLeadOutThatCrossesTheLeadIn()
|
||||||
|
{
|
||||||
|
// Wound the other way, the shared bisector puts the lead-out across the lead-in.
|
||||||
|
const double fillet = 0.015;
|
||||||
|
var clean = new Program(Mode.Absolute);
|
||||||
|
clean.MoveTo(fillet, 10); clean.ArcTo(0, 10 - fillet, fillet, 10 - fillet, RotationType.CCW);
|
||||||
|
clean.LineTo(0, 0); clean.LineTo(10, 0); clean.LineTo(10, 10); clean.LineTo(fillet, 10);
|
||||||
|
var part = new Part(new Drawing("tabbed-fillet", clean));
|
||||||
|
var perimeter = LeadInTestHelpers.Profile(part).Perimeter;
|
||||||
|
var entry = new Vector(0, 10 - fillet);
|
||||||
|
var entity = perimeter.Entities.OfType<Line>().First(l => l.StartPoint.DistanceTo(entry) < 1e-9);
|
||||||
|
var parameters = new CuttingParameters
|
||||||
|
{
|
||||||
|
ExternalLeadIn = new LineLeadIn { Length = 0.15, ApproachAngle = 60 },
|
||||||
|
ExternalLeadOut = new LineLeadOut { Length = 0.1, ApproachAngle = 60 },
|
||||||
|
TabsEnabled = true,
|
||||||
|
TabConfig = new NormalTab { Size = 0.03 },
|
||||||
|
};
|
||||||
|
|
||||||
|
part.ApplySingleLeadIn(parameters, entry, entity, ContourType.External);
|
||||||
|
|
||||||
|
var geometry = part.Program.ToGeometry();
|
||||||
|
var leadIn = Assert.IsType<Line>(Assert.Single(geometry.Where(e => e.Layer == SpecialLayers.Leadin)));
|
||||||
|
LeadInTestHelpers.AssertPoint(entry, leadIn.EndPoint);
|
||||||
|
LeadInTestHelpers.AssertPoint(entry + Polar(0.15, 3 * System.Math.PI / 4 - OpenNest.Math.Angle.ToRadians(30)),
|
||||||
|
leadIn.StartPoint);
|
||||||
|
Assert.DoesNotContain(geometry, e => e.Layer == SpecialLayers.Leadout);
|
||||||
|
}
|
||||||
|
|
||||||
private static Vector Polar(double length, double angle) =>
|
private static Vector Polar(double length, double angle) =>
|
||||||
new(length * System.Math.Cos(angle), length * System.Math.Sin(angle));
|
new(length * System.Math.Cos(angle), length * System.Math.Sin(angle));
|
||||||
|
|
||||||
|
|||||||
@@ -104,6 +104,11 @@ plate settings, so parts that need no tab are not tabbed.
|
|||||||
|
|
||||||
The emitter tabs a perimeter at its entry: the cut stops short of the entry by the tab size. A
|
The emitter tabs a perimeter at its entry: the cut stops short of the entry by the tab size. A
|
||||||
round perimeter, one circle, is cut as an arc that stops the tab's chord short of its entry.
|
round perimeter, one circle, is cut as an arc that stops the tab's chord short of its entry.
|
||||||
|
The lead-out leaves from where the cut stops. One that touches the lead-in, or passes within the
|
||||||
|
kerf of it, would cut the tab free, so the emitter leaves it out and the cut ends at its tab. A
|
||||||
|
line lead-out angled forward does that whenever its run along the edge is longer than the tab,
|
||||||
|
as a 0.1 lead-out at 60 degrees (0.05 along the edge) beside a 0.03 tab does. This holds for every
|
||||||
|
tabbed outside, support-tabbed or not.
|
||||||
A support-tabbed perimeter's automatic entries are therefore limited to catalog points the
|
A support-tabbed perimeter's automatic entries are therefore limited to catalog points the
|
||||||
analysis accepts, plus the closest native point to its best tab point (`AutomaticEntryKind.SupportTab`,
|
analysis accepts, plus the closest native point to its best tab point (`AutomaticEntryKind.SupportTab`,
|
||||||
never on a reflex or cusp vertex). Ranking and lead checks are unchanged.
|
never on a reflex or cusp vertex). Ranking and lead checks are unchanged.
|
||||||
|
|||||||
Reference in new issue
Block a user