diff --git a/OpenNest.Core/CNC/CuttingStrategy/ContourCuttingStrategy.cs b/OpenNest.Core/CNC/CuttingStrategy/ContourCuttingStrategy.cs index 6cc402b..d8d360f 100644 --- a/OpenNest.Core/CNC/CuttingStrategy/ContourCuttingStrategy.cs +++ b/OpenNest.Core/CNC/CuttingStrategy/ContourCuttingStrategy.cs @@ -69,9 +69,17 @@ namespace OpenNest.CNC.CuttingStrategy EmitScribeContours(result, scribeEntities); foreach (var entry in cutoutEntries) - EmitContour(result, entry.Shape, entry.Point, entry.Entity); + { + if (!entry.Shape.IsClosed()) + EmitRawContour(result, entry.Shape); + else + EmitContour(result, entry.Shape, entry.Point, entry.Entity); + } - EmitContour(result, profile.Perimeter, perimeterPt, perimeterEntity, ContourType.External); + if (!profile.Perimeter.IsClosed()) + EmitRawContour(result, profile.Perimeter); + else + EmitContour(result, profile.Perimeter, perimeterPt, perimeterEntity, ContourType.External); result.Mode = Mode.Incremental; @@ -99,10 +107,14 @@ namespace OpenNest.CNC.CuttingStrategy // Find the target shape that contains the clicked entity var (targetShape, matchedEntity) = FindTargetShape(profile, point, entity); - // Emit cutouts — only the target gets lead-in/out + // Emit cutouts — only the target gets lead-in/out (skip open contours) foreach (var cutout in profile.Cutouts) { - if (cutout == targetShape) + if (!cutout.IsClosed()) + { + EmitRawContour(result, cutout); + } + else if (cutout == targetShape) { var ct = DetectContourType(cutout); EmitContour(result, cutout, point, matchedEntity, ct); @@ -114,7 +126,11 @@ namespace OpenNest.CNC.CuttingStrategy } // Emit perimeter - if (profile.Perimeter == targetShape) + if (!profile.Perimeter.IsClosed()) + { + EmitRawContour(result, profile.Perimeter); + } + else if (profile.Perimeter == targetShape) { EmitContour(result, profile.Perimeter, point, matchedEntity, ContourType.External); } diff --git a/OpenNest.Core/Geometry/Arc.cs b/OpenNest.Core/Geometry/Arc.cs index 0ed1272..d51a4c9 100644 --- a/OpenNest.Core/Geometry/Arc.cs +++ b/OpenNest.Core/Geometry/Arc.cs @@ -267,6 +267,13 @@ namespace OpenNest.Geometry get { return Diameter * System.Math.PI * SweepAngle() / Angle.TwoPI; } } + public override Entity Clone() + { + var copy = new Arc(center, radius, startAngle, endAngle, reversed); + CopyBaseTo(copy); + return copy; + } + /// /// Reverses the rotation direction. /// diff --git a/OpenNest.Core/Geometry/Circle.cs b/OpenNest.Core/Geometry/Circle.cs index 05a03de..ac25197 100644 --- a/OpenNest.Core/Geometry/Circle.cs +++ b/OpenNest.Core/Geometry/Circle.cs @@ -165,6 +165,13 @@ namespace OpenNest.Geometry get { return Circumference(); } } + public override Entity Clone() + { + var copy = new Circle(center, radius) { Rotation = Rotation }; + CopyBaseTo(copy); + return copy; + } + /// /// Reverses the rotation direction. /// diff --git a/OpenNest.Core/Geometry/Entity.cs b/OpenNest.Core/Geometry/Entity.cs index bd2e7fe..723ddc6 100644 --- a/OpenNest.Core/Geometry/Entity.cs +++ b/OpenNest.Core/Geometry/Entity.cs @@ -251,6 +251,23 @@ namespace OpenNest.Geometry /// public abstract bool Intersects(Shape shape, out List pts); + /// + /// Creates a deep copy of the entity with a new Id. + /// + public abstract Entity Clone(); + + /// + /// Copies common Entity properties from this instance to the target. + /// + protected void CopyBaseTo(Entity target) + { + target.Color = Color; + target.Layer = Layer; + target.LineTypeName = LineTypeName; + target.IsVisible = IsVisible; + target.Tag = Tag; + } + /// /// Type of entity. /// @@ -259,6 +276,14 @@ namespace OpenNest.Geometry public static class EntityExtensions { + public static List CloneAll(this IEnumerable entities) + { + var result = new List(); + foreach (var e in entities) + result.Add(e.Clone()); + return result; + } + public static List CollectPoints(this IEnumerable entities) { var points = new List(); diff --git a/OpenNest.Core/Geometry/Line.cs b/OpenNest.Core/Geometry/Line.cs index e0317d8..9b4474b 100644 --- a/OpenNest.Core/Geometry/Line.cs +++ b/OpenNest.Core/Geometry/Line.cs @@ -257,6 +257,13 @@ namespace OpenNest.Geometry } } + public override Entity Clone() + { + var copy = new Line(pt1, pt2); + CopyBaseTo(copy); + return copy; + } + /// /// Reversed the line. /// diff --git a/OpenNest.Core/Geometry/Polygon.cs b/OpenNest.Core/Geometry/Polygon.cs index 22e2131..9ae1cab 100644 --- a/OpenNest.Core/Geometry/Polygon.cs +++ b/OpenNest.Core/Geometry/Polygon.cs @@ -168,6 +168,13 @@ namespace OpenNest.Geometry get { return Perimeter(); } } + public override Entity Clone() + { + var copy = new Polygon { Vertices = new List(Vertices) }; + CopyBaseTo(copy); + return copy; + } + /// /// Reverses the rotation direction of the polygon. /// diff --git a/OpenNest.Core/Geometry/Shape.cs b/OpenNest.Core/Geometry/Shape.cs index 6e35f1c..6cd9358 100644 --- a/OpenNest.Core/Geometry/Shape.cs +++ b/OpenNest.Core/Geometry/Shape.cs @@ -349,6 +349,15 @@ namespace OpenNest.Geometry return polygon; } + public override Entity Clone() + { + var copy = new Shape(); + foreach (var e in Entities) + copy.Entities.Add(e.Clone()); + CopyBaseTo(copy); + return copy; + } + /// /// Reverses the rotation direction of the shape. /// diff --git a/OpenNest.Core/Geometry/ShapeProfile.cs b/OpenNest.Core/Geometry/ShapeProfile.cs index 23928e6..e73632d 100644 --- a/OpenNest.Core/Geometry/ShapeProfile.cs +++ b/OpenNest.Core/Geometry/ShapeProfile.cs @@ -75,7 +75,8 @@ namespace OpenNest.Geometry /// public static List NormalizeEntities(IEnumerable entities) { - var profile = new ShapeProfile(entities.ToList()); + var cloned = entities.CloneAll(); + var profile = new ShapeProfile(cloned); return profile.ToNormalizedEntities(); } diff --git a/OpenNest.Core/Geometry/SpatialQuery.cs b/OpenNest.Core/Geometry/SpatialQuery.cs index df25865..c7bac71 100644 --- a/OpenNest.Core/Geometry/SpatialQuery.cs +++ b/OpenNest.Core/Geometry/SpatialQuery.cs @@ -306,49 +306,38 @@ namespace OpenNest.Geometry var minDist = double.MaxValue; var vx = vertex.X; var vy = vertex.Y; + var horizontal = IsHorizontalDirection(direction); - // Pruning: edges are sorted by their perpendicular min-coordinate in PartBoundary. - if (direction == PushDirection.Left || direction == PushDirection.Right) + // Pruning: edges are sorted by their perpendicular min-coordinate. + // For horizontal push, prune by Y range; for vertical push, prune by X range. + for (var i = 0; i < edges.Length; i++) { - for (var i = 0; i < edges.Length; i++) + var e1 = edges[i].start + edgeOffset; + var e2 = edges[i].end + edgeOffset; + + double perpValue, edgeMin, edgeMax; + if (horizontal) { - var e1 = edges[i].start + edgeOffset; - var e2 = edges[i].end + edgeOffset; - - var minY = e1.Y < e2.Y ? e1.Y : e2.Y; - var maxY = e1.Y > e2.Y ? e1.Y : e2.Y; - - // Since edges are sorted by minY, if vy < minY, then vy < all subsequent minY. - if (vy < minY - Tolerance.Epsilon) - break; - - if (vy > maxY + Tolerance.Epsilon) - continue; - - var d = RayEdgeDistance(vx, vy, e1.X, e1.Y, e2.X, e2.Y, direction); - if (d < minDist) minDist = d; + perpValue = vy; + edgeMin = e1.Y < e2.Y ? e1.Y : e2.Y; + edgeMax = e1.Y > e2.Y ? e1.Y : e2.Y; } - } - else // Up/Down - { - for (var i = 0; i < edges.Length; i++) + else { - var e1 = edges[i].start + edgeOffset; - var e2 = edges[i].end + edgeOffset; - - var minX = e1.X < e2.X ? e1.X : e2.X; - var maxX = e1.X > e2.X ? e1.X : e2.X; - - // Since edges are sorted by minX, if vx < minX, then vx < all subsequent minX. - if (vx < minX - Tolerance.Epsilon) - break; - - if (vx > maxX + Tolerance.Epsilon) - continue; - - var d = RayEdgeDistance(vx, vy, e1.X, e1.Y, e2.X, e2.Y, direction); - if (d < minDist) minDist = d; + perpValue = vx; + edgeMin = e1.X < e2.X ? e1.X : e2.X; + edgeMax = e1.X > e2.X ? e1.X : e2.X; } + + // Since edges are sorted by edgeMin, if perpValue < edgeMin, all subsequent edges are also past. + if (perpValue < edgeMin - Tolerance.Epsilon) + break; + + if (perpValue > edgeMax + Tolerance.Epsilon) + continue; + + var d = RayEdgeDistance(vx, vy, e1.X, e1.Y, e2.X, e2.Y, direction); + if (d < minDist) minDist = d; } return minDist; @@ -642,19 +631,46 @@ namespace OpenNest.Geometry { for (var i = 0; i < arcEntities.Count; i++) { - if (arcEntities[i] is Arc arc) + if (arcEntities[i] is not Arc arc) + continue; + + var cx = arc.Center.X; + var cy = arc.Center.Y; + var r = arc.Radius; + + for (var j = 0; j < lineEntities.Count; j++) { - for (var j = 0; j < lineEntities.Count; j++) + if (lineEntities[j] is not Line line) + continue; + + var p1x = line.pt1.X; + var p1y = line.pt1.Y; + var ex = line.pt2.X - p1x; + var ey = line.pt2.Y - p1y; + + var det = ex * dirY - ey * dirX; + if (System.Math.Abs(det) < Tolerance.Epsilon) + continue; + + // The directional distance from an arc point at angle θ to the + // line is t(θ) = [A + r·(ey·cosθ − ex·sinθ)] / det. + // dt/dθ = 0 at θ = atan2(−ex, ey) and θ + π. + var theta1 = Angle.NormalizeRad(System.Math.Atan2(-ex, ey)); + var theta2 = Angle.NormalizeRad(theta1 + System.Math.PI); + + for (var k = 0; k < 2; k++) { - if (lineEntities[j] is Line line) - { - var linePt = line.ClosestPointTo(arc.Center); - var arcPt = arc.ClosestPointTo(linePt); - var d = RayEdgeDistance(arcPt.X, arcPt.Y, - line.pt1.X, line.pt1.Y, line.pt2.X, line.pt2.Y, - dirX, dirY); - if (d < minDist) { minDist = d; if (d <= 0) return 0; } - } + var theta = k == 0 ? theta1 : theta2; + + if (!Angle.IsBetweenRad(theta, arc.StartAngle, arc.EndAngle, arc.IsReversed)) + continue; + + var qx = cx + r * System.Math.Cos(theta); + var qy = cy + r * System.Math.Sin(theta); + + var d = RayEdgeDistance(qx, qy, p1x, p1y, line.pt2.X, line.pt2.Y, + dirX, dirY); + if (d < minDist) { minDist = d; if (d <= 0) return 0; } } } } diff --git a/OpenNest.Core/PartGeometry.cs b/OpenNest.Core/PartGeometry.cs index c30f6e0..573d641 100644 --- a/OpenNest.Core/PartGeometry.cs +++ b/OpenNest.Core/PartGeometry.cs @@ -126,20 +126,10 @@ namespace OpenNest { var result = new List(source.Count); - for (var i = 0; i < source.Count; i++) + foreach (var entity in source) { - var entity = source[i]; - Entity copy; - - if (entity is Line line) - copy = new Line(line.StartPoint + location, line.EndPoint + location); - else if (entity is Arc arc) - copy = new Arc(arc.Center + location, arc.Radius, arc.StartAngle, arc.EndAngle, arc.IsReversed); - else if (entity is Circle circle) - copy = new Circle(circle.Center + location, circle.Radius); - else - continue; - + var copy = entity.Clone(); + copy.Offset(location); result.Add(copy); } diff --git a/OpenNest.Core/Plate.cs b/OpenNest.Core/Plate.cs index 8e58ea9..e5a3714 100644 --- a/OpenNest.Core/Plate.cs +++ b/OpenNest.Core/Plate.cs @@ -1,6 +1,7 @@ using OpenNest.Collections; using OpenNest.Geometry; using OpenNest.Math; +using OpenNest.Shapes; using System; using System.Collections.Generic; using System.Linq; @@ -548,6 +549,65 @@ namespace OpenNest Rounding.RoundUpToNearest(xExtent, roundingFactor)); } + /// + /// Sizes the plate using the catalog: small + /// layouts snap to an increment, larger ones round up to the next + /// standard mill sheet. The plate's long-axis orientation (X vs Y) + /// is preserved. Does nothing if the plate has no parts. + /// + public PlateSizeResult SnapToStandardSize(PlateSizeOptions options = null) + { + if (Parts.Count == 0) + return default; + + var bounds = Parts.GetBoundingBox(); + + // Quadrant-aware extents relative to the plate origin, matching AutoSize. + double xExtent; + double yExtent; + + switch (Quadrant) + { + case 1: + xExtent = System.Math.Abs(bounds.Right) + EdgeSpacing.Right; + yExtent = System.Math.Abs(bounds.Top) + EdgeSpacing.Top; + break; + + case 2: + xExtent = System.Math.Abs(bounds.Left) + EdgeSpacing.Left; + yExtent = System.Math.Abs(bounds.Top) + EdgeSpacing.Top; + break; + + case 3: + xExtent = System.Math.Abs(bounds.Left) + EdgeSpacing.Left; + yExtent = System.Math.Abs(bounds.Bottom) + EdgeSpacing.Bottom; + break; + + case 4: + xExtent = System.Math.Abs(bounds.Right) + EdgeSpacing.Right; + yExtent = System.Math.Abs(bounds.Bottom) + EdgeSpacing.Bottom; + break; + + default: + return default; + } + + // PlateSizes.Recommend takes (short, long); canonicalize then map + // the result back so the plate's long axis stays aligned with the + // parts' long axis. + var shortDim = System.Math.Min(xExtent, yExtent); + var longDim = System.Math.Max(xExtent, yExtent); + var result = PlateSizes.Recommend(shortDim, longDim, options); + + // Plate convention: Length = X axis, Width = Y axis. + if (xExtent >= yExtent) + Size = new Size(result.Width, result.Length); // X is the long axis + else + Size = new Size(result.Length, result.Width); // Y is the long axis + + return result; + } + /// /// Gets the area of the top surface of the plate. /// diff --git a/OpenNest.Core/Shapes/FlangeShape.cs b/OpenNest.Core/Shapes/PipeFlangeShape.cs similarity index 68% rename from OpenNest.Core/Shapes/FlangeShape.cs rename to OpenNest.Core/Shapes/PipeFlangeShape.cs index 2eff093..7c5de3d 100644 --- a/OpenNest.Core/Shapes/FlangeShape.cs +++ b/OpenNest.Core/Shapes/PipeFlangeShape.cs @@ -3,31 +3,33 @@ using System.Collections.Generic; namespace OpenNest.Shapes { - public class FlangeShape : ShapeDefinition + public class PipeFlangeShape : ShapeDefinition { - public double NominalPipeSize { get; set; } public double OD { get; set; } public double HoleDiameter { get; set; } public double HolePatternDiameter { get; set; } public int HoleCount { get; set; } + public string PipeSize { get; set; } + public double PipeClearance { get; set; } + public bool Blind { get; set; } public override void SetPreviewDefaults() { - NominalPipeSize = 2; OD = 7.5; HoleDiameter = 0.875; HolePatternDiameter = 5.5; HoleCount = 8; + PipeSize = "2"; + PipeClearance = 0.0625; + Blind = false; } public override Drawing GetDrawing() { var entities = new List(); - // Outer circle entities.Add(new Circle(0, 0, OD / 2.0)); - // Bolt holes evenly spaced on the bolt circle var boltCircleRadius = HolePatternDiameter / 2.0; var holeRadius = HoleDiameter / 2.0; var angleStep = 2.0 * System.Math.PI / HoleCount; @@ -40,6 +42,12 @@ namespace OpenNest.Shapes entities.Add(new Circle(cx, cy, holeRadius)); } + if (!Blind && !string.IsNullOrEmpty(PipeSize) && PipeSizes.TryGetOD(PipeSize, out var pipeOD)) + { + var boreDiameter = pipeOD + PipeClearance; + entities.Add(new Circle(0, 0, boreDiameter / 2.0)); + } + return CreateDrawing(entities); } } diff --git a/OpenNest.Core/Shapes/PipeSizes.cs b/OpenNest.Core/Shapes/PipeSizes.cs new file mode 100644 index 0000000..b8ac4c5 --- /dev/null +++ b/OpenNest.Core/Shapes/PipeSizes.cs @@ -0,0 +1,78 @@ +using System.Collections.Generic; + +namespace OpenNest.Shapes +{ + public static class PipeSizes + { + public readonly record struct Entry(string Label, double OuterDiameter); + + public static IReadOnlyList All { get; } = new[] + { + new Entry("1/8", 0.405), + new Entry("1/4", 0.540), + new Entry("3/8", 0.675), + new Entry("1/2", 0.840), + new Entry("3/4", 1.050), + new Entry("1", 1.315), + new Entry("1 1/4", 1.660), + new Entry("1 1/2", 1.900), + new Entry("2", 2.375), + new Entry("2 1/2", 2.875), + new Entry("3", 3.500), + new Entry("3 1/2", 4.000), + new Entry("4", 4.500), + new Entry("4 1/2", 5.000), + new Entry("5", 5.563), + new Entry("6", 6.625), + new Entry("7", 7.625), + new Entry("8", 8.625), + new Entry("9", 9.625), + new Entry("10", 10.750), + new Entry("11", 11.750), + new Entry("12", 12.750), + new Entry("14", 14.000), + new Entry("16", 16.000), + new Entry("18", 18.000), + new Entry("20", 20.000), + new Entry("24", 24.000), + new Entry("26", 26.000), + new Entry("28", 28.000), + new Entry("30", 30.000), + new Entry("32", 32.000), + new Entry("34", 34.000), + new Entry("36", 36.000), + new Entry("42", 42.000), + new Entry("48", 48.000), + }; + + public static bool TryGetOD(string label, out double outerDiameter) + { + foreach (var entry in All) + { + if (entry.Label == label) + { + outerDiameter = entry.OuterDiameter; + return true; + } + } + + outerDiameter = 0; + return false; + } + + /// + /// Returns all pipe sizes whose outer diameter is less than or equal to . + /// The bound is inclusive. + /// + public static IEnumerable GetFittingSizes(double maxOD) + { + foreach (var entry in All) + { + if (entry.OuterDiameter <= maxOD) + { + yield return entry; + } + } + } + } +} diff --git a/OpenNest.Core/Shapes/PlateSizes.cs b/OpenNest.Core/Shapes/PlateSizes.cs new file mode 100644 index 0000000..08af25d --- /dev/null +++ b/OpenNest.Core/Shapes/PlateSizes.cs @@ -0,0 +1,255 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using OpenNest.Geometry; + +namespace OpenNest.Shapes +{ + /// + /// Catalog of standard mill sheet sizes (inches) with helpers for matching + /// a bounding box to a recommended plate size. Uses the project-wide + /// (Width, Length) convention where Width is the short dimension and + /// Length is the long dimension. + /// + public static class PlateSizes + { + public readonly record struct Entry(string Label, double Width, double Length) + { + public double Area => Width * Length; + + /// + /// Returns true if a part of the given dimensions fits within this entry + /// in either orientation. + /// + public bool Fits(double width, double length) => + (width <= Width && length <= Length) || (width <= Length && length <= Width); + } + + /// + /// Standard mill sheet sizes (inches), sorted by area ascending. + /// Canonical orientation: Width <= Length. + /// + public static IReadOnlyList All { get; } = new[] + { + new Entry("48x96", 48, 96), // 4608 + new Entry("48x120", 48, 120), // 5760 + new Entry("48x144", 48, 144), // 6912 + new Entry("60x120", 60, 120), // 7200 + new Entry("60x144", 60, 144), // 8640 + new Entry("72x120", 72, 120), // 8640 + new Entry("72x144", 72, 144), // 10368 + new Entry("96x240", 96, 240), // 23040 + }; + + /// + /// Looks up a standard size by label. Case-insensitive. + /// + public static bool TryGet(string label, out Entry entry) + { + if (!string.IsNullOrWhiteSpace(label)) + { + foreach (var candidate in All) + { + if (string.Equals(candidate.Label, label, StringComparison.OrdinalIgnoreCase)) + { + entry = candidate; + return true; + } + } + } + + entry = default; + return false; + } + + /// + /// Recommends a plate size for the given bounding box. The box's + /// spatial axes are normalized to (short, long) so neither the bbox + /// orientation nor Box's internal Length/Width naming matters. + /// + public static PlateSizeResult Recommend(Box bbox, PlateSizeOptions options = null) + { + var a = bbox.Width; + var b = bbox.Length; + return Recommend(System.Math.Min(a, b), System.Math.Max(a, b), options); + } + + /// + /// Recommends a plate size for the envelope of the given boxes. + /// + public static PlateSizeResult Recommend(IEnumerable boxes, PlateSizeOptions options = null) + { + if (boxes == null) + throw new ArgumentNullException(nameof(boxes)); + + var hasAny = false; + var minX = double.PositiveInfinity; + var minY = double.PositiveInfinity; + var maxX = double.NegativeInfinity; + var maxY = double.NegativeInfinity; + + foreach (var box in boxes) + { + hasAny = true; + if (box.Left < minX) minX = box.Left; + if (box.Bottom < minY) minY = box.Bottom; + if (box.Right > maxX) maxX = box.Right; + if (box.Top > maxY) maxY = box.Top; + } + + if (!hasAny) + throw new ArgumentException("At least one box is required.", nameof(boxes)); + + var b = maxX - minX; + var a = maxY - minY; + return Recommend(System.Math.Min(a, b), System.Math.Max(a, b), options); + } + + /// + /// Recommends a plate size for a (width, length) pair. + /// Inputs are treated as orientation-independent. + /// + public static PlateSizeResult Recommend(double width, double length, PlateSizeOptions options = null) + { + options ??= new PlateSizeOptions(); + + var w = width + 2 * options.Margin; + var l = length + 2 * options.Margin; + + // Canonicalize (short, long) — Fits handles rotation anyway, but + // normalizing lets the below-min comparison use the narrower + // MinSheet dimensions consistently. + if (w > l) + (w, l) = (l, w); + + // Below full-sheet threshold: snap each dimension up to the nearest increment. + if (w <= options.MinSheetWidth && l <= options.MinSheetLength) + return SnapResult(w, l, options.SnapIncrement); + + var catalog = BuildCatalog(options.AllowedSizes); + + var best = PickBest(catalog, w, l, options.Selection); + if (best.HasValue) + return new PlateSizeResult(best.Value.Width, best.Value.Length, best.Value.Label); + + // Nothing in the catalog fits - fall back to snap-up (ad-hoc oversize sheet). + return SnapResult(w, l, options.SnapIncrement); + } + + private static PlateSizeResult SnapResult(double width, double length, double increment) + { + if (increment <= 0) + return new PlateSizeResult(width, length, null); + + return new PlateSizeResult(SnapUp(width, increment), SnapUp(length, increment), null); + } + + private static double SnapUp(double value, double increment) + { + var steps = System.Math.Ceiling(value / increment); + return steps * increment; + } + + private static IReadOnlyList BuildCatalog(IReadOnlyList allowedSizes) + { + if (allowedSizes == null || allowedSizes.Count == 0) + return All; + + var result = new List(allowedSizes.Count); + foreach (var label in allowedSizes) + { + if (TryParseEntry(label, out var entry)) + result.Add(entry); + } + + return result; + } + + private static bool TryParseEntry(string label, out Entry entry) + { + if (TryGet(label, out entry)) + return true; + + // Accept ad-hoc "WxL" strings (e.g. "50x100", "50 x 100"). + if (!string.IsNullOrWhiteSpace(label)) + { + var parts = label.Split(new[] { 'x', 'X' }, 2); + if (parts.Length == 2 + && double.TryParse(parts[0].Trim(), System.Globalization.NumberStyles.Float, System.Globalization.CultureInfo.InvariantCulture, out var a) + && double.TryParse(parts[1].Trim(), System.Globalization.NumberStyles.Float, System.Globalization.CultureInfo.InvariantCulture, out var b) + && a > 0 && b > 0) + { + var width = System.Math.Min(a, b); + var length = System.Math.Max(a, b); + entry = new Entry(label.Trim(), width, length); + return true; + } + } + + entry = default; + return false; + } + + private static Entry? PickBest(IReadOnlyList catalog, double width, double length, PlateSizeSelection selection) + { + var fitting = catalog.Where(e => e.Fits(width, length)); + + fitting = selection switch + { + PlateSizeSelection.NarrowestFirst => fitting.OrderBy(e => e.Width).ThenBy(e => e.Area), + _ => fitting.OrderBy(e => e.Area).ThenBy(e => e.Width), + }; + + foreach (var candidate in fitting) + return candidate; + + return null; + } + } + + public readonly record struct PlateSizeResult(double Width, double Length, string MatchedLabel) + { + public bool IsStandard => MatchedLabel != null; + } + + public sealed class PlateSizeOptions + { + /// + /// If the margin-adjusted bounding box fits within MinSheetWidth x MinSheetLength + /// the result is snapped to instead of routed to a + /// standard sheet. Default 48" x 48". + /// + public double MinSheetWidth { get; set; } = 48; + public double MinSheetLength { get; set; } = 48; + + /// + /// Increment used for below-threshold rounding and oversize fallback. Default 1". + /// + public double SnapIncrement { get; set; } = 1.0; + + /// + /// Extra clearance added to each side of the bounding box before matching. + /// + public double Margin { get; set; } = 0; + + /// + /// Optional whitelist. When non-empty, only these sizes are considered. + /// Entries may be standard catalog labels (e.g. "48x96") or arbitrary + /// "WxL" strings (e.g. "50x100"). + /// + public IReadOnlyList AllowedSizes { get; set; } + + /// + /// Tiebreaker when multiple sheets can contain the bounding box. + /// + public PlateSizeSelection Selection { get; set; } = PlateSizeSelection.SmallestArea; + } + + public enum PlateSizeSelection + { + /// Pick the cheapest sheet that contains the bbox (smallest area). + SmallestArea, + /// Prefer narrower-width sheets (e.g. 48-wide before 60-wide). + NarrowestFirst, + } +} diff --git a/OpenNest.Core/Splitting/DrawingSplitter.cs b/OpenNest.Core/Splitting/DrawingSplitter.cs index 99e54eb..0bbd577 100644 --- a/OpenNest.Core/Splitting/DrawingSplitter.cs +++ b/OpenNest.Core/Splitting/DrawingSplitter.cs @@ -32,12 +32,20 @@ public static class DrawingSplitter var regions = BuildClipRegions(sortedLines, bounds); var feature = GetFeature(parameters.Type); + // Polygonize cutouts once. Used for trimming feature edges (so cut lines + // don't travel through a cutout interior) and for hole/containment tests + // in the final component-assembly pass. + var cutoutPolygons = profile.Cutouts + .Select(c => c.ToPolygon()) + .Where(p => p != null) + .ToList(); + var results = new List(); var pieceIndex = 1; foreach (var region in regions) { - var pieceEntities = ClipPerimeterToRegion(perimeter, region, sortedLines, feature, parameters); + var pieceEntities = ClipPerimeterToRegion(perimeter, region, sortedLines, feature, parameters, cutoutPolygons); if (pieceEntities.Count == 0) continue; @@ -47,9 +55,16 @@ public static class DrawingSplitter allEntities.AddRange(pieceEntities); allEntities.AddRange(cutoutEntities); - var piece = BuildPieceDrawing(drawing, allEntities, pieceIndex, region); - results.Add(piece); - pieceIndex++; + // A single region may yield multiple physically-disjoint pieces when an + // interior cutout spans across it. Group the region's entities into + // connected closed loops, nest holes by containment, and emit one + // Drawing per outer loop (with its contained holes). + foreach (var pieceOfRegion in AssemblePieces(allEntities)) + { + var piece = BuildPieceDrawing(drawing, pieceOfRegion, pieceIndex, region); + results.Add(piece); + pieceIndex++; + } } return results; @@ -218,100 +233,108 @@ public static class DrawingSplitter /// and stitching in feature edges. No polygon clipping library needed. /// private static List ClipPerimeterToRegion(Shape perimeter, Box region, - List splitLines, ISplitFeature feature, SplitParameters parameters) + List splitLines, ISplitFeature feature, SplitParameters parameters, + List cutoutPolygons) { var boundarySplitLines = GetBoundarySplitLines(region, splitLines); var entities = new List(); - var splitPoints = new List<(Vector Point, SplitLine Line, bool IsExit)>(); foreach (var entity in perimeter.Entities) - { - ProcessEntity(entity, region, boundarySplitLines, entities, splitPoints); - } + ProcessEntity(entity, region, entities); if (entities.Count == 0) return new List(); - InsertFeatureEdges(entities, splitPoints, region, boundarySplitLines, feature, parameters); - EnsurePerimeterWinding(entities); + InsertFeatureEdges(entities, region, boundarySplitLines, feature, parameters, cutoutPolygons); + // Winding is handled later in AssemblePieces, once connected components + // are known. At this stage the piece may still be multiple disjoint loops. return entities; } - private static void ProcessEntity(Entity entity, Box region, - List boundarySplitLines, List entities, - List<(Vector Point, SplitLine Line, bool IsExit)> splitPoints) - { - // Find the first boundary split line this entity crosses - SplitLine crossedLine = null; - Vector? intersectionPt = null; - - foreach (var sl in boundarySplitLines) - { - if (SplitLineIntersect.CrossesSplitLine(entity, sl)) - { - var pt = SplitLineIntersect.FindIntersection(entity, sl); - if (pt != null) - { - crossedLine = sl; - intersectionPt = pt; - break; - } - } - } - - if (crossedLine != null) - { - // Entity crosses a split line — split it and keep the half inside the region - var regionSide = RegionSideOf(region, crossedLine); - var startPt = GetStartPoint(entity); - var startSide = SplitLineIntersect.SideOf(startPt, crossedLine); - var startInRegion = startSide == regionSide || startSide == 0; - - SplitEntityAtPoint(entity, intersectionPt.Value, startInRegion, crossedLine, entities, splitPoints); - } - else - { - // Entity doesn't cross any boundary split line — check if it's inside the region - var mid = MidPoint(entity); - if (region.Contains(mid)) - entities.Add(entity); - } - } - - private static void SplitEntityAtPoint(Entity entity, Vector point, bool startInRegion, - SplitLine crossedLine, List entities, - List<(Vector Point, SplitLine Line, bool IsExit)> splitPoints) + private static void ProcessEntity(Entity entity, Box region, List entities) { if (entity is Line line) { - var (first, second) = line.SplitAt(point); - if (startInRegion) - { - if (first != null) entities.Add(first); - splitPoints.Add((point, crossedLine, true)); - } - else - { - splitPoints.Add((point, crossedLine, false)); - if (second != null) entities.Add(second); - } + var clipped = ClipLineToBox(line.StartPoint, line.EndPoint, region); + if (clipped == null) return; + if (clipped.Value.Start.DistanceTo(clipped.Value.End) < Math.Tolerance.Epsilon) return; + entities.Add(new Line(clipped.Value.Start, clipped.Value.End)); + return; } - else if (entity is Arc arc) + + if (entity is Arc arc) { - var (first, second) = arc.SplitAt(point); - if (startInRegion) - { - if (first != null) entities.Add(first); - splitPoints.Add((point, crossedLine, true)); - } - else - { - splitPoints.Add((point, crossedLine, false)); - if (second != null) entities.Add(second); - } + foreach (var sub in ClipArcToRegion(arc, region)) + entities.Add(sub); + return; } } + /// + /// Clips an arc against the four edges of a region box. Returns the sub-arcs + /// whose midpoints lie inside the region. Uses line-arc intersection to find + /// split points, then iteratively bisects the arc at each crossing. + /// + private static List ClipArcToRegion(Arc arc, Box region) + { + var edges = new[] + { + new Line(new Vector(region.Left, region.Bottom), new Vector(region.Right, region.Bottom)), + new Line(new Vector(region.Right, region.Bottom), new Vector(region.Right, region.Top)), + new Line(new Vector(region.Right, region.Top), new Vector(region.Left, region.Top)), + new Line(new Vector(region.Left, region.Top), new Vector(region.Left, region.Bottom)) + }; + + var arcs = new List { arc }; + + foreach (var edge in edges) + { + var next = new List(); + foreach (var a in arcs) + { + if (!Intersect.Intersects(a, edge, out var pts) || pts.Count == 0) + { + next.Add(a); + continue; + } + + // Split the arc at each intersection that actually lies on one of + // the working sub-arcs. Prior splits may make some original hits + // moot for the sub-arc that now holds them. + var working = new List { a }; + foreach (var pt in pts) + { + var replaced = new List(); + foreach (var w in working) + { + var onArc = OpenNest.Math.Angle.IsBetweenRad( + w.Center.AngleTo(pt), w.StartAngle, w.EndAngle, w.IsReversed); + if (!onArc) + { + replaced.Add(w); + continue; + } + + var (first, second) = w.SplitAt(pt); + if (first != null && first.SweepAngle() > Math.Tolerance.Epsilon) replaced.Add(first); + if (second != null && second.SweepAngle() > Math.Tolerance.Epsilon) replaced.Add(second); + } + working = replaced; + } + next.AddRange(working); + } + arcs = next; + } + + var result = new List(); + foreach (var a in arcs) + { + if (region.Contains(a.MidPoint())) + result.Add(a); + } + return result; + } + /// /// Returns split lines whose position matches a boundary edge of the region. /// @@ -365,104 +388,157 @@ public static class DrawingSplitter } /// - /// Groups split points by split line, pairs exits with entries, and generates feature edges. + /// For each boundary split line of the region, generates a feature edge that + /// spans the full region boundary along that split line and trims it against + /// interior cutouts. This produces one (or zero) feature edge per contiguous + /// material interval on the boundary, handling corner regions (one perimeter + /// crossing), spanning cutouts (two holes puncturing the line), and + /// normal mid-part splits uniformly. /// private static void InsertFeatureEdges(List entities, - List<(Vector Point, SplitLine Line, bool IsExit)> splitPoints, Box region, List boundarySplitLines, - ISplitFeature feature, SplitParameters parameters) + ISplitFeature feature, SplitParameters parameters, + List cutoutPolygons) { - // Group split points by their split line - var groups = new Dictionary>(); - foreach (var sp in splitPoints) + foreach (var sl in boundarySplitLines) { - if (!groups.ContainsKey(sp.Line)) - groups[sp.Line] = new List<(Vector, bool)>(); - groups[sp.Line].Add((sp.Point, sp.IsExit)); - } + var isVertical = sl.Axis == CutOffAxis.Vertical; + var extentStart = isVertical ? region.Bottom : region.Left; + var extentEnd = isVertical ? region.Top : region.Right; - foreach (var kvp in groups) - { - var sl = kvp.Key; - var points = kvp.Value; - - // Pair each exit with the next entry - var exits = points.Where(p => p.IsExit).Select(p => p.Point).ToList(); - var entries = points.Where(p => !p.IsExit).Select(p => p.Point).ToList(); - - if (exits.Count == 0 || entries.Count == 0) + if (extentEnd - extentStart < Math.Tolerance.Epsilon) continue; - // For each exit, find the matching entry to form the feature edge span - // Sort exits and entries by their position along the split line - var isVertical = sl.Axis == CutOffAxis.Vertical; - exits = exits.OrderBy(p => isVertical ? p.Y : p.X).ToList(); - entries = entries.OrderBy(p => isVertical ? p.Y : p.X).ToList(); + var featureResult = feature.GenerateFeatures(sl, extentStart, extentEnd, parameters); + var isNegativeSide = RegionSideOf(region, sl) < 0; + var featureEdge = isNegativeSide ? featureResult.NegativeSideEdge : featureResult.PositiveSideEdge; - // Pair them up: each exit with the next entry (or vice versa) - var pairCount = System.Math.Min(exits.Count, entries.Count); - for (var i = 0; i < pairCount; i++) + // Trim any line segments that cross a cutout — cut lines must never + // travel through a hole. + featureEdge = TrimFeatureEdgeAgainstCutouts(featureEdge, cutoutPolygons); + + entities.AddRange(featureEdge); + } + } + + /// + /// Subtracts any portions of line entities in that + /// lie inside any of the supplied cutout polygons. Non-line entities (arcs) are + /// passed through unchanged; a tighter fix for arcs in feature edges (weld-gap + /// tabs, spike-groove) can be added later if a test demands it. + /// + private static List TrimFeatureEdgeAgainstCutouts(List featureEdge, List cutoutPolygons) + { + if (cutoutPolygons.Count == 0 || featureEdge.Count == 0) + return featureEdge; + + var result = new List(); + foreach (var entity in featureEdge) + { + if (entity is Line line) + result.AddRange(SubtractCutoutsFromLine(line, cutoutPolygons)); + else + result.Add(entity); + } + return result; + } + + /// + /// Returns the sub-segments of that lie outside every + /// cutout polygon. Handles the common axis-aligned feature-edge case exactly. + /// + private static List SubtractCutoutsFromLine(Line line, List cutoutPolygons) + { + // Collect parameter values t in [0,1] where the line crosses any cutout edge. + var ts = new List { 0.0, 1.0 }; + foreach (var poly in cutoutPolygons) + { + var polyLines = poly.ToLines(); + foreach (var edge in polyLines) { - var exitPt = exits[i]; - var entryPt = entries[i]; - - var extentStart = isVertical - ? System.Math.Min(exitPt.Y, entryPt.Y) - : System.Math.Min(exitPt.X, entryPt.X); - var extentEnd = isVertical - ? System.Math.Max(exitPt.Y, entryPt.Y) - : System.Math.Max(exitPt.X, entryPt.X); - - var featureResult = feature.GenerateFeatures(sl, extentStart, extentEnd, parameters); - - var isNegativeSide = RegionSideOf(region, sl) < 0; - var featureEdge = isNegativeSide ? featureResult.NegativeSideEdge : featureResult.PositiveSideEdge; - - if (featureEdge.Count > 0) - featureEdge = AlignFeatureDirection(featureEdge, exitPt, entryPt, sl.Axis); - - entities.AddRange(featureEdge); + if (TryIntersectSegments(line.StartPoint, line.EndPoint, edge.StartPoint, edge.EndPoint, out var t)) + { + if (t > Math.Tolerance.Epsilon && t < 1.0 - Math.Tolerance.Epsilon) + ts.Add(t); + } } } - } - private static List AlignFeatureDirection(List featureEdge, Vector start, Vector end, CutOffAxis axis) - { - var featureStart = GetStartPoint(featureEdge[0]); - var featureEnd = GetEndPoint(featureEdge[^1]); - var isVertical = axis == CutOffAxis.Vertical; + ts.Sort(); - var edgeGoesForward = isVertical ? start.Y < end.Y : start.X < end.X; - var featureGoesForward = isVertical ? featureStart.Y < featureEnd.Y : featureStart.X < featureEnd.X; - - if (edgeGoesForward != featureGoesForward) + var segments = new List(); + for (var i = 0; i < ts.Count - 1; i++) { - featureEdge = new List(featureEdge); - featureEdge.Reverse(); - foreach (var e in featureEdge) - e.Reverse(); + var t0 = ts[i]; + var t1 = ts[i + 1]; + if (t1 - t0 < Math.Tolerance.Epsilon) continue; + + var tMid = (t0 + t1) * 0.5; + var mid = new Vector( + line.StartPoint.X + (line.EndPoint.X - line.StartPoint.X) * tMid, + line.StartPoint.Y + (line.EndPoint.Y - line.StartPoint.Y) * tMid); + + var insideCutout = false; + foreach (var poly in cutoutPolygons) + { + if (poly.ContainsPoint(mid)) + { + insideCutout = true; + break; + } + } + if (insideCutout) continue; + + var p0 = new Vector( + line.StartPoint.X + (line.EndPoint.X - line.StartPoint.X) * t0, + line.StartPoint.Y + (line.EndPoint.Y - line.StartPoint.Y) * t0); + var p1 = new Vector( + line.StartPoint.X + (line.EndPoint.X - line.StartPoint.X) * t1, + line.StartPoint.Y + (line.EndPoint.Y - line.StartPoint.Y) * t1); + + segments.Add(new Line(p0, p1)); } - return featureEdge; + return segments; } - private static void EnsurePerimeterWinding(List entities) + /// + /// Segment-segment intersection. On hit, returns the parameter t along segment AB + /// (0 = a0, 1 = a1) via . + /// + private static bool TryIntersectSegments(Vector a0, Vector a1, Vector b0, Vector b1, out double tOnA) { - var shape = new Shape(); - shape.Entities.AddRange(entities); - var poly = shape.ToPolygon(); - if (poly != null && poly.RotationDirection() != RotationType.CW) - shape.Reverse(); + tOnA = 0; + var rx = a1.X - a0.X; + var ry = a1.Y - a0.Y; + var sx = b1.X - b0.X; + var sy = b1.Y - b0.Y; - entities.Clear(); - entities.AddRange(shape.Entities); + var denom = rx * sy - ry * sx; + if (System.Math.Abs(denom) < Math.Tolerance.Epsilon) + return false; + + var dx = b0.X - a0.X; + var dy = b0.Y - a0.Y; + var t = (dx * sy - dy * sx) / denom; + var u = (dx * ry - dy * rx) / denom; + + if (t < -Math.Tolerance.Epsilon || t > 1 + Math.Tolerance.Epsilon) return false; + if (u < -Math.Tolerance.Epsilon || u > 1 + Math.Tolerance.Epsilon) return false; + + tOnA = t; + return true; } private static bool IsCutoutInRegion(Shape cutout, Box region) { if (cutout.Entities.Count == 0) return false; - var pt = GetStartPoint(cutout.Entities[0]); - return region.Contains(pt); + var bb = cutout.BoundingBox; + // Fully contained iff the cutout's bounding box fits inside the region. + return bb.Left >= region.Left - Math.Tolerance.Epsilon + && bb.Right <= region.Right + Math.Tolerance.Epsilon + && bb.Bottom >= region.Bottom - Math.Tolerance.Epsilon + && bb.Top <= region.Top + Math.Tolerance.Epsilon; } private static bool DoesCutoutCrossSplitLine(Shape cutout, List splitLines) @@ -479,57 +555,135 @@ public static class DrawingSplitter } /// - /// Clip a cutout shape to a region by walking entities, splitting at split line - /// intersections, keeping portions inside the region, and closing gaps with - /// straight lines. No polygon clipping library needed. + /// Clip a cutout shape to a region by walking entities and splitting at split-line + /// crossings. Only returns the cutout-edge fragments that lie inside the region — + /// it deliberately does NOT emit synthetic closing lines at the region boundary. + /// + /// Rationale: a closing line on the region boundary would overlap the split-line + /// feature edge and reintroduce a cut through the cutout interior. The feature + /// edge (trimmed against cutouts in ) and these + /// cutout fragments are stitched together later by + /// using endpoint connectivity, which produces the correct closed loops — one + /// loop per physically-connected strip of material. /// private static List ClipCutoutToRegion(Shape cutout, Box region, List splitLines) { - var boundarySplitLines = GetBoundarySplitLines(region, splitLines); var entities = new List(); - var splitPoints = new List<(Vector Point, SplitLine Line, bool IsExit)>(); - foreach (var entity in cutout.Entities) + ProcessEntity(entity, region, entities); + return entities; + } + + /// + /// Groups a region's entities into closed components and nests holes inside + /// outer loops by point-in-polygon containment. Returns one entity list per + /// output — outer loop first, then its contained holes. + /// Each outer loop is normalized to CW winding and each hole to CCW. + /// + private static List> AssemblePieces(List entities) + { + var pieces = new List>(); + if (entities.Count == 0) return pieces; + + var shapes = ShapeBuilder.GetShapes(entities); + if (shapes.Count == 0) return pieces; + + // Polygonize every shape once so we can run containment tests. + var polygons = new List(shapes.Count); + foreach (var s in shapes) + polygons.Add(s.ToPolygon()); + + // Classify each shape as outer or hole using nesting by containment. + // Shape A is contained in shape B iff A's bounding box is strictly inside + // B's bounding box AND a representative vertex of A lies inside B's polygon. + // The bbox pre-check avoids the ambiguity of bbox-center tests when two + // shapes share a center (e.g., an outer half and a centered cutout). + var isHole = new bool[shapes.Count]; + for (var i = 0; i < shapes.Count; i++) { - ProcessEntity(entity, region, boundarySplitLines, entities, splitPoints); + var bbA = shapes[i].BoundingBox; + var repA = FirstVertexOf(shapes[i]); + + for (var j = 0; j < shapes.Count; j++) + { + if (i == j) continue; + if (polygons[j] == null) continue; + if (polygons[j].Vertices.Count < 3) continue; + + var bbB = shapes[j].BoundingBox; + if (!BoxContainsBox(bbB, bbA)) continue; + if (!polygons[j].ContainsPoint(repA)) continue; + + isHole[i] = true; + break; + } } - if (entities.Count == 0) - return new List(); - - // Close gaps with straight lines (connect exit→entry pairs) - var groups = new Dictionary>(); - foreach (var sp in splitPoints) + // For each outer, attach the holes that fall inside it. + for (var i = 0; i < shapes.Count; i++) { - if (!groups.ContainsKey(sp.Line)) - groups[sp.Line] = new List<(Vector, bool)>(); - groups[sp.Line].Add((sp.Point, sp.IsExit)); + if (isHole[i]) continue; + + var outer = shapes[i]; + var outerPoly = polygons[i]; + + // Enforce perimeter winding = CW. + if (outerPoly != null && outerPoly.Vertices.Count >= 3 + && outerPoly.RotationDirection() != RotationType.CW) + outer.Reverse(); + + var piece = new List(); + piece.AddRange(outer.Entities); + + for (var j = 0; j < shapes.Count; j++) + { + if (!isHole[j]) continue; + if (polygons[i] == null || polygons[i].Vertices.Count < 3) continue; + + var bbJ = shapes[j].BoundingBox; + if (!BoxContainsBox(shapes[i].BoundingBox, bbJ)) continue; + + var rep = FirstVertexOf(shapes[j]); + if (!polygons[i].ContainsPoint(rep)) continue; + + var hole = shapes[j]; + var holePoly = polygons[j]; + if (holePoly != null && holePoly.Vertices.Count >= 3 + && holePoly.RotationDirection() != RotationType.CCW) + hole.Reverse(); + + piece.AddRange(hole.Entities); + } + + pieces.Add(piece); } - foreach (var kvp in groups) - { - var sl = kvp.Key; - var points = kvp.Value; - var isVertical = sl.Axis == CutOffAxis.Vertical; + return pieces; + } - var exits = points.Where(p => p.IsExit).Select(p => p.Point) - .OrderBy(p => isVertical ? p.Y : p.X).ToList(); - var entries = points.Where(p => !p.IsExit).Select(p => p.Point) - .OrderBy(p => isVertical ? p.Y : p.X).ToList(); + /// + /// Returns the first vertex of a shape (start point of its first entity). Used as + /// a representative for containment testing: if bbox pre-check says the whole + /// shape is inside another, testing one vertex is sufficient to confirm. + /// + private static Vector FirstVertexOf(Shape shape) + { + if (shape.Entities.Count == 0) + return new Vector(0, 0); + return GetStartPoint(shape.Entities[0]); + } - var pairCount = System.Math.Min(exits.Count, entries.Count); - for (var i = 0; i < pairCount; i++) - entities.Add(new Line(exits[i], entries[i])); - } - - // Ensure CCW winding for cutouts - var shape = new Shape(); - shape.Entities.AddRange(entities); - var poly = shape.ToPolygon(); - if (poly != null && poly.RotationDirection() != RotationType.CCW) - shape.Reverse(); - - return shape.Entities; + /// + /// True iff box is entirely inside box + /// (tolerant comparison). + /// + private static bool BoxContainsBox(Box outer, Box inner) + { + var eps = Math.Tolerance.Epsilon; + return inner.Left >= outer.Left - eps + && inner.Right <= outer.Right + eps + && inner.Bottom >= outer.Bottom - eps + && inner.Top <= outer.Top + eps; } private static Vector GetStartPoint(Entity entity) diff --git a/OpenNest.IO/Bending/SolidWorksBendDetector.cs b/OpenNest.IO/Bending/SolidWorksBendDetector.cs index 061cc24..15b5d54 100644 --- a/OpenNest.IO/Bending/SolidWorksBendDetector.cs +++ b/OpenNest.IO/Bending/SolidWorksBendDetector.cs @@ -133,7 +133,7 @@ namespace OpenNest.IO.Bending { return document.Entities .OfType() - .Where(l => l.Layer?.Name == "BEND" + .Where(l => (l.Layer?.Name == "BEND" || l.Layer?.Name == "0") && (l.LineType?.Name?.Contains("CENTER") == true || l.LineType?.Name == "CENTERX2")) .ToList(); diff --git a/OpenNest.Tests/Fill/CompactorTests.cs b/OpenNest.Tests/Fill/CompactorTests.cs index 21e30b4..4c27df8 100644 --- a/OpenNest.Tests/Fill/CompactorTests.cs +++ b/OpenNest.Tests/Fill/CompactorTests.cs @@ -8,6 +8,76 @@ namespace OpenNest.Tests.Fill { public class CompactorTests { + [Fact] + public void DirectionalDistance_ArcVsInclinedLine_DoesNotOverPush() + { + // Arc (top semicircle) pushed upward toward a 45° inclined line. + // The critical angle on the arc gives a shorter distance than any + // sampled vertex (endpoints + cardinal extremes). + var arc = new Arc(5, 0, 2, 0, System.Math.PI); + var line = new Line(new Vector(3, 4), new Vector(7, 6)); + + var moving = new List { arc }; + var stationary = new List { line }; + var direction = new Vector(0, 1); // push up + + var dist = SpatialQuery.DirectionalDistance(moving, stationary, direction); + + // Move the arc up by the computed distance, then verify no overlap. + // The topmost reachable point on the arc at the critical angle θ ≈ 2.034 + // (between π/2 and π) should just touch the line. + Assert.True(dist < double.MaxValue, "Should find a finite distance"); + Assert.True(dist > 0, "Should be a positive distance"); + + // Verify: after moving, the closest point on the arc should be within + // tolerance of the line, not past it. + var theta = System.Math.Atan2( + line.pt2.X - line.pt1.X, -(line.pt2.Y - line.pt1.Y)); + theta = OpenNest.Math.Angle.NormalizeRad(theta + System.Math.PI); + var qx = arc.Center.X + arc.Radius * System.Math.Cos(theta); + var qy = arc.Center.Y + arc.Radius * System.Math.Sin(theta) + dist; + + // The moved point should be on or just touching the line, not past it. + // Line equation: (y - 4) / (x - 3) = (6 - 4) / (7 - 3) = 0.5 + // y = 0.5x + 2.5 + var lineYAtQx = 0.5 * qx + 2.5; + Assert.True(qy <= lineYAtQx + 0.001, + $"Arc point ({qx:F4}, {qy:F4}) should not be past line (line Y={lineYAtQx:F4} at X={qx:F4}). " + + $"dist={dist:F6}, overshot by {qy - lineYAtQx:F6}"); + } + + [Fact] + public void DirectionalDistance_ArcVsInclinedLine_BetterThanVertexSampling() + { + // Same geometry — verify the analytical Phase 3 finds a shorter + // distance than the Phase 1/2 vertex sampling alone would. + var arc = new Arc(5, 0, 2, 0, System.Math.PI); + var line = new Line(new Vector(3, 4), new Vector(7, 6)); + + // Phase 1/2 vertex-only distance: sample arc endpoints + cardinal extreme. + var vertices = new[] + { + new Vector(7, 0), // arc endpoint θ=0 + new Vector(3, 0), // arc endpoint θ=π + new Vector(5, 2), // cardinal extreme θ=π/2 + }; + + var vertexMin = double.MaxValue; + foreach (var v in vertices) + { + var d = SpatialQuery.RayEdgeDistance(v.X, v.Y, + line.pt1.X, line.pt1.Y, line.pt2.X, line.pt2.Y, 0, 1); + if (d < vertexMin) vertexMin = d; + } + + // Full directional distance (includes Phase 3 arc-to-line). + var moving = new List { arc }; + var stationary = new List { line }; + var fullDist = SpatialQuery.DirectionalDistance(moving, stationary, new Vector(0, 1)); + + Assert.True(fullDist < vertexMin, + $"Full distance ({fullDist:F6}) should be less than vertex-only ({vertexMin:F6})"); + } private static Drawing MakeRectDrawing(double w, double h) { var pgm = new OpenNest.CNC.Program(); diff --git a/OpenNest.Tests/OpenNest.Tests.csproj b/OpenNest.Tests/OpenNest.Tests.csproj index bc484e8..be3afca 100644 --- a/OpenNest.Tests/OpenNest.Tests.csproj +++ b/OpenNest.Tests/OpenNest.Tests.csproj @@ -34,6 +34,9 @@ PreserveNewest + + PreserveNewest + diff --git a/OpenNest.Tests/PlateSnapToStandardSizeTests.cs b/OpenNest.Tests/PlateSnapToStandardSizeTests.cs new file mode 100644 index 0000000..b4a9cd1 --- /dev/null +++ b/OpenNest.Tests/PlateSnapToStandardSizeTests.cs @@ -0,0 +1,118 @@ +using OpenNest.CNC; +using OpenNest.Geometry; +using OpenNest.Shapes; + +namespace OpenNest.Tests; + +public class PlateSnapToStandardSizeTests +{ + private static Part MakeRectPart(double x, double y, double length, double width) + { + var pgm = new Program(); + pgm.Codes.Add(new RapidMove(new Vector(0, 0))); + pgm.Codes.Add(new LinearMove(new Vector(length, 0))); + pgm.Codes.Add(new LinearMove(new Vector(length, width))); + pgm.Codes.Add(new LinearMove(new Vector(0, width))); + pgm.Codes.Add(new LinearMove(new Vector(0, 0))); + var drawing = new Drawing("test", pgm); + var part = new Part(drawing); + part.Offset(x, y); + return part; + } + + [Fact] + public void SnapToStandardSize_SmallParts_SnapsToIncrement() + { + var plate = new Plate(200, 200); // oversized starting size + plate.Parts.Add(MakeRectPart(0, 0, 10, 20)); + + var result = plate.SnapToStandardSize(); + + // 10x20 is well below 48x48 MinSheet -> snap to integer increment. + Assert.Null(result.MatchedLabel); + Assert.Equal(10, plate.Size.Length); // X axis + Assert.Equal(20, plate.Size.Width); // Y axis + } + + [Fact] + public void SnapToStandardSize_SmallPartsWithFractionalIncrement_UsesIncrement() + { + var plate = new Plate(200, 200); + plate.Parts.Add(MakeRectPart(0, 0, 10.3, 20.7)); + + var result = plate.SnapToStandardSize(new PlateSizeOptions { SnapIncrement = 0.25 }); + + Assert.Null(result.MatchedLabel); + Assert.Equal(10.5, plate.Size.Length, 4); + Assert.Equal(20.75, plate.Size.Width, 4); + } + + [Fact] + public void SnapToStandardSize_40x90Part_SnapsToStandard48x96_XLong() + { + // Part is 90 long (X) x 40 wide (Y) -> X is the long axis. + var plate = new Plate(200, 200); + plate.Parts.Add(MakeRectPart(0, 0, 90, 40)); + + var result = plate.SnapToStandardSize(); + + Assert.Equal("48x96", result.MatchedLabel); + Assert.Equal(96, plate.Size.Length); // X axis = long + Assert.Equal(48, plate.Size.Width); // Y axis = short + } + + [Fact] + public void SnapToStandardSize_90TallPart_SnapsToStandard48x96_YLong() + { + // Part is 40 long (X) x 90 wide (Y) -> Y is the long axis. + var plate = new Plate(200, 200); + plate.Parts.Add(MakeRectPart(0, 0, 40, 90)); + + var result = plate.SnapToStandardSize(); + + Assert.Equal("48x96", result.MatchedLabel); + Assert.Equal(48, plate.Size.Length); // X axis = short + Assert.Equal(96, plate.Size.Width); // Y axis = long + } + + [Fact] + public void SnapToStandardSize_JustOver48_PicksNextStandardSize() + { + var plate = new Plate(200, 200); + plate.Parts.Add(MakeRectPart(0, 0, 100, 50)); + + var result = plate.SnapToStandardSize(); + + Assert.Equal("60x120", result.MatchedLabel); + Assert.Equal(120, plate.Size.Length); // X long + Assert.Equal(60, plate.Size.Width); + } + + [Fact] + public void SnapToStandardSize_EmptyPlate_DoesNotModifySize() + { + var plate = new Plate(60, 120); + + var result = plate.SnapToStandardSize(); + + Assert.Null(result.MatchedLabel); + Assert.Equal(60, plate.Size.Width); + Assert.Equal(120, plate.Size.Length); + } + + [Fact] + public void SnapToStandardSize_MultipleParts_UsesCombinedEnvelope() + { + var plate = new Plate(200, 200); + plate.Parts.Add(MakeRectPart(0, 0, 30, 40)); + plate.Parts.Add(MakeRectPart(30, 0, 30, 40)); // combined X-extent = 60 + plate.Parts.Add(MakeRectPart(0, 40, 60, 60)); // combined extent = 60 x 100 + + var result = plate.SnapToStandardSize(); + + // 60 x 100 fits 60x120 standard sheet, Y is the long axis. + Assert.Equal("60x120", result.MatchedLabel); + Assert.Equal(60, plate.Size.Length); // X + Assert.Equal(120, plate.Size.Width); // Y long + } +} diff --git a/OpenNest.Tests/Shapes/FlangeShapeTests.cs b/OpenNest.Tests/Shapes/FlangeShapeTests.cs deleted file mode 100644 index 931582d..0000000 --- a/OpenNest.Tests/Shapes/FlangeShapeTests.cs +++ /dev/null @@ -1,104 +0,0 @@ -using OpenNest.Shapes; - -namespace OpenNest.Tests.Shapes; - -public class FlangeShapeTests -{ - [Fact] - public void GetDrawing_BoundingBoxMatchesOD() - { - var shape = new FlangeShape - { - OD = 10, - HoleDiameter = 1, - HolePatternDiameter = 7, - HoleCount = 4 - }; - var drawing = shape.GetDrawing(); - - var bbox = drawing.Program.BoundingBox(); - Assert.Equal(10, bbox.Width, 0.01); - Assert.Equal(10, bbox.Length, 0.01); - } - - [Fact] - public void GetDrawing_AreaExcludesBoltHoles() - { - var shape = new FlangeShape - { - OD = 10, - HoleDiameter = 1, - HolePatternDiameter = 7, - HoleCount = 4 - }; - var drawing = shape.GetDrawing(); - - // Area = pi * 5^2 - 4 * pi * 0.5^2 = pi * (25 - 1) = pi * 24 - var expectedArea = System.Math.PI * 24; - Assert.Equal(expectedArea, drawing.Area, 0.5); - } - - [Fact] - public void GetDrawing_DefaultName_IsFlange() - { - var shape = new FlangeShape - { - OD = 10, - HoleDiameter = 1, - HolePatternDiameter = 7, - HoleCount = 4 - }; - var drawing = shape.GetDrawing(); - - Assert.Equal("Flange", drawing.Name); - } - - [Fact] - public void LoadFromJson_ProducesCorrectDrawing() - { - var json = """ - [ - { - "Name": "2in-150#", - "NominalPipeSize": 2.0, - "OD": 6.0, - "HoleDiameter": 0.75, - "HolePatternDiameter": 4.75, - "HoleCount": 4 - }, - { - "Name": "2in-300#", - "NominalPipeSize": 2.0, - "OD": 6.5, - "HoleDiameter": 0.75, - "HolePatternDiameter": 5.0, - "HoleCount": 8 - } - ] - """; - - var tempFile = Path.GetTempFileName(); - try - { - File.WriteAllText(tempFile, json); - - var flanges = ShapeDefinition.LoadFromJson(tempFile); - - Assert.Equal(2, flanges.Count); - - var first = flanges[0]; - Assert.Equal("2in-150#", first.Name); - var drawing = first.GetDrawing(); - var bbox = drawing.Program.BoundingBox(); - Assert.Equal(6, bbox.Width, 0.01); - - var second = flanges[1]; - Assert.Equal("2in-300#", second.Name); - Assert.Equal(8, second.HoleCount); - } - finally - { - File.Delete(tempFile); - } - } -} diff --git a/OpenNest.Tests/Shapes/PipeFlangeShapeTests.cs b/OpenNest.Tests/Shapes/PipeFlangeShapeTests.cs new file mode 100644 index 0000000..5d0e950 --- /dev/null +++ b/OpenNest.Tests/Shapes/PipeFlangeShapeTests.cs @@ -0,0 +1,216 @@ +using System; +using System.IO; +using OpenNest.Shapes; + +namespace OpenNest.Tests.Shapes; + +public class PipeFlangeShapeTests +{ + [Fact] + public void GetDrawing_BoundingBoxMatchesOD() + { + var shape = new PipeFlangeShape + { + OD = 10, + HoleDiameter = 1, + HolePatternDiameter = 7, + HoleCount = 4 + }; + var drawing = shape.GetDrawing(); + + var bbox = drawing.Program.BoundingBox(); + Assert.Equal(10, bbox.Width, 0.01); + Assert.Equal(10, bbox.Length, 0.01); + } + + [Fact] + public void GetDrawing_AreaExcludesBoltHoles() + { + var shape = new PipeFlangeShape + { + OD = 10, + HoleDiameter = 1, + HolePatternDiameter = 7, + HoleCount = 4, + Blind = true + }; + var drawing = shape.GetDrawing(); + + var expectedArea = System.Math.PI * 24; + Assert.Equal(expectedArea, drawing.Area, 0.5); + } + + [Fact] + public void GetDrawing_DefaultName_IsPipeFlange() + { + var shape = new PipeFlangeShape + { + OD = 10, + HoleDiameter = 1, + HolePatternDiameter = 7, + HoleCount = 4 + }; + var drawing = shape.GetDrawing(); + + Assert.Equal("PipeFlange", drawing.Name); + } + + [Fact] + public void GetDrawing_WithPipeSize_CutsCenterBoreAtPipeODPlusClearance() + { + var shape = new PipeFlangeShape + { + OD = 10, + HoleDiameter = 1, + HolePatternDiameter = 7, + HoleCount = 4, + PipeSize = "2", // OD = 2.375 + PipeClearance = 0.125, + Blind = false + }; + var drawing = shape.GetDrawing(); + + // Expected bore diameter = 2.375 + 0.125 = 2.5 + // Area = pi * (5^2 - 0.5^2 * 4 - 1.25^2) = pi * (25 - 1 - 1.5625) = pi * 22.4375 + var expectedArea = System.Math.PI * 22.4375; + Assert.Equal(expectedArea, drawing.Area, 0.5); + } + + [Fact] + public void GetDrawing_Blind_OmitsCenterBore() + { + var shape = new PipeFlangeShape + { + OD = 10, + HoleDiameter = 1, + HolePatternDiameter = 7, + HoleCount = 4, + PipeSize = "2", + PipeClearance = 0.125, + Blind = true + }; + var drawing = shape.GetDrawing(); + + // With Blind=true, area = outer - 4 bolt holes = pi * (25 - 1) = pi * 24 + var expectedArea = System.Math.PI * 24; + Assert.Equal(expectedArea, drawing.Area, 0.5); + } + + [Fact] + public void GetDrawing_UnknownPipeSize_OmitsCenterBore() + { + var shape = new PipeFlangeShape + { + OD = 10, + HoleDiameter = 1, + HolePatternDiameter = 7, + HoleCount = 4, + PipeSize = "not-a-real-pipe", + PipeClearance = 0.125, + Blind = false + }; + var drawing = shape.GetDrawing(); + + // Unknown pipe size → no bore, area matches blind case + var expectedArea = System.Math.PI * 24; + Assert.Equal(expectedArea, drawing.Area, 0.5); + } + + [Theory] + [InlineData(null)] + [InlineData("")] + public void GetDrawing_NullOrEmptyPipeSize_OmitsCenterBore(string pipeSize) + { + var shape = new PipeFlangeShape + { + OD = 10, + HoleDiameter = 1, + HolePatternDiameter = 7, + HoleCount = 4, + PipeSize = pipeSize, + PipeClearance = 0.125 + }; + var drawing = shape.GetDrawing(); + + var expectedArea = System.Math.PI * 24; + Assert.Equal(expectedArea, drawing.Area, 0.5); + } + + [Fact] + public void LoadFromJson_ProducesCorrectDrawing() + { + var json = """ + [ + { + "Name": "2in-150#", + "PipeSize": "2", + "PipeClearance": 0.0625, + "OD": 6.0, + "HoleDiameter": 0.75, + "HolePatternDiameter": 4.75, + "HoleCount": 4 + }, + { + "Name": "2in-300#", + "PipeSize": "2", + "PipeClearance": 0.0625, + "OD": 6.5, + "HoleDiameter": 0.75, + "HolePatternDiameter": 5.0, + "HoleCount": 8 + } + ] + """; + + var tempFile = Path.GetTempFileName(); + try + { + File.WriteAllText(tempFile, json); + + var flanges = ShapeDefinition.LoadFromJson(tempFile); + + Assert.Equal(2, flanges.Count); + + var first = flanges[0]; + Assert.Equal("2in-150#", first.Name); + Assert.Equal("2", first.PipeSize); + Assert.Equal(0.0625, first.PipeClearance, 0.0001); + var drawing = first.GetDrawing(); + var bbox = drawing.Program.BoundingBox(); + Assert.Equal(6, bbox.Width, 0.01); + + var second = flanges[1]; + Assert.Equal("2in-300#", second.Name); + Assert.Equal(8, second.HoleCount); + } + finally + { + File.Delete(tempFile); + } + } + + [Fact] + public void LoadFromJson_RealShippedConfig_LoadsAllEntries() + { + // Resolve the repo-relative config path from the test binary location. + var dir = AppDomain.CurrentDomain.BaseDirectory; + while (dir != null && !File.Exists(Path.Combine(dir, "OpenNest.sln"))) + dir = Path.GetDirectoryName(dir); + + Assert.NotNull(dir); + + var configPath = Path.Combine(dir, "OpenNest", "Configurations", "PipeFlangeShape.json"); + Assert.True(File.Exists(configPath), $"Config missing at {configPath}"); + + var flanges = ShapeDefinition.LoadFromJson(configPath); + + Assert.NotEmpty(flanges); + foreach (var f in flanges) + { + Assert.False(string.IsNullOrWhiteSpace(f.PipeSize)); + Assert.True(PipeSizes.TryGetOD(f.PipeSize, out _), + $"Unknown PipeSize '{f.PipeSize}' in entry '{f.Name}'"); + Assert.Equal(0.0625, f.PipeClearance, 0.0001); + } + } +} diff --git a/OpenNest.Tests/Shapes/PipeSizesTests.cs b/OpenNest.Tests/Shapes/PipeSizesTests.cs new file mode 100644 index 0000000..eb12cfc --- /dev/null +++ b/OpenNest.Tests/Shapes/PipeSizesTests.cs @@ -0,0 +1,64 @@ +using OpenNest.Shapes; + +namespace OpenNest.Tests.Shapes; + +public class PipeSizesTests +{ + [Fact] + public void All_ContainsExpectedCount() + { + Assert.Equal(35, PipeSizes.All.Count); + } + + [Fact] + public void All_IsSortedByOuterDiameterAscending() + { + for (var i = 1; i < PipeSizes.All.Count; i++) + Assert.True(PipeSizes.All[i].OuterDiameter > PipeSizes.All[i - 1].OuterDiameter); + } + + [Theory] + [InlineData("1/8", 0.405)] + [InlineData("1/2", 0.840)] + [InlineData("2", 2.375)] + [InlineData("2 1/2", 2.875)] + [InlineData("12", 12.750)] + [InlineData("48", 48.000)] + public void TryGetOD_KnownLabel_ReturnsExpectedOD(string label, double expected) + { + Assert.True(PipeSizes.TryGetOD(label, out var od)); + Assert.Equal(expected, od, 0.001); + } + + [Fact] + public void TryGetOD_UnknownLabel_ReturnsFalse() + { + Assert.False(PipeSizes.TryGetOD("bogus", out _)); + } + + [Fact] + public void GetFittingSizes_FiltersByMaxOD() + { + var results = PipeSizes.GetFittingSizes(3.0).ToList(); + + Assert.Contains(results, e => e.Label == "2 1/2"); + Assert.DoesNotContain(results, e => e.Label == "3"); + Assert.DoesNotContain(results, e => e.Label == "4"); + } + + [Fact] + public void GetFittingSizes_ExactBoundary_IsInclusive() + { + // NPS 3 has OD 3.500; passing maxOD = 3.500 should include it. + var results = PipeSizes.GetFittingSizes(3.500).ToList(); + + Assert.Contains(results, e => e.Label == "3"); + Assert.DoesNotContain(results, e => e.Label == "3 1/2"); + } + + [Fact] + public void GetFittingSizes_MaxSmallerThanSmallest_ReturnsEmpty() + { + Assert.Empty(PipeSizes.GetFittingSizes(0.1)); + } +} diff --git a/OpenNest.Tests/Shapes/PlateSizesTests.cs b/OpenNest.Tests/Shapes/PlateSizesTests.cs new file mode 100644 index 0000000..7b3e0a7 --- /dev/null +++ b/OpenNest.Tests/Shapes/PlateSizesTests.cs @@ -0,0 +1,311 @@ +using System.Collections.Generic; +using System.Linq; +using OpenNest.Geometry; +using OpenNest.Shapes; + +namespace OpenNest.Tests.Shapes; + +public class PlateSizesTests +{ + [Fact] + public void All_IsNotEmpty() + { + Assert.NotEmpty(PlateSizes.All); + } + + [Fact] + public void All_DoesNotContain48x48() + { + // 48x48 is not a standard sheet - it's the default MinSheet threshold only. + Assert.DoesNotContain(PlateSizes.All, e => e.Width == 48 && e.Length == 48); + } + + [Fact] + public void All_Smallest_Is48x96() + { + var smallest = PlateSizes.All.OrderBy(e => e.Area).First(); + Assert.Equal(48, smallest.Width); + Assert.Equal(96, smallest.Length); + } + + [Fact] + public void All_SortedByAreaAscending() + { + for (var i = 1; i < PlateSizes.All.Count; i++) + Assert.True(PlateSizes.All[i].Area >= PlateSizes.All[i - 1].Area); + } + + [Fact] + public void All_Entries_AreCanonical_WidthLessOrEqualLength() + { + foreach (var entry in PlateSizes.All) + Assert.True(entry.Width <= entry.Length, $"{entry.Label} not in canonical orientation"); + } + + [Theory] + [InlineData(40, 40, true)] // small - fits trivially + [InlineData(48, 96, true)] // exact + [InlineData(96, 48, true)] // rotated exact + [InlineData(90, 40, true)] // rotated + [InlineData(49, 97, false)] // just over in both dims + [InlineData(50, 50, false)] // too wide in both orientations + public void Entry_Fits_RespectsRotation(double w, double h, bool expected) + { + var entry = new PlateSizes.Entry("48x96", 48, 96); + Assert.Equal(expected, entry.Fits(w, h)); + } + + [Fact] + public void TryGet_KnownLabel_ReturnsEntry() + { + Assert.True(PlateSizes.TryGet("48x96", out var entry)); + Assert.Equal(48, entry.Width); + Assert.Equal(96, entry.Length); + } + + [Fact] + public void TryGet_IsCaseInsensitive() + { + Assert.True(PlateSizes.TryGet("48X96", out var entry)); + Assert.Equal(48, entry.Width); + Assert.Equal(96, entry.Length); + } + + [Fact] + public void TryGet_UnknownLabel_ReturnsFalse() + { + Assert.False(PlateSizes.TryGet("bogus", out _)); + } + + [Fact] + public void Recommend_BelowMin_SnapsToDefaultIncrementOfOne() + { + var bbox = new Box(0, 0, 10.3, 20.7); + + var result = PlateSizes.Recommend(bbox); + + Assert.Equal(11, result.Width); + Assert.Equal(21, result.Length); + Assert.Null(result.MatchedLabel); + } + + [Fact] + public void Recommend_BelowMin_UsesCustomIncrement() + { + var bbox = new Box(0, 0, 10.3, 20.7); + var options = new PlateSizeOptions { SnapIncrement = 0.25 }; + + var result = PlateSizes.Recommend(bbox, options); + + Assert.Equal(10.5, result.Width, 4); + Assert.Equal(20.75, result.Length, 4); + Assert.Null(result.MatchedLabel); + } + + [Fact] + public void Recommend_ExactlyAtMin_Snaps() + { + var bbox = new Box(0, 0, 48, 48); + + var result = PlateSizes.Recommend(bbox); + + Assert.Equal(48, result.Width); + Assert.Equal(48, result.Length); + Assert.Null(result.MatchedLabel); + } + + [Fact] + public void Recommend_AboveMin_PicksSmallestContainingStandardSheet() + { + var bbox = new Box(0, 0, 40, 90); + + var result = PlateSizes.Recommend(bbox); + + Assert.Equal(48, result.Width); + Assert.Equal(96, result.Length); + Assert.Equal("48x96", result.MatchedLabel); + } + + [Fact] + public void Recommend_AboveMin_WithRotation_PicksSmallestSheet() + { + var bbox = new Box(0, 0, 90, 40); + + var result = PlateSizes.Recommend(bbox); + + Assert.Equal("48x96", result.MatchedLabel); + } + + [Fact] + public void Recommend_JustOver48_PicksNextStandardSize() + { + var bbox = new Box(0, 0, 50, 100); + + var result = PlateSizes.Recommend(bbox); + + Assert.Equal(60, result.Width); + Assert.Equal(120, result.Length); + Assert.Equal("60x120", result.MatchedLabel); + } + + [Fact] + public void Recommend_MarginIsAppliedPerSide() + { + // 46 + 2*1 = 48 (fits exactly), 94 + 2*1 = 96 (fits exactly) + var bbox = new Box(0, 0, 46, 94); + var options = new PlateSizeOptions { Margin = 1 }; + + var result = PlateSizes.Recommend(bbox, options); + + Assert.Equal("48x96", result.MatchedLabel); + } + + [Fact] + public void Recommend_MarginPushesToNextSheet() + { + // 47 + 2 = 49 > 48, so 48x96 no longer fits -> next standard + var bbox = new Box(0, 0, 47, 95); + var options = new PlateSizeOptions { Margin = 1 }; + + var result = PlateSizes.Recommend(bbox, options); + + Assert.NotEqual("48x96", result.MatchedLabel); + Assert.True(result.Width >= 49); + Assert.True(result.Length >= 97); + } + + [Fact] + public void Recommend_AllowedSizes_StandardLabelWhitelist() + { + // 60x120 is the only option; 50x50 is above min so it routes to standard + var bbox = new Box(0, 0, 50, 50); + var options = new PlateSizeOptions { AllowedSizes = new[] { "60x120" } }; + + var result = PlateSizes.Recommend(bbox, options); + + Assert.Equal("60x120", result.MatchedLabel); + } + + [Fact] + public void Recommend_AllowedSizes_ArbitraryWxHString() + { + // 50x100 isn't in the standard catalog but is valid as an ad-hoc entry. + // bbox 49x99 doesn't fit 48x96 or 48x120, does fit 50x100 and 60x120, + // but only 50x100 is allowed. + var bbox = new Box(0, 0, 49, 99); + var options = new PlateSizeOptions { AllowedSizes = new[] { "50x100" } }; + + var result = PlateSizes.Recommend(bbox, options); + + Assert.Equal(50, result.Width); + Assert.Equal(100, result.Length); + Assert.Equal("50x100", result.MatchedLabel); + } + + [Fact] + public void Recommend_NothingFits_FallsBackToSnapUp() + { + // Larger than any catalog sheet + var bbox = new Box(0, 0, 100, 300); + + var result = PlateSizes.Recommend(bbox); + + Assert.Equal(100, result.Width); + Assert.Equal(300, result.Length); + Assert.Null(result.MatchedLabel); + } + + [Fact] + public void Recommend_NothingFitsInAllowedList_FallsBackToSnapUp() + { + // Only 48x96 allowed, but bbox is too big for it + var bbox = new Box(0, 0, 50, 100); + var options = new PlateSizeOptions { AllowedSizes = new[] { "48x96" } }; + + var result = PlateSizes.Recommend(bbox, options); + + Assert.Equal(50, result.Width); + Assert.Equal(100, result.Length); + Assert.Null(result.MatchedLabel); + } + + [Fact] + public void Recommend_BoxEnumerable_CombinesIntoEnvelope() + { + // Two boxes that together span 0..40 x 0..90 -> fits 48x96 + var boxes = new[] + { + new Box(0, 0, 40, 50), + new Box(0, 40, 30, 50), + }; + + var result = PlateSizes.Recommend(boxes); + + Assert.Equal("48x96", result.MatchedLabel); + } + + [Fact] + public void Recommend_BoxEnumerable_Empty_Throws() + { + Assert.Throws( + () => PlateSizes.Recommend(System.Array.Empty())); + } + + [Fact] + public void PlateSizeOptions_Defaults() + { + var options = new PlateSizeOptions(); + + Assert.Equal(48, options.MinSheetWidth); + Assert.Equal(48, options.MinSheetLength); + Assert.Equal(1.0, options.SnapIncrement); + Assert.Equal(0, options.Margin); + Assert.Null(options.AllowedSizes); + Assert.Equal(PlateSizeSelection.SmallestArea, options.Selection); + } + + [Fact] + public void Recommend_NarrowestFirst_PicksNarrowerSheetOverSmallerArea() + { + // Hypothetical: bbox (47, 47) fits both 48x96 (area 4608) and some narrower option. + // With SmallestArea: picks 48x96 (it's already the smallest 48-wide). + // With NarrowestFirst: also picks 48x96 since that's the narrowest. + // Better test: AllowedSizes = ["60x120", "48x120"] with bbox that fits both. + // 48x120 (area 5760) is narrower; 60x120 (area 7200) has more area. + // SmallestArea picks 48x120; NarrowestFirst also picks 48x120. Both pick the same. + // + // Real divergence: AllowedSizes = ["60x120", "72x120"] with bbox 55x100. + // 60x120 has narrower width (60) AND smaller area (7200 vs 8640), so both agree. + // + // To force divergence: AllowedSizes = ["60x96", "48x144"] with bbox 47x95. + // 60x96 area = 5760, 48x144 area = 6912. SmallestArea -> 60x96. + // NarrowestFirst width 48 < 60 -> 48x144. + var bbox = new Box(0, 0, 47, 95); + var options = new PlateSizeOptions + { + AllowedSizes = new[] { "60x96", "48x144" }, + Selection = PlateSizeSelection.NarrowestFirst, + }; + + var result = PlateSizes.Recommend(bbox, options); + + Assert.Equal(48, result.Width); + Assert.Equal(144, result.Length); + } + + [Fact] + public void Recommend_SmallestArea_PicksSmallerAreaOverNarrowerWidth() + { + var bbox = new Box(0, 0, 47, 95); + var options = new PlateSizeOptions + { + AllowedSizes = new[] { "60x96", "48x144" }, + Selection = PlateSizeSelection.SmallestArea, + }; + + var result = PlateSizes.Recommend(bbox, options); + + Assert.Equal(60, result.Width); + Assert.Equal(96, result.Length); + } +} diff --git a/OpenNest.Tests/Splitting/DrawingSplitterTests.cs b/OpenNest.Tests/Splitting/DrawingSplitterTests.cs index 45ea0d8..534e7b2 100644 --- a/OpenNest.Tests/Splitting/DrawingSplitterTests.cs +++ b/OpenNest.Tests/Splitting/DrawingSplitterTests.cs @@ -384,6 +384,161 @@ public class DrawingSplitterTests } } + [Fact] + public void Split_RectangleWithSpanningSlot_ProducesDisconnectedStrips() + { + // 255x55 outer rectangle with a 235x35 interior slot centered at (10,10)-(245,45). + // 4 vertical splits at x = 55, 110, 165, 220. + // + // Expected: regions R2/R3/R4 are entirely "over" the slot horizontally, so the + // surviving material in each is two physically disjoint strips (upper + lower). + // R1 and R5 each have a solid edge that connects the top and bottom strips, so + // they remain single (notched) pieces. + // + // Total output drawings: 1 (R1) + 2 (R2) + 2 (R3) + 2 (R4) + 1 (R5) = 8. + var outerEntities = new List + { + new Line(new Vector(0, 0), new Vector(255, 0)), + new Line(new Vector(255, 0), new Vector(255, 55)), + new Line(new Vector(255, 55), new Vector(0, 55)), + new Line(new Vector(0, 55), new Vector(0, 0)) + }; + var slotEntities = new List + { + new Line(new Vector(10, 10), new Vector(245, 10)), + new Line(new Vector(245, 10), new Vector(245, 45)), + new Line(new Vector(245, 45), new Vector(10, 45)), + new Line(new Vector(10, 45), new Vector(10, 10)) + }; + var allEntities = new List(); + allEntities.AddRange(outerEntities); + allEntities.AddRange(slotEntities); + + var drawing = new Drawing("SLOT", ConvertGeometry.ToProgram(allEntities)); + var originalArea = drawing.Area; + + var splitLines = new List + { + new SplitLine(55.0, CutOffAxis.Vertical), + new SplitLine(110.0, CutOffAxis.Vertical), + new SplitLine(165.0, CutOffAxis.Vertical), + new SplitLine(220.0, CutOffAxis.Vertical) + }; + + var results = DrawingSplitter.Split(drawing, splitLines, new SplitParameters { Type = SplitType.Straight }); + + // R1 (0..55) → 1 notched piece, height 55 + // R2 (55..110) → upper strip + lower strip, each height 10 + // R3 (110..165)→ upper strip + lower strip, each height 10 + // R4 (165..220)→ upper strip + lower strip, each height 10 + // R5 (220..255)→ 1 notched piece, height 55 + Assert.Equal(8, results.Count); + + // Area preservation: sum of all output areas equals (outer − slot). + var totalArea = results.Sum(d => d.Area); + Assert.Equal(originalArea, totalArea, 1); + + // Box.Length = X-extent, Box.Width = Y-extent. + // Exactly 6 strips (Y-extent ~10mm) from the three middle regions, and + // exactly 2 notched pieces (Y-extent 55mm) from R1 and R5. + var strips = results + .Where(d => System.Math.Abs(d.Program.BoundingBox().Width - 10.0) < 0.5) + .ToList(); + var notched = results + .Where(d => System.Math.Abs(d.Program.BoundingBox().Width - 55.0) < 0.5) + .ToList(); + + Assert.Equal(6, strips.Count); + Assert.Equal(2, notched.Count); + + // Each piece should form a closed perimeter (no dangling edges, no gaps). + foreach (var piece in results) + { + var entities = ConvertProgram.ToGeometry(piece.Program) + .Where(e => e.Layer != SpecialLayers.Rapid).ToList(); + + Assert.True(entities.Count >= 3, $"{piece.Name} must have at least 3 edges"); + + for (var i = 0; i < entities.Count; i++) + { + var end = GetEndPoint(entities[i]); + var nextStart = GetStartPoint(entities[(i + 1) % entities.Count]); + var gap = end.DistanceTo(nextStart); + Assert.True(gap < 0.01, + $"{piece.Name} gap of {gap:F4} between edge {i} end and edge {(i + 1) % entities.Count} start"); + } + } + } + + [Fact] + public void Split_DxfFile_WithSpanningSlot_HasNoCutLinesThroughCutout() + { + // Real DXF regression: 255x55 plate with a centered slot cutout, split into + // five columns. Exercises the same path as the synthetic + // Split_RectangleWithSpanningSlot_ProducesDisconnectedStrips test but through + // the full DXF import pipeline. + var path = Path.Combine(AppContext.BaseDirectory, "Splitting", "TestData", "split_test.dxf"); + Assert.True(File.Exists(path), $"Test DXF not found: {path}"); + + var imported = OpenNest.IO.Dxf.Import(path); + var profile = new OpenNest.Geometry.ShapeProfile(imported.Entities); + + // Normalize to origin so the split line positions are predictable. + var bb = profile.Perimeter.BoundingBox; + var offsetX = -bb.X; + var offsetY = -bb.Y; + foreach (var e in profile.Perimeter.Entities) e.Offset(offsetX, offsetY); + foreach (var cutout in profile.Cutouts) + foreach (var e in cutout.Entities) e.Offset(offsetX, offsetY); + + var allEntities = new List(); + allEntities.AddRange(profile.Perimeter.Entities); + foreach (var cutout in profile.Cutouts) allEntities.AddRange(cutout.Entities); + + var drawing = new Drawing("SPLITTEST", ConvertGeometry.ToProgram(allEntities)); + var originalArea = drawing.Area; + + // Part is ~255x55 with an interior slot. Split into 5 columns (55mm each). + var splitLines = new List + { + new SplitLine(55.0, CutOffAxis.Vertical), + new SplitLine(110.0, CutOffAxis.Vertical), + new SplitLine(165.0, CutOffAxis.Vertical), + new SplitLine(220.0, CutOffAxis.Vertical) + }; + + var results = DrawingSplitter.Split(drawing, splitLines, new SplitParameters { Type = SplitType.Straight }); + + // Area must be preserved within tolerance (floating-point coords in the DXF). + var totalArea = results.Sum(d => d.Area); + Assert.Equal(originalArea, totalArea, 0); + + // At least one region must yield more than one physical strip — that's the + // whole point of the fix: a cutout that spans a region disconnects it. + Assert.True(results.Count > splitLines.Count + 1, + $"Expected more than {splitLines.Count + 1} pieces (some regions split into strips), got {results.Count}"); + + // Every output drawing must resolve into fully-closed shapes (outer loop + // and any hole loops), with no dangling geometry. A piece that contains + // a cutout will have its entities span more than one connected loop. + foreach (var piece in results) + { + var entities = ConvertProgram.ToGeometry(piece.Program) + .Where(e => e.Layer != SpecialLayers.Rapid).ToList(); + + Assert.True(entities.Count >= 3, $"{piece.Name} has only {entities.Count} entities"); + + var shapes = OpenNest.Geometry.ShapeBuilder.GetShapes(entities); + Assert.NotEmpty(shapes); + + foreach (var shape in shapes) + { + Assert.True(shape.IsClosed(), + $"{piece.Name} contains an open chain of {shape.Entities.Count} entities"); + } + } + } + private static Vector GetStartPoint(Entity entity) { return entity switch diff --git a/OpenNest.Tests/Splitting/TestData/split_test.dxf b/OpenNest.Tests/Splitting/TestData/split_test.dxf new file mode 100644 index 0000000..2618e00 --- /dev/null +++ b/OpenNest.Tests/Splitting/TestData/split_test.dxf @@ -0,0 +1,2554 @@ + 0 +SECTION + 2 +HEADER + 9 +$ACADVER + 1 +AC1018 + 9 +$ACADMAINTVER + 70 + 2 + 9 +$DWGCODEPAGE + 3 +ANSI_1252 + 9 +$INSBASE + 10 +0.0 + 20 +0.0 + 30 +0.0 + 9 +$EXTMIN + 10 +19.91850545569161 + 20 +5.515998377183137 + 30 +-0.0000000349181948 + 9 +$EXTMAX + 10 +274.9408108934591 + 20 +60.52360502754011 + 30 +0.0000000814935747 + 9 +$LIMMIN + 10 +0.0 + 20 +0.0 + 9 +$LIMMAX + 10 +12.0 + 20 +9.0 + 9 +$ORTHOMODE + 70 + 0 + 9 +$REGENMODE + 70 + 1 + 9 +$FILLMODE + 70 + 1 + 9 +$QTEXTMODE + 70 + 0 + 9 +$MIRRTEXT + 70 + 0 + 9 +$LTSCALE + 40 +1.0 + 9 +$ATTMODE + 70 + 1 + 9 +$TEXTSIZE + 40 +0.2 + 9 +$TRACEWID + 40 +0.05 + 9 +$TEXTSTYLE + 7 +Standard + 9 +$CLAYER + 8 +0 + 9 +$CELTYPE + 6 +ByLayer + 9 +$CECOLOR + 62 + 256 + 9 +$CELTSCALE + 40 +1.0 + 9 +$DISPSILH + 70 + 0 + 9 +$DIMSCALE + 40 +1.0 + 9 +$DIMASZ + 40 +0.18 + 9 +$DIMEXO + 40 +0.0625 + 9 +$DIMDLI + 40 +0.38 + 9 +$DIMRND + 40 +0.0 + 9 +$DIMDLE + 40 +0.0 + 9 +$DIMEXE + 40 +0.18 + 9 +$DIMTP + 40 +0.0 + 9 +$DIMTM + 40 +0.0 + 9 +$DIMTXT + 40 +0.18 + 9 +$DIMCEN + 40 +0.09 + 9 +$DIMTSZ + 40 +0.0 + 9 +$DIMTOL + 70 + 0 + 9 +$DIMLIM + 70 + 0 + 9 +$DIMTIH + 70 + 1 + 9 +$DIMTOH + 70 + 1 + 9 +$DIMSE1 + 70 + 0 + 9 +$DIMSE2 + 70 + 0 + 9 +$DIMTAD + 70 + 0 + 9 +$DIMZIN + 70 + 0 + 9 +$DIMBLK + 1 + + 9 +$DIMASO + 70 + 1 + 9 +$DIMSHO + 70 + 1 + 9 +$DIMPOST + 1 + + 9 +$DIMAPOST + 1 + + 9 +$DIMALT + 70 + 0 + 9 +$DIMALTD + 70 + 2 + 9 +$DIMALTF + 40 +25.4 + 9 +$DIMLFAC + 40 +1.0 + 9 +$DIMTOFL + 70 + 0 + 9 +$DIMTVP + 40 +0.0 + 9 +$DIMTIX + 70 + 0 + 9 +$DIMSOXD + 70 + 0 + 9 +$DIMSAH + 70 + 0 + 9 +$DIMBLK1 + 1 + + 9 +$DIMBLK2 + 1 + + 9 +$DIMSTYLE + 2 +Standard + 9 +$DIMCLRD + 70 + 0 + 9 +$DIMCLRE + 70 + 0 + 9 +$DIMCLRT + 70 + 0 + 9 +$DIMTFAC + 40 +1.0 + 9 +$DIMGAP + 40 +0.09 + 9 +$DIMJUST + 70 + 0 + 9 +$DIMSD1 + 70 + 0 + 9 +$DIMSD2 + 70 + 0 + 9 +$DIMTOLJ + 70 + 1 + 9 +$DIMTZIN + 70 + 0 + 9 +$DIMALTZ + 70 + 0 + 9 +$DIMALTTZ + 70 + 0 + 9 +$DIMUPT + 70 + 0 + 9 +$DIMDEC + 70 + 4 + 9 +$DIMTDEC + 70 + 4 + 9 +$DIMALTU + 70 + 2 + 9 +$DIMALTTD + 70 + 2 + 9 +$DIMTXSTY + 7 +Standard + 9 +$DIMAUNIT + 70 + 0 + 9 +$DIMADEC + 70 + 0 + 9 +$DIMALTRND + 40 +0.0 + 9 +$DIMAZIN + 70 + 0 + 9 +$DIMDSEP + 70 + 46 + 9 +$DIMATFIT + 70 + 3 + 9 +$DIMFRAC + 70 + 0 + 9 +$DIMLDRBLK + 1 + + 9 +$DIMLUNIT + 70 + 2 + 9 +$DIMLWD + 70 + -2 + 9 +$DIMLWE + 70 + -2 + 9 +$DIMTMOVE + 70 + 0 + 9 +$LUNITS + 70 + 2 + 9 +$LUPREC + 70 + 4 + 9 +$SKETCHINC + 40 +0.1 + 9 +$FILLETRAD + 40 +0.0 + 9 +$AUNITS + 70 + 0 + 9 +$AUPREC + 70 + 0 + 9 +$MENU + 1 +. + 9 +$ELEVATION + 40 +0.0 + 9 +$PELEVATION + 40 +0.0 + 9 +$THICKNESS + 40 +0.0 + 9 +$LIMCHECK + 70 + 0 + 9 +$CHAMFERA + 40 +0.0 + 9 +$CHAMFERB + 40 +0.0 + 9 +$CHAMFERC + 40 +0.0 + 9 +$CHAMFERD + 40 +0.0 + 9 +$SKPOLY + 70 + 0 + 9 +$TDCREATE + 40 +2461141.845430382 + 9 +$TDUCREATE + 40 +2461142.012097049 + 9 +$TDUPDATE + 40 +2461141.879244201 + 9 +$TDUUPDATE + 40 +2461142.045910868 + 9 +$TDINDWG + 40 +0.0024387384 + 9 +$TDUSRTIMER + 40 +0.0024382986 + 9 +$USRTIMER + 70 + 1 + 9 +$ANGBASE + 50 +0.0 + 9 +$ANGDIR + 70 + 0 + 9 +$PDMODE + 70 + 0 + 9 +$PDSIZE + 40 +0.0 + 9 +$PLINEWID + 40 +0.0 + 9 +$SPLFRAME + 70 + 0 + 9 +$SPLINETYPE + 70 + 6 + 9 +$SPLINESEGS + 70 + 8 + 9 +$HANDSEED + 5 +A2 + 9 +$SURFTAB1 + 70 + 6 + 9 +$SURFTAB2 + 70 + 6 + 9 +$SURFTYPE + 70 + 6 + 9 +$SURFU + 70 + 6 + 9 +$SURFV + 70 + 6 + 9 +$UCSBASE + 2 + + 9 +$UCSNAME + 2 + + 9 +$UCSORG + 10 +0.0 + 20 +0.0 + 30 +0.0 + 9 +$UCSXDIR + 10 +1.0 + 20 +0.0 + 30 +0.0 + 9 +$UCSYDIR + 10 +0.0 + 20 +1.0 + 30 +0.0 + 9 +$UCSORTHOREF + 2 + + 9 +$UCSORTHOVIEW + 70 + 0 + 9 +$UCSORGTOP + 10 +0.0 + 20 +0.0 + 30 +0.0 + 9 +$UCSORGBOTTOM + 10 +0.0 + 20 +0.0 + 30 +0.0 + 9 +$UCSORGLEFT + 10 +0.0 + 20 +0.0 + 30 +0.0 + 9 +$UCSORGRIGHT + 10 +0.0 + 20 +0.0 + 30 +0.0 + 9 +$UCSORGFRONT + 10 +0.0 + 20 +0.0 + 30 +0.0 + 9 +$UCSORGBACK + 10 +0.0 + 20 +0.0 + 30 +0.0 + 9 +$PUCSBASE + 2 + + 9 +$PUCSNAME + 2 + + 9 +$PUCSORG + 10 +0.0 + 20 +0.0 + 30 +0.0 + 9 +$PUCSXDIR + 10 +1.0 + 20 +0.0 + 30 +0.0 + 9 +$PUCSYDIR + 10 +0.0 + 20 +1.0 + 30 +0.0 + 9 +$PUCSORTHOREF + 2 + + 9 +$PUCSORTHOVIEW + 70 + 0 + 9 +$PUCSORGTOP + 10 +0.0 + 20 +0.0 + 30 +0.0 + 9 +$PUCSORGBOTTOM + 10 +0.0 + 20 +0.0 + 30 +0.0 + 9 +$PUCSORGLEFT + 10 +0.0 + 20 +0.0 + 30 +0.0 + 9 +$PUCSORGRIGHT + 10 +0.0 + 20 +0.0 + 30 +0.0 + 9 +$PUCSORGFRONT + 10 +0.0 + 20 +0.0 + 30 +0.0 + 9 +$PUCSORGBACK + 10 +0.0 + 20 +0.0 + 30 +0.0 + 9 +$USERI1 + 70 + 0 + 9 +$USERI2 + 70 + 0 + 9 +$USERI3 + 70 + 0 + 9 +$USERI4 + 70 + 0 + 9 +$USERI5 + 70 + 0 + 9 +$USERR1 + 40 +0.0 + 9 +$USERR2 + 40 +0.0 + 9 +$USERR3 + 40 +0.0 + 9 +$USERR4 + 40 +0.0 + 9 +$USERR5 + 40 +0.0 + 9 +$WORLDVIEW + 70 + 1 + 9 +$SHADEDGE + 70 + 3 + 9 +$SHADEDIF + 70 + 70 + 9 +$TILEMODE + 70 + 1 + 9 +$MAXACTVP + 70 + 64 + 9 +$PINSBASE + 10 +0.0 + 20 +0.0 + 30 +0.0 + 9 +$PLIMCHECK + 70 + 0 + 9 +$PEXTMIN + 10 +0.0 + 20 +0.0 + 30 +0.0 + 9 +$PEXTMAX + 10 +0.0 + 20 +0.0 + 30 +0.0 + 9 +$PLIMMIN + 10 +0.0 + 20 +0.0 + 9 +$PLIMMAX + 10 +12.0 + 20 +9.0 + 9 +$UNITMODE + 70 + 0 + 9 +$VISRETAIN + 70 + 1 + 9 +$PLINEGEN + 70 + 0 + 9 +$PSLTSCALE + 70 + 1 + 9 +$TREEDEPTH + 70 + 3020 + 9 +$CMLSTYLE + 2 +Standard + 9 +$CMLJUST + 70 + 0 + 9 +$CMLSCALE + 40 +1.0 + 9 +$PROXYGRAPHICS + 70 + 1 + 9 +$MEASUREMENT + 70 + 0 + 9 +$CELWEIGHT +370 + -1 + 9 +$ENDCAPS +280 + 0 + 9 +$JOINSTYLE +280 + 0 + 9 +$LWDISPLAY +290 + 0 + 9 +$INSUNITS + 70 + 1 + 9 +$HYPERLINKBASE + 1 + + 9 +$STYLESHEET + 1 + + 9 +$XEDIT +290 + 1 + 9 +$CEPSNTYPE +380 + 0 + 9 +$PSTYLEMODE +290 + 1 + 9 +$FINGERPRINTGUID + 2 +{FDEAD576-A652-11D2-9A35-0060089B3A3F} + 9 +$VERSIONGUID + 2 +{43BEA035-DE0A-47E5-AE2D-CFCAFBC579EF} + 9 +$EXTNAMES +290 + 1 + 9 +$PSVPSCALE + 40 +0.0 + 9 +$OLESTARTUP +290 + 0 + 9 +$SORTENTS +280 + 127 + 9 +$INDEXCTL +280 + 0 + 9 +$HIDETEXT +280 + 1 + 9 +$XCLIPFRAME +290 + 0 + 9 +$HALOGAP +280 + 0 + 9 +$OBSCOLOR + 70 + 257 + 9 +$OBSLTYPE +280 + 0 + 9 +$INTERSECTIONDISPLAY +280 + 0 + 9 +$INTERSECTIONCOLOR + 70 + 257 + 9 +$DIMASSOC +280 + 2 + 9 +$PROJECTNAME + 1 + + 0 +ENDSEC + 0 +SECTION + 2 +CLASSES + 0 +CLASS + 1 +ACDBDICTIONARYWDFLT + 2 +AcDbDictionaryWithDefault + 3 +ObjectDBX Classes + 90 + 0 + 91 + 1 +280 + 0 +281 + 0 + 0 +CLASS + 1 +DICTIONARYVAR + 2 +AcDbDictionaryVar + 3 +ObjectDBX Classes + 90 + 0 + 91 + 2 +280 + 0 +281 + 0 + 0 +ENDSEC + 0 +SECTION + 2 +TABLES + 0 +TABLE + 2 +VPORT + 5 +8 +330 +0 +100 +AcDbSymbolTable + 70 + 2 + 0 +VPORT + 5 +A1 +330 +8 +100 +AcDbSymbolTableRecord +100 +AcDbViewportTableRecord + 2 +*Active + 70 + 0 + 10 +0.0 + 20 +0.0 + 11 +1.0 + 21 +1.0 + 12 +147.4296581745753 + 22 +33.01980170236163 + 13 +0.0 + 23 +0.0 + 14 +0.5 + 24 +0.5 + 15 +0.5 + 25 +0.5 + 16 +0.0 + 26 +0.0 + 36 +1.0 + 17 +0.0 + 27 +0.0 + 37 +0.0 + 40 +121.7516279380305 + 41 +2.099662162162162 + 42 +50.0 + 43 +0.0 + 44 +0.0 + 50 +0.0 + 51 +0.0 + 71 + 0 + 72 + 1000 + 73 + 1 + 74 + 3 + 75 + 0 + 76 + 0 + 77 + 0 + 78 + 0 +281 + 0 + 65 + 1 +110 +0.0 +120 +0.0 +130 +0.0 +111 +1.0 +121 +0.0 +131 +0.0 +112 +0.0 +122 +1.0 +132 +0.0 + 79 + 0 +146 +0.0 + 0 +ENDTAB + 0 +TABLE + 2 +LTYPE + 5 +5 +330 +0 +100 +AcDbSymbolTable + 70 + 1 + 0 +LTYPE + 5 +14 +330 +5 +100 +AcDbSymbolTableRecord +100 +AcDbLinetypeTableRecord + 2 +ByBlock + 70 + 0 + 3 + + 72 + 65 + 73 + 0 + 40 +0.0 + 0 +LTYPE + 5 +15 +330 +5 +100 +AcDbSymbolTableRecord +100 +AcDbLinetypeTableRecord + 2 +ByLayer + 70 + 0 + 3 + + 72 + 65 + 73 + 0 + 40 +0.0 + 0 +LTYPE + 5 +16 +330 +5 +100 +AcDbSymbolTableRecord +100 +AcDbLinetypeTableRecord + 2 +Continuous + 70 + 0 + 3 +Solid line + 72 + 65 + 73 + 0 + 40 +0.0 + 0 +ENDTAB + 0 +TABLE + 2 +LAYER + 5 +2 +330 +0 +100 +AcDbSymbolTable + 70 + 1 + 0 +LAYER + 5 +10 +330 +2 +100 +AcDbSymbolTableRecord +100 +AcDbLayerTableRecord + 2 +0 + 70 + 0 + 62 + 7 + 6 +Continuous +370 + -3 +390 +F + 0 +ENDTAB + 0 +TABLE + 2 +STYLE + 5 +3 +330 +0 +100 +AcDbSymbolTable + 70 + 1 + 0 +STYLE + 5 +11 +330 +3 +100 +AcDbSymbolTableRecord +100 +AcDbTextStyleTableRecord + 2 +Standard + 70 + 0 + 40 +0.0 + 41 +1.0 + 50 +0.0 + 71 + 0 + 42 +0.2 + 3 +txt + 4 + + 0 +ENDTAB + 0 +TABLE + 2 +VIEW + 5 +6 +330 +0 +100 +AcDbSymbolTable + 70 + 0 + 0 +ENDTAB + 0 +TABLE + 2 +UCS + 5 +7 +330 +0 +100 +AcDbSymbolTable + 70 + 0 + 0 +ENDTAB + 0 +TABLE + 2 +APPID + 5 +9 +330 +0 +100 +AcDbSymbolTable + 70 + 1 + 0 +APPID + 5 +12 +330 +9 +100 +AcDbSymbolTableRecord +100 +AcDbRegAppTableRecord + 2 +ACAD + 70 + 0 + 0 +ENDTAB + 0 +TABLE + 2 +DIMSTYLE + 5 +A +330 +0 +100 +AcDbSymbolTable + 70 + 1 +100 +AcDbDimStyleTable + 71 + 0 + 0 +DIMSTYLE +105 +27 +330 +A +100 +AcDbSymbolTableRecord +100 +AcDbDimStyleTableRecord + 2 +Standard + 70 + 0 +340 +11 + 0 +ENDTAB + 0 +TABLE + 2 +BLOCK_RECORD + 5 +1 +330 +0 +100 +AcDbSymbolTable + 70 + 1 + 0 +BLOCK_RECORD + 5 +1F +330 +1 +100 +AcDbSymbolTableRecord +100 +AcDbBlockTableRecord + 2 +*Model_Space +340 +22 + 0 +BLOCK_RECORD + 5 +58 +330 +1 +100 +AcDbSymbolTableRecord +100 +AcDbBlockTableRecord + 2 +*Paper_Space +340 +59 + 0 +BLOCK_RECORD + 5 +5D +330 +1 +100 +AcDbSymbolTableRecord +100 +AcDbBlockTableRecord + 2 +*Paper_Space0 +340 +5E + 0 +ENDTAB + 0 +ENDSEC + 0 +SECTION + 2 +BLOCKS + 0 +BLOCK + 5 +20 +330 +1F +100 +AcDbEntity + 8 +0 +100 +AcDbBlockBegin + 2 +*Model_Space + 70 + 0 + 10 +0.0 + 20 +0.0 + 30 +0.0 + 3 +*Model_Space + 1 + + 0 +ENDBLK + 5 +21 +330 +1F +100 +AcDbEntity + 8 +0 +100 +AcDbBlockEnd + 0 +BLOCK + 5 +5A +330 +58 +100 +AcDbEntity + 67 + 1 + 8 +0 +100 +AcDbBlockBegin + 2 +*Paper_Space + 70 + 0 + 10 +0.0 + 20 +0.0 + 30 +0.0 + 3 +*Paper_Space + 1 + + 0 +ENDBLK + 5 +5B +330 +58 +100 +AcDbEntity + 67 + 1 + 8 +0 +100 +AcDbBlockEnd + 0 +BLOCK + 5 +5F +330 +5D +100 +AcDbEntity + 8 +0 +100 +AcDbBlockBegin + 2 +*Paper_Space0 + 70 + 0 + 10 +0.0 + 20 +0.0 + 30 +0.0 + 3 +*Paper_Space0 + 1 + + 0 +ENDBLK + 5 +60 +330 +5D +100 +AcDbEntity + 8 +0 +100 +AcDbBlockEnd + 0 +ENDSEC + 0 +SECTION + 2 +ENTITIES + 0 +LINE + 5 +89 +330 +1F +100 +AcDbEntity + 8 +0 +100 +AcDbLine + 10 +19.92402932605608 + 20 +5.519910847131079 + 30 +0.0 + 11 +19.92402932605608 + 21 +60.51991084713108 + 31 +0.0 + 0 +LINE + 5 +8A +330 +1F +100 +AcDbEntity + 8 +0 +100 +AcDbLine + 10 +19.92402932605608 + 20 +60.51991084713108 + 30 +0.0 + 11 +274.9240293260561 + 21 +60.51991084713108 + 31 +0.0 + 0 +LINE + 5 +8B +330 +1F +100 +AcDbEntity + 8 +0 +100 +AcDbLine + 10 +19.92402932605608 + 20 +5.519910847131079 + 30 +0.0 + 11 +274.924029326056 + 21 +5.519910847131079 + 31 +0.0 + 0 +LINE + 5 +8C +330 +1F +100 +AcDbEntity + 8 +0 +100 +AcDbLine + 10 +274.9240293260561 + 20 +60.51991084713108 + 30 +0.0 + 11 +274.924029326056 + 21 +5.519910847131079 + 31 +0.0 + 0 +LINE + 5 +8D +330 +1F +100 +AcDbEntity + 8 +0 +100 +AcDbLine + 10 +100.1372327616525 + 20 +50.51991084713108 + 30 +0.0 + 11 +264.9240293260561 + 21 +50.51991084713108 + 31 +0.0 + 0 +LINE + 5 +8F +330 +1F +100 +AcDbEntity + 8 +0 +100 +AcDbLine + 10 +100.1372327616525 + 20 +15.51991084713107 + 30 +0.0 + 11 +264.924029326056 + 21 +15.51991084713108 + 31 +0.0 + 0 +LINE + 5 +90 +330 +1F +100 +AcDbEntity + 8 +0 +100 +AcDbLine + 10 +264.9240293260561 + 20 +50.51991084713108 + 30 +0.0 + 11 +264.924029326056 + 21 +15.51991084713108 + 31 +0.0 + 0 +CIRCLE + 5 +98 +330 +1F +100 +AcDbEntity + 8 +0 +100 +AcDbCircle + 10 +78.92402932605609 + 20 +33.01991084713108 + 30 +0.0 + 40 +17.5 + 0 +ARC + 5 +9A +330 +1F +100 +AcDbEntity + 8 +0 +100 +AcDbCircle + 10 +78.92402932605609 + 20 +33.01991084713108 + 30 +0.0 + 40 +27.5 +100 +AcDbArc + 50 +320.4788036413579 + 51 +39.52119635864218 + 0 +ARC + 5 +9B +330 +1F +100 +AcDbEntity + 8 +0 +100 +AcDbCircle + 10 +78.92402932605609 + 20 +33.01991084713108 + 30 +0.0 + 40 +27.5 +100 +AcDbArc + 50 +140.4788036413578 + 51 +219.5211963586422 + 0 +LINE + 5 +9C +330 +1F +100 +AcDbEntity + 8 +0 +100 +AcDbLine + 10 +57.71082589045966 + 20 +15.51991084713107 + 30 +0.0 + 11 +29.92402932605608 + 21 +15.51991084713108 + 31 +0.0 + 0 +LINE + 5 +9D +330 +1F +100 +AcDbEntity + 8 +0 +100 +AcDbLine + 10 +57.71082589045966 + 20 +50.51991084713108 + 30 +0.0 + 11 +29.92402932605609 + 21 +50.51991084713108 + 31 +0.0 + 0 +LINE + 5 +9E +330 +1F +100 +AcDbEntity + 8 +0 +100 +AcDbLine + 10 +29.92402932605608 + 20 +15.51991084713108 + 30 +0.0 + 11 +29.92402932605608 + 21 +50.51991084713109 + 31 +0.0 + 0 +ENDSEC + 0 +SECTION + 2 +OBJECTS + 0 +DICTIONARY + 5 +C +330 +0 +100 +AcDbDictionary +281 + 1 + 3 +ACAD_COLOR +350 +73 + 3 +ACAD_GROUP +350 +D + 3 +ACAD_LAYOUT +350 +1A + 3 +ACAD_MATERIAL +350 +72 + 3 +ACAD_MLINESTYLE +350 +17 + 3 +ACAD_PLOTSETTINGS +350 +19 + 3 +ACAD_PLOTSTYLENAME +350 +E + 3 +AcDbVariableDictionary +350 +66 + 0 +DICTIONARY + 5 +73 +102 +{ACAD_REACTORS +330 +C +102 +} +330 +C +100 +AcDbDictionary +281 + 1 + 0 +DICTIONARY + 5 +D +102 +{ACAD_REACTORS +330 +C +102 +} +330 +C +100 +AcDbDictionary +281 + 1 + 0 +DICTIONARY + 5 +1A +102 +{ACAD_REACTORS +330 +C +102 +} +330 +C +100 +AcDbDictionary +281 + 1 + 3 +Layout1 +350 +59 + 3 +Layout2 +350 +5E + 3 +Model +350 +22 + 0 +DICTIONARY + 5 +72 +102 +{ACAD_REACTORS +330 +C +102 +} +330 +C +100 +AcDbDictionary +281 + 1 + 0 +DICTIONARY + 5 +17 +102 +{ACAD_REACTORS +330 +C +102 +} +330 +C +100 +AcDbDictionary +281 + 1 + 3 +Standard +350 +18 + 0 +DICTIONARY + 5 +19 +102 +{ACAD_REACTORS +330 +C +102 +} +330 +C +100 +AcDbDictionary +281 + 1 + 0 +ACDBDICTIONARYWDFLT + 5 +E +102 +{ACAD_REACTORS +330 +C +102 +} +330 +C +100 +AcDbDictionary +281 + 1 + 3 +Normal +350 +F +100 +AcDbDictionaryWithDefault +340 +F + 0 +DICTIONARY + 5 +66 +102 +{ACAD_REACTORS +330 +C +102 +} +330 +C +100 +AcDbDictionary +281 + 1 + 3 +DIMASSOC +350 +67 + 3 +HIDETEXT +350 +6B + 0 +LAYOUT + 5 +59 +102 +{ACAD_REACTORS +330 +1A +102 +} +330 +1A +100 +AcDbPlotSettings + 1 + + 2 +None + 4 + + 6 + + 40 +0.0 + 41 +0.0 + 42 +0.0 + 43 +0.0 + 44 +0.0 + 45 +0.0 + 46 +0.0 + 47 +0.0 + 48 +0.0 + 49 +0.0 +140 +0.0 +141 +0.0 +142 +1.0 +143 +1.0 + 70 + 688 + 72 + 0 + 73 + 0 + 74 + 5 + 7 + + 75 + 16 +147 +1.0 + 76 + 0 + 77 + 2 + 78 + 300 +148 +0.0 +149 +0.0 +100 +AcDbLayout + 1 +Layout1 + 70 + 1 + 71 + 1 + 10 +0.0 + 20 +0.0 + 11 +12.0 + 21 +9.0 + 12 +0.0 + 22 +0.0 + 32 +0.0 + 14 +0.0 + 24 +0.0 + 34 +0.0 + 15 +0.0 + 25 +0.0 + 35 +0.0 +146 +0.0 + 13 +0.0 + 23 +0.0 + 33 +0.0 + 16 +1.0 + 26 +0.0 + 36 +0.0 + 17 +0.0 + 27 +1.0 + 37 +0.0 + 76 + 0 +330 +58 + 0 +LAYOUT + 5 +5E +102 +{ACAD_REACTORS +330 +1A +102 +} +330 +1A +100 +AcDbPlotSettings + 1 + + 2 +None + 4 + + 6 + + 40 +0.0 + 41 +0.0 + 42 +0.0 + 43 +0.0 + 44 +0.0 + 45 +0.0 + 46 +0.0 + 47 +0.0 + 48 +0.0 + 49 +0.0 +140 +0.0 +141 +0.0 +142 +1.0 +143 +1.0 + 70 + 688 + 72 + 0 + 73 + 0 + 74 + 5 + 7 + + 75 + 16 +147 +1.0 + 76 + 0 + 77 + 2 + 78 + 300 +148 +0.0 +149 +0.0 +100 +AcDbLayout + 1 +Layout2 + 70 + 1 + 71 + 2 + 10 +0.0 + 20 +0.0 + 11 +12.0 + 21 +9.0 + 12 +0.0 + 22 +0.0 + 32 +0.0 + 14 +0.0 + 24 +0.0 + 34 +0.0 + 15 +0.0 + 25 +0.0 + 35 +0.0 +146 +0.0 + 13 +0.0 + 23 +0.0 + 33 +0.0 + 16 +1.0 + 26 +0.0 + 36 +0.0 + 17 +0.0 + 27 +1.0 + 37 +0.0 + 76 + 0 +330 +5D + 0 +LAYOUT + 5 +22 +102 +{ACAD_REACTORS +330 +1A +102 +} +330 +1A +100 +AcDbPlotSettings + 1 + + 2 +none_device + 4 +ANSI_A_(8.50_x_11.00_Inches) + 6 + + 40 +6.349999904632567 + 41 +19.04999923706055 + 42 +6.350006103515625 + 43 +19.04998779296875 + 44 +215.8999938964844 + 45 +279.3999938964844 + 46 +0.0 + 47 +0.0 + 48 +0.0 + 49 +0.0 +140 +0.0 +141 +0.0 +142 +1.0 +143 +2.584895464708373 + 70 + 11952 + 72 + 0 + 73 + 1 + 74 + 0 + 7 + + 75 + 0 +147 +0.3868628397755418 + 76 + 0 + 77 + 2 + 78 + 300 +148 +0.0 +149 +0.0 +100 +AcDbLayout + 1 +Model + 70 + 1 + 71 + 0 + 10 +0.0 + 20 +0.0 + 11 +12.0 + 21 +9.0 + 12 +0.0 + 22 +0.0 + 32 +0.0 + 14 +0.0 + 24 +0.0 + 34 +0.0 + 15 +0.0 + 25 +0.0 + 35 +0.0 +146 +0.0 + 13 +0.0 + 23 +0.0 + 33 +0.0 + 16 +1.0 + 26 +0.0 + 36 +0.0 + 17 +0.0 + 27 +1.0 + 37 +0.0 + 76 + 0 +330 +1F + 0 +MLINESTYLE + 5 +18 +102 +{ACAD_REACTORS +330 +17 +102 +} +330 +17 +100 +AcDbMlineStyle + 2 +STANDARD + 70 + 0 + 3 + + 62 + 256 + 51 +90.0 + 52 +90.0 + 71 + 2 + 49 +0.5 + 62 + 256 + 6 +BYLAYER + 49 +-0.5 + 62 + 256 + 6 +BYLAYER + 0 +ACDBPLACEHOLDER + 5 +F +102 +{ACAD_REACTORS +330 +E +102 +} +330 +E + 0 +DICTIONARYVAR + 5 +67 +102 +{ACAD_REACTORS +330 +66 +102 +} +330 +66 +100 +DictionaryVariables +280 + 0 + 1 +2 + 0 +DICTIONARYVAR + 5 +6B +102 +{ACAD_REACTORS +330 +66 +102 +} +330 +66 +100 +DictionaryVariables +280 + 0 + 1 +1 + 0 +ENDSEC + 0 +EOF diff --git a/OpenNest/Configurations/FlangeShape.json b/OpenNest/Configurations/PipeFlangeShape.json similarity index 63% rename from OpenNest/Configurations/FlangeShape.json rename to OpenNest/Configurations/PipeFlangeShape.json index 07608d2..40a3722 100644 --- a/OpenNest/Configurations/FlangeShape.json +++ b/OpenNest/Configurations/PipeFlangeShape.json @@ -1,7 +1,8 @@ [ { "Name": "0.25in-150#", - "NominalPipeSize": 0.25, + "PipeSize": "1/4", + "PipeClearance": 0.0625, "OD": 3.375, "HoleDiameter": 0.62, "HolePatternDiameter": 2.25, @@ -9,7 +10,8 @@ }, { "Name": "0.25in-300#", - "NominalPipeSize": 0.25, + "PipeSize": "1/4", + "PipeClearance": 0.0625, "OD": 3.375, "HoleDiameter": 0.62, "HolePatternDiameter": 2.25, @@ -17,7 +19,8 @@ }, { "Name": "0.25in-400#", - "NominalPipeSize": 0.25, + "PipeSize": "1/4", + "PipeClearance": 0.0625, "OD": 3.375, "HoleDiameter": 0.62, "HolePatternDiameter": 2.25, @@ -25,7 +28,8 @@ }, { "Name": "0.25in-600#", - "NominalPipeSize": 0.25, + "PipeSize": "1/4", + "PipeClearance": 0.0625, "OD": 3.375, "HoleDiameter": 0.62, "HolePatternDiameter": 2.25, @@ -33,7 +37,8 @@ }, { "Name": "0.5in-150#", - "NominalPipeSize": 0.5, + "PipeSize": "1/2", + "PipeClearance": 0.0625, "OD": 3.5, "HoleDiameter": 0.62, "HolePatternDiameter": 2.38, @@ -41,7 +46,8 @@ }, { "Name": "0.5in-300#", - "NominalPipeSize": 0.5, + "PipeSize": "1/2", + "PipeClearance": 0.0625, "OD": 3.75, "HoleDiameter": 0.62, "HolePatternDiameter": 2.63, @@ -49,7 +55,8 @@ }, { "Name": "0.5in-400#", - "NominalPipeSize": 0.5, + "PipeSize": "1/2", + "PipeClearance": 0.0625, "OD": 3.75, "HoleDiameter": 0.62, "HolePatternDiameter": 2.63, @@ -57,7 +64,8 @@ }, { "Name": "0.5in-600#", - "NominalPipeSize": 0.5, + "PipeSize": "1/2", + "PipeClearance": 0.0625, "OD": 3.75, "HoleDiameter": 0.62, "HolePatternDiameter": 2.63, @@ -65,7 +73,8 @@ }, { "Name": "0.5in-900#", - "NominalPipeSize": 0.5, + "PipeSize": "1/2", + "PipeClearance": 0.0625, "OD": 4.75, "HoleDiameter": 0.88, "HolePatternDiameter": 3.25, @@ -73,7 +82,8 @@ }, { "Name": "0.5in-1500#", - "NominalPipeSize": 0.5, + "PipeSize": "1/2", + "PipeClearance": 0.0625, "OD": 4.75, "HoleDiameter": 0.88, "HolePatternDiameter": 3.25, @@ -81,7 +91,8 @@ }, { "Name": "0.5in-2500#", - "NominalPipeSize": 0.5, + "PipeSize": "1/2", + "PipeClearance": 0.0625, "OD": 5.25, "HoleDiameter": 0.88, "HolePatternDiameter": 3.5, @@ -89,7 +100,8 @@ }, { "Name": "0.75in-150#", - "NominalPipeSize": 0.75, + "PipeSize": "3/4", + "PipeClearance": 0.0625, "OD": 3.875, "HoleDiameter": 0.62, "HolePatternDiameter": 2.75, @@ -97,7 +109,8 @@ }, { "Name": "0.75in-300#", - "NominalPipeSize": 0.75, + "PipeSize": "3/4", + "PipeClearance": 0.0625, "OD": 4.625, "HoleDiameter": 0.75, "HolePatternDiameter": 3.25, @@ -105,7 +118,8 @@ }, { "Name": "0.75in-400#", - "NominalPipeSize": 0.75, + "PipeSize": "3/4", + "PipeClearance": 0.0625, "OD": 4.625, "HoleDiameter": 0.75, "HolePatternDiameter": 3.25, @@ -113,7 +127,8 @@ }, { "Name": "0.75in-600#", - "NominalPipeSize": 0.75, + "PipeSize": "3/4", + "PipeClearance": 0.0625, "OD": 4.625, "HoleDiameter": 0.75, "HolePatternDiameter": 3.25, @@ -121,7 +136,8 @@ }, { "Name": "0.75in-900#", - "NominalPipeSize": 0.75, + "PipeSize": "3/4", + "PipeClearance": 0.0625, "OD": 5.125, "HoleDiameter": 0.88, "HolePatternDiameter": 3.5, @@ -129,7 +145,8 @@ }, { "Name": "0.75in-1500#", - "NominalPipeSize": 0.75, + "PipeSize": "3/4", + "PipeClearance": 0.0625, "OD": 5.125, "HoleDiameter": 0.88, "HolePatternDiameter": 3.5, @@ -137,7 +154,8 @@ }, { "Name": "0.75in-2500#", - "NominalPipeSize": 0.75, + "PipeSize": "3/4", + "PipeClearance": 0.0625, "OD": 5.5, "HoleDiameter": 0.88, "HolePatternDiameter": 3.75, @@ -145,7 +163,8 @@ }, { "Name": "1in-150#", - "NominalPipeSize": 1.0, + "PipeSize": "1", + "PipeClearance": 0.0625, "OD": 4.25, "HoleDiameter": 0.62, "HolePatternDiameter": 3.13, @@ -153,7 +172,8 @@ }, { "Name": "1in-300#", - "NominalPipeSize": 1.0, + "PipeSize": "1", + "PipeClearance": 0.0625, "OD": 4.875, "HoleDiameter": 0.75, "HolePatternDiameter": 3.5, @@ -161,7 +181,8 @@ }, { "Name": "1in-400#", - "NominalPipeSize": 1.0, + "PipeSize": "1", + "PipeClearance": 0.0625, "OD": 4.875, "HoleDiameter": 0.75, "HolePatternDiameter": 3.5, @@ -169,7 +190,8 @@ }, { "Name": "1in-600#", - "NominalPipeSize": 1.0, + "PipeSize": "1", + "PipeClearance": 0.0625, "OD": 4.875, "HoleDiameter": 0.75, "HolePatternDiameter": 3.5, @@ -177,31 +199,35 @@ }, { "Name": "1in-900#", - "NominalPipeSize": 1.0, + "PipeSize": "1", + "PipeClearance": 0.0625, "OD": 5.875, - "HoleDiameter": 1.0, - "HolePatternDiameter": 4.0, + "HoleDiameter": 1, + "HolePatternDiameter": 4, "HoleCount": 4 }, { "Name": "1in-1500#", - "NominalPipeSize": 1.0, + "PipeSize": "1", + "PipeClearance": 0.0625, "OD": 5.875, - "HoleDiameter": 1.0, - "HolePatternDiameter": 4.0, + "HoleDiameter": 1, + "HolePatternDiameter": 4, "HoleCount": 4 }, { "Name": "1in-2500#", - "NominalPipeSize": 1.0, + "PipeSize": "1", + "PipeClearance": 0.0625, "OD": 6.25, - "HoleDiameter": 1.0, + "HoleDiameter": 1, "HolePatternDiameter": 4.25, "HoleCount": 4 }, { "Name": "1.25in-150#", - "NominalPipeSize": 1.25, + "PipeSize": "1 1/4", + "PipeClearance": 0.0625, "OD": 4.625, "HoleDiameter": 0.62, "HolePatternDiameter": 3.5, @@ -209,7 +235,8 @@ }, { "Name": "1.25in-300#", - "NominalPipeSize": 1.25, + "PipeSize": "1 1/4", + "PipeClearance": 0.0625, "OD": 5.25, "HoleDiameter": 0.75, "HolePatternDiameter": 3.88, @@ -217,7 +244,8 @@ }, { "Name": "1.25in-400#", - "NominalPipeSize": 1.25, + "PipeSize": "1 1/4", + "PipeClearance": 0.0625, "OD": 5.25, "HoleDiameter": 0.75, "HolePatternDiameter": 3.88, @@ -225,7 +253,8 @@ }, { "Name": "1.25in-600#", - "NominalPipeSize": 1.25, + "PipeSize": "1 1/4", + "PipeClearance": 0.0625, "OD": 5.25, "HoleDiameter": 0.75, "HolePatternDiameter": 3.88, @@ -233,23 +262,26 @@ }, { "Name": "1.25in-900#", - "NominalPipeSize": 1.25, + "PipeSize": "1 1/4", + "PipeClearance": 0.0625, "OD": 6.25, - "HoleDiameter": 1.0, + "HoleDiameter": 1, "HolePatternDiameter": 4.38, "HoleCount": 4 }, { "Name": "1.25in-1500#", - "NominalPipeSize": 1.25, + "PipeSize": "1 1/4", + "PipeClearance": 0.0625, "OD": 6.25, - "HoleDiameter": 1.0, + "HoleDiameter": 1, "HolePatternDiameter": 4.38, "HoleCount": 4 }, { "Name": "1.25in-2500#", - "NominalPipeSize": 1.25, + "PipeSize": "1 1/4", + "PipeClearance": 0.0625, "OD": 7.25, "HoleDiameter": 1.12, "HolePatternDiameter": 5.13, @@ -257,15 +289,17 @@ }, { "Name": "1.5in-150#", - "NominalPipeSize": 1.5, - "OD": 5.0, + "PipeSize": "1 1/2", + "PipeClearance": 0.0625, + "OD": 5, "HoleDiameter": 0.62, "HolePatternDiameter": 3.88, "HoleCount": 4 }, { "Name": "1.5in-300#", - "NominalPipeSize": 1.5, + "PipeSize": "1 1/2", + "PipeClearance": 0.0625, "OD": 6.125, "HoleDiameter": 0.88, "HolePatternDiameter": 4.5, @@ -273,7 +307,8 @@ }, { "Name": "1.5in-400#", - "NominalPipeSize": 1.5, + "PipeSize": "1 1/2", + "PipeClearance": 0.0625, "OD": 6.125, "HoleDiameter": 0.88, "HolePatternDiameter": 4.5, @@ -281,7 +316,8 @@ }, { "Name": "1.5in-600#", - "NominalPipeSize": 1.5, + "PipeSize": "1 1/2", + "PipeClearance": 0.0625, "OD": 6.125, "HoleDiameter": 0.88, "HolePatternDiameter": 4.5, @@ -289,79 +325,89 @@ }, { "Name": "1.5in-900#", - "NominalPipeSize": 1.5, - "OD": 7.0, + "PipeSize": "1 1/2", + "PipeClearance": 0.0625, + "OD": 7, "HoleDiameter": 1.12, "HolePatternDiameter": 4.88, "HoleCount": 4 }, { "Name": "1.5in-1500#", - "NominalPipeSize": 1.5, - "OD": 7.0, + "PipeSize": "1 1/2", + "PipeClearance": 0.0625, + "OD": 7, "HoleDiameter": 1.12, "HolePatternDiameter": 4.88, "HoleCount": 4 }, { "Name": "1.5in-2500#", - "NominalPipeSize": 1.5, - "OD": 8.0, + "PipeSize": "1 1/2", + "PipeClearance": 0.0625, + "OD": 8, "HoleDiameter": 1.25, "HolePatternDiameter": 5.75, "HoleCount": 4 }, { "Name": "2in-150#", - "NominalPipeSize": 2.0, - "OD": 6.0, + "PipeSize": "2", + "PipeClearance": 0.0625, + "OD": 6, "HoleDiameter": 0.75, "HolePatternDiameter": 4.75, "HoleCount": 4 }, { "Name": "2in-300#", - "NominalPipeSize": 2.0, + "PipeSize": "2", + "PipeClearance": 0.0625, "OD": 6.5, "HoleDiameter": 0.75, - "HolePatternDiameter": 5.0, + "HolePatternDiameter": 5, "HoleCount": 8 }, { "Name": "2in-400#", - "NominalPipeSize": 2.0, + "PipeSize": "2", + "PipeClearance": 0.0625, "OD": 6.5, "HoleDiameter": 0.75, - "HolePatternDiameter": 5.0, + "HolePatternDiameter": 5, "HoleCount": 8 }, { "Name": "2in-600#", - "NominalPipeSize": 2.0, + "PipeSize": "2", + "PipeClearance": 0.0625, "OD": 6.5, "HoleDiameter": 0.75, - "HolePatternDiameter": 5.0, + "HolePatternDiameter": 5, "HoleCount": 8 }, { "Name": "2in-900#", - "NominalPipeSize": 2.0, + "PipeSize": "2", + "PipeClearance": 0.0625, "OD": 8.5, - "HoleDiameter": 1.0, + "HoleDiameter": 1, "HolePatternDiameter": 6.5, "HoleCount": 8 }, { "Name": "2in-1500#", - "NominalPipeSize": 2.0, + "PipeSize": "2", + "PipeClearance": 0.0625, "OD": 8.5, - "HoleDiameter": 1.0, + "HoleDiameter": 1, "HolePatternDiameter": 6.5, "HoleCount": 8 }, { "Name": "2in-2500#", - "NominalPipeSize": 2.0, + "PipeSize": "2", + "PipeClearance": 0.0625, "OD": 9.25, "HoleDiameter": 1.12, "HolePatternDiameter": 6.75, @@ -369,15 +415,17 @@ }, { "Name": "2.5in-150#", - "NominalPipeSize": 2.5, - "OD": 7.0, + "PipeSize": "2 1/2", + "PipeClearance": 0.0625, + "OD": 7, "HoleDiameter": 0.75, "HolePatternDiameter": 5.5, "HoleCount": 4 }, { "Name": "2.5in-300#", - "NominalPipeSize": 2.5, + "PipeSize": "2 1/2", + "PipeClearance": 0.0625, "OD": 7.5, "HoleDiameter": 0.88, "HolePatternDiameter": 5.88, @@ -385,7 +433,8 @@ }, { "Name": "2.5in-400#", - "NominalPipeSize": 2.5, + "PipeSize": "2 1/2", + "PipeClearance": 0.0625, "OD": 7.5, "HoleDiameter": 0.88, "HolePatternDiameter": 5.88, @@ -393,7 +442,8 @@ }, { "Name": "2.5in-600#", - "NominalPipeSize": 2.5, + "PipeSize": "2 1/2", + "PipeClearance": 0.0625, "OD": 7.5, "HoleDiameter": 0.88, "HolePatternDiameter": 5.88, @@ -401,7 +451,8 @@ }, { "Name": "2.5in-900#", - "NominalPipeSize": 2.5, + "PipeSize": "2 1/2", + "PipeClearance": 0.0625, "OD": 9.625, "HoleDiameter": 1.12, "HolePatternDiameter": 7.5, @@ -409,7 +460,8 @@ }, { "Name": "2.5in-1500#", - "NominalPipeSize": 2.5, + "PipeSize": "2 1/2", + "PipeClearance": 0.0625, "OD": 9.625, "HoleDiameter": 1.12, "HolePatternDiameter": 7.5, @@ -417,7 +469,8 @@ }, { "Name": "2.5in-2500#", - "NominalPipeSize": 2.5, + "PipeSize": "2 1/2", + "PipeClearance": 0.0625, "OD": 10.5, "HoleDiameter": 1.25, "HolePatternDiameter": 7.75, @@ -425,15 +478,17 @@ }, { "Name": "3in-150#", - "NominalPipeSize": 3.0, + "PipeSize": "3", + "PipeClearance": 0.0625, "OD": 7.5, "HoleDiameter": 0.75, - "HolePatternDiameter": 6.0, + "HolePatternDiameter": 6, "HoleCount": 4 }, { "Name": "3in-300#", - "NominalPipeSize": 3.0, + "PipeSize": "3", + "PipeClearance": 0.0625, "OD": 8.25, "HoleDiameter": 0.88, "HolePatternDiameter": 6.63, @@ -441,7 +496,8 @@ }, { "Name": "3in-400#", - "NominalPipeSize": 3.0, + "PipeSize": "3", + "PipeClearance": 0.0625, "OD": 8.25, "HoleDiameter": 0.88, "HolePatternDiameter": 6.63, @@ -449,7 +505,8 @@ }, { "Name": "3in-600#", - "NominalPipeSize": 3.0, + "PipeSize": "3", + "PipeClearance": 0.0625, "OD": 8.25, "HoleDiameter": 0.88, "HolePatternDiameter": 6.63, @@ -457,95 +514,107 @@ }, { "Name": "3in-900#", - "NominalPipeSize": 3.0, + "PipeSize": "3", + "PipeClearance": 0.0625, "OD": 9.5, - "HoleDiameter": 1.0, + "HoleDiameter": 1, "HolePatternDiameter": 7.5, "HoleCount": 8 }, { "Name": "3in-1500#", - "NominalPipeSize": 3.0, + "PipeSize": "3", + "PipeClearance": 0.0625, "OD": 10.5, "HoleDiameter": 1.25, - "HolePatternDiameter": 8.0, + "HolePatternDiameter": 8, "HoleCount": 8 }, { "Name": "3in-2500#", - "NominalPipeSize": 3.0, - "OD": 12.0, + "PipeSize": "3", + "PipeClearance": 0.0625, + "OD": 12, "HoleDiameter": 1.38, - "HolePatternDiameter": 9.0, + "HolePatternDiameter": 9, "HoleCount": 8 }, { "Name": "3.5in-150#", - "NominalPipeSize": 3.5, + "PipeSize": "3 1/2", + "PipeClearance": 0.0625, "OD": 8.5, "HoleDiameter": 0.75, - "HolePatternDiameter": 7.0, + "HolePatternDiameter": 7, "HoleCount": 8 }, { "Name": "3.5in-300#", - "NominalPipeSize": 3.5, - "OD": 9.0, + "PipeSize": "3 1/2", + "PipeClearance": 0.0625, + "OD": 9, "HoleDiameter": 0.88, "HolePatternDiameter": 7.25, "HoleCount": 8 }, { "Name": "3.5in-400#", - "NominalPipeSize": 3.5, - "OD": 9.0, - "HoleDiameter": 1.0, + "PipeSize": "3 1/2", + "PipeClearance": 0.0625, + "OD": 9, + "HoleDiameter": 1, "HolePatternDiameter": 7.25, "HoleCount": 8 }, { "Name": "3.5in-600#", - "NominalPipeSize": 3.5, - "OD": 9.0, - "HoleDiameter": 1.0, + "PipeSize": "3 1/2", + "PipeClearance": 0.0625, + "OD": 9, + "HoleDiameter": 1, "HolePatternDiameter": 7.25, "HoleCount": 8 }, { "Name": "4in-150#", - "NominalPipeSize": 4.0, - "OD": 9.0, + "PipeSize": "4", + "PipeClearance": 0.0625, + "OD": 9, "HoleDiameter": 0.75, "HolePatternDiameter": 7.5, "HoleCount": 8 }, { "Name": "4in-300#", - "NominalPipeSize": 4.0, - "OD": 10.0, + "PipeSize": "4", + "PipeClearance": 0.0625, + "OD": 10, "HoleDiameter": 0.88, "HolePatternDiameter": 7.88, "HoleCount": 8 }, { "Name": "4in-400#", - "NominalPipeSize": 4.0, - "OD": 10.0, - "HoleDiameter": 1.0, + "PipeSize": "4", + "PipeClearance": 0.0625, + "OD": 10, + "HoleDiameter": 1, "HolePatternDiameter": 7.88, "HoleCount": 8 }, { "Name": "4in-600#", - "NominalPipeSize": 4.0, + "PipeSize": "4", + "PipeClearance": 0.0625, "OD": 10.75, - "HoleDiameter": 1.0, + "HoleDiameter": 1, "HolePatternDiameter": 8.5, "HoleCount": 8 }, { "Name": "4in-900#", - "NominalPipeSize": 4.0, + "PipeSize": "4", + "PipeClearance": 0.0625, "OD": 11.5, "HoleDiameter": 1.25, "HolePatternDiameter": 9.25, @@ -553,7 +622,8 @@ }, { "Name": "4in-1500#", - "NominalPipeSize": 4.0, + "PipeSize": "4", + "PipeClearance": 0.0625, "OD": 12.25, "HoleDiameter": 1.38, "HolePatternDiameter": 9.5, @@ -561,55 +631,62 @@ }, { "Name": "4in-2500#", - "NominalPipeSize": 4.0, - "OD": 14.0, + "PipeSize": "4", + "PipeClearance": 0.0625, + "OD": 14, "HoleDiameter": 1.62, "HolePatternDiameter": 10.75, "HoleCount": 8 }, { "Name": "5in-150#", - "NominalPipeSize": 5.0, - "OD": 10.0, + "PipeSize": "5", + "PipeClearance": 0.0625, + "OD": 10, "HoleDiameter": 0.88, "HolePatternDiameter": 8.5, "HoleCount": 8 }, { "Name": "5in-300#", - "NominalPipeSize": 5.0, - "OD": 11.0, + "PipeSize": "5", + "PipeClearance": 0.0625, + "OD": 11, "HoleDiameter": 0.88, "HolePatternDiameter": 9.25, "HoleCount": 8 }, { "Name": "5in-400#", - "NominalPipeSize": 5.0, - "OD": 11.0, - "HoleDiameter": 1.0, + "PipeSize": "5", + "PipeClearance": 0.0625, + "OD": 11, + "HoleDiameter": 1, "HolePatternDiameter": 9.25, "HoleCount": 8 }, { "Name": "5in-600#", - "NominalPipeSize": 5.0, - "OD": 13.0, + "PipeSize": "5", + "PipeClearance": 0.0625, + "OD": 13, "HoleDiameter": 1.12, "HolePatternDiameter": 10.5, "HoleCount": 8 }, { "Name": "5in-900#", - "NominalPipeSize": 5.0, + "PipeSize": "5", + "PipeClearance": 0.0625, "OD": 13.75, "HoleDiameter": 1.38, - "HolePatternDiameter": 11.0, + "HolePatternDiameter": 11, "HoleCount": 8 }, { "Name": "5in-1500#", - "NominalPipeSize": 5.0, + "PipeSize": "5", + "PipeClearance": 0.0625, "OD": 14.75, "HoleDiameter": 1.62, "HolePatternDiameter": 11.5, @@ -617,7 +694,8 @@ }, { "Name": "5in-2500#", - "NominalPipeSize": 5.0, + "PipeSize": "5", + "PipeClearance": 0.0625, "OD": 16.5, "HoleDiameter": 1.88, "HolePatternDiameter": 12.75, @@ -625,15 +703,17 @@ }, { "Name": "6in-150#", - "NominalPipeSize": 6.0, - "OD": 11.0, + "PipeSize": "6", + "PipeClearance": 0.0625, + "OD": 11, "HoleDiameter": 0.88, "HolePatternDiameter": 9.5, "HoleCount": 8 }, { "Name": "6in-300#", - "NominalPipeSize": 6.0, + "PipeSize": "6", + "PipeClearance": 0.0625, "OD": 12.5, "HoleDiameter": 0.88, "HolePatternDiameter": 10.63, @@ -641,31 +721,35 @@ }, { "Name": "6in-400#", - "NominalPipeSize": 6.0, + "PipeSize": "6", + "PipeClearance": 0.0625, "OD": 12.5, - "HoleDiameter": 1.0, + "HoleDiameter": 1, "HolePatternDiameter": 10.63, "HoleCount": 12 }, { "Name": "6in-600#", - "NominalPipeSize": 6.0, - "OD": 14.0, + "PipeSize": "6", + "PipeClearance": 0.0625, + "OD": 14, "HoleDiameter": 1.12, "HolePatternDiameter": 11.5, "HoleCount": 12 }, { "Name": "6in-900#", - "NominalPipeSize": 6.0, - "OD": 15.0, + "PipeSize": "6", + "PipeClearance": 0.0625, + "OD": 15, "HoleDiameter": 1.25, "HolePatternDiameter": 12.5, "HoleCount": 12 }, { "Name": "6in-1500#", - "NominalPipeSize": 6.0, + "PipeSize": "6", + "PipeClearance": 0.0625, "OD": 15.5, "HoleDiameter": 1.5, "HolePatternDiameter": 12.5, @@ -673,15 +757,17 @@ }, { "Name": "6in-2500#", - "NominalPipeSize": 6.0, - "OD": 19.0, + "PipeSize": "6", + "PipeClearance": 0.0625, + "OD": 19, "HoleDiameter": 2.12, "HolePatternDiameter": 14.5, "HoleCount": 8 }, { "Name": "8in-150#", - "NominalPipeSize": 8.0, + "PipeSize": "8", + "PipeClearance": 0.0625, "OD": 13.5, "HoleDiameter": 0.88, "HolePatternDiameter": 11.75, @@ -689,23 +775,26 @@ }, { "Name": "8in-300#", - "NominalPipeSize": 8.0, - "OD": 15.0, - "HoleDiameter": 1.0, - "HolePatternDiameter": 13.0, + "PipeSize": "8", + "PipeClearance": 0.0625, + "OD": 15, + "HoleDiameter": 1, + "HolePatternDiameter": 13, "HoleCount": 12 }, { "Name": "8in-400#", - "NominalPipeSize": 8.0, - "OD": 15.0, + "PipeSize": "8", + "PipeClearance": 0.0625, + "OD": 15, "HoleDiameter": 1.12, - "HolePatternDiameter": 13.0, + "HolePatternDiameter": 13, "HoleCount": 12 }, { "Name": "8in-600#", - "NominalPipeSize": 8.0, + "PipeSize": "8", + "PipeClearance": 0.0625, "OD": 16.5, "HoleDiameter": 1.25, "HolePatternDiameter": 13.75, @@ -713,7 +802,8 @@ }, { "Name": "8in-900#", - "NominalPipeSize": 8.0, + "PipeSize": "8", + "PipeClearance": 0.0625, "OD": 18.5, "HoleDiameter": 1.5, "HolePatternDiameter": 15.5, @@ -721,15 +811,17 @@ }, { "Name": "8in-1500#", - "NominalPipeSize": 8.0, - "OD": 19.0, + "PipeSize": "8", + "PipeClearance": 0.0625, + "OD": 19, "HoleDiameter": 1.75, "HolePatternDiameter": 15.5, "HoleCount": 12 }, { "Name": "8in-2500#", - "NominalPipeSize": 8.0, + "PipeSize": "8", + "PipeClearance": 0.0625, "OD": 21.75, "HoleDiameter": 2.12, "HolePatternDiameter": 17.25, @@ -737,15 +829,17 @@ }, { "Name": "10in-150#", - "NominalPipeSize": 10.0, - "OD": 16.0, - "HoleDiameter": 1.0, + "PipeSize": "10", + "PipeClearance": 0.0625, + "OD": 16, + "HoleDiameter": 1, "HolePatternDiameter": 14.25, "HoleCount": 12 }, { "Name": "10in-300#", - "NominalPipeSize": 10.0, + "PipeSize": "10", + "PipeClearance": 0.0625, "OD": 17.5, "HoleDiameter": 1.12, "HolePatternDiameter": 15.25, @@ -753,7 +847,8 @@ }, { "Name": "10in-400#", - "NominalPipeSize": 10.0, + "PipeSize": "10", + "PipeClearance": 0.0625, "OD": 17.5, "HoleDiameter": 1.25, "HolePatternDiameter": 15.25, @@ -761,15 +856,17 @@ }, { "Name": "10in-600#", - "NominalPipeSize": 10.0, - "OD": 20.0, + "PipeSize": "10", + "PipeClearance": 0.0625, + "OD": 20, "HoleDiameter": 1.38, - "HolePatternDiameter": 17.0, + "HolePatternDiameter": 17, "HoleCount": 16 }, { "Name": "10in-900#", - "NominalPipeSize": 10.0, + "PipeSize": "10", + "PipeClearance": 0.0625, "OD": 21.5, "HoleDiameter": 1.5, "HolePatternDiameter": 18.5, @@ -777,15 +874,17 @@ }, { "Name": "10in-1500#", - "NominalPipeSize": 10.0, - "OD": 23.0, - "HoleDiameter": 2.0, - "HolePatternDiameter": 19.0, + "PipeSize": "10", + "PipeClearance": 0.0625, + "OD": 23, + "HoleDiameter": 2, + "HolePatternDiameter": 19, "HoleCount": 12 }, { "Name": "10in-2500#", - "NominalPipeSize": 10.0, + "PipeSize": "10", + "PipeClearance": 0.0625, "OD": 26.5, "HoleDiameter": 2.62, "HolePatternDiameter": 21.25, @@ -793,15 +892,17 @@ }, { "Name": "12in-150#", - "NominalPipeSize": 12.0, - "OD": 19.0, - "HoleDiameter": 1.0, - "HolePatternDiameter": 17.0, + "PipeSize": "12", + "PipeClearance": 0.0625, + "OD": 19, + "HoleDiameter": 1, + "HolePatternDiameter": 17, "HoleCount": 12 }, { "Name": "12in-300#", - "NominalPipeSize": 12.0, + "PipeSize": "12", + "PipeClearance": 0.0625, "OD": 20.5, "HoleDiameter": 1.25, "HolePatternDiameter": 17.75, @@ -809,7 +910,8 @@ }, { "Name": "12in-400#", - "NominalPipeSize": 12.0, + "PipeSize": "12", + "PipeClearance": 0.0625, "OD": 20.5, "HoleDiameter": 1.38, "HolePatternDiameter": 17.75, @@ -817,23 +919,26 @@ }, { "Name": "12in-600#", - "NominalPipeSize": 12.0, - "OD": 22.0, + "PipeSize": "12", + "PipeClearance": 0.0625, + "OD": 22, "HoleDiameter": 1.38, "HolePatternDiameter": 19.25, "HoleCount": 20 }, { "Name": "12in-900#", - "NominalPipeSize": 12.0, - "OD": 24.0, + "PipeSize": "12", + "PipeClearance": 0.0625, + "OD": 24, "HoleDiameter": 1.5, - "HolePatternDiameter": 21.0, + "HolePatternDiameter": 21, "HoleCount": 20 }, { "Name": "12in-1500#", - "NominalPipeSize": 12.0, + "PipeSize": "12", + "PipeClearance": 0.0625, "OD": 26.5, "HoleDiameter": 2.12, "HolePatternDiameter": 22.5, @@ -841,39 +946,44 @@ }, { "Name": "12in-2500#", - "NominalPipeSize": 12.0, - "OD": 30.0, + "PipeSize": "12", + "PipeClearance": 0.0625, + "OD": 30, "HoleDiameter": 2.88, "HolePatternDiameter": 24.375, "HoleCount": 12 }, { "Name": "14in-150#", - "NominalPipeSize": 14.0, - "OD": 21.0, + "PipeSize": "14", + "PipeClearance": 0.0625, + "OD": 21, "HoleDiameter": 1.12, "HolePatternDiameter": 18.75, "HoleCount": 12 }, { "Name": "14in-300#", - "NominalPipeSize": 14.0, - "OD": 23.0, + "PipeSize": "14", + "PipeClearance": 0.0625, + "OD": 23, "HoleDiameter": 1.25, "HolePatternDiameter": 20.25, "HoleCount": 20 }, { "Name": "14in-400#", - "NominalPipeSize": 14.0, - "OD": 23.0, + "PipeSize": "14", + "PipeClearance": 0.0625, + "OD": 23, "HoleDiameter": 1.38, "HolePatternDiameter": 20.25, "HoleCount": 20 }, { "Name": "14in-600#", - "NominalPipeSize": 14.0, + "PipeSize": "14", + "PipeClearance": 0.0625, "OD": 23.75, "HoleDiameter": 1.5, "HolePatternDiameter": 20.75, @@ -881,23 +991,26 @@ }, { "Name": "14in-900#", - "NominalPipeSize": 14.0, + "PipeSize": "14", + "PipeClearance": 0.0625, "OD": 25.25, "HoleDiameter": 1.62, - "HolePatternDiameter": 22.0, + "HolePatternDiameter": 22, "HoleCount": 20 }, { "Name": "14in-1500#", - "NominalPipeSize": 14.0, + "PipeSize": "14", + "PipeClearance": 0.0625, "OD": 29.5, "HoleDiameter": 2.38, - "HolePatternDiameter": 25.0, + "HolePatternDiameter": 25, "HoleCount": 16 }, { "Name": "16in-150#", - "NominalPipeSize": 16.0, + "PipeSize": "16", + "PipeClearance": 0.0625, "OD": 23.5, "HoleDiameter": 1.12, "HolePatternDiameter": 21.25, @@ -905,7 +1018,8 @@ }, { "Name": "16in-300#", - "NominalPipeSize": 16.0, + "PipeSize": "16", + "PipeClearance": 0.0625, "OD": 25.5, "HoleDiameter": 1.38, "HolePatternDiameter": 22.5, @@ -913,7 +1027,8 @@ }, { "Name": "16in-400#", - "NominalPipeSize": 16.0, + "PipeSize": "16", + "PipeClearance": 0.0625, "OD": 25.5, "HoleDiameter": 1.5, "HolePatternDiameter": 22.5, @@ -921,15 +1036,17 @@ }, { "Name": "16in-600#", - "NominalPipeSize": 16.0, - "OD": 27.0, + "PipeSize": "16", + "PipeClearance": 0.0625, + "OD": 27, "HoleDiameter": 1.62, "HolePatternDiameter": 23.75, "HoleCount": 20 }, { "Name": "16in-900#", - "NominalPipeSize": 16.0, + "PipeSize": "16", + "PipeClearance": 0.0625, "OD": 27.75, "HoleDiameter": 1.75, "HolePatternDiameter": 24.5, @@ -937,7 +1054,8 @@ }, { "Name": "16in-1500#", - "NominalPipeSize": 16.0, + "PipeSize": "16", + "PipeClearance": 0.0625, "OD": 32.5, "HoleDiameter": 2.62, "HolePatternDiameter": 27.75, @@ -945,31 +1063,35 @@ }, { "Name": "18in-150#", - "NominalPipeSize": 18.0, - "OD": 25.0, + "PipeSize": "18", + "PipeClearance": 0.0625, + "OD": 25, "HoleDiameter": 1.25, "HolePatternDiameter": 22.75, "HoleCount": 16 }, { "Name": "18in-300#", - "NominalPipeSize": 18.0, - "OD": 28.0, + "PipeSize": "18", + "PipeClearance": 0.0625, + "OD": 28, "HoleDiameter": 1.38, "HolePatternDiameter": 24.75, "HoleCount": 24 }, { "Name": "18in-400#", - "NominalPipeSize": 18.0, - "OD": 28.0, + "PipeSize": "18", + "PipeClearance": 0.0625, + "OD": 28, "HoleDiameter": 1.5, "HolePatternDiameter": 24.75, "HoleCount": 24 }, { "Name": "18in-600#", - "NominalPipeSize": 18.0, + "PipeSize": "18", + "PipeClearance": 0.0625, "OD": 29.25, "HoleDiameter": 1.75, "HolePatternDiameter": 25.75, @@ -977,55 +1099,62 @@ }, { "Name": "18in-900#", - "NominalPipeSize": 18.0, - "OD": 31.0, - "HoleDiameter": 2.0, - "HolePatternDiameter": 27.0, + "PipeSize": "18", + "PipeClearance": 0.0625, + "OD": 31, + "HoleDiameter": 2, + "HolePatternDiameter": 27, "HoleCount": 20 }, { "Name": "18in-1500#", - "NominalPipeSize": 18.0, - "OD": 36.0, + "PipeSize": "18", + "PipeClearance": 0.0625, + "OD": 36, "HoleDiameter": 2.88, "HolePatternDiameter": 30.5, "HoleCount": 16 }, { "Name": "20in-150#", - "NominalPipeSize": 20.0, + "PipeSize": "20", + "PipeClearance": 0.0625, "OD": 27.5, "HoleDiameter": 1.25, - "HolePatternDiameter": 25.0, + "HolePatternDiameter": 25, "HoleCount": 20 }, { "Name": "20in-300#", - "NominalPipeSize": 20.0, + "PipeSize": "20", + "PipeClearance": 0.0625, "OD": 30.5, "HoleDiameter": 1.38, - "HolePatternDiameter": 27.0, + "HolePatternDiameter": 27, "HoleCount": 24 }, { "Name": "20in-400#", - "NominalPipeSize": 20.0, + "PipeSize": "20", + "PipeClearance": 0.0625, "OD": 30.5, "HoleDiameter": 1.62, - "HolePatternDiameter": 27.0, + "HolePatternDiameter": 27, "HoleCount": 24 }, { "Name": "20in-600#", - "NominalPipeSize": 20.0, - "OD": 32.0, + "PipeSize": "20", + "PipeClearance": 0.0625, + "OD": 32, "HoleDiameter": 1.75, "HolePatternDiameter": 28.5, "HoleCount": 24 }, { "Name": "20in-900#", - "NominalPipeSize": 20.0, + "PipeSize": "20", + "PipeClearance": 0.0625, "OD": 33.75, "HoleDiameter": 2.12, "HolePatternDiameter": 29.5, @@ -1033,7 +1162,8 @@ }, { "Name": "20in-1500#", - "NominalPipeSize": 20.0, + "PipeSize": "20", + "PipeClearance": 0.0625, "OD": 38.75, "HoleDiameter": 3.12, "HolePatternDiameter": 32.75, @@ -1041,50 +1171,56 @@ }, { "Name": "24in-150#", - "NominalPipeSize": 24.0, - "OD": 32.0, + "PipeSize": "24", + "PipeClearance": 0.0625, + "OD": 32, "HoleDiameter": 1.38, "HolePatternDiameter": 29.5, "HoleCount": 20 }, { "Name": "24in-300#", - "NominalPipeSize": 24.0, - "OD": 36.0, + "PipeSize": "24", + "PipeClearance": 0.0625, + "OD": 36, "HoleDiameter": 1.62, - "HolePatternDiameter": 32.0, + "HolePatternDiameter": 32, "HoleCount": 24 }, { "Name": "24in-400#", - "NominalPipeSize": 24.0, - "OD": 36.0, + "PipeSize": "24", + "PipeClearance": 0.0625, + "OD": 36, "HoleDiameter": 1.88, - "HolePatternDiameter": 32.0, + "HolePatternDiameter": 32, "HoleCount": 24 }, { "Name": "24in-600#", - "NominalPipeSize": 24.0, - "OD": 37.0, - "HoleDiameter": 2.0, - "HolePatternDiameter": 33.0, + "PipeSize": "24", + "PipeClearance": 0.0625, + "OD": 37, + "HoleDiameter": 2, + "HolePatternDiameter": 33, "HoleCount": 24 }, { "Name": "24in-900#", - "NominalPipeSize": 24.0, - "OD": 41.0, + "PipeSize": "24", + "PipeClearance": 0.0625, + "OD": 41, "HoleDiameter": 2.62, "HolePatternDiameter": 35.5, "HoleCount": 20 }, { "Name": "24in-1500#", - "NominalPipeSize": 24.0, - "OD": 46.0, + "PipeSize": "24", + "PipeClearance": 0.0625, + "OD": 46, "HoleDiameter": 3.62, - "HolePatternDiameter": 39.0, + "HolePatternDiameter": 39, "HoleCount": 16 } ] \ No newline at end of file diff --git a/OpenNest/Controls/FilterPanel.cs b/OpenNest/Controls/FilterPanel.cs index 9f245ca..5cc07e9 100644 --- a/OpenNest/Controls/FilterPanel.cs +++ b/OpenNest/Controls/FilterPanel.cs @@ -27,6 +27,7 @@ namespace OpenNest.Controls public event EventHandler FilterChanged; public event EventHandler BendLineSelected; public event EventHandler BendLineRemoved; + public event EventHandler BendLineEdited; public event EventHandler AddBendLineClicked; public FilterPanel() @@ -51,6 +52,18 @@ namespace OpenNest.Controls bendLinesList.SelectedIndexChanged += (s, e) => BendLineSelected?.Invoke(this, bendLinesList.SelectedIndex); + var bendEditLink = new LinkLabel + { + Text = "Edit", + AutoSize = true, + Font = new Font("Segoe UI", 8f) + }; + bendEditLink.LinkClicked += (s, e) => + { + if (bendLinesList.SelectedIndex >= 0) + BendLineEdited?.Invoke(this, bendLinesList.SelectedIndex); + }; + var bendDeleteLink = new LinkLabel { Text = "Remove", @@ -63,6 +76,12 @@ namespace OpenNest.Controls BendLineRemoved?.Invoke(this, bendLinesList.SelectedIndex); }; + bendLinesList.DoubleClick += (s, e) => + { + if (bendLinesList.SelectedIndex >= 0) + BendLineEdited?.Invoke(this, bendLinesList.SelectedIndex); + }; + bendAddLink = new LinkLabel { Text = "Add Bend Line", @@ -80,6 +99,7 @@ namespace OpenNest.Controls WrapContents = false }; bendLinksPanel.Controls.Add(bendAddLink); + bendLinksPanel.Controls.Add(bendEditLink); bendLinksPanel.Controls.Add(bendDeleteLink); bendLinesPanel.ContentPanel.Controls.Add(bendLinesList); diff --git a/OpenNest/Controls/ProgramEditorControl.cs b/OpenNest/Controls/ProgramEditorControl.cs index 0941463..0b026aa 100644 --- a/OpenNest/Controls/ProgramEditorControl.cs +++ b/OpenNest/Controls/ProgramEditorControl.cs @@ -209,15 +209,8 @@ namespace OpenNest.Controls private static Entity CloneEntity(Entity entity, Color color) { - Entity clone = entity switch - { - Line line => new Line(line.StartPoint, line.EndPoint) { Layer = line.Layer, IsVisible = line.IsVisible }, - Arc arc => new Arc(arc.Center, arc.Radius, arc.StartAngle, arc.EndAngle, arc.IsReversed) { Layer = arc.Layer, IsVisible = arc.IsVisible }, - Circle circle => new Circle(circle.Center, circle.Radius) { Layer = circle.Layer, IsVisible = circle.IsVisible }, - _ => null, - }; - if (clone != null) - clone.Color = color; + var clone = entity.Clone(); + clone.Color = color; return clone; } diff --git a/OpenNest/Forms/BendLineDialog.cs b/OpenNest/Forms/BendLineDialog.cs index 797ad8a..130119a 100644 --- a/OpenNest/Forms/BendLineDialog.cs +++ b/OpenNest/Forms/BendLineDialog.cs @@ -99,5 +99,17 @@ namespace OpenNest.Forms public double BendAngle => (double)numAngle.Value; public double? BendRadius => chkRadius.Checked ? (double)numRadius.Value : null; + + public void LoadBend(Bend bend) + { + cboDirection.SelectedIndex = bend.Direction == BendDirection.Up ? 1 : 0; + if (bend.Angle.HasValue) + numAngle.Value = (decimal)bend.Angle.Value; + if (bend.Radius.HasValue) + { + chkRadius.Checked = true; + numRadius.Value = (decimal)bend.Radius.Value; + } + } } } diff --git a/OpenNest/Forms/CadConverterForm.cs b/OpenNest/Forms/CadConverterForm.cs index 53fff87..7958bca 100644 --- a/OpenNest/Forms/CadConverterForm.cs +++ b/OpenNest/Forms/CadConverterForm.cs @@ -41,6 +41,7 @@ namespace OpenNest.Forms filterPanel.FilterChanged += OnFilterChanged; filterPanel.BendLineSelected += OnBendLineSelected; filterPanel.BendLineRemoved += OnBendLineRemoved; + filterPanel.BendLineEdited += OnBendLineEdited; filterPanel.AddBendLineClicked += OnAddBendLineClicked; entityView1.LinePicked += OnLinePicked; entityView1.PickCancelled += OnPickCancelled; @@ -292,6 +293,29 @@ namespace OpenNest.Forms entityView1.Invalidate(); } + private void OnBendLineEdited(object sender, int index) + { + var item = CurrentItem; + if (item == null || index < 0 || index >= item.Bends.Count) return; + + var bend = item.Bends[index]; + using var dialog = new BendLineDialog(); + dialog.LoadBend(bend); + + if (dialog.ShowDialog(this) != DialogResult.OK) return; + + bend.Direction = dialog.Direction; + bend.Angle = dialog.BendAngle; + bend.Radius = dialog.BendRadius; + + Bend.UpdateEtchEntities(item.Entities, item.Bends); + entityView1.Entities.Clear(); + entityView1.Entities.AddRange(item.Entities); + entityView1.Bends = item.Bends; + filterPanel.LoadItem(item.Entities, item.Bends); + entityView1.Invalidate(); + } + private void OnQuantityChanged(object sender, EventArgs e) { var item = CurrentItem; diff --git a/OpenNest/Forms/EditNestForm.cs b/OpenNest/Forms/EditNestForm.cs index 845ea22..f26abcc 100644 --- a/OpenNest/Forms/EditNestForm.cs +++ b/OpenNest/Forms/EditNestForm.cs @@ -7,6 +7,7 @@ using OpenNest.Engine.Sequencing; using OpenNest.IO; using OpenNest.Math; using OpenNest.Properties; +using OpenNest.Shapes; using System; using System.ComponentModel; using System.Diagnostics; @@ -453,7 +454,11 @@ namespace OpenNest.Forms public void ResizePlateToFitParts() { - PlateView.Plate.AutoSize(Settings.Default.AutoSizePlateFactor); + var options = new PlateSizeOptions + { + SnapIncrement = Settings.Default.AutoSizePlateFactor, + }; + PlateView.Plate.SnapToStandardSize(options); PlateView.ZoomToPlate(); PlateView.Refresh(); UpdatePlateList(); diff --git a/OpenNest/Forms/ShapeLibraryForm.cs b/OpenNest/Forms/ShapeLibraryForm.cs index 0b98dec..3c9e6bd 100644 --- a/OpenNest/Forms/ShapeLibraryForm.cs +++ b/OpenNest/Forms/ShapeLibraryForm.cs @@ -180,27 +180,66 @@ namespace OpenNest.Forms y += 18; - var tb = new TextBox + Control editor; + if (prop.PropertyType == typeof(bool)) { - Location = new Point(parametersPanel.Padding.Left, y), - Width = panelWidth, - Anchor = AnchorStyles.Top | AnchorStyles.Left | AnchorStyles.Right - }; + var cb = new CheckBox + { + Location = new Point(parametersPanel.Padding.Left, y), + AutoSize = true, + Checked = sourceValues != null && (bool)prop.GetValue(sourceValues) + }; + cb.CheckedChanged += (s, ev) => UpdatePreview(); + editor = cb; + } + else if (prop.PropertyType == typeof(string) && prop.Name == "PipeSize") + { + var combo = new ComboBox + { + Location = new Point(parametersPanel.Padding.Left, y), + Width = panelWidth, + Anchor = AnchorStyles.Top | AnchorStyles.Left | AnchorStyles.Right, + DropDownStyle = ComboBoxStyle.DropDownList + }; - if (sourceValues != null) + // Initial population: every entry; the filter runs on first UpdatePreview. + foreach (var entry in PipeSizes.All) + combo.Items.Add(entry.Label); + + var initial = sourceValues != null ? (string)prop.GetValue(sourceValues) : null; + if (!string.IsNullOrEmpty(initial) && combo.Items.Contains(initial)) + combo.SelectedItem = initial; + else if (combo.Items.Count > 0) + combo.SelectedIndex = 0; + + combo.SelectedIndexChanged += (s, ev) => UpdatePreview(); + editor = combo; + } + else { - if (prop.PropertyType == typeof(int)) - tb.Text = ((int)prop.GetValue(sourceValues)).ToString(); - else - tb.Text = ((double)prop.GetValue(sourceValues)).ToString("G"); + var tb = new TextBox + { + Location = new Point(parametersPanel.Padding.Left, y), + Width = panelWidth, + Anchor = AnchorStyles.Top | AnchorStyles.Left | AnchorStyles.Right + }; + + if (sourceValues != null) + { + if (prop.PropertyType == typeof(int)) + tb.Text = ((int)prop.GetValue(sourceValues)).ToString(); + else + tb.Text = ((double)prop.GetValue(sourceValues)).ToString("G"); + } + + tb.TextChanged += (s, ev) => UpdatePreview(); + editor = tb; } - tb.TextChanged += (s, ev) => UpdatePreview(); - - parameterBindings.Add(new ParameterBinding { Property = prop, Control = tb }); + parameterBindings.Add(new ParameterBinding { Property = prop, Control = editor }); parametersPanel.Controls.Add(label); - parametersPanel.Controls.Add(tb); + parametersPanel.Controls.Add(editor); y += 30; } @@ -212,6 +251,8 @@ namespace OpenNest.Forms { if (suppressPreview || selectedEntry == null) return; + UpdatePipeSizeFilter(); + try { var shape = CreateShapeFromInputs(); @@ -223,9 +264,17 @@ namespace OpenNest.Forms if (drawing?.Program != null) { var bb = drawing.Program.BoundingBox(); - previewBox.SetInfo( - nameTextBox.Text, - string.Format("{0:F3} x {1:F3}", bb.Size.Length, bb.Size.Width)); + var info = string.Format("{0:F3} x {1:F3}", bb.Size.Length, bb.Size.Width); + + if (shape is PipeFlangeShape flange + && !flange.Blind + && !string.IsNullOrEmpty(flange.PipeSize) + && !PipeSizes.TryGetOD(flange.PipeSize, out _)) + { + info += " — Invalid pipe size, no bore cut"; + } + + previewBox.SetInfo(nameTextBox.Text, info); } } catch @@ -234,6 +283,72 @@ namespace OpenNest.Forms } } + private void UpdatePipeSizeFilter() + { + // Find the PipeSize combo and the numeric inputs it depends on. + ComboBox pipeCombo = null; + double holePattern = 0, holeDia = 0, clearance = 0; + bool blind = false; + + foreach (var binding in parameterBindings) + { + var name = binding.Property.Name; + if (name == "PipeSize" && binding.Control is ComboBox cb) + pipeCombo = cb; + else if (name == "HolePatternDiameter" && binding.Control is TextBox tb1) + double.TryParse(tb1.Text, out holePattern); + else if (name == "HoleDiameter" && binding.Control is TextBox tb2) + double.TryParse(tb2.Text, out holeDia); + else if (name == "PipeClearance" && binding.Control is TextBox tb3) + double.TryParse(tb3.Text, out clearance); + else if (name == "Blind" && binding.Control is CheckBox chk) + blind = chk.Checked; + } + + if (pipeCombo == null) + return; + + // Disable when blind, but keep visible with the selection preserved. + pipeCombo.Enabled = !blind; + + // Compute filter: pipeOD + clearance < HolePatternDiameter - HoleDiameter. + var maxPipeOD = holePattern - holeDia - clearance; + var fittingLabels = PipeSizes.GetFittingSizes(maxPipeOD).Select(e => e.Label).ToList(); + + // Sequence-equal on existing items — no-op if unchanged (avoids flicker). + var currentLabels = pipeCombo.Items.Cast().ToList(); + if (currentLabels.SequenceEqual(fittingLabels)) + return; + + var previousSelection = pipeCombo.SelectedItem as string; + + pipeCombo.BeginUpdate(); + try + { + pipeCombo.Items.Clear(); + foreach (var label in fittingLabels) + pipeCombo.Items.Add(label); + + if (fittingLabels.Count == 0) + { + // No pipe fits — leave unselected. + } + else if (previousSelection != null && fittingLabels.Contains(previousSelection)) + { + pipeCombo.SelectedItem = previousSelection; + } + else + { + // Select the largest (last, since PipeSizes.All is sorted ascending). + pipeCombo.SelectedIndex = fittingLabels.Count - 1; + } + } + finally + { + pipeCombo.EndUpdate(); + } + } + private ShapeDefinition CreateShapeFromInputs() { var shape = (ShapeDefinition)Activator.CreateInstance(selectedEntry.ShapeType); @@ -241,6 +356,19 @@ namespace OpenNest.Forms foreach (var binding in parameterBindings) { + if (binding.Property.PropertyType == typeof(bool)) + { + var cb = (CheckBox)binding.Control; + binding.Property.SetValue(shape, cb.Checked); + continue; + } + + if (binding.Control is ComboBox combo) + { + binding.Property.SetValue(shape, combo.SelectedItem?.ToString()); + continue; + } + var tb = (TextBox)binding.Control; if (binding.Property.PropertyType == typeof(int)) diff --git a/README.md b/README.md index 8dae5cf..ebefd90 100644 --- a/README.md +++ b/README.md @@ -2,32 +2,52 @@ A Windows desktop application for CNC nesting — imports DXF drawings, arranges parts on material plates, and exports layouts as DXF or G-code for cutting. -![OpenNest - parts nested on a 36x36 plate](screenshots/screenshot-nest-1.png) +

+ OpenNest - parts nested on a 36x36 plate + OpenNest - 44 parts nested on a 60x120 plate +

OpenNest takes your part drawings, lets you define your sheet (plate) sizes, and arranges the parts to make efficient use of material. The result can be exported as DXF files or post-processed into G-code that your CNC cutting machine understands. ## Features -- **DXF/DWG Import & Export** — Load part drawings from DXF or DWG files and export completed nest layouts as DXF -- **Multiple Fill Strategies** — Grid-based linear fill, interlocking pair fill, rectangle bin packing, extents-based tiling, and more via a pluggable strategy system -- **Best-Fit Pair Nesting** — NFP-based (No Fit Polygon) pair evaluation finds tight-fitting interlocking orientations between parts -- **GPU Acceleration** — Optional ILGPU-based bitmap overlap detection for faster best-fit evaluation -- **Part Rotation** — Automatically tries different rotation angles to find better fits, with optional ML-based angle prediction (ONNX) -- **Gravity Compaction** — After placing parts, pushes them together using polygon-based directional distance to close gaps between irregular shapes -- **Multi-Plate Support** — Work with multiple plates of different sizes and materials in a single nest -- **Sheet Cut-Offs** — Automatically cut the plate to size after nesting, with geometry-aware clearance that avoids placed parts -- **Drawing Splitting** — Split oversized parts into pieces that fit your plate, with straight cuts, weld-gap tabs, or interlocking spike-groove joints -- **BOM Import** — Read bills of materials from Excel spreadsheets to batch-import part lists with quantities -- **Bend Line Detection** — Import bend lines from DXF files with pluggable detectors (SolidWorks flat pattern support built in) -- **Lead-In/Lead-Out & Tabs** — Configurable approach paths, exit paths, and holding tabs for CNC cutting, with snap-to-endpoint/midpoint placement -- **Contour & Program Editing** — Inline G-code editor with contour reordering, direction arrows, and cut direction reversal -- **G-code Output** — Post-process nested layouts to G-code via plugin post-processors -- **User-Defined Variables** — Define named variables in G-code (`diameter = 0.3`) referenced with `$name` syntax; Cincinnati post emits numbered machine variables (`#200`) so operators can adjust values at the control -- **Built-in Shapes** — 12 parametric shapes (circles, rectangles, L-shapes, T-shapes, flanges, etc.) for quick testing or simple parts -- **Interactive Editing** — Zoom, pan, select, clone, push, and manually arrange parts on the plate view -- **Pluggable Engine Architecture** — Swap between built-in nesting engines or load custom engines from plugin DLLs +### Import & Export -![OpenNest - 44 parts nested on a 60x120 plate](screenshots/screenshot-nest-2.png) +| Feature | Description | +|---------|-------------| +| **DXF/DWG Import** | Load part drawings from AutoCAD DXF or DWG files via ACadSharp | +| **DXF Export** | Export completed nest layouts back to DXF for downstream tools | +| **BOM Import** | Batch-import part lists with quantities from Excel spreadsheets | +| **Bend Line Detection** | Import bend lines from DXF via pluggable detectors (SolidWorks flat pattern built in) | +| **Built-in Shapes** | 12 parametric shapes (circles, rectangles, L/T/flange, etc.) for quick parts | + +### Nesting + +| Feature | Description | +|---------|-------------| +| **Pluggable Engines** | Default multi-phase, Vertical Remnant, Horizontal Remnant, plus custom plugin DLLs | +| **Fill Strategies** | Linear grid, interlocking pairs, rectangle best-fit, and extents-based tiling | +| **Best-Fit Pair Nesting** | NFP-based pair evaluation finds tight interlocking orientations between parts | +| **Gravity Compaction** | Polygon-based directional push to close gaps after filling | +| **Part Rotation** | Automatic angle sweep to find better fits across allowed orientations | +| **Multi-Plate Support** | Manage multiple plates of different sizes and materials in one nest | + +### Plate Operations + +| Feature | Description | +|---------|-------------| +| **Sheet Cut-Offs** | Auto-generated trim cuts with geometry-aware clearance around placed parts | +| **Drawing Splitting** | Split oversized parts with straight cuts, weld-gap tabs, or spike-groove joints | +| **Interactive Editing** | Zoom, pan, select, clone, rotate, push, and manually arrange parts | + +### CNC Output + +| Feature | Description | +|---------|-------------| +| **Lead-Ins, Lead-Outs & Tabs** | Configurable approach/exit paths and holding tabs with snap placement | +| **Contour & Program Editing** | Inline G-code editor with contour reordering and cut-direction reversal | +| **User-Defined Variables** | Named G-code variables (`$name`) emitted as machine variables (`#200+`) at post time | +| **Post-Processors** | Plugin-based G-code generation; Cincinnati CL-707/800/900/940/CLX included | ## Prerequisites @@ -61,6 +81,15 @@ Or open `OpenNest.sln` in Visual Studio and run the `OpenNest` project. 5. **Add cut-offs** — Optionally add horizontal/vertical cut-off lines to trim unused plate material 6. **Export** — Save as a `.nest` file, export to DXF, or post-process to G-code +### CAD Converter + +The CAD Converter turns DXF/DWG files into nest-ready drawings. Toggle layers, colors, and linetypes to exclude construction geometry; review detected bend lines; and preview the generated cut program with contour ordering before accepting the drawing into the nest. + +

+ CAD Converter — layer, color, and linetype filtering + CAD Converter — contour list and G-code preview +

+ ## Command-Line Interface OpenNest includes a CLI for batch nesting without the GUI — useful for automation, scripting, and CI pipelines. @@ -172,6 +201,8 @@ Oversized parts that don't fit on a single plate can be split into smaller piece The split system supports fit-to-plate (auto-calculates split lines) and split-by-count modes, with an interactive UI for adjusting split positions and feature parameters. +**Cutout-aware clipping.** Split lines are trimmed against interior cutouts so cut paths never travel through a hole. Lines are Liang-Barsky clipped at region boundaries and arcs/circles are iteratively split at their intersections with the region box, so a cutout that straddles a split correctly contributes material to both sides. When a cutout fully spans the region between two splits, the material breaks into physically disconnected strips — the splitter detects the connected components via endpoint connectivity, nests any remaining holes inside their outer loops by bounding-box and point-in-polygon containment, and emits one drawing per strip. + ## Post-Processors Post-processors convert nested layouts into machine-specific G-code. They are loaded as plugin DLLs from the `Posts/` directory at runtime. @@ -212,16 +243,11 @@ Custom post-processors implement the `IPostProcessor` interface and are auto-dis Nest files (`.nest`) are ZIP archives containing: -- `nest.json` — JSON metadata: nest info, plate defaults, drawings (with bend data), and plates (with parts and cut-offs) -- `programs/program-N` — G-code text for each drawing's cut program (may include variable definitions and `$name` references) -- `bestfits/bestfit-N` — Cached best-fit pair evaluation results (optional) - -## Roadmap - -- **NFP-based auto-nesting** — Simulated annealing optimizer and NFP placement exist in the engine but aren't exposed as a selectable engine yet -- **Geometry simplifier** — Replace consecutive small line segments with fitted arcs to reduce program size and improve nesting performance -- **Shape library UI** — 12 built-in parametric shapes exist in code; needs a browsable library UI for quick access -- **Additional post-processors** — Plugin interface is in place; more machine-specific post-processors planned +- `nest.json` — JSON metadata: nest info (name, customer, units, material, thickness, assist gas, salvage rate), plate defaults, plate options (alternative sizes with cost), drawings (with bend lines, material, source path, rotation constraints), and plates (size, quadrant, grain angle, parts with manual lead-in flags, cut-offs) +- `programs/program-N` — G-code text for drawing N's cut program (may include variable definitions and `$name` references) +- `programs/program-N-subs` — Sub-program definitions for drawing N (M98/G65-callable blocks for repeated features like holes) +- `entities/entities-N` — Original source entities for drawing N (preserved from DXF import with per-entity suppression state for round-trip editing) +- `bestfits/bestfit-N` — Cached best-fit pair evaluation results for drawing N, keyed by plate size and spacing (optional) ## Status diff --git a/screenshots/screenshot-cad-converter-1.png b/screenshots/screenshot-cad-converter-1.png new file mode 100644 index 0000000..c082736 Binary files /dev/null and b/screenshots/screenshot-cad-converter-1.png differ diff --git a/screenshots/screenshot-cad-converter-2.png b/screenshots/screenshot-cad-converter-2.png new file mode 100644 index 0000000..d24aab7 Binary files /dev/null and b/screenshots/screenshot-cad-converter-2.png differ