feat(cutoffs): add automatic skeleton cutoffs with tail preservation
This commit is contained in:
@@ -0,0 +1,353 @@
|
||||
using System.IO.Compression;
|
||||
using System.Text.Json;
|
||||
using OpenNest.CNC;
|
||||
using OpenNest.Converters;
|
||||
using OpenNest.Geometry;
|
||||
using OpenNest.IO;
|
||||
using OpenNest.Math;
|
||||
|
||||
namespace OpenNest.Tests.CutOffs;
|
||||
|
||||
public class AutomaticCutOffLifecycleTests
|
||||
{
|
||||
[Theory]
|
||||
[InlineData(1)]
|
||||
[InlineData(2)]
|
||||
[InlineData(3)]
|
||||
[InlineData(4)]
|
||||
public void Apply_AppendsPlannedDefinitions_AfterExistingMixedSequence(int quadrant)
|
||||
{
|
||||
var settings = new CutOffSettings { PartClearance = 0.75, Overtravel = 2 };
|
||||
var nest = MakeNest(quadrant, settings);
|
||||
var plate = Assert.Single(nest.Plates);
|
||||
var realParts = CaptureRealParts(plate);
|
||||
var manual = Assert.Single(plate.CutOffs);
|
||||
var manualDefinition = Definition(manual);
|
||||
var originalSequence = plate.Parts.ToArray();
|
||||
|
||||
var plan = CreatePlan(plate, settings);
|
||||
|
||||
Assert.Equal(originalSequence, plate.Parts.ToArray());
|
||||
Assert.Same(manual, Assert.Single(plate.CutOffs));
|
||||
Assert.Equal(3, plan.PreviewParts.Count);
|
||||
Assert.All(plan.PreviewParts, preview => Assert.DoesNotContain(preview, plate.Parts));
|
||||
var previewPrograms = plan.PreviewParts.Select(p => NestWriter.GetProgramText(p.Program)).ToArray();
|
||||
|
||||
Apply(plate, plan, settings);
|
||||
|
||||
Assert.Equal(new[] { manual }.Concat(plan.Definitions), plate.CutOffs);
|
||||
Assert.Equal(manualDefinition, Definition(manual));
|
||||
AssertSequence(plate, realParts[0].Part, realParts[1].Part);
|
||||
AssertOnePartPerDefinition(plate);
|
||||
AssertRealPartsUnchanged(plate, realParts);
|
||||
for (var i = 0; i < plan.Definitions.Count; i++)
|
||||
{
|
||||
var materialized = plate.Parts[i + 3];
|
||||
Assert.Same(plan.Definitions[i].Drawing, materialized.BaseDrawing);
|
||||
Assert.NotSame(plan.PreviewParts[i], materialized);
|
||||
Assert.Equal(previewPrograms[i], NestWriter.GetProgramText(materialized.Program));
|
||||
}
|
||||
|
||||
var repeated = AutomaticCutOffPlanner.Create(plate, new AutomaticCutOffOptions { Spacing = 35 }, settings);
|
||||
Assert.Empty(repeated.Definitions);
|
||||
Assert.Empty(repeated.PreviewParts);
|
||||
Assert.False(repeated.HasBlockingDiagnostics);
|
||||
Assert.True(repeated.HasSeparatedTail);
|
||||
Assert.Equal(plan.TailSeparatorX, repeated.TailSeparatorX);
|
||||
Assert.Equal(plan.UsedSpan, repeated.UsedSpan);
|
||||
Assert.Equal(plan.TailLength, repeated.TailLength);
|
||||
Assert.Equal(3, repeated.Diagnostics.Count(d => d.Code == AutomaticCutOffDiagnosticCode.ExistingCutOff));
|
||||
|
||||
// Accepting the empty repeat and regenerating must not duplicate or resequence anything.
|
||||
Apply(plate, repeated, settings);
|
||||
Assert.Equal(new[] { manual }.Concat(plan.Definitions), plate.CutOffs);
|
||||
AssertSequence(plate, realParts[0].Part, realParts[1].Part);
|
||||
AssertOnePartPerDefinition(plate);
|
||||
AssertRealPartsUnchanged(plate, realParts);
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[InlineData(1)]
|
||||
[InlineData(2)]
|
||||
[InlineData(3)]
|
||||
[InlineData(4)]
|
||||
public void SaveAndReload_PreservesDefinitionsLimitsAndExactMixedSequence(int quadrant)
|
||||
{
|
||||
// NestReader uses default CutOffSettings; nondefault toolpath fidelity is not this contract.
|
||||
var settings = new CutOffSettings();
|
||||
var nest = MakeNest(quadrant, settings);
|
||||
var plate = Assert.Single(nest.Plates);
|
||||
var realParts = CaptureRealParts(plate);
|
||||
Apply(plate, CreatePlan(plate, settings), settings);
|
||||
var definitions = plate.CutOffs.Select(Definition).ToArray();
|
||||
|
||||
using var stream = new MemoryStream();
|
||||
Assert.True(new NestWriter(nest).Write(stream));
|
||||
AssertArchiveContainsOnlyRealParts(stream, plate);
|
||||
stream.Position = 0;
|
||||
var loaded = new NestReader(stream).Read();
|
||||
var loadedPlate = Assert.Single(loaded.Plates);
|
||||
var loadedRealParts = loadedPlate.Parts.Where(p => !p.BaseDrawing.IsCutOff).ToArray();
|
||||
|
||||
Assert.Equal(quadrant, loadedPlate.Quadrant);
|
||||
Assert.Equal(plate.Size, loadedPlate.Size);
|
||||
Assert.Equal(plate.PartSpacing, loadedPlate.PartSpacing);
|
||||
Assert.Equal(plate.Quantity, loadedPlate.Quantity);
|
||||
Assert.Equal(definitions, loadedPlate.CutOffs.Select(Definition));
|
||||
Assert.Equal(realParts.Select(p => p.Location), loadedRealParts.Select(p => p.Location));
|
||||
Assert.Equal(realParts.Select(p => p.ProgramText), loadedRealParts.Select(p => NestWriter.GetProgramText(p.Program)));
|
||||
Assert.Equal(realParts.Select(p => p.Rotation), loadedRealParts.Select(p => p.Rotation));
|
||||
AssertSequence(loadedPlate, loadedRealParts[0], loadedRealParts[1]);
|
||||
AssertOnePartPerDefinition(loadedPlate);
|
||||
var loadedDrawing = Assert.Single(loaded.Drawings);
|
||||
Assert.False(loadedDrawing.IsCutOff);
|
||||
Assert.All(loadedRealParts, p => Assert.Same(loadedDrawing, p.BaseDrawing));
|
||||
Assert.Equal(realParts[0].Required, loadedDrawing.Quantity.Required);
|
||||
Assert.Equal(realParts[0].Nested, loadedDrawing.Quantity.Nested);
|
||||
AssertRealPartsUnchanged(plate, realParts);
|
||||
|
||||
var loadedState = CaptureRealParts(loadedPlate);
|
||||
loadedPlate.RegenerateCutOffs(settings);
|
||||
Assert.Equal(definitions, loadedPlate.CutOffs.Select(Definition));
|
||||
AssertSequence(loadedPlate, loadedRealParts[0], loadedRealParts[1]);
|
||||
AssertOnePartPerDefinition(loadedPlate);
|
||||
AssertRealPartsUnchanged(loadedPlate, loadedState);
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[InlineData(1, 5)]
|
||||
[InlineData(2, 5)]
|
||||
[InlineData(3, 5)]
|
||||
[InlineData(4, 5)]
|
||||
[InlineData(1, 10)]
|
||||
[InlineData(2, 10)]
|
||||
[InlineData(3, 10)]
|
||||
[InlineData(4, 10)]
|
||||
public void MovePartAfterReload_RegeneratesSafeSegments_WithoutMovingDefinitions(int quadrant, double offsetX)
|
||||
{
|
||||
var settings = new CutOffSettings();
|
||||
var nest = MakeNest(quadrant, settings);
|
||||
var source = Assert.Single(nest.Plates);
|
||||
Apply(source, CreatePlan(source, settings), settings);
|
||||
using var stream = new MemoryStream();
|
||||
Assert.True(new NestWriter(nest).Write(stream));
|
||||
stream.Position = 0;
|
||||
var loaded = new NestReader(stream).Read();
|
||||
var plate = Assert.Single(loaded.Plates);
|
||||
var definitions = plate.CutOffs.ToArray();
|
||||
var definitionValues = definitions.Select(Definition).ToArray();
|
||||
var realParts = CaptureRealParts(plate);
|
||||
var moved = realParts[1].Part;
|
||||
var separator = definitions[^1];
|
||||
var separatorPart = plate.Parts[^1];
|
||||
var before = Assert.Single(Segments(separatorPart));
|
||||
var bounds = plate.BoundingBox(false);
|
||||
Assert.Equal(bounds.Bottom, before.From.Y);
|
||||
Assert.Equal(bounds.Top, before.To.Y);
|
||||
Assert.Equal(separator.Position.X, before.From.X);
|
||||
Assert.Equal(separator.Position.X, before.To.X);
|
||||
AssertCutsAvoidRectangles(plate, settings.PartClearance);
|
||||
|
||||
// Move the outer part across the old separator: its fixed line must now be trimmed,
|
||||
// not shifted to a new tail or left as a stale full-width cut through the part.
|
||||
var offset = new Vector(quadrant is 2 or 3 ? -offsetX : offsetX, quadrant is 3 or 4 ? -10 : 10);
|
||||
moved.Offset(offset);
|
||||
Assert.Equal(realParts[1].Location + offset, moved.Location);
|
||||
var movedState = CaptureRealParts(plate);
|
||||
plate.RegenerateCutOffs(settings);
|
||||
|
||||
Assert.Equal(definitions, plate.CutOffs.ToArray());
|
||||
Assert.Equal(definitionValues, plate.CutOffs.Select(Definition));
|
||||
AssertSequence(plate, realParts[0].Part, moved);
|
||||
AssertOnePartPerDefinition(plate);
|
||||
AssertRealPartsUnchanged(plate, movedState);
|
||||
AssertRealPartsUnchanged(plate, new[] { realParts[0], realParts[1] with { Location = moved.Location } });
|
||||
Assert.NotSame(separatorPart, plate.Parts[^1]);
|
||||
Assert.DoesNotContain(separatorPart, plate.Parts);
|
||||
var after = Segments(plate.Parts[^1]);
|
||||
Assert.Equal(2, after.Length);
|
||||
Assert.All(after, s =>
|
||||
{
|
||||
Assert.Equal(separator.Position.X, s.From.X);
|
||||
Assert.Equal(separator.Position.X, s.To.X);
|
||||
});
|
||||
AssertCutsAvoidRectangles(plate, settings.PartClearance);
|
||||
|
||||
var regeneratedPrograms = plate.Parts.Where(p => p.BaseDrawing.IsCutOff)
|
||||
.Select(p => NestWriter.GetProgramText(p.Program)).ToArray();
|
||||
plate.RegenerateCutOffs(settings);
|
||||
Assert.Equal(definitionValues, plate.CutOffs.Select(Definition));
|
||||
Assert.Equal(regeneratedPrograms, plate.Parts.Where(p => p.BaseDrawing.IsCutOff)
|
||||
.Select(p => NestWriter.GetProgramText(p.Program)));
|
||||
AssertSequence(plate, realParts[0].Part, moved);
|
||||
AssertOnePartPerDefinition(plate);
|
||||
AssertRealPartsUnchanged(plate, movedState);
|
||||
AssertCutsAvoidRectangles(plate, settings.PartClearance);
|
||||
}
|
||||
|
||||
private static Nest MakeNest(int quadrant, CutOffSettings settings)
|
||||
{
|
||||
var program = new Program();
|
||||
program.Codes.Add(new RapidMove(0, 0));
|
||||
program.Codes.Add(new LinearMove(20, 0));
|
||||
program.Codes.Add(new LinearMove(20, 20));
|
||||
program.Codes.Add(new LinearMove(0, 20));
|
||||
program.Codes.Add(new LinearMove(0, 0));
|
||||
Assert.True(Assert.Single(ShapeBuilder.GetShapes(ConvertProgram.ToGeometry(program))).IsClosed());
|
||||
var drawing = new Drawing("square", program);
|
||||
Assert.Equal(400, drawing.Area);
|
||||
drawing.Quantity.Required = 10;
|
||||
var nest = new Nest("automatic-cutoff-lifecycle");
|
||||
nest.Drawings.Add(drawing);
|
||||
var plate = new Plate(81, 120) { Quadrant = quadrant, PartSpacing = 0.5, Quantity = 2 };
|
||||
var negativeX = quadrant is 2 or 3;
|
||||
var negativeY = quadrant is 3 or 4;
|
||||
var first = new Part(drawing, new Vector(negativeX ? -30 : 10, negativeY ? -40 : 20));
|
||||
var second = new Part(drawing, new Vector(negativeX ? -80 : 60, negativeY ? -40 : 20));
|
||||
plate.Parts.Add(first);
|
||||
plate.Parts.Add(second);
|
||||
var manual = new CutOff(new Vector(negativeX ? -15 : 15, negativeY ? -10 : 10), CutOffAxis.Horizontal)
|
||||
{
|
||||
StartLimit = negativeX ? -25 : 5,
|
||||
EndLimit = negativeX ? -5 : 25,
|
||||
};
|
||||
plate.CutOffs.Add(manual);
|
||||
plate.RegenerateCutOffs(settings);
|
||||
var manualPart = plate.Parts[^1];
|
||||
plate.Parts.Remove(manualPart);
|
||||
plate.Parts.Insert(1, manualPart);
|
||||
Assert.Equal(new[] { first, manualPart, second }, plate.Parts);
|
||||
Assert.Equal(4, drawing.Quantity.Nested);
|
||||
nest.Plates.Add(plate);
|
||||
return nest;
|
||||
}
|
||||
|
||||
private static AutomaticCutOffPlan CreatePlan(Plate plate, CutOffSettings settings)
|
||||
{
|
||||
var plan = AutomaticCutOffPlanner.Create(plate, new AutomaticCutOffOptions { Spacing = 35 }, settings);
|
||||
var sign = plate.Quadrant is 2 or 3 ? -1 : 1;
|
||||
var separator = 80 + System.Math.Max(plate.PartSpacing, settings.PartClearance) + Tolerance.Epsilon;
|
||||
Assert.False(plan.HasBlockingDiagnostics);
|
||||
Assert.True(plan.HasSeparatedTail);
|
||||
Assert.Equal(80, plan.OccupiedSpan);
|
||||
Assert.Equal(separator, plan.UsedSpan);
|
||||
Assert.Equal(120 - separator, plan.TailLength);
|
||||
Assert.Equal(sign * separator, plan.TailSeparatorX);
|
||||
Assert.Equal(new[] { sign * 35.0, sign * 70.0, sign * separator }, plan.Definitions.Select(c => c.Position.X));
|
||||
Assert.All(plan.Definitions, c =>
|
||||
{
|
||||
Assert.Equal(CutOffAxis.Vertical, c.Axis);
|
||||
Assert.Null(c.StartLimit);
|
||||
Assert.Null(c.EndLimit);
|
||||
});
|
||||
return plan;
|
||||
}
|
||||
|
||||
private static void Apply(Plate plate, AutomaticCutOffPlan plan, CutOffSettings settings)
|
||||
{
|
||||
Assert.False(plan.HasBlockingDiagnostics);
|
||||
foreach (var definition in plan.Definitions)
|
||||
plate.CutOffs.Add(definition);
|
||||
plate.RegenerateCutOffs(settings);
|
||||
}
|
||||
|
||||
private static void AssertSequence(Plate plate, Part first, Part second) =>
|
||||
Assert.Collection(plate.Parts,
|
||||
p => Assert.Same(first, p),
|
||||
p => Assert.Same(plate.CutOffs[0].Drawing, p.BaseDrawing),
|
||||
p => Assert.Same(second, p),
|
||||
p => Assert.Same(plate.CutOffs[1].Drawing, p.BaseDrawing),
|
||||
p => Assert.Same(plate.CutOffs[2].Drawing, p.BaseDrawing),
|
||||
p => Assert.Same(plate.CutOffs[3].Drawing, p.BaseDrawing));
|
||||
|
||||
private static void AssertOnePartPerDefinition(Plate plate)
|
||||
{
|
||||
Assert.Equal(4, plate.CutOffs.Count);
|
||||
Assert.Equal(4, plate.Parts.Count(p => p.BaseDrawing.IsCutOff));
|
||||
Assert.All(plate.CutOffs, c =>
|
||||
{
|
||||
Assert.True(c.Drawing.IsCutOff);
|
||||
Assert.Single(plate.Parts.Where(p => ReferenceEquals(p.BaseDrawing, c.Drawing)));
|
||||
});
|
||||
}
|
||||
|
||||
private static (double X, double Y, CutOffAxis Axis, double? Start, double? End) Definition(CutOff cut) =>
|
||||
(cut.Position.X, cut.Position.Y, cut.Axis, cut.StartLimit, cut.EndLimit);
|
||||
|
||||
private sealed record RealPartState(Part Part, Program Program, string ProgramText, Vector Location,
|
||||
double Rotation, Program DrawingProgram, string DrawingText, int Required, int Nested);
|
||||
|
||||
private static RealPartState[] CaptureRealParts(Plate plate) => plate.Parts
|
||||
.Where(p => !p.BaseDrawing.IsCutOff)
|
||||
.Select(p => new RealPartState(p, p.Program, NestWriter.GetProgramText(p.Program), p.Location,
|
||||
p.Rotation, p.BaseDrawing.Program, NestWriter.GetProgramText(p.BaseDrawing.Program),
|
||||
p.BaseDrawing.Quantity.Required, p.BaseDrawing.Quantity.Nested)).ToArray();
|
||||
|
||||
private static void AssertRealPartsUnchanged(Plate plate, RealPartState[] expected)
|
||||
{
|
||||
Assert.Equal(expected.Select(s => s.Part), plate.Parts.Where(p => !p.BaseDrawing.IsCutOff));
|
||||
Assert.All(expected, s =>
|
||||
{
|
||||
Assert.Same(s.Program, s.Part.Program);
|
||||
Assert.Equal(s.ProgramText, NestWriter.GetProgramText(s.Part.Program));
|
||||
Assert.Equal(s.Location, s.Part.Location);
|
||||
Assert.Equal(s.Rotation, s.Part.Rotation);
|
||||
Assert.Same(s.DrawingProgram, s.Part.BaseDrawing.Program);
|
||||
Assert.Equal(s.DrawingText, NestWriter.GetProgramText(s.Part.BaseDrawing.Program));
|
||||
Assert.Equal(s.Required, s.Part.BaseDrawing.Quantity.Required);
|
||||
Assert.Equal(s.Nested, s.Part.BaseDrawing.Quantity.Nested);
|
||||
});
|
||||
}
|
||||
|
||||
private static void AssertArchiveContainsOnlyRealParts(MemoryStream stream, Plate plate)
|
||||
{
|
||||
stream.Position = 0;
|
||||
using var archive = new ZipArchive(stream, ZipArchiveMode.Read, leaveOpen: true);
|
||||
using var reader = new StreamReader(archive.GetEntry("nest.json")!.Open());
|
||||
using var json = JsonDocument.Parse(reader.ReadToEnd());
|
||||
var savedPlate = Assert.Single(json.RootElement.GetProperty("plates").EnumerateArray());
|
||||
var savedParts = savedPlate.GetProperty("parts").EnumerateArray().ToArray();
|
||||
Assert.Equal(2, savedParts.Length);
|
||||
Assert.Single(json.RootElement.GetProperty("drawings").EnumerateArray());
|
||||
Assert.Single(archive.Entries.Where(e => e.FullName.StartsWith("programs/", StringComparison.Ordinal)));
|
||||
Assert.DoesNotContain(archive.Entries, e => e.FullName.StartsWith("parts/", StringComparison.Ordinal));
|
||||
var realParts = plate.Parts.Where(p => !p.BaseDrawing.IsCutOff).ToArray();
|
||||
for (var i = 0; i < realParts.Length; i++)
|
||||
{
|
||||
Assert.Equal(realParts[i].Location.X, savedParts[i].GetProperty("x").GetDouble());
|
||||
Assert.Equal(realParts[i].Location.Y, savedParts[i].GetProperty("y").GetDouble());
|
||||
}
|
||||
var cuts = savedPlate.GetProperty("cutOffs").EnumerateArray().ToArray();
|
||||
Assert.Equal(new[] { 1, 3, 4, 5 }, cuts.Select(c => c.GetProperty("sequence").GetInt32()));
|
||||
}
|
||||
|
||||
private static (Vector From, Vector To)[] Segments(Part part)
|
||||
{
|
||||
Assert.NotEmpty(part.Program.Codes);
|
||||
Assert.Equal(0, part.Program.Codes.Count % 2);
|
||||
return Enumerable.Range(0, part.Program.Codes.Count / 2).Select(i => (
|
||||
Assert.IsType<RapidMove>(part.Program.Codes[2 * i]).EndPoint + part.Location,
|
||||
Assert.IsType<LinearMove>(part.Program.Codes[2 * i + 1]).EndPoint + part.Location)).ToArray();
|
||||
}
|
||||
|
||||
private static void AssertCutsAvoidRectangles(Plate plate, double clearance)
|
||||
{
|
||||
// Independent axis-aligned rectangle oracle: inspect every emitted cutting move,
|
||||
// not rapids, counts, or the same CutOff.ComputeSegments algorithm under test.
|
||||
var rectangles = plate.Parts.Where(p => !p.BaseDrawing.IsCutOff).Select(p => p.BoundingBox).ToArray();
|
||||
foreach (var cutPart in plate.Parts.Where(p => p.BaseDrawing.IsCutOff))
|
||||
foreach (var segment in Segments(cutPart))
|
||||
{
|
||||
var minX = System.Math.Min(segment.From.X, segment.To.X);
|
||||
var maxX = System.Math.Max(segment.From.X, segment.To.X);
|
||||
var minY = System.Math.Min(segment.From.Y, segment.To.Y);
|
||||
var maxY = System.Math.Max(segment.From.Y, segment.To.Y);
|
||||
Assert.True(minX == maxX || minY == maxY);
|
||||
Assert.True(minX < maxX || minY < maxY);
|
||||
Assert.All(rectangles, box => Assert.True(
|
||||
maxX <= box.Left - clearance || minX >= box.Right + clearance ||
|
||||
maxY <= box.Bottom - clearance || minY >= box.Top + clearance,
|
||||
$"Cut {segment.From} -> {segment.To} crosses a rectangle or its clearance."));
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user