diff --git a/OpenNest.Reporting/NestPdfWriter.cs b/OpenNest.Reporting/NestPdfWriter.cs
index 3782f7e4..3c77a93f 100644
--- a/OpenNest.Reporting/NestPdfWriter.cs
+++ b/OpenNest.Reporting/NestPdfWriter.cs
@@ -461,6 +461,16 @@ public static class NestPdfWriter
var groupPen = new XPen(XColors.Black, 0.6) { DashPattern = [1, 3] };
foreach (var group in view.Groups)
gfx.DrawRectangle(groupPen, group.Boundary);
+ // Leaders first, so each label's white box covers the end that runs to its center.
+ var leader = new XPen(XColors.Black, 0.5);
+ foreach (var label in view.Labels)
+ {
+ if (label.Anchor is not { } anchor)
+ continue;
+ gfx.DrawLine(leader, anchor, new XPoint(label.Box.X + label.Box.Width / 2, label.Box.Y + label.Box.Height / 2));
+ const double dot = 1.2;
+ gfx.DrawEllipse(XBrushes.Black, anchor.X - dot, anchor.Y - dot, 2 * dot, 2 * dot);
+ }
var font = NestReportDiagram.LabelFont();
foreach (var label in view.Labels.Concat(view.Groups.Select(group => group.Label)))
{
diff --git a/OpenNest.Reporting/NestReportDiagram.cs b/OpenNest.Reporting/NestReportDiagram.cs
index b0843d93..b96008eb 100644
--- a/OpenNest.Reporting/NestReportDiagram.cs
+++ b/OpenNest.Reporting/NestReportDiagram.cs
@@ -4,8 +4,11 @@ using PdfSharp.Drawing;
namespace OpenNest.Reporting;
-/// A part ID label in canvas-local page coordinates (Y down).
-internal sealed record DiagramLabel(int Part, string Id, XRect Box);
+///
+/// A part ID label in canvas-local page coordinates (Y down). A label set beside a part too thin
+/// to hold it has a leader on the part's material.
+///
+internal sealed record DiagramLabel(int Part, string Id, XRect Box, XPoint? Anchor = null);
/// A dotted group boundary and its shared ID, in canvas coordinates.
internal sealed record DiagramGroup(IReadOnlyList Parts, XRect Boundary, DiagramLabel Label);
@@ -108,6 +111,9 @@ internal static class NestReportDiagram
var canvas = new Canvas(new XRect(0, 0, width, height), [rulers.Horizontal, rulers.Vertical]);
var labels = PlaceLabels(plate, shapes, obstacles, all, fit, canvas, font, out var failed);
var groups = PlaceGroups(plate, obstacles, failed, labels, fit, canvas, font);
+ var grouped = groups.SelectMany(group => group.Parts).ToHashSet();
+ PlaceLeaders(plate, shapes, obstacles, failed.Where(index => !grouped.Contains(index)), labels, groups,
+ fit, canvas, font);
return new DiagramView(new XSize(width, height), fit, labels, groups, rulers);
}
@@ -368,8 +374,9 @@ internal static class NestReportDiagram
failed.Add(index);
}
- // A part too narrow at its pole (a ring around a large hole) may still have clear room
- // elsewhere within its own extents, such as the hole itself.
+ // A part too narrow at its pole (a ring around a large hole) may still have clear room in
+ // one of its own holes. Only an enclosed hole: open space beside a concave part (inside a
+ // C shape's opening) reads as belonging to whatever is near it, so that part gets a leader.
foreach (var index in failed.ToList())
{
var id = plate.Parts[index].ReportId;
@@ -377,7 +384,7 @@ internal static class NestReportDiagram
var area = fit.Rect(shapes[index].Bounds);
var others = obstacles.Where((_, other) => other != index).ToList();
var spot = BestSpot(Grid(area, size.Width + 2 * LabelPadding, size.Height + 2 * LabelPadding)
- .Where(area.Contains), obstacles, others, fit,
+ .Where(area.Contains).Where(box => shapes[index].InHole(Center(fit, box))), obstacles, others, fit,
padded => !canvas.Holds(padded) || OnSheetEdge(fit.Rect(plate.Bounds), padded) || placed.Any(label => label.Box.IntersectsWith(padded)),
new XPoint(area.X + area.Width / 2, area.Y + area.Height / 2));
if (spot is not { } found)
@@ -388,6 +395,123 @@ internal static class NestReportDiagram
return placed;
}
+ /// The model-space point under a canvas rectangle's center.
+ private static Vector Center(Fit fit, XRect box)
+ {
+ var center = fit.Model(new XPoint(box.X + box.Width / 2, box.Y + box.Height / 2));
+ return new Vector(center.X, center.Y);
+ }
+
+ ///
+ /// Sets the ID of each part still unlabeled (too thin for it, with no hole to hold it and no
+ /// same-ID neighbors to share one) in the nearest clear space outside it, with a leader to
+ /// its pole. Tiny parts whose ID other unlabeled parts share are skipped. The label keeps the usual clearance from every contour and other label; the
+ /// leader crosses no other part, cutoff, clamp, label or leader. A part with no such spot
+ /// within reach stays unlabeled, as before.
+ ///
+ private static void PlaceLeaders(ReportPlate plate, List shapes, List obstacles,
+ IEnumerable targets, List labels, List groups, Fit fit, Canvas canvas,
+ XFont font)
+ {
+ var sheet = fit.Rect(plate.Bounds);
+ var boxes = labels.Select(label => label.Box)
+ .Concat(groups.SelectMany(group => new[] { group.Boundary, group.Label.Box })).ToList();
+ var leaders = new List<(XPoint From, XPoint To)>();
+ var unlabeled = targets.ToList();
+ var shared = unlabeled.GroupBy(index => plate.Parts[index].ReportId)
+ .Where(group => group.Count() > 1).Select(group => group.Key).ToHashSet();
+ foreach (var index in unlabeled)
+ {
+ var id = plate.Parts[index].ReportId;
+ var size = ReportText.Size(id, font);
+ var width = size.Width + 2 * LabelPadding;
+ var height = size.Height + 2 * LabelPadding;
+ // Leaders are for thin parts. Tiny repeated parts that could not share a group label
+ // would bury the sheet in leaders, so they stay unlabeled; a lone tiny part gets one.
+ var extent = fit.Rect(shapes[index].Bounds);
+ if (shared.Contains(id) && System.Math.Max(extent.Width, extent.Height) < 2 * height)
+ continue;
+ var anchor = fit.Point(shapes[index].Pole.X, shapes[index].Pole.Y);
+ var others = obstacles.Where((_, other) => other != index).ToList();
+ var step = System.Math.Max(1, height / 3);
+ XRect? found = null;
+ XPoint end = default;
+ foreach (var reach in LeaderReach)
+ {
+ var area = fit.Rect(shapes[index].Bounds);
+ area.Inflate(reach * height, reach * height);
+ var candidates = new List<(XRect Box, double Distance)>();
+ for (var y = area.Top; y <= area.Bottom - height; y += step)
+ {
+ for (var x = area.Left; x <= area.Right - width; x += step)
+ {
+ var box = new XRect(x, y, width, height);
+ var near = Nearest(box, anchor);
+ candidates.Add((box, System.Math.Pow(near.X - anchor.X, 2) + System.Math.Pow(near.Y - anchor.Y, 2)));
+ }
+ }
+ foreach (var (box, _) in candidates.OrderBy(candidate => candidate.Distance))
+ {
+ var padded = box;
+ padded.Inflate(Clearance, Clearance);
+ if (!canvas.Holds(padded) || OnSheetEdge(sheet, padded) || boxes.Any(other => other.IntersectsWith(padded))
+ || leaders.Any(leader => SegmentHitsRect(leader.From, leader.To, padded)))
+ continue;
+ var near = Nearest(box, anchor);
+ var model = ModelBox(fit, box);
+ var reachBox = ModelBox(fit, padded);
+ if (obstacles.Any(shape => shape.Overlaps(reachBox) && shape.Distance(model) * fit.Scale < Clearance))
+ continue;
+ var center = Center(fit, box);
+ if (obstacles.Any(shape => shape.InMaterial(center)))
+ continue;
+ // The leader runs from the label's edge to the anchor: it may cross only its own
+ // part's outline, and no other label or leader.
+ var from = fit.Model(near);
+ var to = fit.Model(anchor);
+ if (others.Any(shape => shape.CrossesSegment(new Vector(from.X, from.Y), new Vector(to.X, to.Y)))
+ || boxes.Any(other => SegmentHitsRect(near, anchor, other))
+ || leaders.Any(leader => SegmentsCross(leader.From, leader.To, near, anchor)))
+ continue;
+ found = box;
+ end = near;
+ break;
+ }
+ if (found != null)
+ break;
+ }
+ if (found is not { } spot)
+ continue;
+ labels.Add(new DiagramLabel(index, id, spot, anchor));
+ boxes.Add(spot);
+ leaders.Add((end, anchor));
+ }
+ }
+
+ // How far, in label heights, the leader search looks past the part: near first, then wider.
+ private static readonly double[] LeaderReach = [4, 12];
+
+ /// The point of a rectangle (its border, for an outside point) nearest to a point.
+ private static XPoint Nearest(XRect box, XPoint point) =>
+ new(System.Math.Clamp(point.X, box.Left, box.Right), System.Math.Clamp(point.Y, box.Top, box.Bottom));
+
+ /// Whether a canvas segment touches a canvas rectangle.
+ private static bool SegmentHitsRect(XPoint a, XPoint b, XRect rect)
+ {
+ if (rect.Contains(a) || rect.Contains(b))
+ return true;
+ XPoint[] corners = [rect.TopLeft, rect.TopRight, rect.BottomRight, rect.BottomLeft];
+ for (var i = 0; i < 4; i++)
+ {
+ if (SegmentsCross(a, b, corners[i], corners[(i + 1) % 4]))
+ return true;
+ }
+ return false;
+ }
+
+ private static bool SegmentsCross(XPoint a, XPoint b, XPoint c, XPoint d) =>
+ Shape.SegmentsCross(new Vector(a.X, a.Y), new Vector(b.X, b.Y), new Vector(c.X, c.Y), new Vector(d.X, d.Y));
+
/// The model-space rectangle under a canvas rectangle.
private static Box ModelBox(Fit fit, XRect rect)
{
@@ -500,17 +624,49 @@ internal static class NestReportDiagram
if (!Box.Contains(point))
return false;
var inside = false;
+ foreach (var ring in Rings)
+ inside ^= Inside(ring, point);
+ return inside;
+ }
+
+ ///
+ /// Whether the point lies in one of the part's enclosed holes: inside its perimeter (the
+ /// largest ring) but not in its material.
+ ///
+ public bool InHole(Vector point) =>
+ Rings.Count > 1 && Box.Contains(point) && Inside(Rings.MaxBy(ring => ring.Area())!, point)
+ && !InMaterial(point);
+
+ /// Whether a model-space segment touches any contour edge.
+ public bool CrossesSegment(Vector a, Vector b)
+ {
+ // Box.Intersects is strict, which would miss a leader lying on the bounding box's edge.
+ if (System.Math.Max(a.X, b.X) < Box.Left || System.Math.Min(a.X, b.X) > Box.Right
+ || System.Math.Max(a.Y, b.Y) < Box.Bottom || System.Math.Min(a.Y, b.Y) > Box.Top)
+ return false;
foreach (var ring in Rings)
{
var vertices = ring.Vertices;
- for (int i = 0, j = vertices.Count - 1; i < vertices.Count; j = i++)
+ for (var i = 0; i < vertices.Count; i++)
{
- if ((vertices[i].Y > point.Y) != (vertices[j].Y > point.Y)
- && point.X < (vertices[j].X - vertices[i].X) * (point.Y - vertices[i].Y)
- / (vertices[j].Y - vertices[i].Y) + vertices[i].X)
- inside = !inside;
+ if (SegmentsCross(a, b, vertices[i], vertices[(i + 1) % vertices.Count]))
+ return true;
}
}
+ return false;
+ }
+
+ private static bool Inside(Polygon ring, Vector point)
+ {
+ var inside = false;
+ var vertices = ring.Vertices;
+ for (int i = 0, j = vertices.Count - 1; i < vertices.Count; j = i++)
+ {
+ if ((vertices[i].Y > point.Y) != (vertices[j].Y > point.Y)
+ && point.X < (vertices[j].X - vertices[i].X) * (point.Y - vertices[i].Y)
+ / (vertices[j].Y - vertices[i].Y) + vertices[i].X)
+ inside = !inside;
+ }
return inside;
}
@@ -550,7 +706,7 @@ internal static class NestReportDiagram
return System.Math.Sqrt(x * x + y * y);
}
- private static bool SegmentsCross(Vector a, Vector b, Vector c, Vector d)
+ internal static bool SegmentsCross(Vector a, Vector b, Vector c, Vector d)
{
static double Cross(Vector o, Vector p, Vector q) => (p.X - o.X) * (q.Y - o.Y) - (p.Y - o.Y) * (q.X - o.X);
var d1 = Cross(c, d, a);
diff --git a/OpenNest.Tests/Reporting/NestPdfLayoutTests.cs b/OpenNest.Tests/Reporting/NestPdfLayoutTests.cs
index abde310a..7722dc16 100644
--- a/OpenNest.Tests/Reporting/NestPdfLayoutTests.cs
+++ b/OpenNest.Tests/Reporting/NestPdfLayoutTests.cs
@@ -212,7 +212,9 @@ public sealed class NestPdfLayoutTests : IDisposable
var snapshot = NestReportBuilder.Capture(nest, NestReportTestData.GeneratedAt);
var plan = NestReportDiagram.Plan(snapshot.Plates[0], 720, 320);
Assert.Empty(plan.Groups);
- Assert.Equal(2, plan.Labels.Count);
+ // The washers stay unlabeled; a lone obstacle part gets its ID on a leader.
+ Assert.DoesNotContain(plan.Labels, label => label.Id == "2");
+ Assert.Equal(cutoff ? 2 : 3, plan.Labels.Count);
}
[Fact]
@@ -298,12 +300,118 @@ public sealed class NestPdfLayoutTests : IDisposable
var label = Assert.Single(plan.Labels);
Assert.Empty(plan.Groups);
+ Assert.Null(label.Anchor);
var center = plan.Fit.Model(new PdfSharp.Drawing.XPoint(label.Box.X + label.Box.Width / 2, label.Box.Y + label.Box.Height / 2));
var bounds = snapshot.Plates[0].Parts[0].Geometry.Bounds;
Assert.InRange(center.X - (bounds.Left + bounds.Right) / 2, -0.5, 0.5);
Assert.InRange(center.Y - (bounds.Bottom + bounds.Top) / 2, -0.5, 0.5);
}
+ [Fact]
+ public void Plan_PartsTooThinForTheirIdsGetLeaderLabelsBesideThem()
+ {
+ // From N26-2CJ: a 0.5 x 20 in strip and a 1 in wide half ring on a 48 x 96 sheet are a
+ // few points wide at overview scale. The strip was left unlabeled; the ring's ID went in
+ // its open side, off the part, with nothing tying it to the ring.
+ var nest = new Nest("Thin parts") { Units = Units.Inches };
+ var strip = NestReportTestData.Rectangle("Strip", 0.5, 20);
+ var ring = new Drawing("Half ring", HalfRing(outer: 10, inner: 9));
+ var block = NestReportTestData.Rectangle("Block", 30, 20);
+ nest.Drawings.Add(strip);
+ nest.Drawings.Add(ring);
+ nest.Drawings.Add(block);
+ var plate = new Plate(48, 96) { Quantity = 1, PartSpacing = 0.25 };
+ plate.Parts.Add(new Part(block, new Vector(1, 1)));
+ plate.Parts.Add(new Part(strip, new Vector(40, 1)));
+ plate.Parts.Add(new Part(ring, new Vector(30, 24)));
+ nest.Plates.Add(plate);
+ var snapshot = NestReportBuilder.Capture(nest, NestReportTestData.GeneratedAt);
+
+ var plan = NestReportDiagram.Plan(snapshot.Plates[0], 720, 320);
+
+ Assert.Equal(3, plan.Labels.Count);
+ Assert.Empty(plan.Groups);
+ Assert.Null(plan.Labels.Single(label => label.Part == 0).Anchor);
+ var parts = snapshot.Plates[0].Parts;
+ foreach (var index in new[] { 1, 2 })
+ {
+ var label = plan.Labels.Single(label => label.Part == index);
+ var anchor = plan.Fit.Model(Assert.NotNull(label.Anchor));
+ var bounds = parts[index].Geometry.Bounds;
+ Assert.InRange(anchor.X, bounds.Left, bounds.Right);
+ Assert.InRange(anchor.Y, bounds.Bottom, bounds.Top);
+ // The ID sits off the material, clear of the other parts, a short leader away.
+ foreach (var other in new[] { 0, 1 })
+ Assert.False(label.Box.IntersectsWith(plan.Fit.Rect(parts[other].Geometry.Bounds)));
+ var center = plan.Fit.Model(new PdfSharp.Drawing.XPoint(label.Box.X + label.Box.Width / 2, label.Box.Y + label.Box.Height / 2));
+ var radius = System.Math.Sqrt(System.Math.Pow(center.X - 40, 2) + System.Math.Pow(center.Y - 34, 2));
+ Assert.False(radius is >= 9 and <= 10, "The ID covers the ring's band.");
+ var nearX = System.Math.Clamp(label.Anchor!.Value.X, label.Box.Left, label.Box.Right);
+ var nearY = System.Math.Clamp(label.Anchor.Value.Y, label.Box.Top, label.Box.Bottom);
+ Assert.InRange(System.Math.Sqrt(System.Math.Pow(nearX - label.Anchor.Value.X, 2)
+ + System.Math.Pow(nearY - label.Anchor.Value.Y, 2)), 0, 4 * label.Box.Height);
+ }
+ // Every anchor lies in its own part's band: the ring's is between its two radii.
+ var ringAnchor = plan.Fit.Model(plan.Labels.Single(label => label.Part == 2).Anchor!.Value);
+ Assert.InRange(System.Math.Sqrt(System.Math.Pow(ringAnchor.X - 40, 2) + System.Math.Pow(ringAnchor.Y - 34, 2)), 9, 10);
+ Assert.True(ringAnchor.X >= 40);
+ }
+
+ [SkippableTheory]
+ [InlineData(0.5, true)]
+ [InlineData(3, false)]
+ public void Write_LeaderLabelDrawsADotOnThePart(double width, bool leader)
+ {
+ var nest = new Nest("Strip") { Units = Units.Inches };
+ var strip = NestReportTestData.Rectangle("Strip", width, 20);
+ nest.Drawings.Add(strip);
+ var plate = new Plate(48, 96) { Quantity = 1 };
+ plate.Parts.Add(new Part(strip, new Vector(40, 1)));
+ nest.Plates.Add(plate);
+ var snapshot = NestReportBuilder.Capture(nest, NestReportTestData.GeneratedAt);
+ Assert.Equal(leader, Assert.Single(NestReportDiagram.Plan(snapshot.Plates[0], 720, 320).Labels).Anchor != null);
+
+ var path = Write(nest);
+
+ using var pdf = PdfReader.Open(path, PdfDocumentOpenMode.Import);
+ var diagram = ReportPdf.ContentStreams(pdf.Pages[1]).Last();
+ // Nothing else on this all-straight plate draws a curve: only the leader's anchor dot.
+ Assert.Equal(leader, Regex.IsMatch(diagram, @"(?m)\sc\s*$"));
+ }
+
+ [Fact]
+ public void Plan_LoneTinyPartGetsALeaderButAnUngroupableClusterDoesNot()
+ {
+ // The dense nest's washer cluster cannot be grouped around the obstacle: its washers stay
+ // unlabeled rather than each sprouting a leader. A lone washer elsewhere gets one.
+ var nest = NestReportTestData.CreateDenseNest();
+ nest.Plates[0].Parts.Add(new Part(NestReportTestData.Rectangle("Obstacle", 0.1, 0.1), new Vector(63.2, 31.2)));
+ var lone = new Drawing("Lone washer", NestReportTestData.HoledSquare(1, 0.25));
+ nest.Drawings.Add(lone);
+ nest.Plates[0].Parts.Add(new Part(lone, new Vector(80, 80)));
+ var snapshot = NestReportBuilder.Capture(nest, NestReportTestData.GeneratedAt);
+
+ var plan = NestReportDiagram.Plan(snapshot.Plates[0], 720, 320);
+
+ Assert.Empty(plan.Groups);
+ Assert.DoesNotContain(plan.Labels, label => label.Id == "2");
+ var leader = Assert.Single(plan.Labels, label => label.Part == snapshot.Plates[0].Parts.Length - 1);
+ Assert.NotNull(leader.Anchor);
+ }
+
+ /// The right half of a ring centered at (, ).
+ private static Program HalfRing(double outer, double inner)
+ {
+ var center = new Vector(outer, outer);
+ var program = new Program();
+ program.Codes.Add(new RapidMove(outer, 2 * outer));
+ program.Codes.Add(new ArcMove(new Vector(outer, 0), center, RotationType.CW));
+ program.Codes.Add(new LinearMove(outer, outer - inner));
+ program.Codes.Add(new ArcMove(new Vector(outer, outer + inner), center, RotationType.CCW));
+ program.Codes.Add(new LinearMove(outer, 2 * outer));
+ return program;
+ }
+
[SkippableFact]
public void Write_LabelOnHoledPartAvoidsTheHole()
{
diff --git a/docs/nest-reports.md b/docs/nest-reports.md
index 3fdd5d0f..dab71cd1 100644
--- a/docs/nest-reports.md
+++ b/docs/nest-reports.md
@@ -144,10 +144,20 @@ Individual IDs use 7 pt text centered on the part's pole of inaccessibility
(`PolyLabel`, as in `PlateView`), clear of edges, holes, cutoffs and other labels.
The search uses a placement-independent quantized copy for consistent placement
on identical parts. When the pole is too narrow (a ring around a large hole), the
-ID goes in the clear spot within the part's own extents with the most room, such
-as an empty hole, nearest the part's center. Labels are best effort: there are no
-closeup or grid pages, and a part too small to label never prevents export. Every
-part remains in the quantity tables even when its diagram label cannot fit.
+ID goes in the clear spot of one of the part's own enclosed holes with the most
+room, nearest the part's center. Open space beside a concave part (inside a C
+shape's opening) never holds its ID that way, since it reads as belonging to
+whatever is nearby.
+
+A part still unlabeled after the groups below (a thin strip or a narrow band with
+no hole to hold its ID) gets its ID in the nearest clear space outside it, with a
+thin leader to a dot at its pole. The label keeps the usual clearance; the leader
+crosses no other part, cutoff, clamp, label or leader. Tiny parts (under two label
+heights long) whose ID other unlabeled parts share get no leaders, so an ungroupable
+cluster does not bury the sheet in them; a lone tiny part gets one. Labels are best
+effort: there are no closeup or grid pages, and a part too small to label never
+prevents export. Every part remains in the quantity tables even when its diagram
+label cannot fit.
Nearby small parts with the same report ID may share a dotted rectangular outline
and one ID. Separate clusters get separate outlines; an outline stays within half