Files
OpenNest/OpenNest.Core/PartGeometry.cs
T
ajandClaude Opus 5.5 c48fbd87b8 fix(fill): thin dense spacing outlines and stop near-circle offset joints
A braze-casing angle whose 0.98" curve was exported as 199 lines of
0.005" made a single Fill of 33 copies take 8.6 minutes, and Auto Nest's
Irregular engine never finished its first plate in 15 minutes: it
proposes such fills as Lattice blocks.

Two causes. Shape.JoinOffsetLines tested convexity with an unnormalized
cross product, so shallow concave turns between tiny lines fell under
the epsilon, the nearly parallel offsets missed each other, and the
fallback arc swept the long way round: a near circle per joint, 414
entities in the spacing outline. A non-convex turn now gets a straight
bridge, as concave corners already do.

Spacing outlines with a dense run of tiny entities are also thinned to
Douglas-Peucker chords on an offset padded by 0.0015, so every chord
stays outside the true spacing outline: clearance can only grow, by at
most 0.003 beside the run, and validation still reads true geometry.
The angle's outline is now 21 entities; the Fill takes 69 s with no
overlaps, and Irregular finishes the whole job (24 sheets in under 5
minutes, 22 by a 15-minute limit, against 28).

Problem-nest corpus (auto-nest, fill): all layouts and counts unchanged.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-21 13:26:51 -05:00

278 lines
9.7 KiB
C#

using System.Collections.Generic;
using System.Linq;
using OpenNest.Converters;
using OpenNest.Geometry;
namespace OpenNest
{
public static class PartGeometry
{
/// <summary>
/// Nesting material of a program, without lead-ins and lead-outs: a lead is a cut
/// into scrap, not part material, and chaining it into the perimeter leaves an open
/// spur, so the offset contour no longer closes and every slide contact against it
/// blocks. A perimeter tab leaves the same open chain, so the contour is closed
/// across it (<see cref="NestingMaterial.ClosedAcrossTab"/>).
/// </summary>
private static List<Entity> MaterialEntities(CNC.Program program) =>
ConvertProgram.ToGeometry(program)
.Where(e => e.Layer != SpecialLayers.Leadin && e.Layer != SpecialLayers.Leadout)
.ForNesting()
.ClosedAcrossTab();
public static List<Line> GetPartLines(Part part, double chordTolerance = 0.001)
{
var entities = MaterialEntities(part.Program);
var shapes = ShapeBuilder.GetShapes(entities);
var lines = new List<Line>();
foreach (var shape in shapes)
{
var polygon = shape.ToPolygonWithTolerance(chordTolerance);
polygon.Offset(part.Location);
lines.AddRange(polygon.ToLines());
}
return lines;
}
public static List<Line> GetPartLines(
Part part,
PushDirection facingDirection,
double chordTolerance = 0.001
)
{
return GetDirectionalPartLines(
part, chordTolerance, useVector: false, facingDirection, default
);
}
/// <summary>
/// Returns the perimeter entities (Line, Arc, Circle) with spacing offset applied,
/// without tessellation, which keeps arc-heavy parts fast in directional-distance loops.
/// </summary>
public static List<Entity> GetOffsetPerimeterEntities(Part part, double spacing)
{
var entities = GetOffsetPerimeterEntities(part.Program, spacing);
foreach (var entity in entities)
entity.Offset(part.Location);
return entities;
}
/// <summary>
/// Prepares a fresh offset perimeter in the program's local frame, without translation.
/// </summary>
public static List<Entity> GetOffsetPerimeterEntities(CNC.Program program, double spacing)
{
PerfCounters.CountOffsetPerimeterEntities();
var geoEntities = MaterialEntities(program);
var profile = new ShapeProfile(geoEntities);
// A dense run of tiny entities is thinned to a few chords on a slightly wider offset;
// the chords stay outside the true one, so only clearance is added (DenseOutline).
if (DenseOutline.HasDenseRun(profile.Perimeter.Entities))
{
var padded = profile.Perimeter.OffsetOutward(spacing + DenseOutline.Pad);
if (padded != null)
return DenseOutline.Thin(padded.Entities);
}
var offsetShape = profile.Perimeter.OffsetOutward(spacing);
if (offsetShape == null)
return new List<Entity>();
return offsetShape.Entities;
}
/// <summary>
/// Returns all entities (perimeter + cutouts) with spacing offset applied,
/// without tessellation. Perimeter is offset outward, cutouts inward.
/// </summary>
public static List<Entity> GetOffsetPartEntities(Part part, double spacing)
{
var geoEntities = MaterialEntities(part.Program);
var profile = new ShapeProfile(geoEntities);
var entities = new List<Entity>();
var perimeter = profile.Perimeter.OffsetOutward(spacing);
if (perimeter != null)
{
foreach (var entity in perimeter.Entities)
entity.Offset(part.Location);
entities.AddRange(perimeter.Entities);
}
foreach (var cutout in profile.Cutouts)
{
var inset = cutout.OffsetInward(spacing);
if (inset == null)
continue;
foreach (var entity in inset.Entities)
entity.Offset(part.Location);
entities.AddRange(inset.Entities);
}
return entities;
}
/// <summary>
/// Returns perimeter entities at the part's world location, without tessellation
/// or spacing offset.
/// </summary>
public static List<Entity> GetPerimeterEntities(Part part)
{
var geoEntities = MaterialEntities(part.Program);
var profile = new ShapeProfile(geoEntities);
return CopyEntitiesAtLocation(profile.Perimeter.Entities, part.Location);
}
/// <summary>
/// Returns all entities (perimeter + cutouts) at the part's world location,
/// without tessellation or spacing offset.
/// </summary>
public static List<Entity> GetPartEntities(Part part)
{
var geoEntities = MaterialEntities(part.Program);
var profile = new ShapeProfile(geoEntities);
var entities = CopyEntitiesAtLocation(profile.Perimeter.Entities, part.Location);
foreach (var cutout in profile.Cutouts)
entities.AddRange(CopyEntitiesAtLocation(cutout.Entities, part.Location));
return entities;
}
private static List<Entity> CopyEntitiesAtLocation(List<Entity> source, Vector location)
{
var result = new List<Entity>(source.Count);
foreach (var entity in source)
{
var copy = entity.Clone();
copy.Offset(location);
result.Add(copy);
}
return result;
}
public static List<Line> GetPartLines(
Part part,
Vector facingDirection,
double chordTolerance = 0.001
)
{
return GetDirectionalPartLines(
part, chordTolerance, useVector: true, default, facingDirection
);
}
private static List<Line> GetDirectionalPartLines(
Part part,
double chordTolerance,
bool useVector,
PushDirection cardinalDirection,
Vector vectorDirection
)
{
var entities = MaterialEntities(part.Program);
var shapes = ShapeBuilder.GetShapes(entities);
var lines = new List<Line>();
foreach (var shape in shapes)
{
var polygon = shape.ToPolygonWithTolerance(chordTolerance);
polygon.Offset(part.Location);
// Keep the overload-specific arithmetic and invalid-direction behavior.
lines.AddRange(useVector
? GetDirectionalLines(polygon, vectorDirection)
: GetDirectionalLines(polygon, cardinalDirection));
}
return lines;
}
/// <summary>
/// Returns only polygon edges whose outward normal faces the specified direction vector.
/// </summary>
private static List<Line> GetDirectionalLines(Polygon polygon, Vector direction)
{
if (polygon.Vertices.Count < 3)
return polygon.ToLines();
var sign = polygon.RotationDirection() == RotationType.CCW ? 1.0 : -1.0;
var lines = new List<Line>();
var last = polygon.Vertices[0];
for (var i = 1; i < polygon.Vertices.Count; i++)
{
var current = polygon.Vertices[i];
var edx = current.X - last.X;
var edy = current.Y - last.Y;
var keep = sign * (edy * direction.X - edx * direction.Y) > 0;
if (keep)
lines.Add(new Line(last, current));
last = current;
}
return lines;
}
/// <summary>
/// Returns only polygon edges whose outward normal faces the specified direction.
/// </summary>
private static List<Line> GetDirectionalLines(
Polygon polygon,
PushDirection facingDirection
)
{
if (polygon.Vertices.Count < 3)
return polygon.ToLines();
var sign = polygon.RotationDirection() == RotationType.CCW ? 1.0 : -1.0;
var lines = new List<Line>();
var last = polygon.Vertices[0];
for (int i = 1; i < polygon.Vertices.Count; i++)
{
var current = polygon.Vertices[i];
var dx = current.X - last.X;
var dy = current.Y - last.Y;
bool keep;
switch (facingDirection)
{
case PushDirection.Left:
keep = -sign * dy > 0;
break;
case PushDirection.Right:
keep = sign * dy > 0;
break;
case PushDirection.Up:
keep = -sign * dx > 0;
break;
case PushDirection.Down:
keep = sign * dx > 0;
break;
default:
keep = true;
break;
}
if (keep)
lines.Add(new Line(last, current));
last = current;
}
return lines;
}
}
}