964 lines
30 KiB
Markdown
964 lines
30 KiB
Markdown
# Best-Fit Pair Finding Implementation Plan
|
|
|
|
> **For Claude:** REQUIRED SUB-SKILL: Use superpowers:executing-plans to implement this plan task-by-task.
|
|
|
|
**Goal:** Build a pair-finding engine that arranges two copies of a part in the tightest configuration, then tiles that pair across a plate.
|
|
|
|
**Architecture:** Strategy pattern where `RotationSlideStrategy` instances (parameterized by angle) generate candidate pair configurations by sliding one part against another using existing raycast collision. A `PairEvaluator` scores candidates by bounding area, a `BestFitFilter` prunes bad fits, and a `TileEvaluator` simulates tiling the best pairs onto a plate.
|
|
|
|
**Tech Stack:** .NET Framework 4.8, C# 7.3, OpenNest.Engine (class library referencing OpenNest.Core)
|
|
|
|
---
|
|
|
|
## Important Context
|
|
|
|
### Codebase Conventions
|
|
- **All angles are in radians** — use `Angle.ToRadians()`, `Angle.HalfPI`, `Angle.TwoPI`
|
|
- **Always use `var`** instead of explicit types
|
|
- **`OpenNest.Math` shadows `System.Math`** — use `System.Math` fully qualified
|
|
- **Legacy `.csproj`** — every new `.cs` file must be added to `OpenNest.Engine.csproj` `<Compile>` items
|
|
- **No test project exists** — skip TDD steps, verify by building
|
|
|
|
### Key Existing Types
|
|
- `Vector` (struct, `OpenNest.Geometry`) — 2D point, has `Rotate()`, `Offset()`, `DistanceTo()`, operators
|
|
- `Box` (class, `OpenNest.Geometry`) — AABB with `Left/Right/Top/Bottom/Width/Height`, `Contains()`, `Intersects()`
|
|
- `Part` (class, `OpenNest`) — wraps `Drawing` + `Program`, has `Location`, `Rotation`, `Rotate()`, `Offset()`, `Clone()`, `BoundingBox`
|
|
- `Drawing` (class, `OpenNest`) — has `Program`, `Area`, `Name`
|
|
- `Program` (class, `OpenNest.CNC`) — G-code program, has `BoundingBox()`, `Rotate()`, `Clone()`
|
|
- `Plate` (class, `OpenNest`) — has `Size` (Width/Height), `EdgeSpacing`, `PartSpacing`, `WorkArea()`
|
|
- `Shape` (class, `OpenNest.Geometry`) — closed contour, has `Intersects(Shape)`, `Area()`, `ToPolygon()`, `OffsetEntity()`
|
|
- `Polygon` (class, `OpenNest.Geometry`) — vertex list, has `FindBestRotation()`, `Rotate()`, `Offset()`
|
|
- `ConvexHull.Compute(IList<Vector>)` — returns closed `Polygon`
|
|
- `BoundingRectangleResult` — `Angle`, `Width`, `Height`, `Area` from rotating calipers
|
|
|
|
### Key Existing Methods (in `Helper`)
|
|
- `Helper.GetShapes(IEnumerable<Entity>)` — builds `Shape` list from geometry entities
|
|
- `Helper.GetPartLines(Part, PushDirection)` — gets polygon edges facing a direction (uses chord tolerance 0.01)
|
|
- `Helper.DirectionalDistance(movingLines, stationaryLines, PushDirection)` — raycasts to find minimum contact distance
|
|
- `Helper.OppositeDirection(PushDirection)` — flips direction
|
|
- `ConvertProgram.ToGeometry(Program)` — converts CNC program to geometry entities
|
|
|
|
### How Existing Push/Contact Works (in `FillLinear`)
|
|
```
|
|
1. Create partA at position
|
|
2. Clone to partB, offset by bounding box dimension along axis
|
|
3. Get facing lines: movingLines = GetPartLines(partB, pushDir)
|
|
4. Get facing lines: stationaryLines = GetPartLines(partA, oppositeDir)
|
|
5. slideDistance = DirectionalDistance(movingLines, stationaryLines, pushDir)
|
|
6. copyDistance = bboxDim - slideDistance + spacing
|
|
```
|
|
The best-fit system adapts this: part2 is rotated, offset perpendicular to the push axis, then pushed toward part1.
|
|
|
|
### Hull Edge Angles (existing pattern in `NestEngine`)
|
|
```
|
|
1. Convert part to polygon via ConvertProgram.ToGeometry → GetShapes → ToPolygonWithTolerance
|
|
2. Compute convex hull via ConvexHull.Compute(vertices)
|
|
3. Extract edge angles: atan2(dy, dx) for each hull edge
|
|
4. Deduplicate angles (within Tolerance.Epsilon)
|
|
```
|
|
|
|
---
|
|
|
|
## Task 1: PairCandidate Data Class
|
|
|
|
**Files:**
|
|
- Create: `OpenNest.Engine/BestFit/PairCandidate.cs`
|
|
- Modify: `OpenNest.Engine/OpenNest.Engine.csproj` (add Compile entry)
|
|
|
|
**Step 1: Create directory and file**
|
|
|
|
```csharp
|
|
using OpenNest.Geometry;
|
|
|
|
namespace OpenNest.Engine.BestFit
|
|
{
|
|
public class PairCandidate
|
|
{
|
|
public Drawing Drawing { get; set; }
|
|
public double Part1Rotation { get; set; }
|
|
public double Part2Rotation { get; set; }
|
|
public Vector Part2Offset { get; set; }
|
|
public int StrategyType { get; set; }
|
|
public int TestNumber { get; set; }
|
|
public double Spacing { get; set; }
|
|
}
|
|
}
|
|
```
|
|
|
|
**Step 2: Add to .csproj**
|
|
|
|
Add inside the `<ItemGroup>` that contains `<Compile>` entries, before `</ItemGroup>`:
|
|
```xml
|
|
<Compile Include="BestFit\PairCandidate.cs" />
|
|
```
|
|
|
|
**Step 3: Build to verify**
|
|
|
|
Run: `msbuild OpenNest.Engine/OpenNest.Engine.csproj /p:Configuration=Debug /v:q`
|
|
Expected: Build succeeded
|
|
|
|
**Step 4: Commit**
|
|
|
|
```
|
|
feat: add PairCandidate data class for best-fit pair finding
|
|
```
|
|
|
|
---
|
|
|
|
## Task 2: BestFitResult Data Class
|
|
|
|
**Files:**
|
|
- Create: `OpenNest.Engine/BestFit/BestFitResult.cs`
|
|
- Modify: `OpenNest.Engine/OpenNest.Engine.csproj`
|
|
|
|
**Step 1: Create file**
|
|
|
|
```csharp
|
|
namespace OpenNest.Engine.BestFit
|
|
{
|
|
public class BestFitResult
|
|
{
|
|
public PairCandidate Candidate { get; set; }
|
|
public double RotatedArea { get; set; }
|
|
public double BoundingWidth { get; set; }
|
|
public double BoundingHeight { get; set; }
|
|
public double OptimalRotation { get; set; }
|
|
public bool Keep { get; set; }
|
|
public string Reason { get; set; }
|
|
public double TrueArea { get; set; }
|
|
|
|
public double Utilization
|
|
{
|
|
get { return RotatedArea > 0 ? TrueArea / RotatedArea : 0; }
|
|
}
|
|
|
|
public double LongestSide
|
|
{
|
|
get { return System.Math.Max(BoundingWidth, BoundingHeight); }
|
|
}
|
|
|
|
public double ShortestSide
|
|
{
|
|
get { return System.Math.Min(BoundingWidth, BoundingHeight); }
|
|
}
|
|
}
|
|
|
|
public enum BestFitSortField
|
|
{
|
|
Area,
|
|
LongestSide,
|
|
ShortestSide,
|
|
Type,
|
|
OriginalSequence,
|
|
Keep,
|
|
WhyKeepDrop
|
|
}
|
|
}
|
|
```
|
|
|
|
**Step 2: Add to .csproj**
|
|
|
|
```xml
|
|
<Compile Include="BestFit\BestFitResult.cs" />
|
|
```
|
|
|
|
**Step 3: Build to verify**
|
|
|
|
Run: `msbuild OpenNest.Engine/OpenNest.Engine.csproj /p:Configuration=Debug /v:q`
|
|
|
|
**Step 4: Commit**
|
|
|
|
```
|
|
feat: add BestFitResult data class and BestFitSortField enum
|
|
```
|
|
|
|
---
|
|
|
|
## Task 3: IBestFitStrategy Interface
|
|
|
|
**Files:**
|
|
- Create: `OpenNest.Engine/BestFit/IBestFitStrategy.cs`
|
|
- Modify: `OpenNest.Engine/OpenNest.Engine.csproj`
|
|
|
|
**Step 1: Create file**
|
|
|
|
```csharp
|
|
using System.Collections.Generic;
|
|
|
|
namespace OpenNest.Engine.BestFit
|
|
{
|
|
public interface IBestFitStrategy
|
|
{
|
|
int Type { get; }
|
|
string Description { get; }
|
|
List<PairCandidate> GenerateCandidates(Drawing drawing, double spacing, double stepSize);
|
|
}
|
|
}
|
|
```
|
|
|
|
**Step 2: Add to .csproj**
|
|
|
|
```xml
|
|
<Compile Include="BestFit\IBestFitStrategy.cs" />
|
|
```
|
|
|
|
**Step 3: Build to verify**
|
|
|
|
**Step 4: Commit**
|
|
|
|
```
|
|
feat: add IBestFitStrategy interface
|
|
```
|
|
|
|
---
|
|
|
|
## Task 4: RotationSlideStrategy
|
|
|
|
This is the core algorithm. It generates pair candidates by:
|
|
1. Creating part1 at origin
|
|
2. Creating part2 with a specific rotation
|
|
3. For each push direction (Left, Down):
|
|
- For each perpendicular offset (stepping across the part):
|
|
- Place part2 far away along the push axis
|
|
- Use `DirectionalDistance` to find contact
|
|
- Record position as a candidate
|
|
|
|
**Files:**
|
|
- Create: `OpenNest.Engine/BestFit/RotationSlideStrategy.cs`
|
|
- Modify: `OpenNest.Engine/OpenNest.Engine.csproj`
|
|
|
|
**Step 1: Create file**
|
|
|
|
```csharp
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using OpenNest.Converters;
|
|
using OpenNest.Geometry;
|
|
using OpenNest.Math;
|
|
|
|
namespace OpenNest.Engine.BestFit
|
|
{
|
|
public class RotationSlideStrategy : IBestFitStrategy
|
|
{
|
|
private const double ChordTolerance = 0.01;
|
|
|
|
public RotationSlideStrategy(double part2Rotation, int type, string description)
|
|
{
|
|
Part2Rotation = part2Rotation;
|
|
Type = type;
|
|
Description = description;
|
|
}
|
|
|
|
public double Part2Rotation { get; }
|
|
public int Type { get; }
|
|
public string Description { get; }
|
|
|
|
public List<PairCandidate> GenerateCandidates(Drawing drawing, double spacing, double stepSize)
|
|
{
|
|
var candidates = new List<PairCandidate>();
|
|
|
|
var part1 = new Part(drawing);
|
|
var bbox1 = part1.Program.BoundingBox();
|
|
part1.Offset(-bbox1.Location.X, -bbox1.Location.Y);
|
|
part1.UpdateBounds();
|
|
|
|
var part2Template = new Part(drawing);
|
|
if (!Part2Rotation.IsEqualTo(0))
|
|
part2Template.Rotate(Part2Rotation);
|
|
var bbox2 = part2Template.Program.BoundingBox();
|
|
part2Template.Offset(-bbox2.Location.X, -bbox2.Location.Y);
|
|
part2Template.UpdateBounds();
|
|
|
|
var testNumber = 0;
|
|
|
|
// Slide along horizontal axis (push left toward part1)
|
|
GenerateCandidatesForAxis(
|
|
part1, part2Template, drawing, spacing, stepSize,
|
|
PushDirection.Left, candidates, ref testNumber);
|
|
|
|
// Slide along vertical axis (push down toward part1)
|
|
GenerateCandidatesForAxis(
|
|
part1, part2Template, drawing, spacing, stepSize,
|
|
PushDirection.Down, candidates, ref testNumber);
|
|
|
|
return candidates;
|
|
}
|
|
|
|
private void GenerateCandidatesForAxis(
|
|
Part part1, Part part2Template, Drawing drawing,
|
|
double spacing, double stepSize, PushDirection pushDir,
|
|
List<PairCandidate> candidates, ref int testNumber)
|
|
{
|
|
var bbox1 = part1.BoundingBox;
|
|
var bbox2 = part2Template.BoundingBox;
|
|
|
|
// Determine perpendicular range based on push direction
|
|
double perpMin, perpMax, pushStartOffset;
|
|
bool isHorizontalPush = (pushDir == PushDirection.Left || pushDir == PushDirection.Right);
|
|
|
|
if (isHorizontalPush)
|
|
{
|
|
// Pushing horizontally: perpendicular axis is Y
|
|
perpMin = -(bbox2.Height + spacing);
|
|
perpMax = bbox1.Height + bbox2.Height + spacing;
|
|
pushStartOffset = bbox1.Width + bbox2.Width + spacing * 2;
|
|
}
|
|
else
|
|
{
|
|
// Pushing vertically: perpendicular axis is X
|
|
perpMin = -(bbox2.Width + spacing);
|
|
perpMax = bbox1.Width + bbox2.Width + spacing;
|
|
pushStartOffset = bbox1.Height + bbox2.Height + spacing * 2;
|
|
}
|
|
|
|
var part1Lines = Helper.GetOffsetPartLines(part1, spacing / 2);
|
|
var opposite = Helper.OppositeDirection(pushDir);
|
|
|
|
for (var offset = perpMin; offset <= perpMax; offset += stepSize)
|
|
{
|
|
var part2 = (Part)part2Template.Clone();
|
|
|
|
if (isHorizontalPush)
|
|
part2.Offset(pushStartOffset, offset);
|
|
else
|
|
part2.Offset(offset, pushStartOffset);
|
|
|
|
var movingLines = Helper.GetOffsetPartLines(part2, spacing / 2);
|
|
var slideDist = Helper.DirectionalDistance(movingLines, part1Lines, pushDir);
|
|
|
|
if (slideDist >= double.MaxValue || slideDist < 0)
|
|
continue;
|
|
|
|
// Move part2 to contact position
|
|
var contactOffset = GetPushVector(pushDir, slideDist);
|
|
var finalPosition = part2.Location + contactOffset;
|
|
|
|
candidates.Add(new PairCandidate
|
|
{
|
|
Drawing = drawing,
|
|
Part1Rotation = 0,
|
|
Part2Rotation = Part2Rotation,
|
|
Part2Offset = finalPosition,
|
|
StrategyType = Type,
|
|
TestNumber = testNumber++,
|
|
Spacing = spacing
|
|
});
|
|
}
|
|
}
|
|
|
|
private static Vector GetPushVector(PushDirection direction, double distance)
|
|
{
|
|
switch (direction)
|
|
{
|
|
case PushDirection.Left: return new Vector(-distance, 0);
|
|
case PushDirection.Right: return new Vector(distance, 0);
|
|
case PushDirection.Down: return new Vector(0, -distance);
|
|
case PushDirection.Up: return new Vector(0, distance);
|
|
default: return Vector.Zero;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
```
|
|
|
|
**Step 2: Add to .csproj**
|
|
|
|
```xml
|
|
<Compile Include="BestFit\RotationSlideStrategy.cs" />
|
|
```
|
|
|
|
**Step 3: Build to verify**
|
|
|
|
Run: `msbuild OpenNest.Engine/OpenNest.Engine.csproj /p:Configuration=Debug /v:q`
|
|
|
|
**Step 4: Commit**
|
|
|
|
```
|
|
feat: add RotationSlideStrategy with directional push contact algorithm
|
|
```
|
|
|
|
---
|
|
|
|
## Task 5: PairEvaluator
|
|
|
|
Scores each candidate by computing the combined bounding box, finding the optimal rotation (via rotating calipers on the convex hull), and checking for overlaps.
|
|
|
|
**Files:**
|
|
- Create: `OpenNest.Engine/BestFit/PairEvaluator.cs`
|
|
- Modify: `OpenNest.Engine/OpenNest.Engine.csproj`
|
|
|
|
**Step 1: Create file**
|
|
|
|
```csharp
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using OpenNest.Converters;
|
|
using OpenNest.Geometry;
|
|
|
|
namespace OpenNest.Engine.BestFit
|
|
{
|
|
public class PairEvaluator
|
|
{
|
|
private const double ChordTolerance = 0.01;
|
|
|
|
public BestFitResult Evaluate(PairCandidate candidate)
|
|
{
|
|
var drawing = candidate.Drawing;
|
|
|
|
// Build part1 at origin
|
|
var part1 = new Part(drawing);
|
|
var bbox1 = part1.Program.BoundingBox();
|
|
part1.Offset(-bbox1.Location.X, -bbox1.Location.Y);
|
|
part1.UpdateBounds();
|
|
|
|
// Build part2 with rotation and offset
|
|
var part2 = new Part(drawing);
|
|
if (!candidate.Part2Rotation.IsEqualTo(0))
|
|
part2.Rotate(candidate.Part2Rotation);
|
|
var bbox2 = part2.Program.BoundingBox();
|
|
part2.Offset(-bbox2.Location.X, -bbox2.Location.Y);
|
|
part2.Location = candidate.Part2Offset;
|
|
part2.UpdateBounds();
|
|
|
|
// Check overlap via shape intersection
|
|
var overlaps = CheckOverlap(part1, part2, candidate.Spacing);
|
|
|
|
// Collect all polygon vertices for convex hull / optimal rotation
|
|
var allPoints = GetPartVertices(part1);
|
|
allPoints.AddRange(GetPartVertices(part2));
|
|
|
|
// Find optimal bounding rectangle via rotating calipers
|
|
double bestArea, bestWidth, bestHeight, bestRotation;
|
|
|
|
if (allPoints.Count >= 3)
|
|
{
|
|
var hull = ConvexHull.Compute(allPoints);
|
|
var result = RotatingCalipers.MinimumBoundingRectangle(hull);
|
|
bestArea = result.Area;
|
|
bestWidth = result.Width;
|
|
bestHeight = result.Height;
|
|
bestRotation = result.Angle;
|
|
}
|
|
else
|
|
{
|
|
var combinedBox = ((IEnumerable<IBoundable>)new[] { part1, part2 }).GetBoundingBox();
|
|
bestArea = combinedBox.Area();
|
|
bestWidth = combinedBox.Width;
|
|
bestHeight = combinedBox.Height;
|
|
bestRotation = 0;
|
|
}
|
|
|
|
var trueArea = drawing.Area * 2;
|
|
|
|
return new BestFitResult
|
|
{
|
|
Candidate = candidate,
|
|
RotatedArea = bestArea,
|
|
BoundingWidth = bestWidth,
|
|
BoundingHeight = bestHeight,
|
|
OptimalRotation = bestRotation,
|
|
TrueArea = trueArea,
|
|
Keep = !overlaps,
|
|
Reason = overlaps ? "Overlap detected" : "Valid"
|
|
};
|
|
}
|
|
|
|
private bool CheckOverlap(Part part1, Part part2, double spacing)
|
|
{
|
|
var shapes1 = GetPartShapes(part1);
|
|
var shapes2 = GetPartShapes(part2);
|
|
|
|
for (var i = 0; i < shapes1.Count; i++)
|
|
{
|
|
for (var j = 0; j < shapes2.Count; j++)
|
|
{
|
|
List<Vector> pts;
|
|
|
|
if (shapes1[i].Intersects(shapes2[j], out pts))
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
private List<Shape> GetPartShapes(Part part)
|
|
{
|
|
var entities = ConvertProgram.ToGeometry(part.Program)
|
|
.Where(e => e.Layer != SpecialLayers.Rapid);
|
|
var shapes = Helper.GetShapes(entities);
|
|
shapes.ForEach(s => s.Offset(part.Location));
|
|
return shapes;
|
|
}
|
|
|
|
private List<Vector> GetPartVertices(Part part)
|
|
{
|
|
var entities = ConvertProgram.ToGeometry(part.Program)
|
|
.Where(e => e.Layer != SpecialLayers.Rapid);
|
|
var shapes = Helper.GetShapes(entities);
|
|
var points = new List<Vector>();
|
|
|
|
foreach (var shape in shapes)
|
|
{
|
|
var polygon = shape.ToPolygonWithTolerance(ChordTolerance);
|
|
polygon.Offset(part.Location);
|
|
|
|
foreach (var vertex in polygon.Vertices)
|
|
points.Add(vertex);
|
|
}
|
|
|
|
return points;
|
|
}
|
|
}
|
|
}
|
|
```
|
|
|
|
**Step 2: Add to .csproj**
|
|
|
|
```xml
|
|
<Compile Include="BestFit\PairEvaluator.cs" />
|
|
```
|
|
|
|
**Step 3: Build to verify**
|
|
|
|
**Step 4: Commit**
|
|
|
|
```
|
|
feat: add PairEvaluator with overlap detection and optimal rotation
|
|
```
|
|
|
|
---
|
|
|
|
## Task 6: BestFitFilter
|
|
|
|
**Files:**
|
|
- Create: `OpenNest.Engine/BestFit/BestFitFilter.cs`
|
|
- Modify: `OpenNest.Engine/OpenNest.Engine.csproj`
|
|
|
|
**Step 1: Create file**
|
|
|
|
```csharp
|
|
using System.Collections.Generic;
|
|
|
|
namespace OpenNest.Engine.BestFit
|
|
{
|
|
public class BestFitFilter
|
|
{
|
|
public double MaxPlateWidth { get; set; }
|
|
public double MaxPlateHeight { get; set; }
|
|
public double MaxAspectRatio { get; set; } = 5.0;
|
|
public double MinUtilization { get; set; } = 0.3;
|
|
|
|
public void Apply(List<BestFitResult> results)
|
|
{
|
|
foreach (var result in results)
|
|
{
|
|
if (!result.Keep)
|
|
continue;
|
|
|
|
if (result.ShortestSide > System.Math.Min(MaxPlateWidth, MaxPlateHeight))
|
|
{
|
|
result.Keep = false;
|
|
result.Reason = "Exceeds plate dimensions";
|
|
continue;
|
|
}
|
|
|
|
var aspect = result.LongestSide / result.ShortestSide;
|
|
|
|
if (aspect > MaxAspectRatio)
|
|
{
|
|
result.Keep = false;
|
|
result.Reason = string.Format("Aspect ratio {0:F1} exceeds max {1}", aspect, MaxAspectRatio);
|
|
continue;
|
|
}
|
|
|
|
if (result.Utilization < MinUtilization)
|
|
{
|
|
result.Keep = false;
|
|
result.Reason = string.Format("Utilization {0:P0} below minimum", result.Utilization);
|
|
continue;
|
|
}
|
|
|
|
result.Reason = "Valid";
|
|
}
|
|
}
|
|
}
|
|
}
|
|
```
|
|
|
|
**Step 2: Add to .csproj**
|
|
|
|
```xml
|
|
<Compile Include="BestFit\BestFitFilter.cs" />
|
|
```
|
|
|
|
**Step 3: Build to verify**
|
|
|
|
**Step 4: Commit**
|
|
|
|
```
|
|
feat: add BestFitFilter with plate size, aspect ratio, and utilization rules
|
|
```
|
|
|
|
---
|
|
|
|
## Task 7: TileResult and TileEvaluator
|
|
|
|
**Files:**
|
|
- Create: `OpenNest.Engine/BestFit/Tiling/TileResult.cs`
|
|
- Create: `OpenNest.Engine/BestFit/Tiling/TileEvaluator.cs`
|
|
- Modify: `OpenNest.Engine/OpenNest.Engine.csproj`
|
|
|
|
**Step 1: Create TileResult.cs**
|
|
|
|
```csharp
|
|
using System.Collections.Generic;
|
|
using OpenNest.Geometry;
|
|
|
|
namespace OpenNest.Engine.BestFit.Tiling
|
|
{
|
|
public class TileResult
|
|
{
|
|
public BestFitResult BestFit { get; set; }
|
|
public int PairsNested { get; set; }
|
|
public int PartsNested { get; set; }
|
|
public int Rows { get; set; }
|
|
public int Columns { get; set; }
|
|
public double Utilization { get; set; }
|
|
public List<PairPlacement> Placements { get; set; }
|
|
public bool PairRotated { get; set; }
|
|
}
|
|
|
|
public class PairPlacement
|
|
{
|
|
public Vector Position { get; set; }
|
|
public double PairRotation { get; set; }
|
|
}
|
|
}
|
|
```
|
|
|
|
**Step 2: Create TileEvaluator.cs**
|
|
|
|
```csharp
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using OpenNest.Geometry;
|
|
using OpenNest.Math;
|
|
|
|
namespace OpenNest.Engine.BestFit.Tiling
|
|
{
|
|
public class TileEvaluator
|
|
{
|
|
public TileResult Evaluate(BestFitResult bestFit, Plate plate)
|
|
{
|
|
var plateWidth = plate.Size.Width - plate.EdgeSpacing.Left - plate.EdgeSpacing.Right;
|
|
var plateHeight = plate.Size.Height - plate.EdgeSpacing.Top - plate.EdgeSpacing.Bottom;
|
|
|
|
var result1 = TryTile(bestFit, plateWidth, plateHeight, false);
|
|
var result2 = TryTile(bestFit, plateWidth, plateHeight, true);
|
|
return result1.PartsNested >= result2.PartsNested ? result1 : result2;
|
|
}
|
|
|
|
private TileResult TryTile(BestFitResult bestFit, double plateWidth, double plateHeight, bool rotatePair)
|
|
{
|
|
var pairWidth = rotatePair ? bestFit.BoundingHeight : bestFit.BoundingWidth;
|
|
var pairHeight = rotatePair ? bestFit.BoundingWidth : bestFit.BoundingHeight;
|
|
var spacing = bestFit.Candidate.Spacing;
|
|
|
|
var cols = (int)System.Math.Floor((plateWidth + spacing) / (pairWidth + spacing));
|
|
var rows = (int)System.Math.Floor((plateHeight + spacing) / (pairHeight + spacing));
|
|
var pairsNested = cols * rows;
|
|
var partsNested = pairsNested * 2;
|
|
|
|
var usedArea = partsNested * (bestFit.TrueArea / 2);
|
|
var plateArea = plateWidth * plateHeight;
|
|
|
|
var placements = new List<PairPlacement>();
|
|
|
|
for (var row = 0; row < rows; row++)
|
|
{
|
|
for (var col = 0; col < cols; col++)
|
|
{
|
|
placements.Add(new PairPlacement
|
|
{
|
|
Position = new Vector(
|
|
col * (pairWidth + spacing),
|
|
row * (pairHeight + spacing)),
|
|
PairRotation = rotatePair ? Angle.HalfPI : 0
|
|
});
|
|
}
|
|
}
|
|
|
|
return new TileResult
|
|
{
|
|
BestFit = bestFit,
|
|
PairsNested = pairsNested,
|
|
PartsNested = partsNested,
|
|
Rows = rows,
|
|
Columns = cols,
|
|
Utilization = plateArea > 0 ? usedArea / plateArea : 0,
|
|
Placements = placements,
|
|
PairRotated = rotatePair
|
|
};
|
|
}
|
|
}
|
|
}
|
|
```
|
|
|
|
**Step 3: Add to .csproj**
|
|
|
|
```xml
|
|
<Compile Include="BestFit\Tiling\TileResult.cs" />
|
|
<Compile Include="BestFit\Tiling\TileEvaluator.cs" />
|
|
```
|
|
|
|
**Step 4: Build to verify**
|
|
|
|
**Step 5: Commit**
|
|
|
|
```
|
|
feat: add TileEvaluator and TileResult for pair tiling on plates
|
|
```
|
|
|
|
---
|
|
|
|
## Task 8: BestFitFinder (Orchestrator)
|
|
|
|
Computes hull edge angles from the drawing, builds `RotationSlideStrategy` instances for each angle in `{0, pi/2, pi, 3pi/2} + hull edges + hull edges + pi`, runs all strategies, evaluates, filters, and sorts.
|
|
|
|
**Files:**
|
|
- Create: `OpenNest.Engine/BestFit/BestFitFinder.cs`
|
|
- Modify: `OpenNest.Engine/OpenNest.Engine.csproj`
|
|
|
|
**Step 1: Create file**
|
|
|
|
```csharp
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using OpenNest.Converters;
|
|
using OpenNest.Engine.BestFit.Tiling;
|
|
using OpenNest.Geometry;
|
|
using OpenNest.Math;
|
|
|
|
namespace OpenNest.Engine.BestFit
|
|
{
|
|
public class BestFitFinder
|
|
{
|
|
private readonly PairEvaluator _evaluator;
|
|
private readonly BestFitFilter _filter;
|
|
|
|
public BestFitFinder(double maxPlateWidth, double maxPlateHeight)
|
|
{
|
|
_evaluator = new PairEvaluator();
|
|
_filter = new BestFitFilter
|
|
{
|
|
MaxPlateWidth = maxPlateWidth,
|
|
MaxPlateHeight = maxPlateHeight
|
|
};
|
|
}
|
|
|
|
public List<BestFitResult> FindBestFits(
|
|
Drawing drawing,
|
|
double spacing = 0.25,
|
|
double stepSize = 0.25,
|
|
BestFitSortField sortBy = BestFitSortField.Area)
|
|
{
|
|
var strategies = BuildStrategies(drawing);
|
|
|
|
var allCandidates = new List<PairCandidate>();
|
|
|
|
foreach (var strategy in strategies)
|
|
allCandidates.AddRange(strategy.GenerateCandidates(drawing, spacing, stepSize));
|
|
|
|
var results = allCandidates.Select(c => _evaluator.Evaluate(c)).ToList();
|
|
|
|
_filter.Apply(results);
|
|
|
|
results = SortResults(results, sortBy);
|
|
|
|
for (var i = 0; i < results.Count; i++)
|
|
results[i].Candidate.TestNumber = i;
|
|
|
|
return results;
|
|
}
|
|
|
|
public List<TileResult> FindAndTile(
|
|
Drawing drawing, Plate plate,
|
|
double spacing = 0.25, double stepSize = 0.25, int topN = 10)
|
|
{
|
|
var bestFits = FindBestFits(drawing, spacing, stepSize);
|
|
var tileEvaluator = new TileEvaluator();
|
|
|
|
return bestFits
|
|
.Where(r => r.Keep)
|
|
.Take(topN)
|
|
.Select(r => tileEvaluator.Evaluate(r, plate))
|
|
.OrderByDescending(t => t.PartsNested)
|
|
.ThenByDescending(t => t.Utilization)
|
|
.ToList();
|
|
}
|
|
|
|
private List<IBestFitStrategy> BuildStrategies(Drawing drawing)
|
|
{
|
|
var angles = GetRotationAngles(drawing);
|
|
var strategies = new List<IBestFitStrategy>();
|
|
var type = 1;
|
|
|
|
foreach (var angle in angles)
|
|
{
|
|
var desc = string.Format("{0:F1} deg rotated, offset slide", Angle.ToDegrees(angle));
|
|
strategies.Add(new RotationSlideStrategy(angle, type++, desc));
|
|
}
|
|
|
|
return strategies;
|
|
}
|
|
|
|
private List<double> GetRotationAngles(Drawing drawing)
|
|
{
|
|
var angles = new List<double>
|
|
{
|
|
0,
|
|
Angle.HalfPI,
|
|
System.Math.PI,
|
|
Angle.HalfPI * 3
|
|
};
|
|
|
|
// Add hull edge angles
|
|
var hullAngles = GetHullEdgeAngles(drawing);
|
|
|
|
foreach (var hullAngle in hullAngles)
|
|
{
|
|
AddUniqueAngle(angles, hullAngle);
|
|
AddUniqueAngle(angles, Angle.NormalizeRad(hullAngle + System.Math.PI));
|
|
}
|
|
|
|
return angles;
|
|
}
|
|
|
|
private List<double> GetHullEdgeAngles(Drawing drawing)
|
|
{
|
|
var entities = ConvertProgram.ToGeometry(drawing.Program)
|
|
.Where(e => e.Layer != SpecialLayers.Rapid);
|
|
var shapes = Helper.GetShapes(entities);
|
|
|
|
var points = new List<Vector>();
|
|
|
|
foreach (var shape in shapes)
|
|
{
|
|
var polygon = shape.ToPolygonWithTolerance(0.1);
|
|
points.AddRange(polygon.Vertices);
|
|
}
|
|
|
|
if (points.Count < 3)
|
|
return new List<double>();
|
|
|
|
var hull = ConvexHull.Compute(points);
|
|
var vertices = hull.Vertices;
|
|
var n = hull.IsClosed() ? vertices.Count - 1 : vertices.Count;
|
|
var hullAngles = new List<double>();
|
|
|
|
for (var i = 0; i < n; i++)
|
|
{
|
|
var next = (i + 1) % n;
|
|
var dx = vertices[next].X - vertices[i].X;
|
|
var dy = vertices[next].Y - vertices[i].Y;
|
|
|
|
if (dx * dx + dy * dy < Tolerance.Epsilon)
|
|
continue;
|
|
|
|
var angle = Angle.NormalizeRad(System.Math.Atan2(dy, dx));
|
|
AddUniqueAngle(hullAngles, angle);
|
|
}
|
|
|
|
return hullAngles;
|
|
}
|
|
|
|
private static void AddUniqueAngle(List<double> angles, double angle)
|
|
{
|
|
angle = Angle.NormalizeRad(angle);
|
|
|
|
foreach (var existing in angles)
|
|
{
|
|
if (existing.IsEqualTo(angle))
|
|
return;
|
|
}
|
|
|
|
angles.Add(angle);
|
|
}
|
|
|
|
private List<BestFitResult> SortResults(List<BestFitResult> results, BestFitSortField sortBy)
|
|
{
|
|
switch (sortBy)
|
|
{
|
|
case BestFitSortField.Area:
|
|
return results.OrderBy(r => r.RotatedArea).ToList();
|
|
case BestFitSortField.LongestSide:
|
|
return results.OrderBy(r => r.LongestSide).ToList();
|
|
case BestFitSortField.ShortestSide:
|
|
return results.OrderBy(r => r.ShortestSide).ToList();
|
|
case BestFitSortField.Type:
|
|
return results.OrderBy(r => r.Candidate.StrategyType)
|
|
.ThenBy(r => r.Candidate.TestNumber).ToList();
|
|
case BestFitSortField.OriginalSequence:
|
|
return results.OrderBy(r => r.Candidate.TestNumber).ToList();
|
|
case BestFitSortField.Keep:
|
|
return results.OrderByDescending(r => r.Keep)
|
|
.ThenBy(r => r.RotatedArea).ToList();
|
|
case BestFitSortField.WhyKeepDrop:
|
|
return results.OrderBy(r => r.Reason)
|
|
.ThenBy(r => r.RotatedArea).ToList();
|
|
default:
|
|
return results;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
```
|
|
|
|
**Step 2: Add to .csproj**
|
|
|
|
```xml
|
|
<Compile Include="BestFit\BestFitFinder.cs" />
|
|
```
|
|
|
|
**Step 3: Build full solution to verify all references resolve**
|
|
|
|
Run: `msbuild OpenNest.sln /p:Configuration=Debug /v:q`
|
|
|
|
**Step 4: Commit**
|
|
|
|
```
|
|
feat: add BestFitFinder orchestrator with hull edge angle strategies
|
|
```
|
|
|
|
---
|
|
|
|
## Task 9: Final Integration Build and Smoke Test
|
|
|
|
**Step 1: Clean build of entire solution**
|
|
|
|
Run: `msbuild OpenNest.sln /t:Rebuild /p:Configuration=Debug /v:q`
|
|
Expected: Build succeeded, 0 errors
|
|
|
|
**Step 2: Verify all new files are included**
|
|
|
|
Check that all 8 new files appear in the build output by reviewing the .csproj has these entries:
|
|
```xml
|
|
<Compile Include="BestFit\PairCandidate.cs" />
|
|
<Compile Include="BestFit\BestFitResult.cs" />
|
|
<Compile Include="BestFit\IBestFitStrategy.cs" />
|
|
<Compile Include="BestFit\RotationSlideStrategy.cs" />
|
|
<Compile Include="BestFit\PairEvaluator.cs" />
|
|
<Compile Include="BestFit\BestFitFilter.cs" />
|
|
<Compile Include="BestFit\Tiling\TileResult.cs" />
|
|
<Compile Include="BestFit\Tiling\TileEvaluator.cs" />
|
|
<Compile Include="BestFit\BestFitFinder.cs" />
|
|
```
|
|
|
|
**Step 3: Final commit**
|
|
|
|
If any build fixes were needed, commit them:
|
|
```
|
|
fix: resolve build issues in best-fit pair finding engine
|
|
```
|