mirror of
https://github.com/ajisaacs/OpenNest.git
synced 2026-11-20 20:27:42 -05:00
A part whose planned outside carries a perimeter tab could not be pushed away from a neighbor it rested against at the part spacing, and the neighbor could not be pushed away from it: the push returned 0 with open sheet ahead. It showed whenever the neighbor's bounds wrapped the part (an eared or C-shaped neighbor), since otherwise the broad phase skips an obstacle that is wholly behind. The tab stops the cut short of its entry, so with the leads dropped the outside is an open chain. Its spacing-offset contour does not close, the slide kernel cannot tell which side of it is material, and it blocks every contact against a boundary it cannot resolve. The parts were never closer than the spacing. PartGeometry now closes a tabbed contour across its tab before any offset: the trimmed last cut is restored along its own line or arc (exact), a round outside cut as one arc becomes its circle, and a tab that swallowed whole entities is bridged by its chord, as flattening to a polygon already closes it. Only a single gap is closed; closed material is returned untouched, so untabbed parts and the fills see the same geometry as before. No kernel code or tolerance changed, so a push into a neighbor still returns 0 and a contour cut in several pieces still blocks. Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
269 lines
9.2 KiB
C#
269 lines
9.2 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);
|
|
|
|
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;
|
|
}
|
|
}
|
|
}
|