Files
OpenNest/OpenNest.Engine/Jobs/NestJobPlacementValidator.cs
T
ajandClaude Fable 5.2 b137df8428 fix(review): a round part resting on an outlined sheet's edge is not flagged
On a sheet with a custom outline the plate edge review, Auto Nest's layout
check and the runner's candidate validation tested the part's spacing
outline against the usable area. That outline circumscribes arcs by up to
0.001, more than any of their slacks, so a disc whose true bounds rest on
the work-area edge read as inside the outline's edge spacing (or off the
plate at zero spacing) while the same disc on a rectangular sheet, judged
on its true bounds, was clean.

The outline test now works as the part-spacing check does: the spacing
outline finds the candidates and a failure is confirmed on the part's
native contour (NativeContours.Region: arcs circumscribed at 0.000025 and
clipped to the perimeter's true bounds). Both regions contain the material,
so a part past the usable edge by more than the slack still fails; no slack
changed. The runner now calls the layout check's own outline test
(NestLayoutCheck.InsideOutline): its separately flattened candidate could
accept a pose on a slanted edge that the layout check then rejected.

Pushes on an outlined sheet measured the same circumscribed perimeter so a
part would rest where the review passed, and box pushes stopped 0.0012
short of a wall for it. With the review confirming on native contours they
slide the material's own lines and arcs, so a round part rests on a wall
exactly as on the plate edge, and a box push rests the box on the wall.

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
2026-11-20 08:49:00 -05:00

218 lines
9.2 KiB
C#

using System;
using System.Collections.Generic;
using OpenNest.Engine.Jobs.Placement;
using OpenNest.Geometry;
namespace OpenNest.Engine.Jobs;
/// <summary>Validates a trial against immutable job geometry before the runner commits accounting.</summary>
internal static class NestJobPlacementValidator
{
private const double Epsilon = 0.0000001;
// Flattening for the placement overlap check: the same 0.001 Part.Intersects uses. Part
// spacing is judged by NestLayoutCheck.KeepsSpacing instead, so this validator and the
// layout check accept exactly the same pairs.
private const double PlacementChordTolerance = NestTolerances.ValidationOutline;
internal static void ValidateCandidate(
PlateCandidate candidate,
NestPlateStock stock,
IReadOnlyDictionary<string, int> remaining,
IReadOnlyDictionary<string, NestJobPart> parts
)
{
if (candidate == null)
throw new InvalidOperationException("The plate nester returned a null candidate.");
var counts = new Dictionary<string, int>(StringComparer.Ordinal);
var placed = new List<ShapeTopology>();
// Spacing outlines per placement, prepared only once a neighbor comes near.
var poses = new List<(JobPartGeometry Geometry, NestJobPlacement Pose)>();
var spaced = new List<NestLayoutCheck.PreparedPlacement>();
var geometries = new Dictionary<string, JobPartGeometry>(StringComparer.Ordinal);
var sources = new Dictionary<string, ShapeTopology>(StringComparer.Ordinal);
foreach (var placement in candidate.Placements)
{
if (
placement.PartId == null
|| !remaining.TryGetValue(placement.PartId, out var available)
|| !parts.TryGetValue(placement.PartId, out var part)
)
throw new InvalidOperationException(
"Candidate references an unknown requirement ID."
);
if (
!double.IsFinite(placement.X)
|| !double.IsFinite(placement.Y)
|| !double.IsFinite(placement.Rotation)
)
throw new InvalidOperationException("Candidate poses must be finite.");
counts.TryGetValue(placement.PartId, out var count);
if (count >= available)
throw new InvalidOperationException("Candidate overproduces a requirement.");
if (!part.Rotation.Allows(placement.Rotation))
throw new InvalidOperationException(
"Candidate rotation is not allowed for the requirement."
);
if (!sources.TryGetValue(placement.PartId, out var source))
{
var geometry = JobPartGeometry.Read(part.Geometry);
geometries[placement.PartId] = geometry;
sources[placement.PartId] = source = new ShapeTopology(geometry.Perimeter,
new List<Shape>(geometry.Cutouts));
}
var shape = Transform(source, placement);
if (!FitsWorkArea(shape, stock))
throw new InvalidOperationException(
"Candidate placement falls outside the usable stock area."
);
poses.Add((geometries[placement.PartId], placement));
spaced.Add(null);
// An outlined sheet is judged by the layout check's own test, so both accept the same
// poses. A rectangle needs no outline prepared for it.
if (stock.Outline != null && !NestLayoutCheck.InsideOutline(Spaced(placed.Count), stock, Epsilon))
throw new InvalidOperationException(
"Candidate placement falls outside the usable stock area."
);
for (var k = 0; k < placed.Count; k++)
{
var other = placed[k];
// Analytic contour bounds give a conservative lower bound on clearance.
// Do not polygonize or compare every hole edge for distant placements.
if (BoundsDistance(shape.Perimeter.BoundingBox, other.Perimeter.BoundingBox)
>= stock.PartSpacing && !shape.Perimeter.BoundingBox.Intersects(other.Perimeter.BoundingBox))
continue;
if (Overlaps(shape, other))
throw new InvalidOperationException("Candidate placements overlap.");
// Earlier placement first, so ties inflate it as the layout check's sweep does.
if (stock.PartSpacing > 0
&& !NestLayoutCheck.KeepsSpacing(Spaced(k), Spaced(placed.Count)))
throw new InvalidOperationException(
"Candidate placements violate required part spacing."
);
}
placed.Add(shape);
counts[placement.PartId] = count + 1;
}
NestLayoutCheck.PreparedPlacement Spaced(int index) =>
spaced[index] ??= NestLayoutCheck.Prepare(poses[index].Geometry, poses[index].Pose,
stock.PartSpacing);
}
private static ShapeTopology Transform(ShapeTopology source, NestJobPlacement placement)
{
var perimeter = TransformContour(source.Perimeter, placement);
var cutouts = new List<Shape>(source.Cutouts.Count);
foreach (var cutout in source.Cutouts)
cutouts.Add(TransformContour(cutout, placement));
return new ShapeTopology(perimeter, cutouts);
}
private static Shape TransformContour(Shape source, NestJobPlacement placement)
{
var contour = (Shape)source.Clone();
contour.Rotate(placement.Rotation);
contour.Offset(placement.X, placement.Y);
return contour;
}
private static bool FitsWorkArea(ShapeTopology shape, NestPlateStock stock)
{
var workArea = stock.WorkArea;
if (!FitsWorkArea(shape.Perimeter, workArea))
return false;
foreach (var cutout in shape.Cutouts)
if (!FitsWorkArea(cutout, workArea))
return false;
return true;
}
private static bool FitsWorkArea(Shape contour, Box workArea)
{
var bounds = contour.BoundingBox;
return bounds.Left >= workArea.Left - Epsilon
&& bounds.Right <= workArea.Right + Epsilon
&& bounds.Bottom >= workArea.Bottom - Epsilon
&& bounds.Top <= workArea.Top + Epsilon;
}
private static bool Overlaps(ShapeTopology left, ShapeTopology right)
{
var leftPoly = left.Contours[0].Polygon;
var rightPoly = right.Contours[0].Polygon;
if (!leftPoly.BoundingBox.Intersects(rightPoly.BoundingBox))
return false;
// True material overlap requires shared interior area, not boundary touching.
// Edge/corner contact (zero clearance) is a valid placement when part spacing is zero.
// Collision checks this by clipping triangulated polygons and rejecting zero-area
// slivers, so it catches containment and small corner intersections that a witness
// probe can miss, while contact stays legal; cutouts are subtracted from both sides.
return Collision.HasOverlap(
leftPoly,
rightPoly,
left.CutoutPolygons,
right.CutoutPolygons
);
}
private static double BoundsDistance(Box left, Box right)
{
var x = System.Math.Max(0, System.Math.Max(left.Left - right.Right, right.Left - left.Right));
var y = System.Math.Max(0, System.Math.Max(left.Bottom - right.Top, right.Bottom - left.Top));
return System.Math.Sqrt(x * x + y * y);
}
private sealed class ShapeTopology(Shape perimeter, List<Shape> cutouts)
{
private Contour[] contours;
private List<Polygon> cutoutPolygons;
internal Shape Perimeter { get; } = perimeter;
internal List<Shape> Cutouts { get; } = cutouts;
/// <summary>The perimeter first, then the cutouts, each flattened once on first use.</summary>
internal Contour[] Contours
{
get
{
if (contours != null)
return contours;
var result = new Contour[Cutouts.Count + 1];
result[0] = new Contour(Perimeter);
for (var i = 0; i < Cutouts.Count; i++)
result[i + 1] = new Contour(Cutouts[i]);
return contours = result;
}
}
internal List<Polygon> CutoutPolygons
{
get
{
if (cutoutPolygons != null)
return cutoutPolygons;
var result = new List<Polygon>(Cutouts.Count);
for (var i = 1; i < Contours.Length; i++)
result.Add(Contours[i].Polygon);
return cutoutPolygons = result;
}
}
}
/// <summary>
/// A contour flattened once, at <see cref="PlacementChordTolerance"/>, for the overlap check
/// against every other placement.
/// </summary>
private sealed class Contour
{
internal Contour(Shape shape)
{
Polygon = shape.ToPolygonWithTolerance(PlacementChordTolerance);
}
internal Polygon Polygon { get; }
}
}