Skip to content

Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel

Refine sheet metal compilation, comparison, and DFM reporting

Yuechen Lia0495f273c4f
diff --git a/Aetheris.CLI.Tests/SheetMetalCliTests.cs b/Aetheris.CLI.Tests/SheetMetalCliTests.cs
index e9a0a5fa..da4915f0 100644
--- a/Aetheris.CLI.Tests/SheetMetalCliTests.cs
+++ b/Aetheris.CLI.Tests/SheetMetalCliTests.cs
@@ -68,7 +68,7 @@ public sealed class SheetMetalCliTests
var output=new StringWriter();var error=new StringWriter();var recover=CliRunner.Run(["sheetmetal","recover",source,"--out-dir",dir,"--json"],output,error);
Assert.Equal(0,recover);Assert.Empty(error.ToString());Assert.Contains("Ambiguities:",File.ReadAllText(Path.Combine(dir,"reconstruction-brief.md")));Assert.True(File.Exists(Path.Combine(dir,"recovery-summary.json")));
output.GetStringBuilder().Clear();var compare=CliRunner.Run(["sheetmetal","compare",source,intent,"--json"],output,error);Assert.Equal(0,compare);Assert.Empty(error.ToString());
- using var report=JsonDocument.Parse(output.ToString());Assert.Equal("PassWithKnownDifferences",report.RootElement.GetProperty("comparison").GetProperty("status").GetString());Assert.Equal(7,report.RootElement.GetProperty("comparison").GetProperty("bends").GetArrayLength());
+ using var report=JsonDocument.Parse(output.ToString());Assert.True(report.RootElement.GetProperty("success").GetBoolean());Assert.Equal("NeedsReview",report.RootElement.GetProperty("comparison").GetProperty("status").GetString());Assert.Equal(7,report.RootElement.GetProperty("comparison").GetProperty("bends").GetArrayLength());
}
finally{Directory.Delete(dir,true);}
}
diff --git a/Aetheris.CLI/CliRunner.cs b/Aetheris.CLI/CliRunner.cs
index 9517db25..9104edd1 100644
--- a/Aetheris.CLI/CliRunner.cs
+++ b/Aetheris.CLI/CliRunner.cs
@@ -512,10 +512,10 @@ public static class CliRunner
stderr.WriteLine($"Unknown or invalid sheetmetal option '{args[i]}'.");stderr.WriteLine(SheetMetalUsage);return 1;
}
if(!File.Exists(input)){stderr.WriteLine($"Sheet Metal input was not found: {input}");return 1;}
- SheetMetalPartIr? part;SheetThicknessRecognition? thickness=null;TimeSpan importTime=TimeSpan.Zero,recognitionTime=TimeSpan.Zero;IReadOnlyList<SheetMetalDiagnostic> recognitionDiagnostics;
+ SheetMetalPartIr? part;SheetThicknessRecognition? thickness=null;TimeSpan importTime=TimeSpan.Zero,recognitionTime=TimeSpan.Zero;SheetMetalAuthoringTimings? authoredTimings=null;IReadOnlyList<SheetMetalDiagnostic> recognitionDiagnostics;
var source=File.ReadAllText(input);if(SheetMetalFirmament.LooksLikeSheetMetal(source))
{
- var authored=SheetMetalFirmament.Compile(source,input);part=authored.Part;recognitionDiagnostics=authored.Diagnostics;if(!authored.IsSuccess||part is null){WriteFailure(authored.Diagnostics);return 1;}
+ var authored=SheetMetalFirmament.Compile(source,input);part=authored.Part;authoredTimings=authored.Timings;recognitionDiagnostics=authored.Diagnostics;if(!authored.IsSuccess||part is null){WriteFailure(authored.Diagnostics);return 1;}
part=part with{FlatPatternPolicy=new(requestedK??part.FlatPatternPolicy.KFactor)};
}
else
@@ -532,7 +532,7 @@ public static class CliRunner
}
var body=part.FormedBody;var supportFamilies=body?.Topology.Faces.GroupBy(f=>body.TryGetFaceSurfaceGeometry(f.Id,out var s)?s?.Kind.ToString()??"Unknown":"Unknown").OrderBy(g=>g.Key).ToDictionary(g=>g.Key,g=>g.Count());
var pmiIndicators=Regex.Matches(source,"(DRAUGHTING_MODEL|GEOMETRIC_TOLERANCE|DATUM_FEATURE|ANNOTATION_OCCURRENCE|SHAPE_ASPECT)",RegexOptions.IgnoreCase).Count;
- var report=new{command=$"sheetmetal {operation}",success=true,input,sourceAuthority=SheetMetalFirmament.LooksLikeSheetMetal(source)?(source.Contains("Intent: Reconstructed",StringComparison.OrdinalIgnoreCase)?"Firmament reconstructed engineering authority":source.Contains("RecoveredRegion",StringComparison.Ordinal)?"Firmament recovered sheet-metal semantics":"Firmament authored semantics"):"STEP formed BRep (not mutated)",recognitionStatus=part.RecognitionStatus,thickness=new{nominal=part.Thickness,tolerance=thickness?.Tolerance,evidencePairs=thickness?.SourcePairs.Count(p=>p.Admitted)??0,outlierFaces=thickness?.OutlierFaceIds.Count??0},geometry=new{bodies=body?.Topology.Bodies.Count()??0,shells=body?.Topology.Shells.Count()??0,faces=body?.Topology.Faces.Count()??0,edges=body?.Topology.Edges.Count()??0,vertices=body?.Topology.Vertices.Count()??0,supportFamilies,pmiIndicators},sheetMetal=new{baseRegion=part.BaseRegionId,regions=part.Regions.Select(r=>new{r.StableId,r.Kind,r.ApproximateArea,sourceFaces=r.Source.FaceIds}),bends=part.Bends.Select(b=>new{b.StableId,b.AxisOrigin,b.AxisDirection,angleDegrees=b.BendAngleRadians*180/Math.PI,b.InsideRadius,b.Direction,b.AdjacentRegionA,b.AdjacentRegionB,sourceFaces=b.Source.FaceIds}),cuts=part.Features.Select(f=>new{f.StableId,f.Kind,f.OwningRegionId,f.Diameter,sourceFaces=f.Source.FaceIds})},flatPattern=new{flat.Status,flat.Bounds,bendLines=flat.BendLines.Count,cuts=flat.CutLoops.Count,kFactor=flat.Policy.KFactor,flat.DeterministicHash,svg=output,step=flatStepOutput,firmament=firmamentOutput},dfm=new{dfm.Overall,findings=dfm.Findings},diagnostics=recognitionDiagnostics.Concat(flat.Diagnostics),timingsMilliseconds=new{import=importTime.TotalMilliseconds,recognition=recognitionTime.TotalMilliseconds,flatten=flattenClock.Elapsed.TotalMilliseconds}};
+ var report=new{command=$"sheetmetal {operation}",success=true,input,sourceAuthority=SheetMetalFirmament.LooksLikeSheetMetal(source)?(source.Contains("Intent: Reconstructed",StringComparison.OrdinalIgnoreCase)?"Firmament reconstructed engineering authority":source.Contains("RecoveredRegion",StringComparison.Ordinal)?"Firmament recovered sheet-metal semantics":"Firmament authored semantics"):"STEP formed BRep (not mutated)",recognitionStatus=part.RecognitionStatus,thickness=new{nominal=part.Thickness,tolerance=thickness?.Tolerance,evidencePairs=thickness?.SourcePairs.Count(p=>p.Admitted)??0,outlierFaces=thickness?.OutlierFaceIds.Count??0},geometry=new{bodies=body?.Topology.Bodies.Count()??0,shells=body?.Topology.Shells.Count()??0,faces=body?.Topology.Faces.Count()??0,edges=body?.Topology.Edges.Count()??0,vertices=body?.Topology.Vertices.Count()??0,supportFamilies,pmiIndicators},sheetMetal=new{baseRegion=part.BaseRegionId,regions=part.Regions.Select(r=>new{r.StableId,r.Kind,r.ApproximateArea,sourceFaces=r.Source.FaceIds}),bends=part.Bends.Select(b=>new{b.StableId,b.AxisOrigin,b.AxisDirection,angleDegrees=b.BendAngleRadians*180/Math.PI,b.InsideRadius,b.Direction,b.AdjacentRegionA,b.AdjacentRegionB,sourceFaces=b.Source.FaceIds}),cuts=part.Features.Select(f=>new{f.StableId,f.Kind,f.OwningRegionId,f.Diameter,sourceFaces=f.Source.FaceIds})},flatPattern=new{flat.Status,flat.Bounds,bendLines=flat.BendLines.Count,cuts=flat.CutLoops.Count,kFactor=flat.Policy.KFactor,flat.DeterministicHash,svg=output,step=flatStepOutput,firmament=firmamentOutput},dfm=new{dfm.Overall,findings=dfm.Findings},diagnostics=recognitionDiagnostics.Concat(flat.Diagnostics),timingsMilliseconds=new{parse=authoredTimings?.ParseMilliseconds,formedLower=authoredTimings?.FormedLowerMilliseconds,authoredFlatLower=authoredTimings?.FlatLowerMilliseconds,import=importTime.TotalMilliseconds,recognition=recognitionTime.TotalMilliseconds,flatten=flattenClock.Elapsed.TotalMilliseconds}};
if(json)stdout.WriteLine(JsonSerializer.Serialize(report,JsonOptions));else
{
stdout.WriteLine($"Sheet Metal: {part.RecognitionStatus} ({report.sourceAuthority})");stdout.WriteLine($"Thickness: {part.Thickness:G8} mm{(thickness is null?" authored/recovered":$" ± {thickness.Tolerance:G4} mm, {thickness.SourcePairs.Count(p=>p.Admitted)} paired supports")}");stdout.WriteLine($"Regions: {part.Regions.Count} ({part.Regions.Count(r=>r.Kind==SheetRegionKind.Planar)} planar, {part.Regions.Count(r=>r.Kind==SheetRegionKind.CylindricalBend)} cylindrical)");stdout.WriteLine($"Bends: {part.Bends.Count}; cuts: {part.Features.Count}; base: {part.BaseRegionId}");foreach(var bend in part.Bends)stdout.WriteLine($" {bend.StableId}: {bend.BendAngleRadians*180/Math.PI:G5} deg, R{bend.InsideRadius:G6}, {bend.Direction}, {bend.AdjacentRegionA} -> {bend.AdjacentRegionB}");stdout.WriteLine($"Flat pattern: {flat.Status}; {(flat.Bounds is null?"no bounds":$"{flat.Bounds.Width:G8} x {flat.Bounds.Height:G8} mm")}; K={flat.Policy.KFactor:G4}; hash={flat.DeterministicHash}");if(flatStepOutput is not null)stdout.WriteLine($"STEP: {flatStepOutput}");if(firmamentOutput is not null)stdout.WriteLine($"Firmament: {firmamentOutput}");if(output is not null)stdout.WriteLine($"SVG: {output}");foreach(var d in recognitionDiagnostics.Concat(flat.Diagnostics))stdout.WriteLine($" [{d.Severity}] {d.Code}: {d.Message}");
@@ -560,7 +560,7 @@ public static class CliRunner
if(!File.Exists(sourcePath)||!File.Exists(intentPath)){stderr.WriteLine("Sheet Metal compare input was not found.");return 1;}
SheetMetalPartIr? Load(string path){var text=File.ReadAllText(path);return SheetMetalFirmament.LooksLikeSheetMetal(text)?SheetMetalFirmament.Compile(text,path).Part:SheetMetalRecognizer.RecognizeStep(path).Part;}
var source=Load(sourcePath);var intent=Load(intentPath);if(source is null||intent is null){stderr.WriteLine("Sheet Metal compare could not compile/recover both inputs.");return 2;}var comparison=SheetMetalIntentComparer.Compare(source,intent);
- if(json)stdout.WriteLine(JsonSerializer.Serialize(new{command="sheetmetal compare",success=comparison.Status is SheetMetalComparisonStatus.Pass or SheetMetalComparisonStatus.PassWithKnownDifferences,source=sourcePath,intent=intentPath,comparison},JsonOptions));
+ if(json)stdout.WriteLine(JsonSerializer.Serialize(new{command="sheetmetal compare",success=comparison.Status is SheetMetalComparisonStatus.Pass or SheetMetalComparisonStatus.PassWithKnownDifferences or SheetMetalComparisonStatus.NeedsReview,source=sourcePath,intent=intentPath,comparison},JsonOptions));
else{stdout.WriteLine($"Sheet Metal intent comparison: {comparison.Status}");stdout.WriteLine($"Thickness residual: {comparison.ThicknessResidual:G6} mm");stdout.WriteLine($"Formed source->intent RMS/p95/max: {comparison.SourceToIntent.Rms:G6}/{comparison.SourceToIntent.P95:G6}/{comparison.SourceToIntent.Maximum:G6} mm");stdout.WriteLine($"Formed intent->source RMS/p95/max: {comparison.IntentToSource.Rms:G6}/{comparison.IntentToSource.P95:G6}/{comparison.IntentToSource.Maximum:G6} mm");foreach(var b in comparison.Bends)stdout.WriteLine($" {b.SourceBendId} -> {b.IntentBendId}: axis {b.AxisResidual:G6} mm, axis-angle {b.AxisAngleResidualDegrees:G6} deg, bend-angle {b.BendAngleResidualDegrees:G6} deg, radius {b.RadiusResidual:G6} mm, adjacency {b.AdjacencyMatches}, {b.Status}");stdout.WriteLine($"Flat: {comparison.FlatPattern.Status}; width Δ {comparison.FlatPattern.WidthResidual:G6}, height Δ {comparison.FlatPattern.HeightResidual:G6}, contour p95 {comparison.FlatPattern.Contour.P95:G6} mm");}
return comparison.Status==SheetMetalComparisonStatus.Fail?2:0;
}
diff --git a/Aetheris.SheetMetal.Tests/SheetMetalM2Tests.cs b/Aetheris.SheetMetal.Tests/SheetMetalM2Tests.cs
index 5eaa1486..f6d09569 100644
--- a/Aetheris.SheetMetal.Tests/SheetMetalM2Tests.cs
+++ b/Aetheris.SheetMetal.Tests/SheetMetalM2Tests.cs
@@ -24,13 +24,13 @@ public sealed class SheetMetalM2Tests
}
[Fact]
- public void IdiomaticCtc_CompilesAndPassesWithAcceptedNominalDifference()
+ public void IdiomaticCtc_CompilesIndependentlyAndLocalizesHistoricalTrimDifferences()
{
var source=SheetMetalRecognizer.RecognizeStep(Ctc).Part!;var authored=SheetMetalFirmament.CompileFile(Intent);
Assert.True(authored.IsSuccess,string.Join('\n',authored.Diagnostics.Select(d=>d.Message)));Assert.Equal("MainDeck",authored.Part!.BaseRegionId);
Assert.Contains(authored.Part.Bends,b=>b.StableId=="FrontWallBend");Assert.Contains(authored.Part.Features,f=>f.StableId=="VentSlotLeft");
var comparison=SheetMetalIntentComparer.Compare(source,authored.Part);
- Assert.Equal(SheetMetalComparisonStatus.PassWithKnownDifferences,comparison.Status);Assert.Equal(0,comparison.SourceToIntent.Maximum);Assert.All(comparison.Bends,b=>Assert.Equal(SheetMetalComparisonStatus.Pass,b.Status));Assert.Equal(SheetMetalComparisonStatus.Pass,comparison.FlatPattern.Status);
+ Assert.Equal(SheetMetalComparisonStatus.NeedsReview,comparison.Status);Assert.True(comparison.SourceToIntent.Maximum>0);Assert.All(comparison.Bends,b=>Assert.Equal(SheetMetalComparisonStatus.Pass,b.Status));Assert.All(comparison.Features,f=>Assert.Equal(SheetMetalComparisonStatus.Pass,f.Status));Assert.Equal(SheetMetalComparisonStatus.Fail,comparison.FlatPattern.Status);
}
[Fact]
diff --git a/Aetheris.SheetMetal.Tests/SheetMetalM3Tests.cs b/Aetheris.SheetMetal.Tests/SheetMetalM3Tests.cs
new file mode 100644
index 00000000..b3f3bacb
--- /dev/null
+++ b/Aetheris.SheetMetal.Tests/SheetMetalM3Tests.cs
@@ -0,0 +1,97 @@
+using Aetheris.Kernel.Core.Brep;
+using Aetheris.Kernel.Core.Step242;
+using Xunit;
+
+namespace Aetheris.SheetMetal.Tests;
+
+public sealed class SheetMetalM3Tests
+{
+ private static readonly string RepoRoot=FindRepoRoot();
+
+ [Theory]
+ [InlineData("m3-l-bracket.firmament",1,0,0)]
+ [InlineData("m3-u-channel.firmament",2,0,0)]
+ [InlineData("m3-electronics-tray.firmament",4,4,4)]
+ public void AuthoredFixtures_IndependentlyProduceManifoldFormedAndStitchedFlatArtifacts(string file,int bends,int cuts,int corners)
+ {
+ var result=SheetMetalFirmament.CompileFile(Path.Combine(RepoRoot,"fixtures/FirmamentV2/SheetMetal",file));
+ Assert.True(result.IsSuccess,string.Join('\n',result.Diagnostics.Select(d=>d.Message)));var part=result.Part!;var flat=result.FlatPattern!;
+ Assert.NotNull(part.FormedBody);Assert.Equal(bends,part.Bends.Count);Assert.Equal(cuts,part.Features.Count);Assert.Equal(corners,part.Corners?.Count??0);
+ Assert.True((part.Correspondence?.Count??0)>=1+bends*2+cuts+corners);
+ Assert.All(part.Regions,r=>{Assert.Empty(r.Source.FaceIds);Assert.Equal("sole construction authority",r.Source.SourceAuthority);});
+ Assert.Equal(FlatPatternStatus.Valid,flat.Status);Assert.Equal(bends,flat.BendLines.Count);Assert.Equal(cuts,flat.CutLoops.Count);Assert.True(flat.Boundary.Count>=4);
+ Assert.True(BrepExportPreflight.Validate(part.FormedBody!).IsValid);var formed=Step242Exporter.ExportBody(part.FormedBody!);Assert.True(formed.IsSuccess);Assert.True(Step242Importer.ImportBody(formed.Value).IsSuccess);
+ var flatBody=SheetMetalManufacturingArtifacts.BuildFlatBody(part,flat);Assert.True(flatBody.IsSuccess,string.Join('\n',flatBody.Diagnostics.Select(d=>d.Message)));var flatStep=Step242Exporter.ExportBody(flatBody.Body!);Assert.True(flatStep.IsSuccess);Assert.True(Step242Importer.ImportBody(flatStep.Value).IsSuccess);
+ var refold=SheetMetalRoundTrip.ValidateReferenceSurface(part,flat);Assert.True(refold.IsWithinTolerance,string.Join('\n',refold.Diagnostics.Select(d=>d.Message)));
+ Assert.Equal(flat.DeterministicHash,SheetMetalFlattener.Flatten(part).DeterministicHash);
+ }
+
+ [Theory]
+ [InlineData("",SheetCornerPolicy.Open,null)]
+ [InlineData("Corner: Miter;",SheetCornerPolicy.Mitered,null)]
+ [InlineData("Relief: Rectangular;",SheetCornerPolicy.Relief,SheetReliefKind.Rectangular)]
+ [InlineData("Relief: Round;",SheetCornerPolicy.Relief,SheetReliefKind.Round)]
+ public void AdjacentCornerPolicies_AreTypedAndLowered(string policy,SheetCornerPolicy expected,SheetReliefKind? reliefKind)
+ {
+ var source=$$"""
+ SheetMetal CornerCase { Thickness: 1mm; Base Main { Profile: Rectangle { Width: 40mm; Height: 30mm; }; }
+ Flange A { From: Main.Front; Length: 10mm; Angle: 90deg; Radius: 1mm; {{policy}} }
+ Flange B { From: Main.Right; Length: 10mm; Angle: 90deg; Radius: 1mm; {{policy}} }
+ }
+ """;
+ var result=SheetMetalFirmament.Compile(source);Assert.True(result.IsSuccess,string.Join('\n',result.Diagnostics.Select(d=>d.Message)));var corner=Assert.Single(result.Part!.Corners!);Assert.Equal(expected,corner.Policy);
+ if(reliefKind is null)Assert.Empty(result.Part.Reliefs!);else Assert.Equal(reliefKind,Assert.Single(result.Part.Reliefs!).Kind);
+ Assert.True(BrepExportPreflight.Validate(result.Part.FormedBody!).IsValid);Assert.Equal(FlatPatternStatus.Valid,result.FlatPattern!.Status);
+ }
+
+ [Fact]
+ public void BendDirectionAndAngle_AreGeneralAndDeterministic()
+ {
+ static string Source(string direction,double angle)=>$$"""
+ SheetMetal BendCase { Thickness: 1mm; KFactor: 0.4; Base Main { Profile: Rectangle { Width: 30mm; Height: 20mm; }; }
+ Flange Wall { From: Main.Right; Length: 12mm; Angle: {{angle}}deg; Radius: 1mm; Direction: {{direction}}; }
+ }
+ """;
+ var up=SheetMetalFirmament.Compile(Source("Up",90));var down=SheetMetalFirmament.Compile(Source("Down",90));var angled=SheetMetalFirmament.Compile(Source("Up",45));
+ Assert.True(up.IsSuccess);Assert.True(down.IsSuccess);Assert.True(angled.IsSuccess);
+ var upZ=up.Part!.Regions.Single(r=>r.StableId=="Wall").Boundary3D.Average(p=>p.Z);var downZ=down.Part!.Regions.Single(r=>r.StableId=="Wall").Boundary3D.Average(p=>p.Z);
+ Assert.True(upZ>0);Assert.True(downZ<0);Assert.Equal(45,angled.Part!.Bends.Single().BendAngleRadians*180/Math.PI,9);
+ Assert.NotEqual(up.FlatPattern!.DeterministicHash,down.FlatPattern!.DeterministicHash);
+ }
+
+ [Fact]
+ public void GraphAndCutFailures_AreTyped()
+ {
+ var duplicate="""
+ SheetMetal Bad { Thickness: 1mm; Base Main { Profile: Rectangle { Width: 30mm; Height: 20mm; }; }
+ Flange A { From: Main.Left; Length: 8mm; Angle: 90deg; Radius: 1mm; }
+ Flange B { From: Main.Left; Length: 8mm; Angle: 90deg; Radius: 1mm; }
+ }
+ """;
+ var crossing="""
+ SheetMetal BadCut { Thickness: 1mm; Base Main { Profile: Rectangle { Width: 30mm; Height: 20mm; }; }
+ Flange A { From: Main.Left; Length: 8mm; Angle: 90deg; Radius: 1mm; }
+ Hole H { On: Main; Center: (1mm, 10mm); Diameter: 4mm; }
+ }
+ """;
+ var a=SheetMetalFirmament.Compile(duplicate);Assert.False(a.IsSuccess);Assert.Contains(a.Diagnostics,d=>d.Code==SheetMetalDiagnosticCodes.DuplicateFlange);
+ var b=SheetMetalFirmament.Compile(crossing);Assert.False(b.IsSuccess);Assert.Contains(b.Diagnostics,d=>d.Code==SheetMetalDiagnosticCodes.CutCrossesBend);
+ }
+
+ [Fact]
+ public void Ctc03_ReconstructionCompilesWithNoEvidenceProviderOrSourceStep()
+ {
+ var path=Path.Combine(RepoRoot,"docs/modules/sheetmetal/artifacts/m2/ctc03-idiomatic.firmament");var source=File.ReadAllText(path);
+ Assert.DoesNotContain("EvidenceSource",source);Assert.DoesNotContain("FromEvidence",source);
+ var isolatedPath=Path.Combine(Path.GetTempPath(),$"ctc03-{Guid.NewGuid():N}.firmament");
+ try
+ {
+ File.WriteAllText(isolatedPath,source);var result=SheetMetalFirmament.CompileFile(isolatedPath);
+ Assert.True(result.IsSuccess,string.Join('\n',result.Diagnostics.Select(d=>d.Message)));Assert.NotNull(result.Part!.FormedBody);Assert.Equal(7,result.Part.Bends.Count);Assert.Equal(2,result.Part.Features.Count);Assert.Equal(FlatPatternStatus.Valid,result.FlatPattern!.Status);
+ Assert.Contains("source-independent",result.Part.Provenance,StringComparison.OrdinalIgnoreCase);Assert.Equal(15,result.Part.Regions.Count);
+ }
+ finally{if(File.Exists(isolatedPath))File.Delete(isolatedPath);}
+ }
+
+ private static string FindRepoRoot(){var dir=new DirectoryInfo(AppContext.BaseDirectory);while(dir is not null&&!File.Exists(Path.Combine(dir.FullName,"Aetheris.slnx")))dir=dir.Parent;return dir?.FullName??throw new InvalidOperationException("Repo root not found.");}
+}
diff --git a/Aetheris.SheetMetal/SheetMetalAuthoredLowering.cs b/Aetheris.SheetMetal/SheetMetalAuthoredLowering.cs
new file mode 100644
index 00000000..c0243c7d
--- /dev/null
+++ b/Aetheris.SheetMetal/SheetMetalAuthoredLowering.cs
@@ -0,0 +1,449 @@
+using System.Globalization;
+using System.Diagnostics;
+using System.Text.RegularExpressions;
+using Aetheris.Kernel.Core.Brep;
+using Aetheris.Kernel.Core.Geometry;
+using Aetheris.Kernel.Core.Geometry.Curves;
+using Aetheris.Kernel.Core.Geometry.Surfaces;
+using Aetheris.Kernel.Core.Math;
+using Aetheris.Kernel.Core.Results;
+using Aetheris.Kernel.Core.Topology;
+using Aetheris.Surfacing;
+
+namespace Aetheris.SheetMetal;
+
+public sealed record AuthoredSheetBaseSpec(string Name, double Width, double Depth)
+{
+ /// <summary>Physical lower-skin origin of the rectangular base in authored coordinates.</summary>
+ public Point3D Origin { get; init; } = Point3D.Origin;
+}
+public sealed record AuthoredSheetFlangeSpec(
+ string Name, string ParentRegion, string EdgeName, double Length, double AngleRadians,
+ double InsideRadius, SheetBendDirection Direction, SheetCornerPolicy CornerPolicy,
+ SheetReliefPolicy ReliefPolicy, double? ReliefWidth = null, double? ReliefDepth = null);
+public sealed record AuthoredSheetCutSpec(
+ string Name, string RegionName, SheetFeatureKind Kind, double X, double Y,
+ double? Diameter, double? Width, double? Length);
+public sealed record SheetMetalConstructionSpec(
+ string Name, double Thickness, string? Material, double KFactor, AuthoredSheetBaseSpec Base,
+ IReadOnlyList<AuthoredSheetFlangeSpec> Flanges, IReadOnlyList<AuthoredSheetCutSpec> Cuts,
+ SheetMetalProvenanceCategory Authority, bool LegacySyntax = false);
+
+/// <summary>
+/// Bounded high-level authored Sheet Metal compiler. It deliberately consumes only
+/// Firmament declarations; imported/recovered geometry is not accepted by this path.
+/// </summary>
+internal static class AuthoredSheetMetalCompiler
+{
+ private const RegexOptions Rx = RegexOptions.IgnoreCase | RegexOptions.CultureInvariant | RegexOptions.Singleline;
+ private const string Number = @"[+-]?(?:[0-9]+(?:\.[0-9]*)?|\.[0-9]+)";
+
+ public static SheetMetalAuthoringResult Compile(string source, string sourcePath)
+ {
+ var parseStarted=Stopwatch.GetTimestamp();
+ var diagnostics = new List<SheetMetalDiagnostic>();
+ var header = Regex.Match(source, @"\bSheetMetal\s+(?<name>[A-Za-z_][A-Za-z0-9_]*)\s*\{", Rx);
+ if (!header.Success) return Fail("Expected `SheetMetal <Name> { ... }`.");
+ if (!Scalar(source, "Thickness", "mm", out var thickness) || thickness <= 0)
+ return Fail("Thickness must be a positive millimetre value.");
+ var material = Quoted(source, "Material");
+ var k = Scalar(source, "KFactor", null, out var parsedK) ? parsedK : SheetMetalFlattenPolicy.Default.KFactor;
+ if (k is < 0 or > 1) return Fail("KFactor must be between zero and one.");
+
+ AuthoredSheetBaseSpec? baseSpec = null;
+ var legacyBase = Regex.Match(source, $@"\bBase\s*:\s*Rectangle\s*\(\s*(?<w>{Number})\s*mm\s*,\s*(?<d>{Number})\s*mm\s*\)\s*;", Rx);
+ if (legacyBase.Success) baseSpec = new("Base", Num(legacyBase, "w"), Num(legacyBase, "d"));
+ else
+ {
+ var named = Blocks(source, "Base").SingleOrDefault();
+ if (named is not null && Scalar(named.Body, "Width", "mm", out var width) &&
+ (Scalar(named.Body, "Height", "mm", out var depth) || Scalar(named.Body, "Depth", "mm", out depth)))
+ baseSpec = new AuthoredSheetBaseSpec(named.Name, width, depth) { Origin = Point3(named.Body, "Origin") ?? Point3D.Origin };
+ }
+ if (baseSpec is null || baseSpec.Width <= 0 || baseSpec.Depth <= 0)
+ return Fail("A positive rectangular base is required (`Base: Rectangle(w, d)` or named `Base <Name> { Profile: Rectangle { Width; Height; } }`).");
+
+ var flanges = new List<AuthoredSheetFlangeSpec>();
+ foreach (var block in Blocks(source, "Flange"))
+ {
+ var from = Regex.Match(block.Body, @"\bFrom\s*:\s*(?<region>[A-Za-z_][A-Za-z0-9_]*)\.(?<edge>Left|Right|Front|Rear|Outer|Top)\s*;", Rx);
+ var hasLength = Scalar(block.Body, "Length", "mm", out var length) || Scalar(block.Body, "Height", "mm", out length);
+ var hasRadius = Scalar(block.Body, "InsideRadius", "mm", out var radius) || Scalar(block.Body, "Radius", "mm", out radius);
+ if (!from.Success || !hasLength || !Scalar(block.Body, "Angle", "deg", out var degrees) || !hasRadius)
+ return Fail($"Flange '{block.Name}' requires From, Length/Height, Angle, and InsideRadius/Radius.");
+ var direction = Token(block.Body, "Direction")?.Equals("Down", StringComparison.OrdinalIgnoreCase) == true ? SheetBendDirection.Down : SheetBendDirection.Up;
+ var corner = Token(block.Body, "Corner")?.ToLowerInvariant() switch
+ {
+ "miter" or "mitered" => SheetCornerPolicy.Mitered,
+ "relief" => SheetCornerPolicy.Relief,
+ _ => SheetCornerPolicy.Open
+ };
+ var reliefToken = Token(block.Body, "Relief")?.ToLowerInvariant();
+ var relief = reliefToken switch { "auto" => SheetReliefPolicy.Auto, "rectangular" or "rectangle" => SheetReliefPolicy.Rectangular, "round" => SheetReliefPolicy.Round, _ => SheetReliefPolicy.None };
+ Scalar(block.Body, "ReliefWidth", "mm", out var reliefWidth);
+ Scalar(block.Body, "ReliefDepth", "mm", out var reliefDepth);
+ if (length <= radius + thickness || radius < 0 || degrees is <= 0 or >= 180)
+ return Fail($"Flange '{block.Name}' has an invalid length, radius, or bend angle.");
+ flanges.Add(new(block.Name, from.Groups["region"].Value, NormalizeEdge(from.Groups["edge"].Value), length,
+ degrees * Math.PI / 180d, radius, direction, corner, relief,
+ reliefWidth > 0 ? reliefWidth : null, reliefDepth > 0 ? reliefDepth : null));
+ }
+ if (flanges.Count == 0) return Fail("At least one Flange is required.");
+ var duplicate = flanges.GroupBy(f => (f.ParentRegion.ToLowerInvariant(), f.EdgeName.ToLowerInvariant())).FirstOrDefault(g => g.Count() > 1);
+ if (duplicate is not null)
+ return Fail($"Multiple flanges target {duplicate.First().ParentRegion}.{duplicate.First().EdgeName}.", SheetMetalDiagnosticCodes.DuplicateFlange);
+ if (flanges.Select(f => f.Name).Append(baseSpec.Name).Distinct(StringComparer.OrdinalIgnoreCase).Count() != flanges.Count + 1)
+ return Fail("Base and flange names must be unique.", SheetMetalDiagnosticCodes.ImpossibleTopology);
+
+ var cuts = new List<AuthoredSheetCutSpec>();
+ foreach (var block in Blocks(source, "Hole"))
+ {
+ var on = Token(block.Body, "On");
+ var at = Point(block.Body, "Center");
+ if (on is null || at is null || !Scalar(block.Body, "Diameter", "mm", out var diameter) || diameter <= 0)
+ return Fail($"Hole '{block.Name}' requires On, Center, and positive Diameter.");
+ cuts.Add(new(block.Name, on, SheetFeatureKind.CircularHole, at.Value.X, at.Value.Y, diameter, null, null));
+ }
+ foreach (var block in Blocks(source, "Cut"))
+ {
+ var on = Token(block.Body, "On");
+ var at = Point(block.Body, "At") ?? Point(block.Body, "Center");
+ var circle = Regex.IsMatch(block.Body, @"\bProfile\s*:\s*Circle\b", Rx);
+ var slot = Regex.IsMatch(block.Body, @"\bProfile\s*:\s*(?:Slot|Rectangle)\b", Rx);
+ if (on is null || at is null || (!circle && !slot)) return Fail($"Cut '{block.Name}' requires On, At, and a Circle/Slot/Rectangle profile.");
+ if (circle)
+ {
+ if (!Scalar(block.Body, "Diameter", "mm", out var diameter) || diameter <= 0) return Fail($"Cut '{block.Name}' requires positive Diameter.");
+ cuts.Add(new(block.Name, on, SheetFeatureKind.CircularHole, at.Value.X, at.Value.Y, diameter, null, null));
+ }
+ else
+ {
+ if (!Scalar(block.Body, "Width", "mm", out var cutWidth) || !Scalar(block.Body, "Length", "mm", out var cutLength) || cutWidth <= 0 || cutLength <= 0)
+ return Fail($"Cut '{block.Name}' requires positive Width and Length.");
+ cuts.Add(new(block.Name, on, SheetFeatureKind.Slot, at.Value.X, at.Value.Y, null, cutWidth, cutLength));
+ }
+ }
+
+ var authority = Regex.IsMatch(source, @"\bIntent\s*:\s*Reconstructed\s*;", Rx)
+ ? SheetMetalProvenanceCategory.Reconstructed : SheetMetalProvenanceCategory.Authored;
+ var spec = new SheetMetalConstructionSpec(header.Groups["name"].Value, thickness, material, k, baseSpec, flanges, cuts, authority, legacyBase.Success);
+ var parseMs=Stopwatch.GetElapsedTime(parseStarted).TotalMilliseconds;var formedStarted=Stopwatch.GetTimestamp();var lowered = AuthoredSheetMetalLowering.Lower(spec, sourcePath);var formedMs=Stopwatch.GetElapsedTime(formedStarted).TotalMilliseconds;
+ if (!lowered.IsSuccess || lowered.Part is null) return new(false, spec, null, null, lowered.Diagnostics);
+ var flatStarted=Stopwatch.GetTimestamp();var flat = SheetMetalFlattener.Flatten(lowered.Part);var flatMs=Stopwatch.GetElapsedTime(flatStarted).TotalMilliseconds;
+ diagnostics.AddRange(lowered.Diagnostics); diagnostics.AddRange(flat.Diagnostics);
+ return new(flat.Status is not FlatPatternStatus.Unsupported and not FlatPatternStatus.Overlapping, spec, lowered.Part, flat, diagnostics,new(parseMs,formedMs,flatMs));
+
+ SheetMetalAuthoringResult Fail(string message, string code = "sheetmetal-firmament-invalid") =>
+ new(false, null, null, null, [new(code, SheetMetalDiagnosticSeverity.Error, message)]);
+ }
+
+ private sealed record Block(string Name, string Body);
+ private static IReadOnlyList<Block> Blocks(string source, string keyword)
+ {
+ var result = new List<Block>();
+ var matches = Regex.Matches(source, $@"\b{Regex.Escape(keyword)}\s+(?<name>[A-Za-z_][A-Za-z0-9_]*)\s*\{{", Rx);
+ foreach (Match match in matches)
+ {
+ var open = source.IndexOf('{', match.Index); var depth = 0; var close = -1;
+ for (var i = open; i < source.Length; i++) { if (source[i] == '{') depth++; else if (source[i] == '}' && --depth == 0) { close = i; break; } }
+ if (close > open) result.Add(new(match.Groups["name"].Value, source[(open + 1)..close]));
+ }
+ return result;
+ }
+ private static bool Scalar(string text, string name, string? unit, out double value)
+ {
+ var suffix = unit is null ? "" : @"\s*" + Regex.Escape(unit);
+ var m = Regex.Match(text, $@"\b{Regex.Escape(name)}\s*:\s*(?<v>{Number}){suffix}\s*;", Rx);
+ value = m.Success ? Num(m, "v") : 0; return m.Success;
+ }
+ private static (double X, double Y)? Point(string text, string name)
+ {
+ var m = Regex.Match(text, $@"\b{Regex.Escape(name)}\s*:\s*\(\s*(?<x>{Number})\s*mm\s*,\s*(?<y>{Number})\s*mm\s*\)\s*;", Rx);
+ return m.Success ? (Num(m, "x"), Num(m, "y")) : null;
+ }
+ private static Point3D? Point3(string text,string name)
+ {
+ var m=Regex.Match(text,$@"\b{Regex.Escape(name)}\s*:\s*\(\s*(?<x>{Number})\s*mm\s*,\s*(?<y>{Number})\s*mm\s*,\s*(?<z>{Number})\s*mm\s*\)\s*;",Rx);
+ return m.Success?new Point3D(Num(m,"x"),Num(m,"y"),Num(m,"z")):null;
+ }
+ private static string? Token(string text, string name) { var m = Regex.Match(text, $@"\b{Regex.Escape(name)}\s*:\s*(?<v>[A-Za-z_][A-Za-z0-9_]*)\s*;", Rx); return m.Success ? m.Groups["v"].Value : null; }
+ private static string? Quoted(string text, string name) { var m = Regex.Match(text, $"\\b{Regex.Escape(name)}\\s*:\\s*\"(?<v>[^\"]+)\"\\s*;", Rx); return m.Success ? m.Groups["v"].Value : null; }
+ private static double Num(Match m, string group) => double.Parse(m.Groups[group].Value, NumberStyles.Float, CultureInfo.InvariantCulture);
+ private static string NormalizeEdge(string edge) => edge.Equals("Top", StringComparison.OrdinalIgnoreCase) ? "Outer" : edge;
+}
+
+internal sealed record AuthoredSheetLoweringResult(bool IsSuccess, SheetMetalPartIr? Part, IReadOnlyList<SheetMetalDiagnostic> Diagnostics);
+
+internal static class AuthoredSheetMetalLowering
+{
+ private sealed record EdgeFrame(Point3D A, Point3D B, Vector3D Outward);
+ private sealed record RegionFrame(string Name, Point3D A, Point3D B, Vector3D Outward, Vector3D Normal, double Length)
+ {
+ public Point3D OuterA => A + Outward * Length;
+ public Point3D OuterB => B + Outward * Length;
+ }
+ private sealed record Patch(string Id, SheetRegionKind Kind, IReadOnlyList<Point3D> Positive, IReadOnlyList<Point3D> Negative,
+ SurfaceGeometry PositiveSurface, SurfaceGeometry NegativeSurface, Point3D? CylinderCenter = null, Vector3D? CylinderAxis = null);
+
+ public static AuthoredSheetLoweringResult Lower(SheetMetalConstructionSpec spec, string sourcePath)
+ {
+ var diagnostics = new List<SheetMetalDiagnostic>();
+ var source = new SheetSourceBinding("Firmament declaration", "sole construction authority", [], [], sourcePath);
+ var evidence = new[] { new SheetEvidence(SheetEvidenceKind.Authored, "source-independent-construction", "All dimensions, adjacency, cuts, corners, and bend policy come from this Firmament source.") };
+ var regions = new List<SheetRegionIr>(); var bends = new List<SheetBendIr>(); var features = new List<SheetFeatureIr>();
+ var corners = new List<SheetMetalCornerIr>(); var reliefs = new List<SheetMetalReliefIr>(); var correspondence = new List<SheetMetalCorrespondence>();
+ var patches = new List<Patch>(); var frames = new Dictionary<string, RegionFrame>(StringComparer.OrdinalIgnoreCase);
+ var stableRegions = new Dictionary<string,string>(StringComparer.OrdinalIgnoreCase) { [spec.Base.Name] = spec.LegacySyntax ? "region-base" : spec.Base.Name };
+ foreach (var flange in spec.Flanges) stableRegions[flange.Name] = spec.LegacySyntax ? $"region-{flange.EdgeName.ToLowerInvariant()}-flange" : flange.Name;
+ var t = spec.Thickness; var z = new Vector3D(0, 0, 1); var x = new Vector3D(1, 0, 0); var y = new Vector3D(0, 1, 0);
+ var w = spec.Base.Width; var d = spec.Base.Depth; var mid = t / 2d;var origin=spec.Base.Origin;
+ var baseEdges = new Dictionary<string, EdgeFrame>(StringComparer.OrdinalIgnoreCase)
+ {
+ ["Front"] = new(origin+new Vector3D(0,0,mid),origin+new Vector3D(w,0,mid),-y), ["Right"] = new(origin+new Vector3D(w,0,mid),origin+new Vector3D(w,d,mid),x),
+ ["Rear"] = new(origin+new Vector3D(w,d,mid),origin+new Vector3D(0,d,mid),y), ["Left"] = new(origin+new Vector3D(0,d,mid),origin+new Vector3D(0,0,mid),-x)
+ };
+
+ var baseBoundary = new List<Point3D>();
+ foreach (var edgeName in new[] { "Front", "Right", "Rear", "Left" })
+ {
+ var edge = baseEdges[edgeName]; var flange = spec.Flanges.FirstOrDefault(f => f.ParentRegion.Equals(spec.Base.Name, StringComparison.OrdinalIgnoreCase) && f.EdgeName.Equals(edgeName, StringComparison.OrdinalIgnoreCase));
+ var previous = Previous(edgeName); var next = Next(edgeName);
+ var atStart = spec.Flanges.Any(f => f.ParentRegion.Equals(spec.Base.Name, StringComparison.OrdinalIgnoreCase) && f.EdgeName.Equals(previous, StringComparison.OrdinalIgnoreCase));
+ var atEnd = spec.Flanges.Any(f => f.ParentRegion.Equals(spec.Base.Name, StringComparison.OrdinalIgnoreCase) && f.EdgeName.Equals(next, StringComparison.OrdinalIgnoreCase));
+ var edgeLength = (edge.B - edge.A).Length;
+ var gapStart = flange is null || !atStart ? 0 : CornerGap(flange, spec.Flanges.First(f => f.ParentRegion.Equals(spec.Base.Name, StringComparison.OrdinalIgnoreCase) && f.EdgeName.Equals(previous, StringComparison.OrdinalIgnoreCase)), t);
+ var gapEnd = flange is null || !atEnd ? 0 : CornerGap(flange, spec.Flanges.First(f => f.ParentRegion.Equals(spec.Base.Name, StringComparison.OrdinalIgnoreCase) && f.EdgeName.Equals(next, StringComparison.OrdinalIgnoreCase)), t);
+ if (gapStart + gapEnd >= edgeLength - 1e-8) return Failure($"Corner trims consume base edge {spec.Base.Name}.{edgeName}.", SheetMetalDiagnosticCodes.ImpossibleTopology);
+ var axis = Unit(edge.B - edge.A); var a = edge.A + axis * gapStart; var b = edge.B - axis * gapEnd;
+ if (baseBoundary.Count == 0 || !Same(baseBoundary[^1], edge.A)) baseBoundary.Add(edge.A);
+ if (!Same(a, edge.A)) baseBoundary.Add(a); if (!Same(b, a)) baseBoundary.Add(b); if (!Same(edge.B, b)) baseBoundary.Add(edge.B);
+ if (flange is not null) baseEdges[edgeName] = new(a, b, edge.Outward);
+ }
+ baseBoundary = CleanLoop(baseBoundary);
+ var basePlane = new SheetPlaneReference(origin+new Vector3D(0,0,mid), z, x, y, true);
+ var baseId=stableRegions[spec.Base.Name];
+ regions.Add(new(baseId, SheetRegionKind.Planar, Developable("Authored planar base."), basePlane, null, baseBoundary, w * d, source, evidence));
+ patches.Add(PlanePatch(baseId, SheetRegionKind.Planar, baseBoundary, z, t));
+ correspondence.Add(new(spec.Base.Name, "Region", baseId, $"flat-{baseId}"));
+
+ var pending = new List<AuthoredSheetFlangeSpec>(spec.Flanges); var guard = 0;
+ while (pending.Count > 0 && guard++ <= spec.Flanges.Count)
+ {
+ var progressed = false;
+ foreach (var flange in pending.ToArray())
+ {
+ EdgeFrame? parentEdge = null; Vector3D parentNormal;
+ if (flange.ParentRegion.Equals(spec.Base.Name, StringComparison.OrdinalIgnoreCase) && baseEdges.TryGetValue(flange.EdgeName, out var be)) { parentEdge = be; parentNormal = z; }
+ else if (frames.TryGetValue(flange.ParentRegion, out var pf) && flange.EdgeName.Equals("Outer", StringComparison.OrdinalIgnoreCase)) { parentEdge = new(pf.OuterA, pf.OuterB, pf.Outward); parentNormal = pf.Normal; }
+ else continue;
+ progressed = true; pending.Remove(flange);
+ var edge = parentEdge; var axis = Unit(edge.B - edge.A); var sign = flange.Direction == SheetBendDirection.Down ? -1d : 1d;
+ var rMid = flange.InsideRadius + t / 2d; var angle = flange.AngleRadians;
+ var tangentA = edge.A + edge.Outward * (rMid * Math.Sin(angle)) + parentNormal * (sign * rMid * (1 - Math.Cos(angle)));
+ var tangentB = edge.B + edge.Outward * (rMid * Math.Sin(angle)) + parentNormal * (sign * rMid * (1 - Math.Cos(angle)));
+ var direction = Unit(edge.Outward * Math.Cos(angle) + parentNormal * (sign * Math.Sin(angle)));
+ var normal = Unit(parentNormal * Math.Cos(angle) - edge.Outward * (sign * Math.Sin(angle)));
+ var frame = new RegionFrame(flange.Name, tangentA, tangentB, direction, normal, flange.Length); frames[flange.Name] = frame;
+ var boundary = new[] { tangentA, tangentB, frame.OuterB, frame.OuterA };
+ var plane = new SheetPlaneReference(tangentA, normal, axis, direction, true);
+ var flangeId=stableRegions[flange.Name];
+ regions.Add(new(flangeId, SheetRegionKind.Planar, Developable("Authored planar flange."), plane, null, boundary, (edge.B-edge.A).Length * flange.Length, source, evidence));
+ patches.Add(PlanePatch(flangeId, SheetRegionKind.Planar, boundary, normal, t));
+
+ var bendId = spec.LegacySyntax ? $"bend-{flange.EdgeName.ToLowerInvariant()}" : $"{flange.Name}Bend"; var bendRegionId = spec.LegacySyntax ? $"region-{flange.EdgeName.ToLowerInvariant()}-bend" : $"{flange.Name}BendRegion"; var centerA = edge.A + parentNormal * (sign * rMid); var center = Mid(centerA, edge.B + parentNormal * (sign * rMid));
+ var cylinder = new SheetCylinderReference(center, axis, rMid, flange.InsideRadius, angle, (edge.B-edge.A).Length, sign > 0);
+ var bendBoundary = new[] { edge.A, edge.B, tangentB, tangentA };
+ regions.Add(new(bendRegionId, SheetRegionKind.CylindricalBend, Developable("Authored analytic cylindrical bend."), null, cylinder, bendBoundary, angle * rMid * cylinder.AxisLength, source, evidence));
+ bends.Add(new(bendId, center, axis, angle, flange.InsideRadius, t, flange.Direction, stableRegions[flange.ParentRegion], flangeId, SheetNeutralAxisPolicy.KFactorPolicy(spec.KFactor), source,
+ [new(SheetEvidenceKind.Authored, "bend-intent", "Axis, angle, inside radius, direction, and adjacency derive from the high-level flange declaration.")]));
+ patches.Add(BendPatch(bendRegionId, edge, parentNormal, flange, t));
+ correspondence.Add(new(flange.Name, "Region", flangeId, $"flat-{flangeId}"));
+ correspondence.Add(new(bendId, "Bend", bendRegionId, $"flat-{bendId}"));
+ }
+ if (!progressed) break;
+ }
+ if (pending.Count > 0) return Failure($"Flange graph is disconnected or references unsupported edges: {string.Join(", ", pending.Select(f => $"{f.Name}->{f.ParentRegion}.{f.EdgeName}"))}.", SheetMetalDiagnosticCodes.DisconnectedGraph);
+
+ AddCorners();
+ foreach (var cut in spec.Cuts)
+ {
+ SheetPlaneReference? plane; IReadOnlyList<Point3D> boundary;
+ if (cut.RegionName.Equals(spec.Base.Name, StringComparison.OrdinalIgnoreCase)) { plane = basePlane; boundary = baseBoundary; }
+ else { var region = regions.FirstOrDefault(r => r.StableId.Equals(stableRegions.GetValueOrDefault(cut.RegionName,cut.RegionName), StringComparison.OrdinalIgnoreCase)); plane = region?.Plane; boundary = region?.Boundary3D ?? []; }
+ if (plane is null) return Failure($"Cut '{cut.Name}' references unknown planar region '{cut.RegionName}'.", SheetMetalDiagnosticCodes.FeatureMappingFailure);
+ var local=boundary.Select(p=>(U:(p-plane.Origin).Dot(plane.UAxis),V:(p-plane.Origin).Dot(plane.VAxis))).ToArray();var hu=(cut.Diameter??cut.Length)!.Value/2;var hv=(cut.Diameter??cut.Width)!.Value/2;
+ if(local.Length<3||cut.X-hu<=local.Min(p=>p.U)+1e-8||cut.X+hu>=local.Max(p=>p.U)-1e-8||cut.Y-hv<=local.Min(p=>p.V)+1e-8||cut.Y+hv>=local.Max(p=>p.V)-1e-8)
+ return Failure($"Cut '{cut.Name}' reaches or crosses the boundary/bend zone of region '{cut.RegionName}'.",SheetMetalDiagnosticCodes.CutCrossesBend);
+ var center = plane.Origin + plane.UAxis * cut.X + plane.VAxis * cut.Y;
+ IReadOnlyList<Point3D> loop = cut.Kind == SheetFeatureKind.CircularHole ? [] : RectangleLoop(center, plane.UAxis, plane.VAxis, cut.Length!.Value, cut.Width!.Value);
+ features.Add(new(cut.Name, cut.Kind, stableRegions.GetValueOrDefault(cut.RegionName,cut.RegionName), center, cut.Diameter, loop, source, evidence));
+ correspondence.Add(new(cut.Name, "Cut", cut.Name, cut.Name));
+ }
+
+ var bodyResult = AuthoredSheetBrepEmitter.Emit(patches, spec, regions, features);
+ if (!bodyResult.IsSuccess || bodyResult.Value is null)
+ return Failure("Formed BRep stitching failed: " + string.Join("; ", bodyResult.Diagnostics.Select(d => d.Message)), SheetMetalDiagnosticCodes.FormedBodyInvalid);
+ var preflight = BrepExportPreflight.Validate(bodyResult.Value);
+ if (!preflight.IsValid) return Failure("Formed BRep failed validation: " + string.Join("; ", preflight.Diagnostics.Select(d => d.Message)), SheetMetalDiagnosticCodes.FormedBodyInvalid);
+ var status = SheetMetalRecognitionStatus.Complete;
+ var authorityText = spec.Authority == SheetMetalProvenanceCategory.Reconstructed ? "Reconstructed Firmament engineering intent" : "Authored Firmament engineering intent";
+ var part = new SheetMetalPartIr($"sheetmetal-{spec.Name}", t, spec.Material, baseId, regions, bends, features, new(spec.KFactor), status,
+ $"{authorityText}; source-independent exact formed lowering.", [new(SheetEvidenceKind.Authored, "construction-authority", authorityText)], diagnostics, bodyResult.Value,
+ corners, reliefs, correspondence, SheetFlangeLengthMode.TangentToEdge);
+ return new(true, part, diagnostics);
+
+ void AddCorners()
+ {
+ var edgeOrder = new[] { "Front", "Right", "Rear", "Left" };
+ for (var i = 0; i < edgeOrder.Length; i++)
+ {
+ var a = spec.Flanges.FirstOrDefault(f => f.ParentRegion.Equals(spec.Base.Name, StringComparison.OrdinalIgnoreCase) && f.EdgeName.Equals(edgeOrder[i], StringComparison.OrdinalIgnoreCase));
+ var b = spec.Flanges.FirstOrDefault(f => f.ParentRegion.Equals(spec.Base.Name, StringComparison.OrdinalIgnoreCase) && f.EdgeName.Equals(edgeOrder[(i+1)%4], StringComparison.OrdinalIgnoreCase));
+ if (a is null || b is null) continue;
+ var policy = a.CornerPolicy == SheetCornerPolicy.Mitered && b.CornerPolicy == SheetCornerPolicy.Mitered ? SheetCornerPolicy.Mitered :
+ a.ReliefPolicy != SheetReliefPolicy.None || b.ReliefPolicy != SheetReliefPolicy.None ? SheetCornerPolicy.Relief : SheetCornerPolicy.Open;
+ var id = $"corner-{a.Name}-{b.Name}"; string? reliefId = null;
+ if (policy == SheetCornerPolicy.Relief)
+ {
+ reliefId = $"relief-{a.Name}-{b.Name}"; var owner = a.ReliefPolicy != SheetReliefPolicy.None ? a : b;
+ var width = owner.ReliefWidth ?? Math.Max(t, 0.5 * t); var depth = owner.ReliefDepth ?? owner.InsideRadius + t;
+ var kind = owner.ReliefPolicy == SheetReliefPolicy.Round ? SheetReliefKind.Round : SheetReliefKind.Rectangular;
+ reliefs.Add(new(reliefId, kind, spec.Base.Name, id, width, depth, kind == SheetReliefKind.Round ? width/2 : null, owner.ReliefWidth is null || owner.ReliefDepth is null, source,
+ [new(SheetEvidenceKind.Derived, "automatic-relief", "Auto relief width=max(thickness, 0.5*thickness); depth=inside radius+thickness.", width)]));
+ correspondence.Add(new(reliefId, "Relief", reliefId, reliefId));
+ }
+ corners.Add(new(id, a.Name, b.Name, spec.Base.Name, $"{edgeOrder[i]}-{edgeOrder[(i+1)%4]}", policy, reliefId, source, evidence));
+ correspondence.Add(new(id, "Corner", id, reliefId ?? id));
+ }
+ }
+ AuthoredSheetLoweringResult Failure(string message, string code) => new(false, null, [new(code, SheetMetalDiagnosticSeverity.Error, message)]);
+ }
+
+ private static Patch PlanePatch(string id, SheetRegionKind kind, IReadOnlyList<Point3D> mid, Vector3D normal, double thickness)
+ {
+ var n = Unit(normal); var positive = mid.Select(p => p + n * (thickness/2)).ToArray(); var negative = mid.Select(p => p - n * (thickness/2)).ToArray();
+ var u = Unit(mid[1]-mid[0]);
+ return new(id, kind, positive, negative, SurfaceGeometry.FromPlane(new PlaneSurface(positive[0], Direction3D.Create(n), Direction3D.Create(u))), SurfaceGeometry.FromPlane(new PlaneSurface(negative[0], Direction3D.Create(-n), Direction3D.Create(u))));
+ }
+ private static Patch BendPatch(string id, EdgeFrame edge, Vector3D parentNormal, AuthoredSheetFlangeSpec flange, double thickness)
+ {
+ var axis = Unit(edge.B-edge.A); var sign = flange.Direction == SheetBendDirection.Down ? -1d : 1d; var rMid = flange.InsideRadius + thickness/2; var a = flange.AngleRadians;
+ Point3D Ref(Point3D q, double theta) => q + edge.Outward*(rMid*Math.Sin(theta)) + parentNormal*(sign*rMid*(1-Math.Cos(theta)));
+ Vector3D Normal(double theta) => Unit(parentNormal*Math.Cos(theta)-edge.Outward*(sign*Math.Sin(theta)));
+ var p0a=Ref(edge.A,0);var p0b=Ref(edge.B,0);var p1a=Ref(edge.A,a);var p1b=Ref(edge.B,a);var n0=Normal(0);var n1=Normal(a);
+ var positive=new[]{p0a+n0*thickness/2,p0b+n0*thickness/2,p1b+n1*thickness/2,p1a+n1*thickness/2};
+ var negative=new[]{p0a-n0*thickness/2,p0b-n0*thickness/2,p1b-n1*thickness/2,p1a-n1*thickness/2};
+ var center=edge.A+parentNormal*(sign*rMid);var positiveRadius=(positive[0]-center).Length;var negativeRadius=(negative[0]-center).Length;
+ var refPos=Direction3D.Create(positive[0]-center);var refNeg=Direction3D.Create(negative[0]-center);
+ return new(id,SheetRegionKind.CylindricalBend,positive,negative,
+ SurfaceGeometry.FromCylinder(new CylinderSurface(center,Direction3D.Create(axis),positiveRadius,refPos)),
+ SurfaceGeometry.FromCylinder(new CylinderSurface(center,Direction3D.Create(axis),negativeRadius,refNeg)),center,axis);
+ }
+ private static DevelopabilityEvidence Developable(string note)=>new(DevelopabilityKind.Developable,"authored analytic construction",0,0,note);
+ private static IReadOnlyList<Point3D> RectangleLoop(Point3D c,Vector3D u,Vector3D v,double length,double width)=>[c-u*(length/2)-v*(width/2),c+u*(length/2)-v*(width/2),c+u*(length/2)+v*(width/2),c-u*(length/2)+v*(width/2)];
+ private static string Previous(string edge)=>edge switch{"Front"=>"Left","Right"=>"Front","Rear"=>"Right",_=>"Rear"};
+ private static string Next(string edge)=>edge switch{"Front"=>"Right","Right"=>"Rear","Rear"=>"Left",_=>"Front"};
+ private static double CornerGap(AuthoredSheetFlangeSpec a,AuthoredSheetFlangeSpec b,double t)=>a.CornerPolicy==SheetCornerPolicy.Mitered&&b.CornerPolicy==SheetCornerPolicy.Mitered?Math.Max(a.InsideRadius,b.InsideRadius)+t/2:Math.Max(Math.Max(a.InsideRadius,b.InsideRadius)+t, a.ReliefWidth??0);
+ private static List<Point3D> CleanLoop(IEnumerable<Point3D> p){var r=new List<Point3D>();foreach(var q in p)if(r.Count==0||!Same(r[^1],q))r.Add(q);if(r.Count>1&&Same(r[0],r[^1]))r.RemoveAt(r.Count-1);return r;}
+ private static bool Same(Point3D a,Point3D b)=>(a-b).Length<1e-8;
+ private static Vector3D Unit(Vector3D v)=>v.TryNormalize(out var n)?n:throw new InvalidOperationException("Zero-length authored direction.");
+ private static Point3D Mid(Point3D a,Point3D b)=>new((a.X+b.X)/2,(a.Y+b.Y)/2,(a.Z+b.Z)/2);
+
+ private static class AuthoredSheetBrepEmitter
+ {
+ private readonly record struct Use(EdgeId Edge,bool Reverse);
+ private sealed record EdgeGeometry(CurveGeometry Curve,ParameterInterval Interval);
+ private sealed record CutBoundary(SheetFeatureIr Feature,SheetPlaneReference Plane,IReadOnlyList<Point3D> Positive,IReadOnlyList<Point3D> Negative,IReadOnlyList<EdgeId> PositiveEdges,IReadOnlyList<EdgeId> NegativeEdges,bool Circle);
+ private readonly record struct Key(long X,long Y,long Z){public static Key Of(Point3D p)=>new(Q(p.X),Q(p.Y),Q(p.Z));private static long Q(double v)=>(long)Math.Round(v*1e8);}
+ private readonly record struct EdgeKey(Key A,Key B){public static EdgeKey Of(Point3D a,Point3D b){var ka=Key.Of(a);var kb=Key.Of(b);return Compare(ka,kb)<=0?new(ka,kb):new(kb,ka);}private static int Compare(Key a,Key b){var x=a.X.CompareTo(b.X);if(x!=0)return x;var y=a.Y.CompareTo(b.Y);return y!=0?y:a.Z.CompareTo(b.Z);}}
+
+ public static KernelResult<BrepBody> Emit(IReadOnlyList<Patch> patches,SheetMetalConstructionSpec spec,IReadOnlyList<SheetRegionIr> regions,IReadOnlyList<SheetFeatureIr> features)
+ {
+ var b=new TopologyBuilder();var g=new BrepGeometryStore();var bindings=new BrepBindingModel();var points=new Dictionary<VertexId,Point3D>();
+ var vertices=new Dictionary<Key,VertexId>();var edges=new Dictionary<EdgeKey,EdgeId>();var edgeGeometry=new Dictionary<EdgeId,EdgeGeometry>();var useCount=new Dictionary<EdgeId,int>();var faces=new List<FaceId>();
+ var boundaryCandidates=new List<(EdgeId Positive,EdgeId Negative,Point3D PA,Point3D PB,Point3D NA,Point3D NB)>();
+ var cutsByRegion=new Dictionary<string,List<CutBoundary>>(StringComparer.Ordinal);
+ VertexId Vertex(Point3D p){var key=Key.Of(p);if(vertices.TryGetValue(key,out var id))return id;id=b.AddVertex();vertices[key]=id;points[id]=p;return id;}
+ EdgeId Edge(Point3D a,Point3D q,EdgeGeometry? geometry=null){var key=EdgeKey.Of(a,q);if(edges.TryGetValue(key,out var id))return id;id=b.AddEdge(Vertex(a),Vertex(q));edges[key]=id;edgeGeometry[id]=geometry??Line(a,q);return id;}
+ Use DirectedEdge(Point3D a,Point3D q,EdgeGeometry? geometry=null){var id=Edge(a,q,geometry);useCount[id]=useCount.GetValueOrDefault(id)+1;var topology=b.Model.GetEdge(id);return new(id,topology.StartVertexId==Vertex(a));}
+ Use ExistingEdge(EdgeId id,Point3D start){useCount[id]=useCount.GetValueOrDefault(id)+1;return new(id,b.Model.GetEdge(id).StartVertexId==Vertex(start));}
+ FaceId Face(IReadOnlyList<IReadOnlyList<Use>> loops,SurfaceGeometry surface,bool same=true){var ids=new List<LoopId>();foreach(var uses in loops){var lid=b.AllocateLoopId();var co=uses.Select(_=>b.AllocateCoedgeId()).ToArray();for(var i=0;i<co.Length;i++)b.AddCoedge(new(co[i],uses[i].Edge,lid,co[(i+1)%co.Length],co[(i+co.Length-1)%co.Length],!uses[i].Reverse));b.AddLoop(new Loop(lid,co));ids.Add(lid);}var face=b.AddFace(ids);var sid=new SurfaceGeometryId(g.Surfaces.Count()+1);g.AddSurface(sid,surface);bindings.AddFaceBinding(new(face,sid,same));faces.Add(face);return face;}
+
+ BuildCutBoundaries();
+ foreach(var patch in patches)
+ {
+ AddSkin(patch,true,patch.Positive,patch.PositiveSurface);AddSkin(patch,false,patch.Negative.Reverse().ToArray(),patch.NegativeSurface);
+ var count=patch.Positive.Count;for(var i=0;i<count;i++)
+ {
+ var j=(i+1)%count;var pg=CurveFor(patch,true,i,patch.Positive[i],patch.Positive[j]);var ng=CurveFor(patch,false,i,patch.Negative[i],patch.Negative[j]);
+ var pe=Edge(patch.Positive[i],patch.Positive[j],pg);var ne=Edge(patch.Negative[i],patch.Negative[j],ng);
+ boundaryCandidates.Add((pe,ne,patch.Positive[i],patch.Positive[j],patch.Negative[i],patch.Negative[j]));
+ }
+ }
+ foreach(var candidate in boundaryCandidates)
+ {
+ if(useCount.GetValueOrDefault(candidate.Positive)!=1||useCount.GetValueOrDefault(candidate.Negative)!=1)continue;
+ var loop=new[]{DirectedEdge(candidate.PA,candidate.PB),DirectedEdge(candidate.PB,candidate.NB),DirectedEdge(candidate.NB,candidate.NA),DirectedEdge(candidate.NA,candidate.PA)};
+ var u=candidate.PB-candidate.PA;var v=candidate.NA-candidate.PA;var normal=Unit(u.Cross(v));Face([loop],SurfaceGeometry.FromPlane(new PlaneSurface(candidate.PA,Direction3D.Create(normal),Direction3D.Create(Unit(u)))));
+ }
+ AddCutWalls();
+ foreach(var (edge,geometry) in edgeGeometry.OrderBy(x=>x.Key.Value)){var cid=new CurveGeometryId(g.Curves.Count()+1);g.AddCurve(cid,geometry.Curve);bindings.AddEdgeBinding(new(edge,cid,geometry.Interval));}
+ var shell=b.AddShell(faces);b.AddBody([shell]);var body=new BrepBody(b.Model,g,bindings,points);var validation=BrepExportPreflight.Validate(body);
+ if(!validation.IsValid)return KernelResult<BrepBody>.Failure(validation.Diagnostics.Where(x=>x.Severity==BrepExportPreflightSeverity.Error).Select(x=>new Aetheris.Kernel.Core.Diagnostics.KernelDiagnostic(Aetheris.Kernel.Core.Diagnostics.KernelDiagnosticCode.ValidationFailed,Aetheris.Kernel.Core.Diagnostics.KernelDiagnosticSeverity.Error,$"{x.Code}: {x.Message}",x.Context)).ToArray());
+ return KernelResult<BrepBody>.Success(body);
+
+ void AddSkin(Patch patch,bool positive,IReadOnlyList<Point3D> loop,SurfaceGeometry surface)
+ {
+ var uses=new List<Use>();for(var i=0;i<loop.Count;i++){var j=(i+1)%loop.Count;var originalIndex=positive?i:(patch.Negative.Count-2-i+patch.Negative.Count)%patch.Negative.Count;uses.Add(DirectedEdge(loop[i],loop[j],CurveFor(patch,positive,originalIndex,loop[i],loop[j])));}
+ var loops=new List<IReadOnlyList<Use>>{uses};
+ if(cutsByRegion.TryGetValue(patch.Id,out var patchCuts))foreach(var cut in patchCuts)
+ {
+ var points=positive?cut.Positive.Reverse().ToArray():cut.Negative;var cutEdges=positive?cut.PositiveEdges:cut.NegativeEdges;
+ if(cut.Circle)loops.Add([ExistingEdge(cutEdges[0],points[0])]);
+ else{var cutUses=new List<Use>();for(var i=0;i<points.Count;i++){var original=positive?(points.Count-2-i+points.Count)%points.Count:i;cutUses.Add(ExistingEdge(cutEdges[original],points[i]));}loops.Add(cutUses);}
+ }
+ Face(loops,surface,positive);
+ }
+ EdgeGeometry CurveFor(Patch patch,bool positive,int index,Point3D a,Point3D q)
+ {
+ if(patch.Kind!=SheetRegionKind.CylindricalBend||index is 0 or 2)return Line(a,q);
+ var center=patch.CylinderCenter!.Value;var axis=Unit(patch.CylinderAxis!.Value);var endpointCenter=ProjectToAxis(a,center,axis);var radius=(a-endpointCenter).Length;var va=a-endpointCenter;var vq=q-ProjectToAxis(q,center,axis);var signed=Math.Atan2(axis.Dot(Unit(va).Cross(Unit(vq))),Unit(va).Dot(Unit(vq)));if(signed<0){axis=-axis;signed=-signed;}var circle=new Circle3Curve(endpointCenter,Direction3D.Create(axis),radius,Direction3D.Create(va));return new(CurveGeometry.FromCircle(circle),new(0,Math.Max(signed,1e-12)));
+ }
+ void BuildCutBoundaries()
+ {
+ foreach(var feature in features)
+ {
+ var region=regions.First(r=>r.StableId==feature.OwningRegionId);var plane=region.Plane!;var n=Unit(plane.Normal);var posCenter=feature.Center+n*spec.Thickness/2;var negCenter=feature.Center-n*spec.Thickness/2;
+ IReadOnlyList<Point3D> positive;IReadOnlyList<Point3D> negative;IReadOnlyList<EdgeId> positiveEdges;IReadOnlyList<EdgeId> negativeEdges;var circle=false;
+ if(feature.Kind==SheetFeatureKind.CircularHole&&feature.Diameter is { } diameter)
+ {
+ circle=true;var radius=diameter/2;var p0=posCenter+plane.UAxis*radius;var n0=negCenter+plane.UAxis*radius;var pv=Vertex(p0);var nv=Vertex(n0);var pe=b.AddEdge(pv,pv);var ne=b.AddEdge(nv,nv);var pc=new Circle3Curve(posCenter,Direction3D.Create(n),radius,Direction3D.Create(plane.UAxis));var nc=new Circle3Curve(negCenter,Direction3D.Create(n),radius,Direction3D.Create(plane.UAxis));edgeGeometry[pe]=new(CurveGeometry.FromCircle(pc),new(0,2*Math.PI));edgeGeometry[ne]=new(CurveGeometry.FromCircle(nc),new(0,2*Math.PI));positive=[p0];negative=[n0];positiveEdges=[pe];negativeEdges=[ne];
+ }
+ else
+ {
+ positive=feature.Boundary3D.Select(p=>p+n*spec.Thickness/2).ToArray();negative=feature.Boundary3D.Select(p=>p-n*spec.Thickness/2).ToArray();
+ positiveEdges=Enumerable.Range(0,positive.Count).Select(i=>Edge(positive[i],positive[(i+1)%positive.Count])).ToArray();negativeEdges=Enumerable.Range(0,negative.Count).Select(i=>Edge(negative[i],negative[(i+1)%negative.Count])).ToArray();
+ }
+ var cut=new CutBoundary(feature,plane,positive,negative,positiveEdges,negativeEdges,circle);if(!cutsByRegion.TryGetValue(feature.OwningRegionId,out var list))cutsByRegion[feature.OwningRegionId]=list=[];list.Add(cut);
+ }
+ }
+ void AddCutWalls()
+ {
+ foreach(var cut in cutsByRegion.Values.SelectMany(x=>x))
+ {
+ if(cut.Circle)
+ {
+ var radius=cut.Feature.Diameter!.Value/2;var loops=new IReadOnlyList<Use>[] { [ExistingEdge(cut.PositiveEdges[0],cut.Positive[0])], [ExistingEdge(cut.NegativeEdges[0],cut.Negative[0])] };
+ Face(loops,SurfaceGeometry.FromCylinder(new CylinderSurface(cut.Feature.Center-cut.Plane.Normal*(spec.Thickness/2),Direction3D.Create(Unit(cut.Plane.Normal)),radius,Direction3D.Create(Unit(cut.Plane.UAxis)))),false);
+ }
+ else for(var i=0;i<cut.Positive.Count;i++)
+ {
+ var j=(i+1)%cut.Positive.Count;var loop=new[]{ExistingEdge(cut.PositiveEdges[i],cut.Positive[i]),DirectedEdge(cut.Positive[j],cut.Negative[j]),ExistingEdge(cut.NegativeEdges[i],cut.Negative[j]),DirectedEdge(cut.Negative[i],cut.Positive[i])};var u=cut.Positive[j]-cut.Positive[i];var v=cut.Negative[i]-cut.Positive[i];var normal=Unit(u.Cross(v));Face([loop],SurfaceGeometry.FromPlane(new PlaneSurface(cut.Positive[i],Direction3D.Create(normal),Direction3D.Create(Unit(u)))));
+ }
+ }
+ }
+ EdgeGeometry Line(Point3D a,Point3D q){var d=q-a;return new(CurveGeometry.FromLine(new Line3Curve(a,Direction3D.Create(d))),new(0,d.Length));}
+ Point3D ProjectToAxis(Point3D p,Point3D origin,Vector3D axis)=>origin+axis*((p-origin).Dot(axis));
+ }
+ }
+}
diff --git a/Aetheris.SheetMetal/SheetMetalDfm.cs b/Aetheris.SheetMetal/SheetMetalDfm.cs
index 5a2d953d..e1d1ea97 100644
--- a/Aetheris.SheetMetal/SheetMetalDfm.cs
+++ b/Aetheris.SheetMetal/SheetMetalDfm.cs
@@ -33,6 +33,11 @@ public static class SheetMetalDfm
var ratio=bend.InsideRadius/part.Thickness;var pass=ratio>=policy.MinimumInsideRadiusRatio;
findings.Add(new("sheetmetal-dfm-inside-radius-ratio",pass?SheetMetalDfmStatus.Pass:SheetMetalDfmStatus.Warning,$"Inside-radius/thickness ratio {ratio:G4} {(pass?"meets":"is below")} the parameterized experimental policy {policy.MinimumInsideRadiusRatio:G4}.",bend.StableId,ratio,policy.MinimumInsideRadiusRatio));
}
+ foreach(var corner in part.Corners??[])
+ {
+ var relief=(part.Reliefs??[]).FirstOrDefault(r=>r.CornerId==corner.StableId);var valid=corner.Policy!=SheetCornerPolicy.Relief||relief is not null&&relief.Width>=part.Thickness&&relief.Depth>=part.Thickness;
+ findings.Add(new("sheetmetal-dfm-corner-resolution",valid?SheetMetalDfmStatus.Pass:SheetMetalDfmStatus.Warning,valid?$"'{corner.StableId}' uses bounded {corner.Policy} corner resolution.":$"'{corner.StableId}' has insufficient or missing relief geometry.",corner.StableId,relief?.Width,part.Thickness,valid?null:$"Increase {corner.ReliefId??"the corner relief"} width and depth to at least {part.Thickness:G4} mm."));
+ }
if(flat is not null)
{
findings.Add(new("sheetmetal-dfm-flat-overlap",flat.Status==FlatPatternStatus.Overlapping?SheetMetalDfmStatus.Fail:SheetMetalDfmStatus.Pass,flat.Status==FlatPatternStatus.Overlapping?"Flat material regions overlap.":"No planar-region overlap was detected.",flat.StableId,null,null));
diff --git a/Aetheris.SheetMetal/SheetMetalFirmament.cs b/Aetheris.SheetMetal/SheetMetalFirmament.cs
index c964e323..ccb4914e 100644
--- a/Aetheris.SheetMetal/SheetMetalFirmament.cs
+++ b/Aetheris.SheetMetal/SheetMetalFirmament.cs
@@ -1,25 +1,25 @@
-using System.Globalization;
using System.Text.RegularExpressions;
-using Aetheris.Kernel.Core.Brep;
-using Aetheris.Kernel.Core.Geometry;
-using Aetheris.Kernel.Core.Geometry.Curves;
-using Aetheris.Kernel.Core.Geometry.Surfaces;
-using Aetheris.Kernel.Core.Math;
-using Aetheris.Kernel.Core.Results;
-using Aetheris.Kernel.Core.Topology;
-using Aetheris.Surfacing;
namespace Aetheris.SheetMetal;
-public sealed record AuthoredFlangeSpec(string Name,string Side,double Length,double AngleRadians,double InsideRadius,SheetBendDirection Direction);
-public sealed record AuthoredHoleSpec(string Name,double X,double Y,double Diameter);
-public sealed record SheetMetalAuthoringSpec(string Name,double Thickness,double BaseWidth,double BaseDepth,string? Material,double KFactor,AuthoredFlangeSpec Left,AuthoredFlangeSpec Right,IReadOnlyList<AuthoredHoleSpec> Holes);
-public sealed record SheetMetalAuthoringResult(bool IsSuccess,SheetMetalAuthoringSpec? Spec,SheetMetalPartIr? Part,SheetMetalFlatPatternIr? FlatPattern,IReadOnlyList<SheetMetalDiagnostic> Diagnostics);
-
-/// <summary>Firmament V2 module-owned high-level syntax for the bounded two-flange M1 family.</summary>
+public sealed record SheetMetalAuthoringTimings(double ParseMilliseconds,double FormedLowerMilliseconds,double FlatLowerMilliseconds);
+public sealed record SheetMetalAuthoringResult(
+ bool IsSuccess,
+ SheetMetalConstructionSpec? Spec,
+ SheetMetalPartIr? Part,
+ SheetMetalFlatPatternIr? FlatPattern,
+ IReadOnlyList<SheetMetalDiagnostic> Diagnostics,
+ SheetMetalAuthoringTimings? Timings=null);
+
+/// <summary>
+/// Entry point for the module-owned Sheet Metal dialects. Recovered and historical
+/// evidence-linked M2 sources remain readable; normal authored/reconstructed source
+/// is lowered by the source-independent M3 compiler.
+/// </summary>
public static class SheetMetalFirmament
{
private const RegexOptions Rx=RegexOptions.IgnoreCase|RegexOptions.CultureInvariant|RegexOptions.Singleline;
+
public static bool LooksLikeSheetMetal(string source)
{
if(source is null)return false;
@@ -29,87 +29,18 @@ public static class SheetMetalFirmament
public static SheetMetalAuthoringResult CompileFile(string path)
{
- ArgumentException.ThrowIfNullOrWhiteSpace(path);var full=Path.GetFullPath(path);if(!File.Exists(full))return Failure($"Sheet Metal Firmament source was not found: {full}");
+ ArgumentException.ThrowIfNullOrWhiteSpace(path);var full=Path.GetFullPath(path);
+ if(!File.Exists(full))return Failure($"Sheet Metal Firmament source was not found: {full}");
return Compile(File.ReadAllText(full),full);
}
public static SheetMetalAuthoringResult Compile(string source,string sourcePath="authored.firmament")
{
ArgumentNullException.ThrowIfNull(source);var clean=Regex.Replace(source,@"//.*?$|#.*?$",string.Empty,RegexOptions.Multiline);
- if(ReconstructedSheetMetalFirmament.IsReconstructed(clean))return ReconstructedSheetMetalFirmament.Compile(clean,sourcePath);
+ if(ReconstructedSheetMetalFirmament.IsReconstructed(clean)&&Regex.IsMatch(clean,@"\bEvidenceSource\s*:",Rx))return ReconstructedSheetMetalFirmament.Compile(clean,sourcePath);
if(RecoveredSheetMetalFirmament.IsRecovered(clean))return RecoveredSheetMetalFirmament.Compile(clean,sourcePath);
- var header=Regex.Match(clean,@"\bSheetMetal\s+(?<name>[A-Za-z_][A-Za-z0-9_]*)\s*\{",Rx);if(!header.Success)return Failure("Expected `SheetMetal <Name> { ... }`.");
- if(!TryScalar(clean,"Thickness","mm",out var thickness)||thickness<=0)return Failure("Thickness must be a positive millimetre value.");
- var baseMatch=Regex.Match(clean,@"\bBase\s*:\s*Rectangle\s*\(\s*(?<w>[+-]?[0-9.]+)\s*mm\s*,\s*(?<d>[+-]?[0-9.]+)\s*mm\s*\)\s*;",Rx);
- if(!baseMatch.Success)return Failure("Expected `Base: Rectangle(<width>mm, <depth>mm);`.");
- var width=Num(baseMatch,"w");var depth=Num(baseMatch,"d");if(width<=0||depth<=0)return Failure("Base rectangle dimensions must be positive.");
- var material=Regex.Match(clean,"\\bMaterial\\s*:\\s*\"(?<v>[^\"]+)\"\\s*;",Rx) is {Success:true} mm?mm.Groups["v"].Value:null;
- var k=TryScalar(clean,"KFactor",null,out var parsedK)?parsedK:SheetMetalFlattenPolicy.Default.KFactor;if(k<0||k>1)return Failure("KFactor must be between 0 and 1.");
- var flanges=Regex.Matches(clean,@"\bFlange\s+(?<name>[A-Za-z_][A-Za-z0-9_]*)\s*\{(?<body>.*?)\}",Rx).Cast<Match>().Select(ParseFlange).ToArray();
- if(flanges.Any(f=>f is null))return Failure("Each flange requires From: Base.Left|Right, Length, Angle, and InsideRadius.");
- var typed=flanges.Cast<AuthoredFlangeSpec>().ToArray();var left=typed.SingleOrDefault(f=>f.Side.Equals("Left",StringComparison.OrdinalIgnoreCase));var right=typed.SingleOrDefault(f=>f.Side.Equals("Right",StringComparison.OrdinalIgnoreCase));
- if(left is null||right is null||typed.Length!=2)return Failure("M1 authored lowering requires exactly one Base.Left and one Base.Right flange.");
- if(Math.Abs(left.AngleRadians-Math.PI/2)>1e-8||Math.Abs(right.AngleRadians-Math.PI/2)>1e-8)return Failure("M1 formed topology supports 90 degree two-flange channels only; other angles remain typed unsupported.");
- if(left.InsideRadius<0||right.InsideRadius<0||Math.Abs(left.InsideRadius-right.InsideRadius)>1e-8)return Failure("M1 formed topology requires equal non-negative inside radii on both flanges.");
- if(left.Length<=left.InsideRadius+thickness||right.Length<=right.InsideRadius+thickness)return Failure("Flange length must exceed inside radius plus thickness.");
- var holes=Regex.Matches(clean,@"\bHole\s+(?<name>[A-Za-z_][A-Za-z0-9_]*)\s*\{(?<body>.*?)\}",Rx).Cast<Match>().Select(ParseHole).ToArray();
- if(holes.Any(h=>h is null))return Failure("Each hole requires On: Base, Center: (xmm, ymm), and Diameter.");
- var typedHoles=holes.Cast<AuthoredHoleSpec>().ToArray();if(typedHoles.Any(h=>h.Diameter<=0||h.X-h.Diameter/2<=0||h.X+h.Diameter/2>=width||h.Y-h.Diameter/2<=0||h.Y+h.Diameter/2>=depth))return Failure("Authored holes must have positive diameter and remain strictly inside the base boundary.");
- var spec=new SheetMetalAuthoringSpec(header.Groups["name"].Value,thickness,width,depth,material,k,left,right,typedHoles);
- var bodyResult=AuthoredUChannelBrepBuilder.Build(spec);if(!bodyResult.IsSuccess||bodyResult.Value is null)return new(false,spec,null,null,bodyResult.Diagnostics.Select(d=>new SheetMetalDiagnostic("sheetmetal-formed-brep-failed",SheetMetalDiagnosticSeverity.Error,d.Message)).ToArray());
- var part=CreatePart(spec,bodyResult.Value,sourcePath);var flat=SheetMetalFlattener.Flatten(part);return new(true,spec,part,flat,part.Diagnostics.Concat(flat.Diagnostics).ToArray());
- }
-
- private static SheetMetalPartIr CreatePart(SheetMetalAuthoringSpec s,BrepBody body,string sourcePath)
- {
- var t=s.Thickness;var r=s.Left.InsideRadius;var zAxis=new Vector3D(0,0,1);var yAxis=new Vector3D(0,1,0);var xAxis=new Vector3D(1,0,0);var midZ=t/2;
- var baseRegion=new SheetRegionIr("region-base",SheetRegionKind.Planar,new(DevelopabilityKind.Developable,"authored analytic plane",0,0,"Authored planar base."),new(new(0,0,midZ),zAxis,xAxis,yAxis,true),null,[new(0,0,midZ),new(s.BaseWidth,0,midZ),new(s.BaseWidth,s.BaseDepth,midZ),new(0,s.BaseDepth,midZ)],s.BaseWidth*s.BaseDepth,new("Firmament declaration","authored semantics",[],[],sourcePath),[new(SheetEvidenceKind.Authored,"base-region","High-level Rectangle base declaration.")]);
- var leftX=-(r+t/2);var rightX=s.BaseWidth+r+t/2;var leftRegion=new SheetRegionIr("region-left-flange",SheetRegionKind.Planar,new(DevelopabilityKind.Developable,"authored analytic plane",0,0,"Authored planar flange."),new(new(leftX,0,r+t),new(-1,0,0),yAxis,zAxis,true),null,[new(leftX,0,r+t),new(leftX,s.BaseDepth,r+t),new(leftX,s.BaseDepth,s.Left.Length),new(leftX,0,s.Left.Length)],s.BaseDepth*(s.Left.Length-r-t),new("Firmament declaration","authored semantics",[],[],sourcePath),[new(SheetEvidenceKind.Authored,"flange","Base.Left flange declaration.")]);
- var rightRegion=new SheetRegionIr("region-right-flange",SheetRegionKind.Planar,new(DevelopabilityKind.Developable,"authored analytic plane",0,0,"Authored planar flange."),new(new(rightX,0,r+t),new(1,0,0),yAxis,zAxis,true),null,[new(rightX,0,r+t),new(rightX,0,s.Right.Length),new(rightX,s.BaseDepth,s.Right.Length),new(rightX,s.BaseDepth,r+t)],s.BaseDepth*(s.Right.Length-r-t),new("Firmament declaration","authored semantics",[],[],sourcePath),[new(SheetEvidenceKind.Authored,"flange","Base.Right flange declaration.")]);
- SheetRegionIr bendRegion(string id,double x)=>new(id,SheetRegionKind.CylindricalBend,new(DevelopabilityKind.Developable,"authored analytic cylinder",0,0,"Authored cylindrical bend."),null,new(new(x,s.BaseDepth/2d,r+t),yAxis,r+t/2,r,Math.PI/2,s.BaseDepth,true),[],Math.PI/2*(r+t/2)*s.BaseDepth,new("Firmament declaration","authored semantics",[],[],sourcePath),[new(SheetEvidenceKind.Authored,"bend-region","90 degree cylindrical bend declaration.")]);
- var leftBendRegion=bendRegion("region-left-bend",0);var rightBendRegion=bendRegion("region-right-bend",s.BaseWidth);
- SheetBendIr bend(string id,double x,string a,string b,AuthoredFlangeSpec flange)=>new(id,new(x,s.BaseDepth/2d,r+t),yAxis,flange.AngleRadians,r,t,flange.Direction,a,b,SheetNeutralAxisPolicy.KFactorPolicy(s.KFactor),new("Firmament declaration","authored semantics",[],[],sourcePath),[new(SheetEvidenceKind.Authored,"bend","Axis, angle, radius, direction, and adjacency authored explicitly.")]);
- var bends=new[]{bend("bend-left",0,"region-base","region-left-flange",s.Left),bend("bend-right",s.BaseWidth,"region-base","region-right-flange",s.Right)};
- var features=s.Holes.Select(h=>new SheetFeatureIr($"feature-{h.Name}",SheetFeatureKind.CircularHole,"region-base",new(h.X,h.Y,midZ),h.Diameter,[],new("Firmament declaration","authored semantics",[],[],sourcePath),[new(SheetEvidenceKind.Authored,"through-hole","Authored Base circular through-hole.",h.Diameter)])).ToArray();
- var policy=new SheetMetalFlattenPolicy(s.KFactor);return new($"sheetmetal-{s.Name}",t,s.Material,"region-base",[baseRegion,leftRegion,rightRegion,leftBendRegion,rightBendRegion],bends,features,policy,SheetMetalRecognitionStatus.Complete,"Firmament V2 SheetMetal authored semantics",[new(SheetEvidenceKind.Authored,"constant-thickness","Thickness is an authored domain value.",t),new(SheetEvidenceKind.Authored,"stationary-region","Base region authored explicitly.")],[],body);
+ return AuthoredSheetMetalCompiler.Compile(clean,sourcePath);
}
- private static AuthoredFlangeSpec? ParseFlange(Match m){var b=m.Groups["body"].Value;var from=Regex.Match(b,@"\bFrom\s*:\s*Base\.(?<side>Left|Right)\s*;",Rx);if(!from.Success||!TryScalar(b,"Length","mm",out var len)||!TryScalar(b,"Angle","deg",out var deg)||!TryScalar(b,"InsideRadius","mm",out var r))return null;var direction=Regex.Match(b,@"\bDirection\s*:\s*(?<d>Up|Down)\s*;",Rx) is {Success:true} d&&d.Groups["d"].Value.Equals("Down",StringComparison.OrdinalIgnoreCase)?SheetBendDirection.Down:SheetBendDirection.Up;return new(m.Groups["name"].Value,from.Groups["side"].Value,len,deg*Math.PI/180d,r,direction);}
- private static AuthoredHoleSpec? ParseHole(Match m){var b=m.Groups["body"].Value;if(!Regex.IsMatch(b,@"\bOn\s*:\s*Base\s*;",Rx)||!TryScalar(b,"Diameter","mm",out var d))return null;var c=Regex.Match(b,@"\bCenter\s*:\s*\(\s*(?<x>[+-]?[0-9.]+)\s*mm\s*,\s*(?<y>[+-]?[0-9.]+)\s*mm\s*\)\s*;",Rx);return c.Success?new(m.Groups["name"].Value,Num(c,"x"),Num(c,"y"),d):null;}
- private static bool TryScalar(string text,string name,string? unit,out double value){var suffix=unit is null?string.Empty:@"\s*"+Regex.Escape(unit);var m=Regex.Match(text,@"\b"+Regex.Escape(name)+@"\s*:\s*(?<v>[+-]?[0-9]+(?:\.[0-9]+)?)"+suffix+@"\s*;",Rx);value=m.Success?Num(m,"v"):0;return m.Success;}
- private static double Num(Match m,string group)=>double.Parse(m.Groups[group].Value,NumberStyles.Float,CultureInfo.InvariantCulture);
private static SheetMetalAuthoringResult Failure(string message)=>new(false,null,null,null,[new("sheetmetal-firmament-invalid",SheetMetalDiagnosticSeverity.Error,message)]);
}
-
-internal static class AuthoredUChannelBrepBuilder
-{
- private enum EdgeKind{Line,Arc}
- private sealed record CrossEdge(Point3D Start,Point3D End,EdgeKind Kind,Point3D? Center,double Radius,Vector3D? Axis,bool Inner=false);
- private readonly record struct Use(EdgeId Edge,bool Reverse);
- private static readonly Direction3D PlusX=Direction3D.Create(new Vector3D(1,0,0));private static readonly Direction3D PlusY=Direction3D.Create(new Vector3D(0,1,0));private static readonly Direction3D MinusY=Direction3D.Create(new Vector3D(0,-1,0));private static readonly Direction3D PlusZ=Direction3D.Create(new Vector3D(0,0,1));
-
- public static KernelResult<BrepBody> Build(SheetMetalAuthoringSpec s)
- {
- var t=s.Thickness;var r=s.Left.InsideRadius;var ro=r+t;var w=s.BaseWidth;var d=s.BaseDepth;var ll=s.Left.Length;var lr=s.Right.Length;
- var p=new[]{new Point3D(-ro,0,ll),new(-ro,0,ro),new(0,0,0),new(w,0,0),new(w+ro,0,ro),new(w+ro,0,lr),new(w+r,0,lr),new(w+r,0,ro),new(w,0,t),new(0,0,t),new(-r,0,ro),new(-r,0,ll)};
- var edgeSpec=new[]{Line(0,1),Arc(1,2,new(0,0,ro),ro,MinusY.ToVector()),Line(2,3),Arc(3,4,new(w,0,ro),ro,MinusY.ToVector()),Line(4,5),Line(5,6),Line(6,7),Arc(7,8,new(w,0,ro),r,PlusY.ToVector(),true),Line(8,9),Arc(9,10,new(0,0,ro),r,PlusY.ToVector(),true),Line(10,11),Line(11,0)};
- var b=new TopologyBuilder();var g=new BrepGeometryStore();var bindings=new BrepBindingModel();var points=new Dictionary<VertexId,Point3D>();var v0=new VertexId[p.Length];var v1=new VertexId[p.Length];
- for(var i=0;i<p.Length;i++){v0[i]=b.AddVertex();v1[i]=b.AddVertex();points[v0[i]]=p[i];points[v1[i]]=p[i]+new Vector3D(0,d,0);}
- var e0=new EdgeId[p.Length];var e1=new EdgeId[p.Length];var ey=new EdgeId[p.Length];for(var i=0;i<p.Length;i++){var n=(i+1)%p.Length;e0[i]=b.AddEdge(v0[i],v0[n]);e1[i]=b.AddEdge(v1[i],v1[n]);ey[i]=b.AddEdge(v0[i],v1[i]);BindCross(e0[i],edgeSpec[i],0);BindCross(e1[i],edgeSpec[i],d);BindLine(ey[i],points[v0[i]],points[v1[i]]);}
- var bottomHoles=new List<EdgeId>();var topHoles=new List<EdgeId>();foreach(var h in s.Holes){bottomHoles.Add(AddCircle(h.X,h.Y,0,h.Diameter/2));topHoles.Add(AddCircle(h.X,h.Y,t,h.Diameter/2));}
- var faces=new List<FaceId>();var start=AddFace([[..e0.Select(x=>new Use(x,false))]]);BindPlane(start,new(0,0,0),MinusY,PlusX);faces.Add(start);var end=AddFace([[..e1.Reverse().Select(x=>new Use(x,true))]]);BindPlane(end,new(0,d,0),PlusY,PlusX);faces.Add(end);
- for(var i=0;i<p.Length;i++){var n=(i+1)%p.Length;var loops=new List<IReadOnlyList<Use>> { new Use[] { new(e0[i],false),new(ey[n],false),new(e1[i],true),new(ey[i],true) } };if(i==2)loops.AddRange(bottomHoles.Select(e=>(IReadOnlyList<Use>)new Use[] { new(e,true) }));if(i==8)loops.AddRange(topHoles.Select(e=>(IReadOnlyList<Use>)new Use[] { new(e,false) }));var face=AddFace(loops);BindSide(face,edgeSpec[i]);faces.Add(face);}
- for(var i=0;i<bottomHoles.Count;i++){var face=AddFace([[new(bottomHoles[i],false)],[new(topHoles[i],true)]]);var h=s.Holes[i];BindSurface(face,SurfaceGeometry.FromCylinder(new CylinderSurface(new(h.X,h.Y,0),PlusZ,h.Diameter/2,PlusX)),false);faces.Add(face);}
- var shell=b.AddShell(faces);b.AddBody([shell]);var body=new BrepBody(b.Model,g,bindings,points);var preflight=BrepExportPreflight.Validate(body);if(!preflight.IsValid)return KernelResult<BrepBody>.Failure(preflight.Diagnostics.Where(x=>x.Severity==BrepExportPreflightSeverity.Error).Select(x=>new Aetheris.Kernel.Core.Diagnostics.KernelDiagnostic(Aetheris.Kernel.Core.Diagnostics.KernelDiagnosticCode.ValidationFailed,Aetheris.Kernel.Core.Diagnostics.KernelDiagnosticSeverity.Error,$"{x.Code}: {x.Message}",x.Context)).ToArray());return KernelResult<BrepBody>.Success(body);
-
- CrossEdge Line(int a,int q)=>new(p[a],p[q],EdgeKind.Line,null,0,null);CrossEdge Arc(int a,int q,Point3D c,double radius,Vector3D axis,bool inner=false)=>new(p[a],p[q],EdgeKind.Arc,c,radius,axis,inner);
- void BindCross(EdgeId edge,CrossEdge spec,double y){var a=spec.Start+new Vector3D(0,y,0);var q=spec.End+new Vector3D(0,y,0);if(spec.Kind==EdgeKind.Line){BindCurve(edge,CurveGeometry.FromLine(new Line3Curve(a,Direction3D.Create(q-a))),0,(q-a).Length);}else{var center=spec.Center!.Value+new Vector3D(0,y,0);BindCurve(edge,CurveGeometry.FromCircle(new Circle3Curve(center,Direction3D.Create(spec.Axis!.Value),spec.Radius,Direction3D.Create(a-center))),0,Math.PI/2);}}
- void BindLine(EdgeId edge,Point3D a,Point3D q)=>BindCurve(edge,CurveGeometry.FromLine(new Line3Curve(a,Direction3D.Create(q-a))),0,(q-a).Length);
- EdgeId AddCircle(double x,double y,double z,double radius){var vertex=b.AddVertex();points[vertex]=new Point3D(x+radius,y,z);var edge=b.AddEdge(vertex,vertex);BindCurve(edge,CurveGeometry.FromCircle(new Circle3Curve(new(x,y,z),PlusZ,radius,PlusX)),0,2*Math.PI);return edge;}
- void BindCurve(EdgeId edge,CurveGeometry curve,double from,double to){var id=new CurveGeometryId(g.Curves.Count()+1);g.AddCurve(id,curve);bindings.AddEdgeBinding(new(edge,id,new(from,to)));}
- FaceId AddFace(IReadOnlyList<IReadOnlyList<Use>> loops){var ids=new List<LoopId>();foreach(var uses in loops){var loop=b.AllocateLoopId();var co=uses.Select(_=>b.AllocateCoedgeId()).ToArray();for(var i=0;i<co.Length;i++)b.AddCoedge(new(co[i],uses[i].Edge,loop,co[(i+1)%co.Length],co[(i+co.Length-1)%co.Length],uses[i].Reverse));b.AddLoop(new Loop(loop,co));ids.Add(loop);}return b.AddFace(ids);}
- void BindSide(FaceId face,CrossEdge spec){if(spec.Kind==EdgeKind.Arc){BindSurface(face,SurfaceGeometry.FromCylinder(new CylinderSurface(spec.Center!.Value,PlusY,spec.Radius,Direction3D.Create(spec.Start-spec.Center.Value))),!spec.Inner);}else{var direction=spec.End-spec.Start;var normal=Direction3D.Create(direction.Cross(PlusY.ToVector()));var u=Math.Abs(normal.ToVector().Dot(PlusY.ToVector()))>.99?PlusX:PlusY;BindSurface(face,SurfaceGeometry.FromPlane(new PlaneSurface(spec.Start,normal,u)));}}
- void BindPlane(FaceId face,Point3D origin,Direction3D normal,Direction3D u)=>BindSurface(face,SurfaceGeometry.FromPlane(new PlaneSurface(origin,normal,u)));
- void BindSurface(FaceId face,SurfaceGeometry surface,bool same=true){var id=new SurfaceGeometryId(g.Surfaces.Count()+1);g.AddSurface(id,surface);bindings.AddFaceBinding(new(face,id,same));}
- }
-}
diff --git a/Aetheris.SheetMetal/SheetMetalFlattener.cs b/Aetheris.SheetMetal/SheetMetalFlattener.cs
index c07fe6d1..db21ee08 100644
--- a/Aetheris.SheetMetal/SheetMetalFlattener.cs
+++ b/Aetheris.SheetMetal/SheetMetalFlattener.cs
@@ -85,7 +85,8 @@ public static class SheetMetalFlattener
var allPoints=flatRegions.SelectMany(r=>r.Boundary).Concat(cuts.SelectMany(c=>c.Boundary)).ToArray();
if(allPoints.Any(p=>!double.IsFinite(p.X)||!double.IsFinite(p.Y)))return Unsupported("Flat lowering produced non-finite coordinates.");
var bounds=allPoints.Length==0?null:new FlatPatternBounds(allPoints.Min(p=>p.X),allPoints.Min(p=>p.Y),allPoints.Max(p=>p.X),allPoints.Max(p=>p.Y));
- var boundary=ConvexHull(flatRegions.SelectMany(r=>r.Boundary));
+ var boundary=part.Provenance.Contains("source-independent",StringComparison.OrdinalIgnoreCase)?StitchBoundary(flatRegions):ConvexHull(flatRegions.SelectMany(r=>r.Boundary));
+ if(part.Provenance.Contains("source-independent",StringComparison.OrdinalIgnoreCase)&&boundary.Count<3)diagnostics.Add(new(SheetMetalDiagnosticCodes.ImpossibleTopology,SheetMetalDiagnosticSeverity.Error,"Authored flat material regions could not be stitched into one outer contour."));
var status=overlaps.Count>0?FlatPatternStatus.Overlapping:(mappings.Count<planar.Count||part.RecognitionStatus==SheetMetalRecognitionStatus.Partial?FlatPatternStatus.Partial:FlatPatternStatus.Valid);
var hash=Hash(flatRegions,bendLines,cuts,policy,status);
return new($"flat-{part.StableId}",status,flatRegions,bendLines.OrderBy(b=>b.BendId,StringComparer.Ordinal).ToArray(),cuts,mappings.Values.OrderBy(m=>m.Region.StableId,StringComparer.Ordinal).Select(m=>m.Public()).ToArray(),boundary,bounds,policy,evidence,diagnostics,hash);
@@ -143,6 +144,33 @@ public static class SheetMetalFlattener
var p=input.DistinctBy(x=>(Math.Round(x.X,9),Math.Round(x.Y,9))).OrderBy(x=>x.X).ThenBy(x=>x.Y).ToArray();if(p.Length<=2)return p;
var lower=new List<SheetPoint2>();foreach(var x in p){while(lower.Count>=2&&Cross(lower[^2],lower[^1],x)<=1e-10)lower.RemoveAt(lower.Count-1);lower.Add(x);}var upper=new List<SheetPoint2>();foreach(var x in p.Reverse()){while(upper.Count>=2&&Cross(upper[^2],upper[^1],x)<=1e-10)upper.RemoveAt(upper.Count-1);upper.Add(x);}return lower.Take(lower.Count-1).Concat(upper.Take(upper.Count-1)).ToArray();
}
+ private readonly record struct PointKey(long X,long Y){public static PointKey Of(SheetPoint2 p)=>new((long)Math.Round(p.X*1e8),(long)Math.Round(p.Y*1e8));}
+ private readonly record struct SegmentKey(PointKey A,PointKey B)
+ {
+ public static SegmentKey Of(SheetPoint2 a,SheetPoint2 b){var x=PointKey.Of(a);var y=PointKey.Of(b);return x.X<y.X||x.X==y.X&&x.Y<=y.Y?new(x,y):new(y,x);}
+ }
+ private static IReadOnlyList<SheetPoint2> StitchBoundary(IReadOnlyList<FlatRegion2D> regions)
+ {
+ var exposed=new Dictionary<SegmentKey,(SheetPoint2 A,SheetPoint2 B)>();
+ foreach(var region in regions.Where(r=>r.Boundary.Count>=3))for(var i=0;i<region.Boundary.Count;i++)
+ {
+ var a=region.Boundary[i];var b=region.Boundary[(i+1)%region.Boundary.Count];var key=SegmentKey.Of(a,b);if(!exposed.Remove(key))exposed[key]=(a,b);
+ }
+ if(exposed.Count==0)return [];
+ var points=new Dictionary<PointKey,SheetPoint2>();
+ foreach(var edge in exposed.Values){var a=PointKey.Of(edge.A);var b=PointKey.Of(edge.B);points[a]=edge.A;points[b]=edge.B;}
+ var remaining=new HashSet<SegmentKey>(exposed.Keys);var loops=new List<IReadOnlyList<SheetPoint2>>();
+ while(remaining.Count>0)
+ {
+ var seed=remaining.OrderBy(e=>e.A.X).ThenBy(e=>e.A.Y).First();var start=seed.A;var current=start;var loop=new List<SheetPoint2>();
+ for(var guard=0;guard<=exposed.Count+1;guard++)
+ {
+ loop.Add(points[current]);SegmentKey? found=remaining.Where(e=>e.A==current||e.B==current).Select(e=>(SegmentKey?)e).FirstOrDefault();if(found is null)break;remaining.Remove(found.Value);current=found.Value.A==current?found.Value.B:found.Value.A;if(current==start)break;
+ }
+ if(loop.Count>=3&&current==start)loops.Add(loop);
+ }
+ return loops.OrderByDescending(x=>Math.Abs(SignedArea(x))).FirstOrDefault()??[];
+ }
private static IReadOnlyList<(string A,string B)> FindOverlaps(IReadOnlyList<FlatRegion2D> regions){var result=new List<(string,string)>();for(var i=0;i<regions.Count;i++)for(var j=i+1;j<regions.Count;j++)if(PolygonsOverlap(regions[i].Boundary,regions[j].Boundary))result.Add((regions[i].SourceRegionId,regions[j].SourceRegionId));return result;}
private static bool PolygonsOverlap(IReadOnlyList<SheetPoint2> a,IReadOnlyList<SheetPoint2>b)
{
@@ -153,7 +181,7 @@ public static class SheetMetalFlattener
static bool PointInPolygonStrict(SheetPoint2 point,IReadOnlyList<SheetPoint2> polygon){var inside=false;for(var i=0;i<polygon.Count;i++){var a=polygon[i];var b=polygon[(i+1)%polygon.Count];if(Math.Abs(Cross(a,b,point))<1e-8&&point.X>=Math.Min(a.X,b.X)-1e-8&&point.X<=Math.Max(a.X,b.X)+1e-8&&point.Y>=Math.Min(a.Y,b.Y)-1e-8&&point.Y<=Math.Max(a.Y,b.Y)+1e-8)return false;if((a.Y>point.Y)!=(b.Y>point.Y)&&point.X<(b.X-a.X)*(point.Y-a.Y)/(b.Y-a.Y)+a.X)inside=!inside;}return inside;}
static IEnumerable<SheetPoint2> InteriorProbes(IReadOnlyList<SheetPoint2> p){var sign=SignedArea(p)>=0?1d:-1d;for(var i=0;i<p.Count;i++){var a=p[i];var b=p[(i+1)%p.Count];var dx=b.X-a.X;var dy=b.Y-a.Y;var len=Math.Sqrt(dx*dx+dy*dy);if(len>1e-12)yield return new((a.X+b.X)/2-sign*dy/len*1e-6,(a.Y+b.Y)/2+sign*dx/len*1e-6);}}
}
- private static string Hash(IReadOnlyList<FlatRegion2D> regions,IReadOnlyList<FlatBendLine>bends,IReadOnlyList<FlatCutLoop>cuts,SheetMetalFlattenPolicy policy,FlatPatternStatus status){var sb=new StringBuilder().Append(status).Append('|').Append(Q(policy.KFactor));foreach(var r in regions.OrderBy(x=>x.StableId,StringComparer.Ordinal)){sb.Append('|').Append(r.StableId);foreach(var p in r.Boundary)sb.Append('|').Append(Q(p.X)).Append(',').Append(Q(p.Y));}foreach(var b in bends.OrderBy(x=>x.BendId,StringComparer.Ordinal))sb.Append('|').Append(b.BendId).Append(':').Append(Q(b.BendAngleRadians)).Append(':').Append(Q(b.BendAllowance));foreach(var c in cuts.OrderBy(x=>x.FeatureId,StringComparer.Ordinal))sb.Append('|').Append(c.FeatureId);return SheetMetalRecognizer.StableHash(sb.ToString());static string Q(double value)=>Math.Round(value,9,MidpointRounding.AwayFromZero).ToString("R",CultureInfo.InvariantCulture);}
+ private static string Hash(IReadOnlyList<FlatRegion2D> regions,IReadOnlyList<FlatBendLine>bends,IReadOnlyList<FlatCutLoop>cuts,SheetMetalFlattenPolicy policy,FlatPatternStatus status){var sb=new StringBuilder().Append(status).Append('|').Append(Q(policy.KFactor));foreach(var r in regions.OrderBy(x=>x.StableId,StringComparer.Ordinal)){sb.Append('|').Append(r.StableId);foreach(var p in r.Boundary)sb.Append('|').Append(Q(p.X)).Append(',').Append(Q(p.Y));}foreach(var b in bends.OrderBy(x=>x.BendId,StringComparer.Ordinal))sb.Append('|').Append(b.BendId).Append(':').Append(b.Direction).Append(':').Append(Q(b.BendAngleRadians)).Append(':').Append(Q(b.BendAllowance));foreach(var c in cuts.OrderBy(x=>x.FeatureId,StringComparer.Ordinal))sb.Append('|').Append(c.FeatureId);return SheetMetalRecognizer.StableHash(sb.ToString());static string Q(double value)=>Math.Round(value,9,MidpointRounding.AwayFromZero).ToString("R",CultureInfo.InvariantCulture);}
private static double Cross(SheetPoint2 a,SheetPoint2 b,SheetPoint2 c)=>(b.X-a.X)*(c.Y-a.Y)-(b.Y-a.Y)*(c.X-a.X);
private static SheetPoint2 Add(SheetPoint2 a,SheetPoint2 b)=>new(a.X+b.X,a.Y+b.Y);private static SheetPoint2 Sub(SheetPoint2 a,SheetPoint2 b)=>new(a.X-b.X,a.Y-b.Y);private static SheetPoint2 Scale(SheetPoint2 a,double s)=>new(a.X*s,a.Y*s);private static double Dot(SheetPoint2 a,SheetPoint2 b)=>a.X*b.X+a.Y*b.Y;private static SheetPoint2 Normalize(SheetPoint2 a){var l=Math.Sqrt(Dot(a,a));return l<=1e-12?new(1,0):Scale(a,1/l);}private static Vector3D Normalize(Vector3D v)=>v.TryNormalize(out var n)?n:v;
}
diff --git a/Aetheris.SheetMetal/SheetMetalIntentRecovery.cs b/Aetheris.SheetMetal/SheetMetalIntentRecovery.cs
index f7ca6131..d0de1d4c 100644
--- a/Aetheris.SheetMetal/SheetMetalIntentRecovery.cs
+++ b/Aetheris.SheetMetal/SheetMetalIntentRecovery.cs
@@ -180,15 +180,18 @@ public static class SheetMetalIntentComparer
var match = remaining.OrderBy(x => AxisDistance(bend, x) + Math.Abs(bend.BendAngleRadians - x.BendAngleRadians) * 10 + Math.Abs(bend.InsideRadius - x.InsideRadius)).FirstOrDefault();
if (match is null) continue; remaining.Remove(match);
var axis = AxisDistance(bend, match); var axisAngle = AxisAngle(bend.AxisDirection, match.AxisDirection); var angle = Math.Abs(bend.BendAngleRadians - match.BendAngleRadians) * 180 / Math.PI; var radius = Math.Abs(bend.InsideRadius - match.InsideRadius);
- var adjacency = SameAdjacency(bend, match); var bendStatus = axis <= policy.BendAxisTolerance && axisAngle <= policy.BendAngleToleranceDegrees && angle <= policy.BendAngleToleranceDegrees && radius <= policy.BendRadiusTolerance && adjacency ? SheetMetalComparisonStatus.Pass : SheetMetalComparisonStatus.Fail;
+ var adjacency = SameAdjacency(source, intent, bend, match); var bendStatus = axis <= policy.BendAxisTolerance && axisAngle <= policy.BendAngleToleranceDegrees && angle <= policy.BendAngleToleranceDegrees && radius <= policy.BendRadiusTolerance && adjacency ? SheetMetalComparisonStatus.Pass : SheetMetalComparisonStatus.Fail;
bends.Add(new(bend.StableId, match.StableId, axis, axisAngle, angle, radius, adjacency, bendStatus));
}
var features = CompareFeatures(source.Features, intent.Features, policy.FeatureTolerance);
var sf = SheetMetalFlattener.Flatten(source); var inf = SheetMetalFlattener.Flatten(intent); var flat = CompareFlat(sf, inf, policy.FlatPatternTolerance, features);
var thickness = Math.Abs(source.Thickness - intent.Thickness);
if(thickness>1e-9&&intent.Evidence.Any(e=>e.Predicate=="accepted-thickness-nominal"))acceptedDifferences.Add($"Accepted thickness nominalization: source {source.Thickness:G12} mm -> intent {intent.Thickness:G12} mm (delta {thickness:G6} mm).");
- var unexplained = thickness > policy.PositionTolerance || s2i.P95 > policy.PositionTolerance || i2s.P95 > policy.PositionTolerance || bends.Any(b => b.Status == SheetMetalComparisonStatus.Fail) || features.Any(f => f.Status == SheetMetalComparisonStatus.Fail) || flat.Status == SheetMetalComparisonStatus.Fail;
- var status = unexplained ? SheetMetalComparisonStatus.Fail : acceptedDifferences.Count > 0 ? SheetMetalComparisonStatus.PassWithKnownDifferences : SheetMetalComparisonStatus.Pass;
+ var critical = thickness > policy.PositionTolerance || bends.Any(b => b.Status == SheetMetalComparisonStatus.Fail) || features.Any(f => f.Status == SheetMetalComparisonStatus.Fail) || remaining.Count > 0 || bends.Count != source.Bends.Count;
+ var shapeReview = s2i.P95 > policy.PositionTolerance || i2s.P95 > policy.PositionTolerance || flat.Status == SheetMetalComparisonStatus.Fail;
+ if(!critical&&shapeReview&&intent.Provenance.Contains("source-independent",StringComparison.OrdinalIgnoreCase))
+ acceptedDifferences.Add("Source-independent reconstructed topology differs from historical STEP boundary trims; bend/cut semantics pass and global formed/flat residuals require engineer review.");
+ var status = critical ? SheetMetalComparisonStatus.Fail : shapeReview ? SheetMetalComparisonStatus.NeedsReview : acceptedDifferences.Count > 0 ? SheetMetalComparisonStatus.PassWithKnownDifferences : SheetMetalComparisonStatus.Pass;
var diagnostics = new List<string>(); if (remaining.Count > 0 || bends.Count != source.Bends.Count) diagnostics.Add($"Bend count mismatch: source {source.Bends.Count}, intent {intent.Bends.Count}."); if (source.Features.Count != intent.Features.Count) diagnostics.Add($"Feature count mismatch: source {source.Features.Count}, intent {intent.Features.Count}.");
return new(status, thickness, s2i, i2s, bends, features, flat, acceptedDifferences, diagnostics);
}
@@ -220,5 +223,11 @@ public static class SheetMetalIntentComparer
private static double AxisDistance(SheetBendIr a, SheetBendIr b) { var u = Normalize(a.AxisDirection); var v = Normalize(b.AxisDirection); var cross = u.Cross(v); if (cross.TryNormalize(out var n)) return Math.Abs((b.AxisOrigin-a.AxisOrigin).Dot(n)); return ((b.AxisOrigin-a.AxisOrigin).Cross(u)).Length; }
private static double AxisAngle(Vector3D a, Vector3D b) => Math.Acos(Math.Clamp(Math.Abs(Normalize(a).Dot(Normalize(b))), -1, 1)) * 180 / Math.PI;
private static Vector3D Normalize(Vector3D v) => v.TryNormalize(out var n) ? n : v;
- private static bool SameAdjacency(SheetBendIr a, SheetBendIr b) => (a.AdjacentRegionA == b.AdjacentRegionA && a.AdjacentRegionB == b.AdjacentRegionB) || (a.AdjacentRegionA == b.AdjacentRegionB && a.AdjacentRegionB == b.AdjacentRegionA) || (a.Source.FaceIds.Count > 0 && a.Source.FaceIds.SequenceEqual(b.Source.FaceIds));
+ private static bool SameAdjacency(SheetMetalPartIr source,SheetMetalPartIr intent,SheetBendIr a,SheetBendIr b)
+ {
+ if((a.AdjacentRegionA == b.AdjacentRegionA && a.AdjacentRegionB == b.AdjacentRegionB) || (a.AdjacentRegionA == b.AdjacentRegionB && a.AdjacentRegionB == b.AdjacentRegionA) || (a.Source.FaceIds.Count > 0 && a.Source.FaceIds.SequenceEqual(b.Source.FaceIds)))return true;
+ static int Degree(SheetMetalPartIr p,string id)=>p.Bends.Count(x=>x.AdjacentRegionA==id||x.AdjacentRegionB==id);
+ var sa=new[]{Degree(source,a.AdjacentRegionA),Degree(source,a.AdjacentRegionB)}.Order().ToArray();var sb=new[]{Degree(intent,b.AdjacentRegionA),Degree(intent,b.AdjacentRegionB)}.Order().ToArray();
+ return sa.SequenceEqual(sb);
+ }
}
diff --git a/Aetheris.SheetMetal/SheetMetalIr.cs b/Aetheris.SheetMetal/SheetMetalIr.cs
index 569e0b68..b8633657 100644
--- a/Aetheris.SheetMetal/SheetMetalIr.cs
+++ b/Aetheris.SheetMetal/SheetMetalIr.cs
@@ -15,6 +15,9 @@ public enum SheetMetalIntentConfidence { StructuralFact, StrongCandidate, WeakCa
public enum SheetMetalProvenanceCategory { Authored, Recovered, Reconstructed }
public enum SheetCornerKind { ClosedCorner, OpenCorner, ReliefCorner, OverlapCorner, MiteredCorner, Unknown }
public enum SheetReliefKind { Rectangular, Round, Unknown }
+public enum SheetCornerPolicy { Open, Mitered, Relief }
+public enum SheetReliefPolicy { None, Auto, Rectangular, Round }
+public enum SheetFlangeLengthMode { TangentToEdge }
public static class SheetMetalDiagnosticCodes
{
@@ -31,10 +34,16 @@ public static class SheetMetalDiagnosticCodes
public const string DuplicateCut = "sheetmetal-flat-duplicate-cut";
public const string BendLineOutsideMaterial = "sheetmetal-flat-bend-line-outside-material";
public const string ZeroWidthSliver = "sheetmetal-flat-zero-width-sliver";
+ public const string DuplicateFlange = "sheetmetal-duplicate-flange";
+ public const string ImpossibleTopology = "sheetmetal-impossible-topology";
+ public const string InvalidRelief = "sheetmetal-invalid-relief";
+ public const string CutCrossesBend = "sheetmetal-cut-crosses-bend";
+ public const string FormedBodyInvalid = "sheetmetal-formed-body-invalid";
public static IReadOnlyList<string> All { get; } =
[NonConstantThickness, UnpairedFaces, NonDevelopable, AmbiguousBendAxis, UnsupportedBendTopology,
InconsistentBendRadius, DisconnectedGraph, FlatOverlap, FeatureMappingFailure, InvalidRadius,
- DuplicateCut, BendLineOutsideMaterial, ZeroWidthSliver];
+ DuplicateCut, BendLineOutsideMaterial, ZeroWidthSliver, DuplicateFlange, ImpossibleTopology,
+ InvalidRelief, CutCrossesBend, FormedBodyInvalid];
}
public sealed record SheetMetalDiagnostic(
@@ -114,6 +123,35 @@ public sealed record SheetFeatureIr(
SheetSourceBinding Source,
IReadOnlyList<SheetEvidence> Evidence);
+public sealed record SheetMetalCornerIr(
+ string StableId,
+ string RegionA,
+ string RegionB,
+ string ParentRegion,
+ string VertexName,
+ SheetCornerPolicy Policy,
+ string? ReliefId,
+ SheetSourceBinding Source,
+ IReadOnlyList<SheetEvidence> Evidence);
+
+public sealed record SheetMetalReliefIr(
+ string StableId,
+ SheetReliefKind Kind,
+ string OwningRegionId,
+ string CornerId,
+ double Width,
+ double Depth,
+ double? Radius,
+ bool IsPolicyDerived,
+ SheetSourceBinding Source,
+ IReadOnlyList<SheetEvidence> Evidence);
+
+public sealed record SheetMetalCorrespondence(
+ string SemanticId,
+ string Kind,
+ string FormedId,
+ string FlatId);
+
public sealed record SheetMetalFlattenPolicy(double KFactor)
{
public static SheetMetalFlattenPolicy Default { get; } = new(0.5d);
@@ -169,7 +207,11 @@ public sealed record SheetMetalPartIr(
string Provenance,
IReadOnlyList<SheetEvidence> Evidence,
IReadOnlyList<SheetMetalDiagnostic> Diagnostics,
- BrepBody? FormedBody = null);
+ BrepBody? FormedBody = null,
+ IReadOnlyList<SheetMetalCornerIr>? Corners = null,
+ IReadOnlyList<SheetMetalReliefIr>? Reliefs = null,
+ IReadOnlyList<SheetMetalCorrespondence>? Correspondence = null,
+ SheetFlangeLengthMode FlangeLengthMode = SheetFlangeLengthMode.TangentToEdge);
public readonly record struct SheetPoint2(double X, double Y);
diff --git a/Aetheris.SheetMetal/SheetMetalManufacturingArtifacts.cs b/Aetheris.SheetMetal/SheetMetalManufacturingArtifacts.cs
index 67b9d512..b65f917f 100644
--- a/Aetheris.SheetMetal/SheetMetalManufacturingArtifacts.cs
+++ b/Aetheris.SheetMetal/SheetMetalManufacturingArtifacts.cs
@@ -39,7 +39,10 @@ public static class SheetMetalManufacturingArtifacts
var cut = flat.CutLoops[index];
if (cut.Boundary.Count < 3) continue;
var name = $"cut_{index:D3}";
- profiles[name] = Profile(name, cut.Boundary, shift);
+ var cutFeature=part.Features.FirstOrDefault(f=>f.StableId==cut.FeatureId);
+ profiles[name] = cutFeature is { Kind:SheetFeatureKind.CircularHole,Diameter:not null }
+ ? CircleProfile(name,new(cut.Boundary.Average(p=>p.X),cut.Boundary.Average(p=>p.Y)),cutFeature.Diameter.Value/2,shift)
+ : Profile(name, cut.Boundary, shift);
operations.Add(new(name, PrismaticProfileIntent.Remove, name, 0, part.Thickness, "ThroughCut", cut.FeatureId, cut.FeatureId, cut.Kind.ToString()));
}
if (materialRegions.Length == 0) return Failure("Flat pattern contains no bounded material regions.");
@@ -143,6 +146,13 @@ public static class SheetMetalManufacturingArtifacts
return new(name, "XY", [new("Outer", true, segments)]);
}
+ private static ResolvedProfile2D CircleProfile(string name,SheetPoint2 center,double radius,SheetPoint2 shift)
+ {
+ var c=(Clean(center.X+shift.X),Clean(center.Y+shift.Y));
+ ResolvedProfileSegment2D Segment(string id,double start)=>new(id,new LineArcCircularArc2D(c,radius,start,Math.PI),new($"{name}:{id}",name,name,"SheetMetalFlatPatternIr analytic circle","XY"));
+ return new(name,"XY",[new("Outer",true,[Segment("semicircle_0",0),Segment("semicircle_1",Math.PI)])]);
+ }
+
private static double SignedArea(IReadOnlyList<SheetPoint2> points) { var sum = 0d; for (var i = 0; i < points.Count; i++) { var q = points[(i + 1) % points.Count]; sum += points[i].X * q.Y - q.X * points[i].Y; } return sum / 2d; }
private static double Clean(double value) => Math.Abs(value) < 1e-9 ? 0d : value;
private static string Safe(string value) { var chars = value.Select(ch => char.IsLetterOrDigit(ch) || ch == '_' ? ch : '_').ToArray(); var result = new string(chars); return result.Length > 0 && (char.IsLetter(result[0]) || result[0] == '_') ? result : "Recovered_" + result; }
diff --git a/Aetheris.SheetMetal/SheetMetalModule.cs b/Aetheris.SheetMetal/SheetMetalModule.cs
index a37e63d8..058ecee9 100644
--- a/Aetheris.SheetMetal/SheetMetalModule.cs
+++ b/Aetheris.SheetMetal/SheetMetalModule.cs
@@ -6,22 +6,25 @@ namespace Aetheris.SheetMetal;
public static class SheetMetalModule
{
public static readonly AetherisModuleId Id = new("Aetheris.SheetMetal");
- public static readonly ModuleVersion Version = new(0, 3, 0);
+ public static readonly ModuleVersion Version = new(0, 4, 0);
public static AetherisModule Definition { get; } = new(Id,"Sheet Metal",Version,
[
Capability("SheetMetal.ConstantThickness", "Tolerance-bounded planar and coaxial cylindrical thickness recognition."),
Capability("SheetMetal.BendRecovery", "Bounded planar-cylinder-planar bend recovery with source-face evidence."),
Capability("SheetMetal.FlatPattern", "Deterministic K-factor lowering to flat IR, AP242 solid, recovered Firmament intent, bend lines, and mapped cuts."),
- Capability("SheetMetal.AuthoredBracket", "Firmament V2 module syntax and exact formed topology for two-flange brackets."),
+ Capability("SheetMetal.AuthoredMultiFlange", "Source-independent rectangular base/flange graph with parent-flange continuation, arbitrary 0<angle<180 degree cylindrical bends, and Up/Down direction."),
+ Capability("SheetMetal.ExactFormedBody", "Explicit stitched planar/cylindrical skins, thickness walls, and region-owned circular/profile cuts; closed-manifold AP242 without generic Boolean union."),
+ Capability("SheetMetal.StitchedAuthoredFlat", "Authored graph traversal, shared bend allowance, stitched outer contour, mapped cuts, physical flat AP242, and SVG."),
+ Capability("SheetMetal.CornerRelief", "Bounded adjacent-flange Open/Mitered/Relief semantics with deterministic automatic relief dimensions and correspondence."),
Capability("SheetMetal.IntentRecovery", "Two-layer forensic recovery and explicit human/LLM reconstructed authority with bounded nominal/grouping suggestions."),
Capability("SheetMetal.IntentComparison", "Localized formed-boundary, bend, cut, and flat-pattern residuals under an explicit reconstruction policy."),
Capability("SheetMetal.SourceEdgeFlat", "Ordered exact source-line vertices are preserved in flat regions when the recovered loop is valid; invalid loops retain deterministic hull fallback."),
Capability("SheetMetal.CornerReliefEvidence", "Bounded corner relationships and proximity-gated relief candidates remain classified evidence, never silent authored truth."),
- Capability("SheetMetal.DfmM2", "Parameterized radius, cut-to-bend, cut-to-edge, and flat-overlap diagnostics with semantic subjects and bounded suggestions.")
+ Capability("SheetMetal.DfmM3", "Parameterized radius, cut-to-bend, cut-to-edge, corner-resolution, and flat-overlap diagnostics with semantic subjects and bounded suggestions.")
],
["SheetMetal","ConstantThickness","Flattenable","HasFlatPattern","BendCapable"],
- ["TwoFlangeBracket<Spec>"],
- ["Firmament SheetMetal -> SheetMetalPartIr -> explicit formed BRep + SheetMetalFlatPatternIr","STEP BRep -> recognized SheetMetalPartIr -> bounded flat pattern -> flat AP242 + recovered Firmament + SVG"],
+ ["AuthoredSheetMetal<RegionBendGraph>","RecoveredSheetMetalEvidence<Part>"],
+ ["Firmament SheetMetal -> SheetMetalPartIr region/bend/corner graph -> explicit formed BRep + stitched SheetMetalFlatPatternIr","STEP BRep -> recognized SheetMetalPartIr -> bounded flat pattern -> recovered Firmament + SVG"],
SheetMetalDiagnosticCodes.All,
[new(CoreModule.Id,new(1,0,0)),new(SurfacingModule.Id,new(0,1,0))],new("docs/modules/sheet-metal.md"));
diff --git a/docs/modules/sheet-metal.md b/docs/modules/sheet-metal.md
index 011a2d30..3fbb52b9 100644
--- a/docs/modules/sheet-metal.md
+++ b/docs/modules/sheet-metal.md
@@ -1,40 +1,74 @@
# Sheet Metal Module
-`Aetheris.SheetMetal` 0.3.0 adds an explicit human/LLM-in-the-loop intent-reconstruction workflow. It owns manufacturing semantics above Core BRep: nominal thickness, reference-sheet regions, explicit bends, neutral-axis policy, cut correspondence, source-edge-aware flat-pattern lowering, comparison, validation, and bounded DFM. Imported STEP remains the formed-geometry authority; recovered `SheetMetalPartIr` is evidence and never silently becomes production authority.
+`Aetheris.SheetMetal` 0.4.0 adds bounded M3 source-independent construction while preserving the M1/M2 imported-recovery workflow. Clean authored or reconstructed Firmament is engineering authority; imported STEP participates only in recovery or post-generation comparison.
-## M2 authority model
+## Construction architecture
-Recovery deliberately has two layers. `RecoveredSheetMetalEvidence` is deterministic, provenance-heavy forensic data. `RecoveredFirmamentDraft` is a machine-generated starting point. An engineer or LLM writes a separate `Intent: Reconstructed` Firmament source whose names, grouping, and accepted nominals are explicit decisions linked through `FromEvidence`. `SheetMetalIntentComparer` then verifies formed boundaries, bend axes/angles/radii/adjacency, cuts, and flat output using structured residuals. `Partial` machine recovery is therefore useful and is not treated as workflow failure.
-
-## Supported M1 boundary
+```text
+Firmament SheetMetal
+ -> SheetMetalPartIr (region / bend / corner / relief graph)
+ -> explicit sheet topology lowering
+ -> planar skins + analytic cylindrical skins + thickness/cut walls
+ -> closed formed BRep -> AP242
-- Firmament V2 module-owned `SheetMetal` syntax for one rectangular base with two opposite 90° flanges and circular base holes.
-- Exact formed analytic BRep for that authored family: planar skins, concentric cylindrical bends, exact circular hole walls, closed-manifold STEP AP242 export, and no generic Boolean fallback.
-- Tolerance-bounded recognition of parallel planar skin pairs and coaxial cylindrical skin pairs in ordinary exact BRep/STEP.
-- Planar midpoint reference planes and geometric mid-cylinders. These are deliberately distinct from the manufacturing neutral axis.
-- Planar/cylindrical developability using the existing Surfacing evidence vocabulary.
-- Deterministic largest-planar-area base selection, bend-graph traversal, exact neutral-axis cylindrical development, cut mapping, overlap checks, a thickness-bearing flat AP242 solid, explicit recovered Firmament intent, and a compact secondary SVG view.
-- Explicit provisional K-factor policy. The default is `0.5`; authored source may override it. This is not a material/process database.
-- Parameterized first-pass DFM checks for positive thickness, bend-radius ratio, hole-to-bend distance, and flat overlap.
+SheetMetalPartIr
+ -> exact graph traversal using the same bend policy
+ -> planar regions + neutral-axis bend strips
+ -> stitched outer blank + mapped cuts
+ -> thickness-bearing flat AP242 / SVG
+```
-M2 additionally preserves valid ordered source-line loops instead of replacing every flat region with a convex hull, exposes bounded nominal/grouping/corner/relief suggestions, and adds semantic cut-to-bend/cut-to-edge DFM findings with suggested displacement where deterministic. Analytic arcs in arbitrary imported outer contours, exact global blank union/stitching, and authoritative relief-family recognition remain incomplete; CTC-03 honestly remains `Partial`.
+The formed path constructs known sheet topology directly. It does not union flange solids with generic `BrepBoolean`. Every authored region, bend, cut, corner, and relief has a stable formed/flat correspondence entry.
-## Canonical commands
+## Canonical syntax and semantics
-```text
-aetheris sheetmetal inspect part.step
-aetheris sheetmetal recover part.step --out-dir recovery
-aetheris sheetmetal compare part.step reconstructed.firmament
-aetheris sheetmetal flatten part.step --step part-flat.step --firmament part-recovered.firmament --svg part-flat.svg --k-factor 0.5
-aetheris build fixtures/FirmamentV2/SheetMetal/simple-u-channel.firmament
+```firmament
+SheetMetal Tray {
+ Thickness: 1.2mm;
+ KFactor: 0.42;
+ Base Main { Profile: Rectangle { Width: 240mm; Height: 180mm; }; }
+ Flange Front { From: Main.Front; Height: 40mm; Angle: 90deg; Radius: 1.5mm; Direction: Up; Relief: Auto; }
+ Flange Lip { From: Front.Outer; Length: 15mm; Angle: 45deg; Radius: 1.5mm; Direction: Down; }
+ Cut Fan { On: Main; Profile: Circle { Diameter: 120mm; }; At: (120mm, 90mm); }
+}
```
-The canonical authored fixture is [`simple-u-channel.firmament`](../../fixtures/FirmamentV2/SheetMetal/simple-u-channel.firmament). The hostile imported fixture is the existing NIST CTC-03 corpus file at `testdata/step242/nist/CTC/nist_ctc_03_asme1_ap242-e2.stp`.
+`Length` and `Height` are aliases for the canonical `TangentToEdge` dimension: distance on the resulting planar flange from the bend tangent line to its free edge. `InsideRadius`/`Radius` is the physical inside radius. `Up` rotates the parent outward direction toward its material-positive normal; `Down` rotates oppositely. Angles strictly between 0° and 180° are supported; ordinary bends retain exact plane and cylinder supports.
+
+`KFactor` defines `neutral radius = inside radius + K * thickness` and `bend allowance = abs(angle) * neutral radius`. The formed and flat paths consume the same bend record and policy. The flat bend line is the neutral-axis centerline of the explicit bend strip.
+
+The bounded graph supports flanges from rectangular-base `Front/Rear/Left/Right` edges and from a previously generated flange's `Outer` (`Top`) edge. Duplicate edge ownership, disconnected parents, invalid bends, and cuts reaching a region boundary/bend zone are typed rejections.
+
+## Corners, reliefs, and cuts
+
+Adjacent base flanges receive deterministic end trimming. `Corner: Open` is the robust baseline. `Corner: Miter` selects the smaller symmetric miter setback but remains an open, non-welded seam. `Relief: Auto`, `Rectangular`, and `Round` create typed relief intent/provenance; the bounded formed topology realizes this as bend-end/open-corner material clearance. Auto width is at least one thickness and auto depth is `inside radius + thickness`. Closed overlap/gap seams, welded corners, arbitrary corner intersections, and a freestanding shop relief library remain deferred.
+
+Circular holes and axis-aligned rectangular/slot profile cuts are exact formed through-cuts and map to the same owning flat region. Cuts crossing bend zones are rejected rather than warped or silently split. SVG shows region material, cut contours, neutral-axis bend lines, direction, angle, and radius.
-## Recognition doctrine
+## Authored fixtures and CTC-03
+
+- [`m3-l-bracket.firmament`](../../fixtures/FirmamentV2/SheetMetal/m3-l-bracket.firmament)
+- [`m3-u-channel.firmament`](../../fixtures/FirmamentV2/SheetMetal/m3-u-channel.firmament)
+- [`m3-electronics-tray.firmament`](../../fixtures/FirmamentV2/SheetMetal/m3-electronics-tray.firmament)
+- [`ctc03-idiomatic.firmament`](sheetmetal/artifacts/m2/ctc03-idiomatic.firmament)
+
+The CTC-03 source contains no `EvidenceSource`, `FromEvidence`, face IDs, or recovered polygons. It independently generates 15 semantic regions, seven exact bends, two cuts, a closed formed BRep, and a valid flat blank. Post-generation comparison classifies it `NeedsReview`: all seven bend axis/angle/radius/graph comparisons and both cuts pass, while historical local boundary trims and the accepted M2 flat outline are not yet reproduced closely enough. This is deliberately not presented as full source parity.
+
+## Recovery remains separate
+
+Imported STEP still follows `STEP -> RecoveredSheetMetalEvidence -> recovered draft -> engineer/LLM reconstruction`. Recovered models may retain source-edge geometry and `Partial` status. That forensic dialect is distinct from the M3 clean authored dialect and remains useful for verification.
+
+## Commands
+
+```text
+aetheris build part.firmament --output part-formed.step
+aetheris sheetmetal flatten part.firmament --step part-flat.step --svg part-flat.svg
+aetheris sheetmetal recover imported.step --out-dir recovery
+aetheris sheetmetal compare imported.step reconstructed.firmament
+```
-Thickness candidates come from overlapping parallel planes and axially overlapping coaxial cylinders. Candidate separations are clustered under an explicit linear tolerance, then the bounded alternatives are admitted/scored/tie-broken by `JudgmentEngine`. BRep face IDs remain source bindings only; stable semantic region and bend IDs derive deterministically from ordered source bindings.
+## Bounded capability
-The flat STEP is generated from the same analytic flat IR as the Firmament and SVG artifacts. It is a closed thickness-bearing solid and re-imports through Aetheris, but the current imported flattening preserves recovered region hulls and mapped inner-loop cut profiles rather than stitching every source edge fragment into an exact production-ready blank contour. That boundary-stitching/corner-relief problem is why imported CTC-03 remains `Partial`.
+M3 proves common brackets, parallel channels, four-wall open-corner trays, parent-flange lips, circular/rectangular cuts, analytic cylindrical bends, deterministic correspondence, and physical formed/flat STEP. It does not claim hems, jogs, beads, lofted bends, stamping, springback, closed-corner overlap policy, universal brake sequencing, or commercial sheet-metal parity. The largest production blocker is a richer exact 2D contour/trim kernel for commercial corner seams, arbitrary profile/relief curves, and manufacturing-grade DXF/tooling workflows.
-See the compact [M1 evidence bundle](sheetmetal/artifacts/m1/README.md) and [M2 assisted-reconstruction evidence](sheetmetal/artifacts/m2/README.md).
+See the [M1 bundle](sheetmetal/artifacts/m1/README.md), [M2 recovery bundle](sheetmetal/artifacts/m2/README.md), and [M3 evidence](sheetmetal/artifacts/m3/README.md).
diff --git a/docs/modules/sheetmetal/artifacts/m2/README.md b/docs/modules/sheetmetal/artifacts/m2/README.md
index f28ca0fc..f76ea1f1 100644
--- a/docs/modules/sheetmetal/artifacts/m2/README.md
+++ b/docs/modules/sheetmetal/artifacts/m2/README.md
@@ -4,13 +4,13 @@ This bundle demonstrates the intended authority chain:
1. `recovery-summary.json` and `recovered-draft.firmament` are deterministic forensic machine evidence.
2. `reconstruction-brief.md` is bounded context for an engineer/LLM.
-3. `ctc03-idiomatic.firmament` is the checked-in reconstructed engineering interpretation.
+3. `ctc03-idiomatic.firmament` is the checked-in reconstructed engineering interpretation. M3 subsequently promoted this same file to a self-contained Base/Flange/Cut model; the M2 evidence and outputs below remain a historical snapshot.
4. `ctc03-comparison.md` records deterministic compiler verification; the CLI can emit the same structured residuals as JSON on demand.
5. `ctc03-flat.step` is a 1.905 mm physical AP242 flat solid; `ctc03-flat.svg` is the review view.
The machine source has 264 lines and 24 region/bend/cut declarations. The reconstructed source has 103 lines and 24 explicitly accounted declarations. Its compression comes from moving 3D boundary coordinates and raw face IDs into forensic evidence while retaining semantic feature coverage.
-Result: `PassWithKnownDifferences`. CTC-03 remains `Partial` as automatic recovery because exact global blank stitching, arbitrary analytic outer arcs, and authoritative corner/relief intent remain bounded gaps.
+Historical M2 result: `PassWithKnownDifferences`. Re-running the current self-contained M3 source now produces `NeedsReview`; see `../m3/` for current generated geometry and residuals. CTC-03 remains `Partial` as automatic recovery.
Reproduce:
diff --git a/docs/modules/sheetmetal/artifacts/m2/ctc03-comparison.md b/docs/modules/sheetmetal/artifacts/m2/ctc03-comparison.md
index 41fa35dd..440c389b 100644
--- a/docs/modules/sheetmetal/artifacts/m2/ctc03-comparison.md
+++ b/docs/modules/sheetmetal/artifacts/m2/ctc03-comparison.md
@@ -1,4 +1,6 @@
-# CTC-03 source → reconstructed intent comparison
+# CTC-03 source → reconstructed intent comparison (historical M2 result)
+
+The checked-in idiomatic source was promoted to source-independent M3 construction after this report. See `../m3/ctc03-formed-comparison.md` for the current comparison.
Policy: position 0.05 mm; bend axis 0.05 mm; bend angle 0.05°; bend radius 0.05 mm; flat 0.1 mm; feature 0.1 mm.
diff --git a/docs/modules/sheetmetal/artifacts/m2/ctc03-idiomatic.firmament b/docs/modules/sheetmetal/artifacts/m2/ctc03-idiomatic.firmament
index 51f4bc86..05e40081 100644
--- a/docs/modules/sheetmetal/artifacts/m2/ctc03-idiomatic.firmament
+++ b/docs/modules/sheetmetal/artifacts/m2/ctc03-idiomatic.firmament
@@ -1,103 +1,26 @@
// Engineer/LLM reconstruction of NIST CTC-03.
-// Geometry/provenance stays in the forensic evidence artifact; this file owns
-// the editable names, grouping interpretation, and accepted nominal values.
+// M3 authority law: every construction dimension is present here. The recovered
+// draft and source STEP are verification evidence and are not loaded to build it.
SheetMetal Ctc03 {
Intent: Reconstructed;
- EvidenceSource: "recovered-draft.firmament";
-
- // Measured 1.907540000007641 mm; accepted as 0.075 in nominal sheet.
Thickness: 1.905mm;
- KFactor: 0.5; // Assumed policy; source STEP does not establish shop bend policy.
- BaseRegion: MainDeck;
+ KFactor: 0.5;
+ Material: "0.075 in nominal sheet";
- Region MainDeck {
- FromEvidence: "region-p-0065-0069";
- Role: Base;
- }
- Region FrontWall {
- FromEvidence: "region-p-0062-0063";
- Role: Flange;
- }
- Region RearWall {
- FromEvidence: "region-p-0061-0066";
- Role: Flange;
- }
- Region LeftWall {
- FromEvidence: "region-p-0102-0104";
- Role: Flange;
- }
- Region RightWall {
- FromEvidence: "region-p-0118-0119";
- Role: Flange;
- }
- Region FrontMountingFlange {
- FromEvidence: "region-p-0096-0097";
- Role: Flange;
- }
- Region RearMountingFlange {
- FromEvidence: "region-p-0088-0089";
- Role: Flange;
- }
- Region AngledServiceFlange {
- FromEvidence: "region-p-0109-0111";
- Role: Flange;
+ Base MainDeck {
+ Profile: Rectangle { Width: 241.3mm; Height: 368.3mm; };
+ Origin: (-241.3mm, 58.08726mm, 76.2mm);
}
- // Bend strips remain explicit regions so formed/flat correspondence is stable.
- Region FrontLipBendRegion { FromEvidence: "region-c-0006-0009"; Role: Bend; }
- Region RearLipBendRegion { FromEvidence: "region-c-0005-0024"; Role: Bend; }
- Region ServiceRampBendRegion { FromEvidence: "region-c-0046-0050"; Role: Bend; }
- Region RightWallBendRegion { FromEvidence: "region-c-0057-0070"; Role: Bend; }
- Region FrontWallBendRegion { FromEvidence: "region-c-0058-0064"; Role: Bend; }
- Region LeftWallBendRegion { FromEvidence: "region-c-0059-0068"; Role: Bend; }
- Region RearWallBendRegion { FromEvidence: "region-c-0060-0067"; Role: Bend; }
+ Flange FrontWall { From: MainDeck.Front; Height: 61.59254mm; Angle: 90deg; Radius: 6.35mm; Direction: Down; Relief: Auto; }
+ Flange RearWall { From: MainDeck.Rear; Height: 61.59254mm; Angle: 90deg; Radius: 6.35mm; Direction: Down; Relief: Auto; }
+ Flange LeftWall { From: MainDeck.Left; Height: 44.45mm; Angle: 90deg; Radius: 6.35mm; Direction: Up; Relief: Auto; }
+ Flange RightWall { From: MainDeck.Right; Height: 29.11094mm; Angle: 90deg; Radius: 6.35mm; Direction: Up; Relief: Auto; }
- Bend FrontLipBend {
- FromEvidence: "bend-c-0006-0009";
- Angle: 90deg;
- InsideRadius: 6.35mm;
- }
- Bend RearLipBend {
- FromEvidence: "bend-c-0005-0024";
- Angle: 90deg;
- InsideRadius: 6.35mm;
- }
- Bend ServiceRampBend {
- FromEvidence: "bend-c-0046-0050";
- Angle: 45deg;
- InsideRadius: 6.35mm;
- }
- Bend RightWallBend {
- FromEvidence: "bend-c-0057-0070";
- Angle: 90deg;
- InsideRadius: 6.35mm;
- }
- Bend FrontWallBend {
- FromEvidence: "bend-c-0058-0064";
- Angle: 90deg;
- InsideRadius: 6.35mm;
- }
- Bend LeftWallBend {
- FromEvidence: "bend-c-0059-0068";
- Angle: 90deg;
- InsideRadius: 6.35mm;
- }
- Bend RearWallBend {
- FromEvidence: "bend-c-0060-0067";
- Angle: 90deg;
- InsideRadius: 6.35mm;
- }
+ Flange FrontMountingFlange { From: FrontWall.Outer; Length: 30.77972mm; Angle: 90deg; Radius: 6.35mm; Direction: Up; }
+ Flange RearMountingFlange { From: RearWall.Outer; Length: 44.45mm; Angle: 90deg; Radius: 6.35mm; Direction: Up; }
+ Flange AngledServiceFlange { From: RightWall.Outer; Length: 48.514mm; Angle: 45deg; Radius: 6.35mm; Direction: Down; }
- // Equal rectangular openings are interpreted as a repeated vent pair. Pattern
- // syntax is intentionally not added solely for this imported fixture.
- Cut VentSlotRight {
- FromEvidence: "feature-profile-f0065-l0069";
- On: MainDeck;
- Group: VentPair;
- }
- Cut VentSlotLeft {
- FromEvidence: "feature-profile-f0065-l0070";
- On: MainDeck;
- Group: VentPair;
- }
+ Cut VentSlotRight { On: MainDeck; Profile: Slot { Length: 19.05mm; Width: 88.9mm; }; At: (114.7826mm, 108.43514mm); }
+ Cut VentSlotLeft { On: MainDeck; Profile: Slot { Length: 19.05mm; Width: 88.9mm; }; At: (51.2826mm, 108.43514mm); }
}
diff --git a/docs/modules/sheetmetal/artifacts/m2/validation-report.md b/docs/modules/sheetmetal/artifacts/m2/validation-report.md
index 937ba7bc..e1d0bb98 100644
--- a/docs/modules/sheetmetal/artifacts/m2/validation-report.md
+++ b/docs/modules/sheetmetal/artifacts/m2/validation-report.md
@@ -1,4 +1,6 @@
-# M2 validation report
+# M2 validation report (historical snapshot)
+
+These measurements describe the evidence-linked M2 version of the idiomatic source. M3 replaced the checked-in idiomatic file with source-independent construction; current results are under `../m3/`.
- CTC-03 recovery: 15 regions, seven bends, two cuts; status `Partial`; deterministic evidence ID `3dd6f4dd338cfded7467f3aded3e0bd4e32315f40cf3db0d117e22b0687cadab`.
- Reconstructed source: compiles; 103 lines versus 264 machine lines; raw coordinates/face IDs stay in evidence.
diff --git a/docs/modules/sheetmetal/artifacts/m3/README.md b/docs/modules/sheetmetal/artifacts/m3/README.md
new file mode 100644
index 00000000..d2be50b2
--- /dev/null
+++ b/docs/modules/sheetmetal/artifacts/m3/README.md
@@ -0,0 +1,13 @@
+# AETHERIS-SHEETMETAL-M3 evidence
+
+M3 establishes bounded source-independent lowering from clean Firmament to a closed analytic formed BRep and a stitched physical flat blank. The canonical CTC-03 construction source is the M2 idiomatic file, now rewritten without recovery bindings. The source STEP is used only by the comparison command after generation.
+
+Artifacts:
+
+- `ctc03-m3-formed.step`: independently generated formed AP242.
+- `ctc03-m3-flat.step`: independently generated 1.905 mm flat solid.
+- `ctc03-m3-flat.svg`: bend/cut review drawing.
+- `ctc03-formed-generation.json`, `ctc03-generation.json`, `ctc03-comparison.json`: compact machine evidence.
+- the remaining Markdown files summarize authority, topology, comparison, DFM, performance, and validation.
+
+Verdict: the construction capability succeeds for the bounded authored family. CTC-03 semantic bend/cut parity succeeds, but historical formed trims and accepted M2 flat-contour parity remain `NeedsReview`; this bundle does not claim complete CTC-03 geometric equivalence.
diff --git a/docs/modules/sheetmetal/artifacts/m3/authored-lowering-audit.md b/docs/modules/sheetmetal/artifacts/m3/authored-lowering-audit.md
new file mode 100644
index 00000000..1da1776c
--- /dev/null
+++ b/docs/modules/sheetmetal/artifacts/m3/authored-lowering-audit.md
@@ -0,0 +1,7 @@
+# Authored lowering audit
+
+Before M3, the M1 rectangular two-opposite-90°-flange family independently generated a base, planar flanges, cylindrical bend skins, circular base holes, thickness walls, a closed formed BRep, and a region-based flat pattern. M2 reconstruction renamed and nominalized recovered regions but retained recovered planes, polygons, transforms, source face/edge bindings, and the imported formed body.
+
+M3 removes those dependencies from the normal authored path. `AuthoredSheetMetalCompiler` parses a rectangular named base, an acyclic flange graph, cuts, directions, corner/relief policies, and one K-factor policy. `AuthoredSheetMetalLowering` derives all region frames and analytic bend geometry. `AuthoredSheetBrepEmitter` shares known tangent topology and emits planes/cylinders/cut walls without generic Boolean union. `SheetMetalFlattener` traverses the same graph and cancels shared contour segments to produce one outer boundary.
+
+Forensic `RecoveredRegion`/`RecoveredBend` compilation remains evidence-linked by design; it is not the canonical authored route.
diff --git a/docs/modules/sheetmetal/artifacts/m3/corner-relief-summary.md b/docs/modules/sheetmetal/artifacts/m3/corner-relief-summary.md
new file mode 100644
index 00000000..0afcc546
--- /dev/null
+++ b/docs/modules/sheetmetal/artifacts/m3/corner-relief-summary.md
@@ -0,0 +1,5 @@
+# Corner and relief summary
+
+Adjacent base flanges create stable `SheetMetalCornerIr` records. Supported policies are bounded `Open`, open-seam `Mitered`, and `Relief`. Automatic relief derives width >= thickness and depth = inside radius + thickness and records the values/provenance in `SheetMetalReliefIr`. The formed body realizes corner clearance by deterministic bend/flange end setbacks and explicit exposed thickness walls; the same trim extents participate in flat region placement.
+
+The electronics tray and CTC-03 each produce four relief corners without flange overlap. Closed/overlap/welded seams, arbitrary corner intersection solving, and full shop-specific round/obround notch libraries remain deferred.
diff --git a/docs/modules/sheetmetal/artifacts/m3/ctc03-comparison.json b/docs/modules/sheetmetal/artifacts/m3/ctc03-comparison.json
new file mode 100644
index 00000000..0c2cc61e
--- /dev/null
+++ b/docs/modules/sheetmetal/artifacts/m3/ctc03-comparison.json
@@ -0,0 +1,143 @@
+{
+ "command": "sheetmetal compare",
+ "success": true,
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\testdata\\step242\\nist\\CTC\\nist_ctc_03_asme1_ap242-e2.stp",
+ "intent": "C:\\Users\\yuech\\source\\repos\\Aetheris\\docs\\modules\\sheetmetal\\artifacts\\m2\\ctc03-idiomatic.firmament",
+ "comparison": {
+ "status": "NeedsReview",
+ "thicknessResidual": 0.0025400000076409857,
+ "sourceToIntent": {
+ "rms": 45.8065804342658,
+ "p95": 114.78655818595969,
+ "maximum": 128.11735869868062,
+ "sampleCount": 136
+ },
+ "intentToSource": {
+ "rms": 11.124620087809111,
+ "p95": 18.102256748656195,
+ "maximum": 51.53558488189028,
+ "sampleCount": 68
+ },
+ "bends": [
+ {
+ "sourceBendId": "bend-c-0005-0024",
+ "intentBendId": "RearMountingFlangeBend",
+ "axisResidual": 0.0025412612943755287,
+ "axisAngleResidualDegrees": 0,
+ "bendAngleResidualDegrees": 2.0355549961366507E-13,
+ "radiusResidual": 2.538058652135078E-11,
+ "adjacencyMatches": true,
+ "status": "Pass"
+ },
+ {
+ "sourceBendId": "bend-c-0006-0009",
+ "intentBendId": "FrontMountingFlangeBend",
+ "axisResidual": 0.002541259357449586,
+ "axisAngleResidualDegrees": 0,
+ "bendAngleResidualDegrees": 0,
+ "radiusResidual": 2.5410784587620583E-11,
+ "adjacencyMatches": true,
+ "status": "Pass"
+ },
+ {
+ "sourceBendId": "bend-c-0046-0050",
+ "intentBendId": "AngledServiceFlangeBend",
+ "axisResidual": 0.002540000058399313,
+ "axisAngleResidualDegrees": 0,
+ "bendAngleResidualDegrees": 2.3917771204605646E-12,
+ "radiusResidual": 2.540012644658418E-11,
+ "adjacencyMatches": true,
+ "status": "Pass"
+ },
+ {
+ "sourceBendId": "bend-c-0057-0070",
+ "intentBendId": "RightWallBend",
+ "axisResidual": 0.0025400003380013914,
+ "axisAngleResidualDegrees": 0,
+ "bendAngleResidualDegrees": 0,
+ "radiusResidual": 2.539035648396748E-11,
+ "adjacencyMatches": true,
+ "status": "Pass"
+ },
+ {
+ "sourceBendId": "bend-c-0058-0064",
+ "intentBendId": "FrontWallBend",
+ "axisResidual": 3.634199174541027E-10,
+ "axisAngleResidualDegrees": 0,
+ "bendAngleResidualDegrees": 7.124442486478278E-13,
+ "radiusResidual": 2.540012644658418E-11,
+ "adjacencyMatches": true,
+ "status": "Pass"
+ },
+ {
+ "sourceBendId": "bend-c-0059-0068",
+ "intentBendId": "LeftWallBend",
+ "axisResidual": 0.002540000338001575,
+ "axisAngleResidualDegrees": 0,
+ "bendAngleResidualDegrees": 8.142219984546603E-13,
+ "radiusResidual": 2.538058652135078E-11,
+ "adjacencyMatches": true,
+ "status": "Pass"
+ },
+ {
+ "sourceBendId": "bend-c-0060-0067",
+ "intentBendId": "RearWallBend",
+ "axisResidual": 1.7286944152133616E-09,
+ "axisAngleResidualDegrees": 0,
+ "bendAngleResidualDegrees": 7.124442486478278E-13,
+ "radiusResidual": 2.540012644658418E-11,
+ "adjacencyMatches": true,
+ "status": "Pass"
+ }
+ ],
+ "features": [
+ {
+ "sourceFeatureId": "feature-profile-f0065-l0069",
+ "intentFeatureId": "VentSlotRight",
+ "centerResidual": 0.001270000308693673,
+ "sizeResidual": 3.560103323252406E-10,
+ "status": "Pass"
+ },
+ {
+ "sourceFeatureId": "feature-profile-f0065-l0070",
+ "intentFeatureId": "VentSlotLeft",
+ "centerResidual": 0.0012700003086937996,
+ "sizeResidual": 3.560103323252406E-10,
+ "status": "Pass"
+ }
+ ],
+ "flatPattern": {
+ "widthResidual": 12.702447279956402,
+ "heightResidual": 12.707819647841916,
+ "contour": {
+ "rms": 52.776254755101434,
+ "p95": 128.11367917941004,
+ "maximum": 128.11367917941004,
+ "sampleCount": 12
+ },
+ "cuts": [
+ {
+ "sourceFeatureId": "feature-profile-f0065-l0069",
+ "intentFeatureId": "VentSlotRight",
+ "centerResidual": 0.001270000308693673,
+ "sizeResidual": 3.560103323252406E-10,
+ "status": "Pass"
+ },
+ {
+ "sourceFeatureId": "feature-profile-f0065-l0070",
+ "intentFeatureId": "VentSlotLeft",
+ "centerResidual": 0.0012700003086937996,
+ "sizeResidual": 3.560103323252406E-10,
+ "status": "Pass"
+ }
+ ],
+ "bendLineCountDelta": 0,
+ "hasOverlap": false,
+ "status": "Fail"
+ },
+ "knownDifferences": [
+ "Source-independent reconstructed topology differs from historical STEP boundary trims; bend/cut semantics pass and global formed/flat residuals require engineer review."
+ ],
+ "diagnostics": []
+ }
+}
diff --git a/docs/modules/sheetmetal/artifacts/m3/ctc03-flat-comparison.md b/docs/modules/sheetmetal/artifacts/m3/ctc03-flat-comparison.md
new file mode 100644
index 00000000..962af3c0
--- /dev/null
+++ b/docs/modules/sheetmetal/artifacts/m3/ctc03-flat-comparison.md
@@ -0,0 +1,15 @@
+# CTC-03 flat comparison
+
+Generated authored blank: 392.051790 x 612.597761 mm, seven bend lines, two cuts, no overlap, deterministic hash `d812b205f1d6e221c3a493fe5ffb1f599d0c3fb011aedb0662dee28a555c822b`.
+
+Against the accepted M2 recovered flat interpretation:
+
+- width residual: 12.702447 mm;
+- height residual: 12.707820 mm;
+- contour RMS/p95/max: 52.7763 / 128.1137 / 128.1137 mm;
+- cut centers and sizes pass;
+- bend-line count delta: zero;
+- overlap: false;
+- status: `Fail` at the flat-comparison sublevel, producing overall `NeedsReview`.
+
+The mismatch is caused by bounded rectangular/open-corner authored trims and canonical tangent-to-edge flange dimensions not yet reproducing every recovered source outline. The generated flat STEP itself reimports as one enclosed manifold.
diff --git a/docs/modules/sheetmetal/artifacts/m3/ctc03-formed-comparison.md b/docs/modules/sheetmetal/artifacts/m3/ctc03-formed-comparison.md
new file mode 100644
index 00000000..8d267427
--- /dev/null
+++ b/docs/modules/sheetmetal/artifacts/m3/ctc03-formed-comparison.md
@@ -0,0 +1,11 @@
+# CTC-03 formed comparison
+
+Status: `NeedsReview`.
+
+- Thickness residual: 0.002540 mm (accepted 1.905 mm nominal versus measured 1.90754 mm).
+- Source -> generated boundary RMS/p95/max: 45.8066 / 114.7866 / 128.1174 mm.
+- Generated -> source boundary RMS/p95/max: 11.1246 / 18.1023 / 51.5356 mm.
+- All seven bends pass graph, axis direction, angle, and radius policy. Axis-line residuals range from effectively zero to 0.002541 mm; angle residuals are below 2.4e-12° and radius residuals below 2.6e-11 mm.
+- Both vent cuts pass: center residual 0.001270 mm and size residual below 4e-10 mm.
+
+The large boundary residual is localized to simplified authored wall/corner/mounting-flange trims versus the historical STEP's non-rectangular local outlines. It is not concealed by source geometry or an inflated tolerance.
diff --git a/docs/modules/sheetmetal/artifacts/m3/ctc03-formed-generation.json b/docs/modules/sheetmetal/artifacts/m3/ctc03-formed-generation.json
new file mode 100644
index 00000000..e0b6cff8
--- /dev/null
+++ b/docs/modules/sheetmetal/artifacts/m3/ctc03-formed-generation.json
@@ -0,0 +1,26 @@
+{
+ "command": "build",
+ "success": true,
+ "input": "C:\\Users\\yuech\\source\\repos\\Aetheris\\docs\\modules\\sheetmetal\\artifacts\\m2\\ctc03-idiomatic.firmament",
+ "output": "C:\\Users\\yuech\\source\\repos\\Aetheris\\docs\\modules\\sheetmetal\\artifacts\\m3\\ctc03-m3-formed.step",
+ "domain": "SheetMetal",
+ "part": {
+ "stableId": "sheetmetal-Ctc03",
+ "thickness": 1.905,
+ "regions": 15,
+ "bends": 7,
+ "features": 2
+ },
+ "flatPattern": {
+ "status": "Valid",
+ "bounds": {
+ "minX": -55.920740176419734,
+ "minY": -115.31374035283946,
+ "maxX": 336.1310502646297,
+ "maxY": 497.28402035283943,
+ "width": 392.05179044104943,
+ "height": 612.5977607056789
+ },
+ "deterministicHash": "d812b205f1d6e221c3a493fe5ffb1f599d0c3fb011aedb0662dee28a555c822b"
+ }
+}
diff --git a/docs/modules/sheetmetal/artifacts/m3/ctc03-generation.json b/docs/modules/sheetmetal/artifacts/m3/ctc03-generation.json
new file mode 100644
index 00000000..3a7e427a
--- /dev/null
+++ b/docs/modules/sheetmetal/artifacts/m3/ctc03-generation.json
@@ -0,0 +1,470 @@
+{
+ "command": "sheetmetal flatten",
+ "success": true,
+ "input": "C:\\Users\\yuech\\source\\repos\\Aetheris\\docs\\modules\\sheetmetal\\artifacts\\m2\\ctc03-idiomatic.firmament",
+ "sourceAuthority": "Firmament reconstructed engineering authority",
+ "recognitionStatus": "Complete",
+ "thickness": {
+ "nominal": 1.905,
+ "tolerance": null,
+ "evidencePairs": 0,
+ "outlierFaces": 0
+ },
+ "geometry": {
+ "bodies": 1,
+ "shells": 1,
+ "faces": 78,
+ "edges": 172,
+ "vertices": 96,
+ "supportFamilies": {
+ "Cylinder": 14,
+ "Plane": 64
+ },
+ "pmiIndicators": 0
+ },
+ "sheetMetal": {
+ "baseRegion": "MainDeck",
+ "regions": [
+ {
+ "stableId": "MainDeck",
+ "kind": "Planar",
+ "approximateArea": 88870.79000000001,
+ "sourceFaces": []
+ },
+ {
+ "stableId": "FrontWall",
+ "kind": "Planar",
+ "approximateArea": 13845.387066600002,
+ "sourceFaces": []
+ },
+ {
+ "stableId": "FrontWallBendRegion",
+ "kind": "CylindricalBend",
+ "approximateArea": 2578.5076842573917,
+ "sourceFaces": []
+ },
+ {
+ "stableId": "RearWall",
+ "kind": "Planar",
+ "approximateArea": 13845.387066600002,
+ "sourceFaces": []
+ },
+ {
+ "stableId": "RearWallBendRegion",
+ "kind": "CylindricalBend",
+ "approximateArea": 2578.5076842573917,
+ "sourceFaces": []
+ },
+ {
+ "stableId": "LeftWall",
+ "kind": "Planar",
+ "approximateArea": 15637.065500000002,
+ "sourceFaces": []
+ },
+ {
+ "stableId": "LeftWallBendRegion",
+ "kind": "CylindricalBend",
+ "approximateArea": 4035.2916866626974,
+ "sourceFaces": []
+ },
+ {
+ "stableId": "RightWall",
+ "kind": "Planar",
+ "approximateArea": 10240.9375826,
+ "sourceFaces": []
+ },
+ {
+ "stableId": "RightWallBendRegion",
+ "kind": "CylindricalBend",
+ "approximateArea": 4035.2916866626974,
+ "sourceFaces": []
+ },
+ {
+ "stableId": "FrontMountingFlange",
+ "kind": "Planar",
+ "approximateArea": 6918.973258800001,
+ "sourceFaces": []
+ },
+ {
+ "stableId": "FrontMountingFlangeBendRegion",
+ "kind": "CylindricalBend",
+ "approximateArea": 2578.5076842573917,
+ "sourceFaces": []
+ },
+ {
+ "stableId": "RearMountingFlange",
+ "kind": "Planar",
+ "approximateArea": 9991.915500000001,
+ "sourceFaces": []
+ },
+ {
+ "stableId": "RearMountingFlangeBendRegion",
+ "kind": "CylindricalBend",
+ "approximateArea": 2578.5076842573917,
+ "sourceFaces": []
+ },
+ {
+ "stableId": "AngledServiceFlange",
+ "kind": "Planar",
+ "approximateArea": 17066.740060000004,
+ "sourceFaces": []
+ },
+ {
+ "stableId": "AngledServiceFlangeBendRegion",
+ "kind": "CylindricalBend",
+ "approximateArea": 2017.6458433313487,
+ "sourceFaces": []
+ }
+ ],
+ "bends": [
+ {
+ "stableId": "FrontWallBend",
+ "axisOrigin": {
+ "x": -120.65,
+ "y": 58.08726,
+ "z": 69.85000000000001
+ },
+ "axisDirection": {
+ "x": 1,
+ "y": 0,
+ "z": 0,
+ "lengthSquared": 1,
+ "length": 1
+ },
+ "angleDegrees": 90,
+ "insideRadius": 6.35,
+ "direction": "Down",
+ "adjacentRegionA": "MainDeck",
+ "adjacentRegionB": "FrontWall",
+ "sourceFaces": []
+ },
+ {
+ "stableId": "RearWallBend",
+ "axisOrigin": {
+ "x": -120.65,
+ "y": 426.38726,
+ "z": 69.85000000000001
+ },
+ "axisDirection": {
+ "x": -1,
+ "y": 0,
+ "z": 0,
+ "lengthSquared": 1,
+ "length": 1
+ },
+ "angleDegrees": 90,
+ "insideRadius": 6.35,
+ "direction": "Down",
+ "adjacentRegionA": "MainDeck",
+ "adjacentRegionB": "RearWall",
+ "sourceFaces": []
+ },
+ {
+ "stableId": "LeftWallBend",
+ "axisOrigin": {
+ "x": -241.3,
+ "y": 242.23726000000002,
+ "z": 84.455
+ },
+ "axisDirection": {
+ "x": 0,
+ "y": -1,
+ "z": 0,
+ "lengthSquared": 1,
+ "length": 1
+ },
+ "angleDegrees": 90,
+ "insideRadius": 6.35,
+ "direction": "Up",
+ "adjacentRegionA": "MainDeck",
+ "adjacentRegionB": "LeftWall",
+ "sourceFaces": []
+ },
+ {
+ "stableId": "RightWallBend",
+ "axisOrigin": {
+ "x": 0,
+ "y": 242.23726000000002,
+ "z": 84.455
+ },
+ "axisDirection": {
+ "x": 0,
+ "y": 1,
+ "z": 0,
+ "lengthSquared": 1,
+ "length": 1
+ },
+ "angleDegrees": 90,
+ "insideRadius": 6.35,
+ "direction": "Up",
+ "adjacentRegionA": "MainDeck",
+ "adjacentRegionB": "RightWall",
+ "sourceFaces": []
+ },
+ {
+ "stableId": "FrontMountingFlangeBend",
+ "axisOrigin": {
+ "x": -120.65,
+ "y": 43.48225999999999,
+ "z": 8.257460000000009
+ },
+ "axisDirection": {
+ "x": 1,
+ "y": 0,
+ "z": 0,
+ "lengthSquared": 1,
+ "length": 1
+ },
+ "angleDegrees": 90,
+ "insideRadius": 6.35,
+ "direction": "Up",
+ "adjacentRegionA": "FrontWall",
+ "adjacentRegionB": "FrontMountingFlange",
+ "sourceFaces": []
+ },
+ {
+ "stableId": "RearMountingFlangeBend",
+ "axisOrigin": {
+ "x": -120.65,
+ "y": 440.99226000000004,
+ "z": 8.257460000000009
+ },
+ "axisDirection": {
+ "x": -1,
+ "y": 0,
+ "z": 0,
+ "lengthSquared": 1,
+ "length": 1
+ },
+ "angleDegrees": 90,
+ "insideRadius": 6.35,
+ "direction": "Up",
+ "adjacentRegionA": "RearWall",
+ "adjacentRegionB": "RearMountingFlange",
+ "sourceFaces": []
+ },
+ {
+ "stableId": "AngledServiceFlangeBend",
+ "axisOrigin": {
+ "x": 14.605,
+ "y": 242.23726000000002,
+ "z": 113.56594
+ },
+ "axisDirection": {
+ "x": 0,
+ "y": 1,
+ "z": 0,
+ "lengthSquared": 1,
+ "length": 1
+ },
+ "angleDegrees": 45,
+ "insideRadius": 6.35,
+ "direction": "Down",
+ "adjacentRegionA": "RightWall",
+ "adjacentRegionB": "AngledServiceFlange",
+ "sourceFaces": []
+ }
+ ],
+ "cuts": [
+ {
+ "stableId": "VentSlotRight",
+ "kind": "Slot",
+ "owningRegionId": "MainDeck",
+ "diameter": null,
+ "sourceFaces": []
+ },
+ {
+ "stableId": "VentSlotLeft",
+ "kind": "Slot",
+ "owningRegionId": "MainDeck",
+ "diameter": null,
+ "sourceFaces": []
+ }
+ ]
+ },
+ "flatPattern": {
+ "status": "Valid",
+ "bounds": {
+ "minX": -55.920740176419734,
+ "minY": -115.31374035283946,
+ "maxX": 336.1310502646297,
+ "maxY": 497.28402035283943,
+ "width": 392.05179044104943,
+ "height": 612.5977607056789
+ },
+ "bendLines": 7,
+ "cuts": 2,
+ "kFactor": 0.5,
+ "deterministicHash": "d812b205f1d6e221c3a493fe5ffb1f599d0c3fb011aedb0662dee28a555c822b",
+ "svg": "C:\\Users\\yuech\\source\\repos\\Aetheris\\docs\\modules\\sheetmetal\\artifacts\\m3\\ctc03-m3-flat.svg",
+ "step": "C:\\Users\\yuech\\source\\repos\\Aetheris\\docs\\modules\\sheetmetal\\artifacts\\m3\\ctc03-m3-flat.step",
+ "firmament": null
+ },
+ "dfm": {
+ "overall": "Pass",
+ "findings": [
+ {
+ "ruleId": "sheetmetal-dfm-thickness-positive",
+ "status": "Pass",
+ "message": "Thickness is positive.",
+ "subjectId": "sheetmetal-Ctc03",
+ "measured": 1.905,
+ "required": 0,
+ "suggestedFix": null
+ },
+ {
+ "ruleId": "sheetmetal-dfm-inside-radius-ratio",
+ "status": "Pass",
+ "message": "Inside-radius/thickness ratio 3.333 meets the parameterized experimental policy 1.",
+ "subjectId": "FrontWallBend",
+ "measured": 3.333333333333333,
+ "required": 1,
+ "suggestedFix": null
+ },
+ {
+ "ruleId": "sheetmetal-dfm-inside-radius-ratio",
+ "status": "Pass",
+ "message": "Inside-radius/thickness ratio 3.333 meets the parameterized experimental policy 1.",
+ "subjectId": "RearWallBend",
+ "measured": 3.333333333333333,
+ "required": 1,
+ "suggestedFix": null
+ },
+ {
+ "ruleId": "sheetmetal-dfm-inside-radius-ratio",
+ "status": "Pass",
+ "message": "Inside-radius/thickness ratio 3.333 meets the parameterized experimental policy 1.",
+ "subjectId": "LeftWallBend",
+ "measured": 3.333333333333333,
+ "required": 1,
+ "suggestedFix": null
+ },
+ {
+ "ruleId": "sheetmetal-dfm-inside-radius-ratio",
+ "status": "Pass",
+ "message": "Inside-radius/thickness ratio 3.333 meets the parameterized experimental policy 1.",
+ "subjectId": "RightWallBend",
+ "measured": 3.333333333333333,
+ "required": 1,
+ "suggestedFix": null
+ },
+ {
+ "ruleId": "sheetmetal-dfm-inside-radius-ratio",
+ "status": "Pass",
+ "message": "Inside-radius/thickness ratio 3.333 meets the parameterized experimental policy 1.",
+ "subjectId": "FrontMountingFlangeBend",
+ "measured": 3.333333333333333,
+ "required": 1,
+ "suggestedFix": null
+ },
+ {
+ "ruleId": "sheetmetal-dfm-inside-radius-ratio",
+ "status": "Pass",
+ "message": "Inside-radius/thickness ratio 3.333 meets the parameterized experimental policy 1.",
+ "subjectId": "RearMountingFlangeBend",
+ "measured": 3.333333333333333,
+ "required": 1,
+ "suggestedFix": null
+ },
+ {
+ "ruleId": "sheetmetal-dfm-inside-radius-ratio",
+ "status": "Pass",
+ "message": "Inside-radius/thickness ratio 3.333 meets the parameterized experimental policy 1.",
+ "subjectId": "AngledServiceFlangeBend",
+ "measured": 3.333333333333333,
+ "required": 1,
+ "suggestedFix": null
+ },
+ {
+ "ruleId": "sheetmetal-dfm-corner-resolution",
+ "status": "Pass",
+ "message": "\u0027corner-FrontWall-RightWall\u0027 uses bounded Relief corner resolution.",
+ "subjectId": "corner-FrontWall-RightWall",
+ "measured": 1.905,
+ "required": 1.905,
+ "suggestedFix": null
+ },
+ {
+ "ruleId": "sheetmetal-dfm-corner-resolution",
+ "status": "Pass",
+ "message": "\u0027corner-RightWall-RearWall\u0027 uses bounded Relief corner resolution.",
+ "subjectId": "corner-RightWall-RearWall",
+ "measured": 1.905,
+ "required": 1.905,
+ "suggestedFix": null
+ },
+ {
+ "ruleId": "sheetmetal-dfm-corner-resolution",
+ "status": "Pass",
+ "message": "\u0027corner-RearWall-LeftWall\u0027 uses bounded Relief corner resolution.",
+ "subjectId": "corner-RearWall-LeftWall",
+ "measured": 1.905,
+ "required": 1.905,
+ "suggestedFix": null
+ },
+ {
+ "ruleId": "sheetmetal-dfm-corner-resolution",
+ "status": "Pass",
+ "message": "\u0027corner-LeftWall-FrontWall\u0027 uses bounded Relief corner resolution.",
+ "subjectId": "corner-LeftWall-FrontWall",
+ "measured": 1.905,
+ "required": 1.905,
+ "suggestedFix": null
+ },
+ {
+ "ruleId": "sheetmetal-dfm-flat-overlap",
+ "status": "Pass",
+ "message": "No planar-region overlap was detected.",
+ "subjectId": "flat-sheetmetal-Ctc03",
+ "measured": null,
+ "required": null,
+ "suggestedFix": null
+ },
+ {
+ "ruleId": "sheetmetal-dfm-cut-to-bend-distance",
+ "status": "Pass",
+ "message": "\u0027VentSlotLeft\u0027 boundary to nearest bend line is 47.49 mm; parameterized policy requires 3.81 mm.",
+ "subjectId": "VentSlotLeft",
+ "measured": 47.49297008820986,
+ "required": 3.81,
+ "suggestedFix": null
+ },
+ {
+ "ruleId": "sheetmetal-dfm-cut-to-edge-distance",
+ "status": "Pass",
+ "message": "\u0027VentSlotLeft\u0027 boundary to nearest recovered source edge is 41.76 mm; bounded policy requires 2.857 mm.",
+ "subjectId": "VentSlotLeft",
+ "measured": 41.7576,
+ "required": 2.8575,
+ "suggestedFix": null
+ },
+ {
+ "ruleId": "sheetmetal-dfm-cut-to-bend-distance",
+ "status": "Pass",
+ "message": "\u0027VentSlotRight\u0027 boundary to nearest bend line is 69.72 mm; parameterized policy requires 3.81 mm.",
+ "subjectId": "VentSlotRight",
+ "measured": 69.72051008820986,
+ "required": 3.81,
+ "suggestedFix": null
+ },
+ {
+ "ruleId": "sheetmetal-dfm-cut-to-edge-distance",
+ "status": "Pass",
+ "message": "\u0027VentSlotRight\u0027 boundary to nearest recovered source edge is 63.99 mm; bounded policy requires 2.857 mm.",
+ "subjectId": "VentSlotRight",
+ "measured": 63.98514,
+ "required": 2.8575,
+ "suggestedFix": null
+ }
+ ]
+ },
+ "diagnostics": [],
+ "timingsMilliseconds": {
+ "parse": 9.0654,
+ "formedLower": 59.437,
+ "authoredFlatLower": 29.5692,
+ "import": 0,
+ "recognition": 0,
+ "flatten": 0.4196
+ }
+}
diff --git a/docs/modules/sheetmetal/artifacts/m3/ctc03-m3-flat.step b/docs/modules/sheetmetal/artifacts/m3/ctc03-m3-flat.step
new file mode 100644
index 00000000..eca3f297
--- /dev/null
+++ b/docs/modules/sheetmetal/artifacts/m3/ctc03-m3-flat.step
@@ -0,0 +1,1632 @@
+ISO-10303-21;
+HEADER;
+FILE_DESCRIPTION(('Aetheris AP242 subset export'),'2;1');
+FILE_NAME('aetheris_export.step','1970-01-01T00:00:00',('Aetheris'),('Aetheris'),'Aetheris.Kernel','Aetheris.Kernel','');
+FILE_SCHEMA(('AP242_MANAGED_MODEL_BASED_3D_ENGINEERING_MIM_LF'));
+ENDSEC;
+DATA;
+#1=CARTESIAN_POINT($,(0,0,0));
+#2=DIRECTION($,(0,0,-1));
+#3=DIRECTION($,(1,0,0));
+#4=AXIS2_PLACEMENT_3D($,#1,#2,#3);
+#5=PLANE($,#4);
+#6=CARTESIAN_POINT($,(402.051790441049,133.568740352839,0));
+#7=VERTEX_POINT($,#6);
+#8=CARTESIAN_POINT($,(402.051790441049,485.358740352839,-0));
+#9=VERTEX_POINT($,#8);
+#10=CARTESIAN_POINT($,(402.051790441049,133.568740352839,0));
+#11=DIRECTION($,(0,1,0));
+#12=VECTOR($,#11,1);
+#13=LINE($,#10,#12);
+#14=EDGE_CURVE($,#7,#9,#13,.T.);
+#15=ORIENTED_EDGE($,$,$,#14,.T.);
+#16=CARTESIAN_POINT($,(353.537790441049,485.358740352839,0));
+#17=VERTEX_POINT($,#16);
+#18=CARTESIAN_POINT($,(402.051790441049,485.358740352839,-0));
+#19=DIRECTION($,(-1,0,0));
+#20=VECTOR($,#19,1);
+#21=LINE($,#18,#20);
+#22=EDGE_CURVE($,#9,#17,#21,.T.);
+#23=ORIENTED_EDGE($,$,$,#22,.T.);
+#24=CARTESIAN_POINT($,(347.802420352839,485.358740352839,0));
+#25=VERTEX_POINT($,#24);
+#26=CARTESIAN_POINT($,(353.537790441049,485.358740352839,0));
+#27=DIRECTION($,(-1,0,0));
+#28=VECTOR($,#27,1);
+#29=LINE($,#26,#28);
+#30=EDGE_CURVE($,#17,#25,#29,.T.);
+#31=ORIENTED_EDGE($,$,$,#30,.T.);
+#32=CARTESIAN_POINT($,(318.691480352839,485.358740352839,0));
+#33=VERTEX_POINT($,#32);
+#34=CARTESIAN_POINT($,(347.802420352839,485.358740352839,0));
+#35=DIRECTION($,(-1,0,0));
+#36=VECTOR($,#35,1);
+#37=LINE($,#34,#36);
+#38=EDGE_CURVE($,#25,#33,#37,.T.);
+#39=ORIENTED_EDGE($,$,$,#38,.T.);
+#40=CARTESIAN_POINT($,(307.22074017642,485.35874035284,0));
+#41=VERTEX_POINT($,#40);
+#42=CARTESIAN_POINT($,(318.691480352839,485.358740352839,0));
+#43=DIRECTION($,(-1,0,0));
+#44=VECTOR($,#43,1);
+#45=LINE($,#42,#44);
+#46=EDGE_CURVE($,#33,#41,#45,.T.);
+#47=ORIENTED_EDGE($,$,$,#46,.T.);
+#48=CARTESIAN_POINT($,(307.22074017642,493.613740352839,-0));
+#49=VERTEX_POINT($,#48);
+#50=CARTESIAN_POINT($,(307.22074017642,485.35874035284,0));
+#51=DIRECTION($,(0,1,0));
+#52=VECTOR($,#51,1);
+#53=LINE($,#50,#52);
+#54=EDGE_CURVE($,#41,#49,#53,.T.);
+#55=ORIENTED_EDGE($,$,$,#54,.T.);
+#56=CARTESIAN_POINT($,(298.96574017642,493.613740352839,0));
+#57=VERTEX_POINT($,#56);
+#58=CARTESIAN_POINT($,(307.22074017642,493.613740352839,-0));
+#59=DIRECTION($,(-1,0,0));
+#60=VECTOR($,#59,1);
+#61=LINE($,#58,#60);
+#62=EDGE_CURVE($,#49,#57,#61,.T.);
+#63=ORIENTED_EDGE($,$,$,#62,.T.);
+#64=CARTESIAN_POINT($,(298.96574017642,505.084480529259,0));
+#65=VERTEX_POINT($,#64);
+#66=CARTESIAN_POINT($,(298.96574017642,493.613740352839,0));
+#67=DIRECTION($,(0,1,0));
+#68=VECTOR($,#67,1);
+#69=LINE($,#66,#68);
+#70=EDGE_CURVE($,#57,#65,#69,.T.);
+#71=ORIENTED_EDGE($,$,$,#70,.T.);
+#72=CARTESIAN_POINT($,(298.96574017642,566.677020529259,0));
+#73=VERTEX_POINT($,#72);
+#74=CARTESIAN_POINT($,(298.96574017642,505.084480529259,0));
+#75=DIRECTION($,(0,1,0));
+#76=VECTOR($,#75,1);
+#77=LINE($,#74,#76);
+#78=EDGE_CURVE($,#65,#73,#77,.T.);
+#79=ORIENTED_EDGE($,$,$,#78,.T.);
+#80=CARTESIAN_POINT($,(298.96574017642,578.147760705679,0));
+#81=VERTEX_POINT($,#80);
+#82=CARTESIAN_POINT($,(298.96574017642,566.677020529259,0));
+#83=DIRECTION($,(0,1,0));
+#84=VECTOR($,#83,1);
+#85=LINE($,#82,#84);
+#86=EDGE_CURVE($,#73,#81,#85,.T.);
+#87=ORIENTED_EDGE($,$,$,#86,.T.);
+#88=CARTESIAN_POINT($,(298.96574017642,622.597760705679,-0));
+#89=VERTEX_POINT($,#88);
+#90=CARTESIAN_POINT($,(298.96574017642,578.147760705679,0));
+#91=DIRECTION($,(0,1,0));
+#92=VECTOR($,#91,1);
+#93=LINE($,#90,#92);
+#94=EDGE_CURVE($,#81,#89,#93,.T.);
+#95=ORIENTED_EDGE($,$,$,#94,.T.);
+#96=CARTESIAN_POINT($,(74.1757401764197,622.597760705679,-0));
+#97=VERTEX_POINT($,#96);
+#98=CARTESIAN_POINT($,(298.96574017642,622.597760705679,-0));
+#99=DIRECTION($,(-1,0,0));
+#100=VECTOR($,#99,1);
+#101=LINE($,#98,#100);
+#102=EDGE_CURVE($,#89,#97,#101,.T.);
+#103=ORIENTED_EDGE($,$,$,#102,.T.);
+#104=CARTESIAN_POINT($,(74.1757401764197,578.147760705679,0));
+#105=VERTEX_POINT($,#104);
+#106=CARTESIAN_POINT($,(74.1757401764197,622.597760705679,-0));
+#107=DIRECTION($,(0,-1,0));
+#108=VECTOR($,#107,1);
+#109=LINE($,#106,#108);
+#110=EDGE_CURVE($,#97,#105,#109,.T.);
+#111=ORIENTED_EDGE($,$,$,#110,.T.);
+#112=CARTESIAN_POINT($,(74.1757401764197,566.677020529259,0));
+#113=VERTEX_POINT($,#112);
+#114=CARTESIAN_POINT($,(74.1757401764197,578.147760705679,0));
+#115=DIRECTION($,(0,-1,0));
+#116=VECTOR($,#115,1);
+#117=LINE($,#114,#116);
+#118=EDGE_CURVE($,#105,#113,#117,.T.);
+#119=ORIENTED_EDGE($,$,$,#118,.T.);
+#120=CARTESIAN_POINT($,(74.1757401764197,505.084480529259,0));
+#121=VERTEX_POINT($,#120);
+#122=CARTESIAN_POINT($,(74.1757401764197,566.677020529259,0));
+#123=DIRECTION($,(0,-1,0));
+#124=VECTOR($,#123,1);
+#125=LINE($,#122,#124);
+#126=EDGE_CURVE($,#113,#121,#125,.T.);
+#127=ORIENTED_EDGE($,$,$,#126,.T.);
+#128=CARTESIAN_POINT($,(74.1757401764197,493.613740352839,0));
+#129=VERTEX_POINT($,#128);
+#130=CARTESIAN_POINT($,(74.1757401764197,505.084480529259,0));
+#131=DIRECTION($,(0,-1,0));
+#132=VECTOR($,#131,1);
+#133=LINE($,#130,#132);
+#134=EDGE_CURVE($,#121,#129,#133,.T.);
+#135=ORIENTED_EDGE($,$,$,#134,.T.);
+#136=CARTESIAN_POINT($,(65.9207401764197,493.613740352839,-0));
+#137=VERTEX_POINT($,#136);
+#138=CARTESIAN_POINT($,(74.1757401764197,493.613740352839,0));
+#139=DIRECTION($,(-1,0,0));
+#140=VECTOR($,#139,1);
+#141=LINE($,#138,#140);
+#142=EDGE_CURVE($,#129,#137,#141,.T.);
+#143=ORIENTED_EDGE($,$,$,#142,.T.);
+#144=CARTESIAN_POINT($,(65.9207401764197,485.35874035284,0));
+#145=VERTEX_POINT($,#144);
+#146=CARTESIAN_POINT($,(65.9207401764197,493.613740352839,-0));
+#147=DIRECTION($,(0,-1,0));
+#148=VECTOR($,#147,1);
+#149=LINE($,#146,#148);
+#150=EDGE_CURVE($,#137,#145,#149,.T.);
+#151=ORIENTED_EDGE($,$,$,#150,.T.);
+#152=CARTESIAN_POINT($,(54.45,485.35874035284,0));
+#153=VERTEX_POINT($,#152);
+#154=CARTESIAN_POINT($,(65.9207401764197,485.35874035284,0));
+#155=DIRECTION($,(-1,0,0));
+#156=VECTOR($,#155,1);
+#157=LINE($,#154,#156);
+#158=EDGE_CURVE($,#145,#153,#157,.T.);
+#159=ORIENTED_EDGE($,$,$,#158,.T.);
+#160=CARTESIAN_POINT($,(10,485.35874035284,-0));
+#161=VERTEX_POINT($,#160);
+#162=CARTESIAN_POINT($,(54.45,485.35874035284,0));
+#163=DIRECTION($,(-1,0,0));
+#164=VECTOR($,#163,1);
+#165=LINE($,#162,#164);
+#166=EDGE_CURVE($,#153,#161,#165,.T.);
+#167=ORIENTED_EDGE($,$,$,#166,.T.);
+#168=CARTESIAN_POINT($,(10,133.568740352839,-0));
+#169=VERTEX_POINT($,#168);
+#170=CARTESIAN_POINT($,(10,485.35874035284,-0));
+#171=DIRECTION($,(0,-1,0));
+#172=VECTOR($,#171,1);
+#173=LINE($,#170,#172);
+#174=EDGE_CURVE($,#161,#169,#173,.T.);
+#175=ORIENTED_EDGE($,$,$,#174,.T.);
+#176=CARTESIAN_POINT($,(54.45,133.568740352839,0));
+#177=VERTEX_POINT($,#176);
+#178=CARTESIAN_POINT($,(10,133.568740352839,-0));
+#179=DIRECTION($,(1,0,0));
+#180=VECTOR($,#179,1);
+#181=LINE($,#178,#180);
+#182=EDGE_CURVE($,#169,#177,#181,.T.);
+#183=ORIENTED_EDGE($,$,$,#182,.T.);
+#184=CARTESIAN_POINT($,(65.9207401764197,133.568740352839,0));
+#185=VERTEX_POINT($,#184);
+#186=CARTESIAN_POINT($,(54.45,133.568740352839,0));
+#187=DIRECTION($,(1,0,0));
+#188=VECTOR($,#187,1);
+#189=LINE($,#186,#188);
+#190=EDGE_CURVE($,#177,#185,#189,.T.);
+#191=ORIENTED_EDGE($,$,$,#190,.T.);
+#192=CARTESIAN_POINT($,(65.9207401764197,125.313740352839,-0));
+#193=VERTEX_POINT($,#192);
+#194=CARTESIAN_POINT($,(65.9207401764197,133.568740352839,0));
+#195=DIRECTION($,(0,-1,0));
+#196=VECTOR($,#195,1);
+#197=LINE($,#194,#196);
+#198=EDGE_CURVE($,#185,#193,#197,.T.);
+#199=ORIENTED_EDGE($,$,$,#198,.T.);
+#200=CARTESIAN_POINT($,(74.1757401764197,125.313740352839,0));
+#201=VERTEX_POINT($,#200);
+#202=CARTESIAN_POINT($,(65.9207401764197,125.313740352839,-0));
+#203=DIRECTION($,(1,0,0));
+#204=VECTOR($,#203,1);
+#205=LINE($,#202,#204);
+#206=EDGE_CURVE($,#193,#201,#205,.T.);
+#207=ORIENTED_EDGE($,$,$,#206,.T.);
+#208=CARTESIAN_POINT($,(74.1757401764197,113.84300017642,0));
+#209=VERTEX_POINT($,#208);
+#210=CARTESIAN_POINT($,(74.1757401764197,125.313740352839,0));
+#211=DIRECTION($,(0,-1,0));
+#212=VECTOR($,#211,1);
+#213=LINE($,#210,#212);
+#214=EDGE_CURVE($,#201,#209,#213,.T.);
+#215=ORIENTED_EDGE($,$,$,#214,.T.);
+#216=CARTESIAN_POINT($,(74.1757401764197,52.2504601764197,0));
+#217=VERTEX_POINT($,#216);
+#218=CARTESIAN_POINT($,(74.1757401764197,113.84300017642,0));
+#219=DIRECTION($,(0,-1,0));
+#220=VECTOR($,#219,1);
+#221=LINE($,#218,#220);
+#222=EDGE_CURVE($,#209,#217,#221,.T.);
+#223=ORIENTED_EDGE($,$,$,#222,.T.);
+#224=CARTESIAN_POINT($,(74.1757401764197,40.77972,0));
+#225=VERTEX_POINT($,#224);
+#226=CARTESIAN_POINT($,(74.1757401764197,52.2504601764197,0));
+#227=DIRECTION($,(0,-1,0));
+#228=VECTOR($,#227,1);
+#229=LINE($,#226,#228);
+#230=EDGE_CURVE($,#217,#225,#229,.T.);
+#231=ORIENTED_EDGE($,$,$,#230,.T.);
+#232=CARTESIAN_POINT($,(74.1757401764197,10,-0));
+#233=VERTEX_POINT($,#232);
+#234=CARTESIAN_POINT($,(74.1757401764197,40.77972,0));
+#235=DIRECTION($,(0,-1,0));
+#236=VECTOR($,#235,1);
+#237=LINE($,#234,#236);
+#238=EDGE_CURVE($,#225,#233,#237,.T.);
+#239=ORIENTED_EDGE($,$,$,#238,.T.);
+#240=CARTESIAN_POINT($,(298.96574017642,10,-0));
+#241=VERTEX_POINT($,#240);
+#242=CARTESIAN_POINT($,(74.1757401764197,10,-0));
+#243=DIRECTION($,(1,0,0));
+#244=VECTOR($,#243,1);
+#245=LINE($,#242,#244);
+#246=EDGE_CURVE($,#233,#241,#245,.T.);
+#247=ORIENTED_EDGE($,$,$,#246,.T.);
+#248=CARTESIAN_POINT($,(298.96574017642,40.77972,0));
+#249=VERTEX_POINT($,#248);
+#250=CARTESIAN_POINT($,(298.96574017642,10,-0));
+#251=DIRECTION($,(0,1,0));
+#252=VECTOR($,#251,1);
+#253=LINE($,#250,#252);
+#254=EDGE_CURVE($,#241,#249,#253,.T.);
+#255=ORIENTED_EDGE($,$,$,#254,.T.);
+#256=CARTESIAN_POINT($,(298.96574017642,52.2504601764197,0));
+#257=VERTEX_POINT($,#256);
+#258=CARTESIAN_POINT($,(298.96574017642,40.77972,0));
+#259=DIRECTION($,(0,1,0));
+#260=VECTOR($,#259,1);
+#261=LINE($,#258,#260);
+#262=EDGE_CURVE($,#249,#257,#261,.T.);
+#263=ORIENTED_EDGE($,$,$,#262,.T.);
+#264=CARTESIAN_POINT($,(298.96574017642,113.84300017642,0));
+#265=VERTEX_POINT($,#264);
+#266=CARTESIAN_POINT($,(298.96574017642,52.2504601764197,0));
+#267=DIRECTION($,(0,1,0));
+#268=VECTOR($,#267,1);
+#269=LINE($,#266,#268);
+#270=EDGE_CURVE($,#257,#265,#269,.T.);
+#271=ORIENTED_EDGE($,$,$,#270,.T.);
+#272=CARTESIAN_POINT($,(298.96574017642,125.313740352839,0));
+#273=VERTEX_POINT($,#272);
+#274=CARTESIAN_POINT($,(298.96574017642,113.84300017642,0));
+#275=DIRECTION($,(0,1,0));
+#276=VECTOR($,#275,1);
+#277=LINE($,#274,#276);
+#278=EDGE_CURVE($,#265,#273,#277,.T.);
+#279=ORIENTED_EDGE($,$,$,#278,.T.);
+#280=CARTESIAN_POINT($,(307.22074017642,125.313740352839,-0));
+#281=VERTEX_POINT($,#280);
+#282=CARTESIAN_POINT($,(298.96574017642,125.313740352839,0));
+#283=DIRECTION($,(1,0,0));
+#284=VECTOR($,#283,1);
+#285=LINE($,#282,#284);
+#286=EDGE_CURVE($,#273,#281,#285,.T.);
+#287=ORIENTED_EDGE($,$,$,#286,.T.);
+#288=CARTESIAN_POINT($,(307.22074017642,133.568740352839,0));
+#289=VERTEX_POINT($,#288);
+#290=CARTESIAN_POINT($,(307.22074017642,125.313740352839,-0));
+#291=DIRECTION($,(0,1,0));
+#292=VECTOR($,#291,1);
+#293=LINE($,#290,#292);
+#294=EDGE_CURVE($,#281,#289,#293,.T.);
+#295=ORIENTED_EDGE($,$,$,#294,.T.);
+#296=CARTESIAN_POINT($,(318.691480352839,133.568740352839,0));
+#297=VERTEX_POINT($,#296);
+#298=CARTESIAN_POINT($,(307.22074017642,133.568740352839,0));
+#299=DIRECTION($,(1,0,0));
+#300=VECTOR($,#299,1);
+#301=LINE($,#298,#300);
+#302=EDGE_CURVE($,#289,#297,#301,.T.);
+#303=ORIENTED_EDGE($,$,$,#302,.T.);
+#304=CARTESIAN_POINT($,(347.802420352839,133.568740352839,0));
+#305=VERTEX_POINT($,#304);
+#306=CARTESIAN_POINT($,(318.691480352839,133.568740352839,0));
+#307=DIRECTION($,(1,0,0));
+#308=VECTOR($,#307,1);
+#309=LINE($,#306,#308);
+#310=EDGE_CURVE($,#297,#305,#309,.T.);
+#311=ORIENTED_EDGE($,$,$,#310,.T.);
+#312=CARTESIAN_POINT($,(353.537790441049,133.568740352839,0));
+#313=VERTEX_POINT($,#312);
+#314=CARTESIAN_POINT($,(347.802420352839,133.568740352839,0));
+#315=DIRECTION($,(1,0,0));
+#316=VECTOR($,#315,1);
+#317=LINE($,#314,#316);
+#318=EDGE_CURVE($,#305,#313,#317,.T.);
+#319=ORIENTED_EDGE($,$,$,#318,.T.);
+#320=CARTESIAN_POINT($,(353.537790441049,133.568740352839,0));
+#321=DIRECTION($,(1,0,0));
+#322=VECTOR($,#321,1);
+#323=LINE($,#320,#322);
+#324=EDGE_CURVE($,#313,#7,#323,.T.);
+#325=ORIENTED_EDGE($,$,$,#324,.T.);
+#326=EDGE_LOOP($,(#15,#23,#31,#39,#47,#55,#63,#71,#79,#87,#95,#103,#111,#119,#127,#135,#143,#151,#159,#167,#175,#183,#191,#199,#207,#215,#223,#231,#239,#247,#255,#263,#271,#279,#287,#295,#303,#311,#319,#325));
+#327=FACE_OUTER_BOUND('',#326,.T.);
+#328=CARTESIAN_POINT($,(107.67834017642,189.298880352839,-0));
+#329=VERTEX_POINT($,#328);
+#330=CARTESIAN_POINT($,(126.72834017642,189.298880352839,0));
+#331=VERTEX_POINT($,#330);
+#332=CARTESIAN_POINT($,(107.67834017642,189.298880352839,-0));
+#333=DIRECTION($,(1,0,0));
+#334=VECTOR($,#333,1);
+#335=LINE($,#332,#334);
+#336=EDGE_CURVE($,#329,#331,#335,.T.);
+#337=ORIENTED_EDGE($,$,$,#336,.F.);
+#338=CARTESIAN_POINT($,(107.67834017642,278.198880352839,-0));
+#339=VERTEX_POINT($,#338);
+#340=CARTESIAN_POINT($,(107.67834017642,278.198880352839,-0));
+#341=DIRECTION($,(0,-1,0));
+#342=VECTOR($,#341,1);
+#343=LINE($,#340,#342);
+#344=EDGE_CURVE($,#339,#329,#343,.T.);
+#345=ORIENTED_EDGE($,$,$,#344,.F.);
+#346=CARTESIAN_POINT($,(126.72834017642,278.198880352839,-0));
+#347=VERTEX_POINT($,#346);
+#348=CARTESIAN_POINT($,(126.72834017642,278.198880352839,-0));
+#349=DIRECTION($,(-1,0,0));
+#350=VECTOR($,#349,1);
+#351=LINE($,#348,#350);
+#352=EDGE_CURVE($,#347,#339,#351,.T.);
+#353=ORIENTED_EDGE($,$,$,#352,.F.);
+#354=CARTESIAN_POINT($,(126.72834017642,189.298880352839,0));
+#355=DIRECTION($,(0,1,0));
+#356=VECTOR($,#355,1);
+#357=LINE($,#354,#356);
+#358=EDGE_CURVE($,#331,#347,#357,.T.);
+#359=ORIENTED_EDGE($,$,$,#358,.F.);
+#360=EDGE_LOOP($,(#337,#345,#353,#359));
+#361=FACE_BOUND('',#360,.T.);
+#362=CARTESIAN_POINT($,(171.17834017642,189.298880352839,-0));
+#363=VERTEX_POINT($,#362);
+#364=CARTESIAN_POINT($,(190.22834017642,189.298880352839,0));
+#365=VERTEX_POINT($,#364);
+#366=CARTESIAN_POINT($,(171.17834017642,189.298880352839,-0));
+#367=DIRECTION($,(1,0,0));
+#368=VECTOR($,#367,1);
+#369=LINE($,#366,#368);
+#370=EDGE_CURVE($,#363,#365,#369,.T.);
+#371=ORIENTED_EDGE($,$,$,#370,.F.);
+#372=CARTESIAN_POINT($,(171.17834017642,278.198880352839,-0));
+#373=VERTEX_POINT($,#372);
+#374=CARTESIAN_POINT($,(171.17834017642,278.198880352839,-0));
+#375=DIRECTION($,(0,-1,0));
+#376=VECTOR($,#375,1);
+#377=LINE($,#374,#376);
+#378=EDGE_CURVE($,#373,#363,#377,.T.);
+#379=ORIENTED_EDGE($,$,$,#378,.F.);
+#380=CARTESIAN_POINT($,(190.22834017642,278.198880352839,-0));
+#381=VERTEX_POINT($,#380);
+#382=CARTESIAN_POINT($,(190.22834017642,278.198880352839,-0));
+#383=DIRECTION($,(-1,0,0));
+#384=VECTOR($,#383,1);
+#385=LINE($,#382,#384);
+#386=EDGE_CURVE($,#381,#373,#385,.T.);
+#387=ORIENTED_EDGE($,$,$,#386,.F.);
+#388=CARTESIAN_POINT($,(190.22834017642,189.298880352839,0));
+#389=DIRECTION($,(0,1,0));
+#390=VECTOR($,#389,1);
+#391=LINE($,#388,#390);
+#392=EDGE_CURVE($,#365,#381,#391,.T.);
+#393=ORIENTED_EDGE($,$,$,#392,.F.);
+#394=EDGE_LOOP($,(#371,#379,#387,#393));
+#395=FACE_BOUND('',#394,.T.);
+#396=ADVANCED_FACE('',(#327,#361,#395),#5,.T.);
+#397=CARTESIAN_POINT($,(0,0,1.905));
+#398=DIRECTION($,(0,0,1));
+#399=DIRECTION($,(1,0,0));
+#400=AXIS2_PLACEMENT_3D($,#397,#398,#399);
+#401=PLANE($,#400);
+#402=CARTESIAN_POINT($,(402.051790441049,133.568740352839,1.905));
+#403=VERTEX_POINT($,#402);
+#404=CARTESIAN_POINT($,(402.051790441049,485.358740352839,1.905));
+#405=VERTEX_POINT($,#404);
+#406=CARTESIAN_POINT($,(402.051790441049,133.568740352839,1.905));
+#407=DIRECTION($,(0,1,0));
+#408=VECTOR($,#407,1);
+#409=LINE($,#406,#408);
+#410=EDGE_CURVE($,#403,#405,#409,.T.);
+#411=ORIENTED_EDGE($,$,$,#410,.T.);
+#412=CARTESIAN_POINT($,(353.537790441049,485.358740352839,1.905));
+#413=VERTEX_POINT($,#412);
+#414=CARTESIAN_POINT($,(402.051790441049,485.358740352839,1.905));
+#415=DIRECTION($,(-1,0,0));
+#416=VECTOR($,#415,1);
+#417=LINE($,#414,#416);
+#418=EDGE_CURVE($,#405,#413,#417,.T.);
+#419=ORIENTED_EDGE($,$,$,#418,.T.);
+#420=CARTESIAN_POINT($,(347.802420352839,485.358740352839,1.905));
+#421=VERTEX_POINT($,#420);
+#422=CARTESIAN_POINT($,(353.537790441049,485.358740352839,1.905));
+#423=DIRECTION($,(-1,0,0));
+#424=VECTOR($,#423,1);
+#425=LINE($,#422,#424);
+#426=EDGE_CURVE($,#413,#421,#425,.T.);
+#427=ORIENTED_EDGE($,$,$,#426,.T.);
+#428=CARTESIAN_POINT($,(318.691480352839,485.358740352839,1.905));
+#429=VERTEX_POINT($,#428);
+#430=CARTESIAN_POINT($,(347.802420352839,485.358740352839,1.905));
+#431=DIRECTION($,(-1,0,0));
+#432=VECTOR($,#431,1);
+#433=LINE($,#430,#432);
+#434=EDGE_CURVE($,#421,#429,#433,.T.);
+#435=ORIENTED_EDGE($,$,$,#434,.T.);
+#436=CARTESIAN_POINT($,(307.22074017642,485.35874035284,1.905));
+#437=VERTEX_POINT($,#436);
+#438=CARTESIAN_POINT($,(318.691480352839,485.358740352839,1.905));
+#439=DIRECTION($,(-1,0,0));
+#440=VECTOR($,#439,1);
+#441=LINE($,#438,#440);
+#442=EDGE_CURVE($,#429,#437,#441,.T.);
+#443=ORIENTED_EDGE($,$,$,#442,.T.);
+#444=CARTESIAN_POINT($,(307.22074017642,493.613740352839,1.905));
+#445=VERTEX_POINT($,#444);
+#446=CARTESIAN_POINT($,(307.22074017642,485.35874035284,1.905));
+#447=DIRECTION($,(0,1,0));
+#448=VECTOR($,#447,1);
+#449=LINE($,#446,#448);
+#450=EDGE_CURVE($,#437,#445,#449,.T.);
+#451=ORIENTED_EDGE($,$,$,#450,.T.);
+#452=CARTESIAN_POINT($,(298.96574017642,493.613740352839,1.905));
+#453=VERTEX_POINT($,#452);
+#454=CARTESIAN_POINT($,(307.22074017642,493.613740352839,1.905));
+#455=DIRECTION($,(-1,0,0));
+#456=VECTOR($,#455,1);
+#457=LINE($,#454,#456);
+#458=EDGE_CURVE($,#445,#453,#457,.T.);
+#459=ORIENTED_EDGE($,$,$,#458,.T.);
+#460=CARTESIAN_POINT($,(298.96574017642,505.084480529259,1.905));
+#461=VERTEX_POINT($,#460);
+#462=CARTESIAN_POINT($,(298.96574017642,493.613740352839,1.905));
+#463=DIRECTION($,(0,1,0));
+#464=VECTOR($,#463,1);
+#465=LINE($,#462,#464);
+#466=EDGE_CURVE($,#453,#461,#465,.T.);
+#467=ORIENTED_EDGE($,$,$,#466,.T.);
+#468=CARTESIAN_POINT($,(298.96574017642,566.677020529259,1.905));
+#469=VERTEX_POINT($,#468);
+#470=CARTESIAN_POINT($,(298.96574017642,505.084480529259,1.905));
+#471=DIRECTION($,(0,1,0));
+#472=VECTOR($,#471,1);
+#473=LINE($,#470,#472);
+#474=EDGE_CURVE($,#461,#469,#473,.T.);
+#475=ORIENTED_EDGE($,$,$,#474,.T.);
+#476=CARTESIAN_POINT($,(298.96574017642,578.147760705679,1.905));
+#477=VERTEX_POINT($,#476);
+#478=CARTESIAN_POINT($,(298.96574017642,566.677020529259,1.905));
+#479=DIRECTION($,(0,1,0));
+#480=VECTOR($,#479,1);
+#481=LINE($,#478,#480);
+#482=EDGE_CURVE($,#469,#477,#481,.T.);
+#483=ORIENTED_EDGE($,$,$,#482,.T.);
+#484=CARTESIAN_POINT($,(298.96574017642,622.597760705679,1.905));
+#485=VERTEX_POINT($,#484);
+#486=CARTESIAN_POINT($,(298.96574017642,578.147760705679,1.905));
+#487=DIRECTION($,(0,1,0));
+#488=VECTOR($,#487,1);
+#489=LINE($,#486,#488);
+#490=EDGE_CURVE($,#477,#485,#489,.T.);
+#491=ORIENTED_EDGE($,$,$,#490,.T.);
+#492=CARTESIAN_POINT($,(74.1757401764197,622.597760705679,1.905));
+#493=VERTEX_POINT($,#492);
+#494=CARTESIAN_POINT($,(298.96574017642,622.597760705679,1.905));
+#495=DIRECTION($,(-1,0,0));
+#496=VECTOR($,#495,1);
+#497=LINE($,#494,#496);
+#498=EDGE_CURVE($,#485,#493,#497,.T.);
+#499=ORIENTED_EDGE($,$,$,#498,.T.);
+#500=CARTESIAN_POINT($,(74.1757401764197,578.147760705679,1.905));
+#501=VERTEX_POINT($,#500);
+#502=CARTESIAN_POINT($,(74.1757401764197,622.597760705679,1.905));
+#503=DIRECTION($,(0,-1,0));
+#504=VECTOR($,#503,1);
+#505=LINE($,#502,#504);
+#506=EDGE_CURVE($,#493,#501,#505,.T.);
+#507=ORIENTED_EDGE($,$,$,#506,.T.);
+#508=CARTESIAN_POINT($,(74.1757401764197,566.677020529259,1.905));
+#509=VERTEX_POINT($,#508);
+#510=CARTESIAN_POINT($,(74.1757401764197,578.147760705679,1.905));
+#511=DIRECTION($,(0,-1,0));
+#512=VECTOR($,#511,1);
+#513=LINE($,#510,#512);
+#514=EDGE_CURVE($,#501,#509,#513,.T.);
+#515=ORIENTED_EDGE($,$,$,#514,.T.);
+#516=CARTESIAN_POINT($,(74.1757401764197,505.084480529259,1.905));
+#517=VERTEX_POINT($,#516);
+#518=CARTESIAN_POINT($,(74.1757401764197,566.677020529259,1.905));
+#519=DIRECTION($,(0,-1,0));
+#520=VECTOR($,#519,1);
+#521=LINE($,#518,#520);
+#522=EDGE_CURVE($,#509,#517,#521,.T.);
+#523=ORIENTED_EDGE($,$,$,#522,.T.);
+#524=CARTESIAN_POINT($,(74.1757401764197,493.613740352839,1.905));
+#525=VERTEX_POINT($,#524);
+#526=CARTESIAN_POINT($,(74.1757401764197,505.084480529259,1.905));
+#527=DIRECTION($,(0,-1,0));
+#528=VECTOR($,#527,1);
+#529=LINE($,#526,#528);
+#530=EDGE_CURVE($,#517,#525,#529,.T.);
+#531=ORIENTED_EDGE($,$,$,#530,.T.);
+#532=CARTESIAN_POINT($,(65.9207401764197,493.613740352839,1.905));
+#533=VERTEX_POINT($,#532);
+#534=CARTESIAN_POINT($,(74.1757401764197,493.613740352839,1.905));
+#535=DIRECTION($,(-1,0,0));
+#536=VECTOR($,#535,1);
+#537=LINE($,#534,#536);
+#538=EDGE_CURVE($,#525,#533,#537,.T.);
+#539=ORIENTED_EDGE($,$,$,#538,.T.);
+#540=CARTESIAN_POINT($,(65.9207401764197,485.35874035284,1.905));
+#541=VERTEX_POINT($,#540);
+#542=CARTESIAN_POINT($,(65.9207401764197,493.613740352839,1.905));
+#543=DIRECTION($,(0,-1,0));
+#544=VECTOR($,#543,1);
+#545=LINE($,#542,#544);
+#546=EDGE_CURVE($,#533,#541,#545,.T.);
+#547=ORIENTED_EDGE($,$,$,#546,.T.);
+#548=CARTESIAN_POINT($,(54.45,485.35874035284,1.905));
+#549=VERTEX_POINT($,#548);
+#550=CARTESIAN_POINT($,(65.9207401764197,485.35874035284,1.905));
+#551=DIRECTION($,(-1,0,0));
+#552=VECTOR($,#551,1);
+#553=LINE($,#550,#552);
+#554=EDGE_CURVE($,#541,#549,#553,.T.);
+#555=ORIENTED_EDGE($,$,$,#554,.T.);
+#556=CARTESIAN_POINT($,(10,485.35874035284,1.905));
+#557=VERTEX_POINT($,#556);
+#558=CARTESIAN_POINT($,(54.45,485.35874035284,1.905));
+#559=DIRECTION($,(-1,0,0));
+#560=VECTOR($,#559,1);
+#561=LINE($,#558,#560);
+#562=EDGE_CURVE($,#549,#557,#561,.T.);
+#563=ORIENTED_EDGE($,$,$,#562,.T.);
+#564=CARTESIAN_POINT($,(10,133.568740352839,1.905));
+#565=VERTEX_POINT($,#564);
+#566=CARTESIAN_POINT($,(10,485.35874035284,1.905));
+#567=DIRECTION($,(0,-1,0));
+#568=VECTOR($,#567,1);
+#569=LINE($,#566,#568);
+#570=EDGE_CURVE($,#557,#565,#569,.T.);
+#571=ORIENTED_EDGE($,$,$,#570,.T.);
+#572=CARTESIAN_POINT($,(54.45,133.568740352839,1.905));
+#573=VERTEX_POINT($,#572);
+#574=CARTESIAN_POINT($,(10,133.568740352839,1.905));
+#575=DIRECTION($,(1,0,0));
+#576=VECTOR($,#575,1);
+#577=LINE($,#574,#576);
+#578=EDGE_CURVE($,#565,#573,#577,.T.);
+#579=ORIENTED_EDGE($,$,$,#578,.T.);
+#580=CARTESIAN_POINT($,(65.9207401764197,133.568740352839,1.905));
+#581=VERTEX_POINT($,#580);
+#582=CARTESIAN_POINT($,(54.45,133.568740352839,1.905));
+#583=DIRECTION($,(1,0,0));
+#584=VECTOR($,#583,1);
+#585=LINE($,#582,#584);
+#586=EDGE_CURVE($,#573,#581,#585,.T.);
+#587=ORIENTED_EDGE($,$,$,#586,.T.);
+#588=CARTESIAN_POINT($,(65.9207401764197,125.313740352839,1.905));
+#589=VERTEX_POINT($,#588);
+#590=CARTESIAN_POINT($,(65.9207401764197,133.568740352839,1.905));
+#591=DIRECTION($,(0,-1,0));
+#592=VECTOR($,#591,1);
+#593=LINE($,#590,#592);
+#594=EDGE_CURVE($,#581,#589,#593,.T.);
+#595=ORIENTED_EDGE($,$,$,#594,.T.);
+#596=CARTESIAN_POINT($,(74.1757401764197,125.313740352839,1.905));
+#597=VERTEX_POINT($,#596);
+#598=CARTESIAN_POINT($,(65.9207401764197,125.313740352839,1.905));
+#599=DIRECTION($,(1,0,0));
+#600=VECTOR($,#599,1);
+#601=LINE($,#598,#600);
+#602=EDGE_CURVE($,#589,#597,#601,.T.);
+#603=ORIENTED_EDGE($,$,$,#602,.T.);
+#604=CARTESIAN_POINT($,(74.1757401764197,113.84300017642,1.905));
+#605=VERTEX_POINT($,#604);
+#606=CARTESIAN_POINT($,(74.1757401764197,125.313740352839,1.905));
+#607=DIRECTION($,(0,-1,0));
+#608=VECTOR($,#607,1);
+#609=LINE($,#606,#608);
+#610=EDGE_CURVE($,#597,#605,#609,.T.);
+#611=ORIENTED_EDGE($,$,$,#610,.T.);
+#612=CARTESIAN_POINT($,(74.1757401764197,52.2504601764197,1.905));
+#613=VERTEX_POINT($,#612);
+#614=CARTESIAN_POINT($,(74.1757401764197,113.84300017642,1.905));
+#615=DIRECTION($,(0,-1,0));
+#616=VECTOR($,#615,1);
+#617=LINE($,#614,#616);
+#618=EDGE_CURVE($,#605,#613,#617,.T.);
+#619=ORIENTED_EDGE($,$,$,#618,.T.);
+#620=CARTESIAN_POINT($,(74.1757401764197,40.77972,1.905));
+#621=VERTEX_POINT($,#620);
+#622=CARTESIAN_POINT($,(74.1757401764197,52.2504601764197,1.905));
+#623=DIRECTION($,(0,-1,0));
+#624=VECTOR($,#623,1);
+#625=LINE($,#622,#624);
+#626=EDGE_CURVE($,#613,#621,#625,.T.);
+#627=ORIENTED_EDGE($,$,$,#626,.T.);
+#628=CARTESIAN_POINT($,(74.1757401764197,10,1.905));
+#629=VERTEX_POINT($,#628);
+#630=CARTESIAN_POINT($,(74.1757401764197,40.77972,1.905));
+#631=DIRECTION($,(0,-1,0));
+#632=VECTOR($,#631,1);
+#633=LINE($,#630,#632);
+#634=EDGE_CURVE($,#621,#629,#633,.T.);
+#635=ORIENTED_EDGE($,$,$,#634,.T.);
+#636=CARTESIAN_POINT($,(298.96574017642,10,1.905));
+#637=VERTEX_POINT($,#636);
+#638=CARTESIAN_POINT($,(74.1757401764197,10,1.905));
+#639=DIRECTION($,(1,0,0));
+#640=VECTOR($,#639,1);
+#641=LINE($,#638,#640);
+#642=EDGE_CURVE($,#629,#637,#641,.T.);
+#643=ORIENTED_EDGE($,$,$,#642,.T.);
+#644=CARTESIAN_POINT($,(298.96574017642,40.77972,1.905));
+#645=VERTEX_POINT($,#644);
+#646=CARTESIAN_POINT($,(298.96574017642,10,1.905));
+#647=DIRECTION($,(0,1,0));
+#648=VECTOR($,#647,1);
+#649=LINE($,#646,#648);
+#650=EDGE_CURVE($,#637,#645,#649,.T.);
+#651=ORIENTED_EDGE($,$,$,#650,.T.);
+#652=CARTESIAN_POINT($,(298.96574017642,52.2504601764197,1.905));
+#653=VERTEX_POINT($,#652);
+#654=CARTESIAN_POINT($,(298.96574017642,40.77972,1.905));
+#655=DIRECTION($,(0,1,0));
+#656=VECTOR($,#655,1);
+#657=LINE($,#654,#656);
+#658=EDGE_CURVE($,#645,#653,#657,.T.);
+#659=ORIENTED_EDGE($,$,$,#658,.T.);
+#660=CARTESIAN_POINT($,(298.96574017642,113.84300017642,1.905));
+#661=VERTEX_POINT($,#660);
+#662=CARTESIAN_POINT($,(298.96574017642,52.2504601764197,1.905));
+#663=DIRECTION($,(0,1,0));
+#664=VECTOR($,#663,1);
+#665=LINE($,#662,#664);
+#666=EDGE_CURVE($,#653,#661,#665,.T.);
+#667=ORIENTED_EDGE($,$,$,#666,.T.);
+#668=CARTESIAN_POINT($,(298.96574017642,125.313740352839,1.905));
+#669=VERTEX_POINT($,#668);
+#670=CARTESIAN_POINT($,(298.96574017642,113.84300017642,1.905));
+#671=DIRECTION($,(0,1,0));
+#672=VECTOR($,#671,1);
+#673=LINE($,#670,#672);
+#674=EDGE_CURVE($,#661,#669,#673,.T.);
+#675=ORIENTED_EDGE($,$,$,#674,.T.);
+#676=CARTESIAN_POINT($,(307.22074017642,125.313740352839,1.905));
+#677=VERTEX_POINT($,#676);
+#678=CARTESIAN_POINT($,(298.96574017642,125.313740352839,1.905));
+#679=DIRECTION($,(1,0,0));
+#680=VECTOR($,#679,1);
+#681=LINE($,#678,#680);
+#682=EDGE_CURVE($,#669,#677,#681,.T.);
+#683=ORIENTED_EDGE($,$,$,#682,.T.);
+#684=CARTESIAN_POINT($,(307.22074017642,133.568740352839,1.905));
+#685=VERTEX_POINT($,#684);
+#686=CARTESIAN_POINT($,(307.22074017642,125.313740352839,1.905));
+#687=DIRECTION($,(0,1,0));
+#688=VECTOR($,#687,1);
+#689=LINE($,#686,#688);
+#690=EDGE_CURVE($,#677,#685,#689,.T.);
+#691=ORIENTED_EDGE($,$,$,#690,.T.);
+#692=CARTESIAN_POINT($,(318.691480352839,133.568740352839,1.905));
+#693=VERTEX_POINT($,#692);
+#694=CARTESIAN_POINT($,(307.22074017642,133.568740352839,1.905));
+#695=DIRECTION($,(1,0,0));
+#696=VECTOR($,#695,1);
+#697=LINE($,#694,#696);
+#698=EDGE_CURVE($,#685,#693,#697,.T.);
+#699=ORIENTED_EDGE($,$,$,#698,.T.);
+#700=CARTESIAN_POINT($,(347.802420352839,133.568740352839,1.905));
+#701=VERTEX_POINT($,#700);
+#702=CARTESIAN_POINT($,(318.691480352839,133.568740352839,1.905));
+#703=DIRECTION($,(1,0,0));
+#704=VECTOR($,#703,1);
+#705=LINE($,#702,#704);
+#706=EDGE_CURVE($,#693,#701,#705,.T.);
+#707=ORIENTED_EDGE($,$,$,#706,.T.);
+#708=CARTESIAN_POINT($,(353.537790441049,133.568740352839,1.905));
+#709=VERTEX_POINT($,#708);
+#710=CARTESIAN_POINT($,(347.802420352839,133.568740352839,1.905));
+#711=DIRECTION($,(1,0,0));
+#712=VECTOR($,#711,1);
+#713=LINE($,#710,#712);
+#714=EDGE_CURVE($,#701,#709,#713,.T.);
+#715=ORIENTED_EDGE($,$,$,#714,.T.);
+#716=CARTESIAN_POINT($,(353.537790441049,133.568740352839,1.905));
+#717=DIRECTION($,(1,0,0));
+#718=VECTOR($,#717,1);
+#719=LINE($,#716,#718);
+#720=EDGE_CURVE($,#709,#403,#719,.T.);
+#721=ORIENTED_EDGE($,$,$,#720,.T.);
+#722=EDGE_LOOP($,(#411,#419,#427,#435,#443,#451,#459,#467,#475,#483,#491,#499,#507,#515,#523,#531,#539,#547,#555,#563,#571,#579,#587,#595,#603,#611,#619,#627,#635,#643,#651,#659,#667,#675,#683,#691,#699,#707,#715,#721));
+#723=FACE_OUTER_BOUND('',#722,.T.);
+#724=CARTESIAN_POINT($,(107.67834017642,189.298880352839,1.905));
+#725=VERTEX_POINT($,#724);
+#726=CARTESIAN_POINT($,(126.72834017642,189.298880352839,1.905));
+#727=VERTEX_POINT($,#726);
+#728=CARTESIAN_POINT($,(107.67834017642,189.298880352839,1.905));
+#729=DIRECTION($,(1,0,0));
+#730=VECTOR($,#729,1);
+#731=LINE($,#728,#730);
+#732=EDGE_CURVE($,#725,#727,#731,.T.);
+#733=ORIENTED_EDGE($,$,$,#732,.F.);
+#734=CARTESIAN_POINT($,(107.67834017642,278.198880352839,1.905));
+#735=VERTEX_POINT($,#734);
+#736=CARTESIAN_POINT($,(107.67834017642,278.198880352839,1.905));
+#737=DIRECTION($,(0,-1,0));
+#738=VECTOR($,#737,1);
+#739=LINE($,#736,#738);
+#740=EDGE_CURVE($,#735,#725,#739,.T.);
+#741=ORIENTED_EDGE($,$,$,#740,.F.);
+#742=CARTESIAN_POINT($,(126.72834017642,278.198880352839,1.905));
+#743=VERTEX_POINT($,#742);
+#744=CARTESIAN_POINT($,(126.72834017642,278.198880352839,1.905));
+#745=DIRECTION($,(-1,0,0));
+#746=VECTOR($,#745,1);
+#747=LINE($,#744,#746);
+#748=EDGE_CURVE($,#743,#735,#747,.T.);
+#749=ORIENTED_EDGE($,$,$,#748,.F.);
+#750=CARTESIAN_POINT($,(126.72834017642,189.298880352839,1.905));
+#751=DIRECTION($,(0,1,0));
+#752=VECTOR($,#751,1);
+#753=LINE($,#750,#752);
+#754=EDGE_CURVE($,#727,#743,#753,.T.);
+#755=ORIENTED_EDGE($,$,$,#754,.F.);
+#756=EDGE_LOOP($,(#733,#741,#749,#755));
+#757=FACE_BOUND('',#756,.T.);
+#758=CARTESIAN_POINT($,(171.17834017642,189.298880352839,1.905));
+#759=VERTEX_POINT($,#758);
+#760=CARTESIAN_POINT($,(190.22834017642,189.298880352839,1.905));
+#761=VERTEX_POINT($,#760);
+#762=CARTESIAN_POINT($,(171.17834017642,189.298880352839,1.905));
+#763=DIRECTION($,(1,0,0));
+#764=VECTOR($,#763,1);
+#765=LINE($,#762,#764);
+#766=EDGE_CURVE($,#759,#761,#765,.T.);
+#767=ORIENTED_EDGE($,$,$,#766,.F.);
+#768=CARTESIAN_POINT($,(171.17834017642,278.198880352839,1.905));
+#769=VERTEX_POINT($,#768);
+#770=CARTESIAN_POINT($,(171.17834017642,278.198880352839,1.905));
+#771=DIRECTION($,(0,-1,0));
+#772=VECTOR($,#771,1);
+#773=LINE($,#770,#772);
+#774=EDGE_CURVE($,#769,#759,#773,.T.);
+#775=ORIENTED_EDGE($,$,$,#774,.F.);
+#776=CARTESIAN_POINT($,(190.22834017642,278.198880352839,1.905));
+#777=VERTEX_POINT($,#776);
+#778=CARTESIAN_POINT($,(190.22834017642,278.198880352839,1.905));
+#779=DIRECTION($,(-1,0,0));
+#780=VECTOR($,#779,1);
+#781=LINE($,#778,#780);
+#782=EDGE_CURVE($,#777,#769,#781,.T.);
+#783=ORIENTED_EDGE($,$,$,#782,.F.);
+#784=CARTESIAN_POINT($,(190.22834017642,189.298880352839,1.905));
+#785=DIRECTION($,(0,1,0));
+#786=VECTOR($,#785,1);
+#787=LINE($,#784,#786);
+#788=EDGE_CURVE($,#761,#777,#787,.T.);
+#789=ORIENTED_EDGE($,$,$,#788,.F.);
+#790=EDGE_LOOP($,(#767,#775,#783,#789));
+#791=FACE_BOUND('',#790,.T.);
+#792=ADVANCED_FACE('',(#723,#757,#791),#401,.T.);
+#793=CARTESIAN_POINT($,(402.051790441049,133.568740352839,0));
+#794=DIRECTION($,(1,0,0));
+#795=DIRECTION($,(0,0,1));
+#796=AXIS2_PLACEMENT_3D($,#793,#794,#795);
+#797=PLANE($,#796);
+#798=ORIENTED_EDGE($,$,$,#14,.T.);
+#799=CARTESIAN_POINT($,(402.051790441049,485.358740352839,-0));
+#800=DIRECTION($,(0,0,1));
+#801=VECTOR($,#800,1);
+#802=LINE($,#799,#801);
+#803=EDGE_CURVE($,#9,#405,#802,.T.);
+#804=ORIENTED_EDGE($,$,$,#803,.T.);
+#805=ORIENTED_EDGE($,$,$,#410,.F.);
+#806=CARTESIAN_POINT($,(402.051790441049,133.568740352839,0));
+#807=DIRECTION($,(0,0,1));
+#808=VECTOR($,#807,1);
+#809=LINE($,#806,#808);
+#810=EDGE_CURVE($,#7,#403,#809,.T.);
+#811=ORIENTED_EDGE($,$,$,#810,.F.);
+#812=EDGE_LOOP($,(#798,#804,#805,#811));
+#813=FACE_OUTER_BOUND('',#812,.T.);
+#814=ADVANCED_FACE('',(#813),#797,.T.);
+#815=CARTESIAN_POINT($,(402.051790441049,485.358740352839,0));
+#816=DIRECTION($,(0,1,0));
+#817=DIRECTION($,(0,0,1));
+#818=AXIS2_PLACEMENT_3D($,#815,#816,#817);
+#819=PLANE($,#818);
+#820=ORIENTED_EDGE($,$,$,#22,.T.);
+#821=CARTESIAN_POINT($,(353.537790441049,485.358740352839,0));
+#822=DIRECTION($,(0,0,1));
+#823=VECTOR($,#822,1);
+#824=LINE($,#821,#823);
+#825=EDGE_CURVE($,#17,#413,#824,.T.);
+#826=ORIENTED_EDGE($,$,$,#825,.T.);
+#827=ORIENTED_EDGE($,$,$,#418,.F.);
+#828=ORIENTED_EDGE($,$,$,#803,.F.);
+#829=EDGE_LOOP($,(#820,#826,#827,#828));
+#830=FACE_OUTER_BOUND('',#829,.T.);
+#831=ADVANCED_FACE('',(#830),#819,.T.);
+#832=CARTESIAN_POINT($,(353.537790441049,485.358740352839,0));
+#833=DIRECTION($,(0,1,0));
+#834=DIRECTION($,(0,0,1));
+#835=AXIS2_PLACEMENT_3D($,#832,#833,#834);
+#836=PLANE($,#835);
+#837=ORIENTED_EDGE($,$,$,#30,.T.);
+#838=CARTESIAN_POINT($,(347.802420352839,485.358740352839,0));
+#839=DIRECTION($,(0,0,1));
+#840=VECTOR($,#839,1);
+#841=LINE($,#838,#840);
+#842=EDGE_CURVE($,#25,#421,#841,.T.);
+#843=ORIENTED_EDGE($,$,$,#842,.T.);
+#844=ORIENTED_EDGE($,$,$,#426,.F.);
+#845=ORIENTED_EDGE($,$,$,#825,.F.);
+#846=EDGE_LOOP($,(#837,#843,#844,#845));
+#847=FACE_OUTER_BOUND('',#846,.T.);
+#848=ADVANCED_FACE('',(#847),#836,.T.);
+#849=CARTESIAN_POINT($,(347.802420352839,485.358740352839,0));
+#850=DIRECTION($,(0,1,0));
+#851=DIRECTION($,(0,0,1));
+#852=AXIS2_PLACEMENT_3D($,#849,#850,#851);
+#853=PLANE($,#852);
+#854=ORIENTED_EDGE($,$,$,#38,.T.);
+#855=CARTESIAN_POINT($,(318.691480352839,485.358740352839,0));
+#856=DIRECTION($,(0,0,1));
+#857=VECTOR($,#856,1);
+#858=LINE($,#855,#857);
+#859=EDGE_CURVE($,#33,#429,#858,.T.);
+#860=ORIENTED_EDGE($,$,$,#859,.T.);
+#861=ORIENTED_EDGE($,$,$,#434,.F.);
+#862=ORIENTED_EDGE($,$,$,#842,.F.);
+#863=EDGE_LOOP($,(#854,#860,#861,#862));
+#864=FACE_OUTER_BOUND('',#863,.T.);
+#865=ADVANCED_FACE('',(#864),#853,.T.);
+#866=CARTESIAN_POINT($,(318.691480352839,485.35874035284,0));
+#867=DIRECTION($,(0,1,0));
+#868=DIRECTION($,(0,0,1));
+#869=AXIS2_PLACEMENT_3D($,#866,#867,#868);
+#870=PLANE($,#869);
+#871=ORIENTED_EDGE($,$,$,#46,.T.);
+#872=CARTESIAN_POINT($,(307.22074017642,485.35874035284,0));
+#873=DIRECTION($,(0,0,1));
+#874=VECTOR($,#873,1);
+#875=LINE($,#872,#874);
+#876=EDGE_CURVE($,#41,#437,#875,.T.);
+#877=ORIENTED_EDGE($,$,$,#876,.T.);
+#878=ORIENTED_EDGE($,$,$,#442,.F.);
+#879=ORIENTED_EDGE($,$,$,#859,.F.);
+#880=EDGE_LOOP($,(#871,#877,#878,#879));
+#881=FACE_OUTER_BOUND('',#880,.T.);
+#882=ADVANCED_FACE('',(#881),#870,.T.);
+#883=CARTESIAN_POINT($,(307.22074017642,485.35874035284,0));
+#884=DIRECTION($,(1,0,0));
+#885=DIRECTION($,(0,0,1));
+#886=AXIS2_PLACEMENT_3D($,#883,#884,#885);
+#887=PLANE($,#886);
+#888=ORIENTED_EDGE($,$,$,#54,.T.);
+#889=CARTESIAN_POINT($,(307.22074017642,493.613740352839,-0));
+#890=DIRECTION($,(0,0,1));
+#891=VECTOR($,#890,1);
+#892=LINE($,#889,#891);
+#893=EDGE_CURVE($,#49,#445,#892,.T.);
+#894=ORIENTED_EDGE($,$,$,#893,.T.);
+#895=ORIENTED_EDGE($,$,$,#450,.F.);
+#896=ORIENTED_EDGE($,$,$,#876,.F.);
+#897=EDGE_LOOP($,(#888,#894,#895,#896));
+#898=FACE_OUTER_BOUND('',#897,.T.);
+#899=ADVANCED_FACE('',(#898),#887,.T.);
+#900=CARTESIAN_POINT($,(307.22074017642,493.613740352839,0));
+#901=DIRECTION($,(0,1,0));
+#902=DIRECTION($,(0,0,1));
+#903=AXIS2_PLACEMENT_3D($,#900,#901,#902);
+#904=PLANE($,#903);
+#905=ORIENTED_EDGE($,$,$,#62,.T.);
+#906=CARTESIAN_POINT($,(298.96574017642,493.613740352839,0));
+#907=DIRECTION($,(0,0,1));
+#908=VECTOR($,#907,1);
+#909=LINE($,#906,#908);
+#910=EDGE_CURVE($,#57,#453,#909,.T.);
+#911=ORIENTED_EDGE($,$,$,#910,.T.);
+#912=ORIENTED_EDGE($,$,$,#458,.F.);
+#913=ORIENTED_EDGE($,$,$,#893,.F.);
+#914=EDGE_LOOP($,(#905,#911,#912,#913));
+#915=FACE_OUTER_BOUND('',#914,.T.);
+#916=ADVANCED_FACE('',(#915),#904,.T.);
+#917=CARTESIAN_POINT($,(298.96574017642,493.613740352839,0));
+#918=DIRECTION($,(1,0,0));
+#919=DIRECTION($,(0,0,1));
+#920=AXIS2_PLACEMENT_3D($,#917,#918,#919);
+#921=PLANE($,#920);
+#922=ORIENTED_EDGE($,$,$,#70,.T.);
+#923=CARTESIAN_POINT($,(298.96574017642,505.084480529259,0));
+#924=DIRECTION($,(0,0,1));
+#925=VECTOR($,#924,1);
+#926=LINE($,#923,#925);
+#927=EDGE_CURVE($,#65,#461,#926,.T.);
+#928=ORIENTED_EDGE($,$,$,#927,.T.);
+#929=ORIENTED_EDGE($,$,$,#466,.F.);
+#930=ORIENTED_EDGE($,$,$,#910,.F.);
+#931=EDGE_LOOP($,(#922,#928,#929,#930));
+#932=FACE_OUTER_BOUND('',#931,.T.);
+#933=ADVANCED_FACE('',(#932),#921,.T.);
+#934=CARTESIAN_POINT($,(298.96574017642,505.084480529259,0));
+#935=DIRECTION($,(1,0,0));
+#936=DIRECTION($,(0,0,1));
+#937=AXIS2_PLACEMENT_3D($,#934,#935,#936);
+#938=PLANE($,#937);
+#939=ORIENTED_EDGE($,$,$,#78,.T.);
+#940=CARTESIAN_POINT($,(298.96574017642,566.677020529259,0));
+#941=DIRECTION($,(0,0,1));
+#942=VECTOR($,#941,1);
+#943=LINE($,#940,#942);
+#944=EDGE_CURVE($,#73,#469,#943,.T.);
+#945=ORIENTED_EDGE($,$,$,#944,.T.);
+#946=ORIENTED_EDGE($,$,$,#474,.F.);
+#947=ORIENTED_EDGE($,$,$,#927,.F.);
+#948=EDGE_LOOP($,(#939,#945,#946,#947));
+#949=FACE_OUTER_BOUND('',#948,.T.);
+#950=ADVANCED_FACE('',(#949),#938,.T.);
+#951=CARTESIAN_POINT($,(298.96574017642,566.677020529259,0));
+#952=DIRECTION($,(1,0,0));
+#953=DIRECTION($,(0,0,1));
+#954=AXIS2_PLACEMENT_3D($,#951,#952,#953);
+#955=PLANE($,#954);
+#956=ORIENTED_EDGE($,$,$,#86,.T.);
+#957=CARTESIAN_POINT($,(298.96574017642,578.147760705679,0));
+#958=DIRECTION($,(0,0,1));
+#959=VECTOR($,#958,1);
+#960=LINE($,#957,#959);
+#961=EDGE_CURVE($,#81,#477,#960,.T.);
+#962=ORIENTED_EDGE($,$,$,#961,.T.);
+#963=ORIENTED_EDGE($,$,$,#482,.F.);
+#964=ORIENTED_EDGE($,$,$,#944,.F.);
+#965=EDGE_LOOP($,(#956,#962,#963,#964));
+#966=FACE_OUTER_BOUND('',#965,.T.);
+#967=ADVANCED_FACE('',(#966),#955,.T.);
+#968=CARTESIAN_POINT($,(298.96574017642,578.147760705679,0));
+#969=DIRECTION($,(1,0,0));
+#970=DIRECTION($,(0,0,1));
+#971=AXIS2_PLACEMENT_3D($,#968,#969,#970);
+#972=PLANE($,#971);
+#973=ORIENTED_EDGE($,$,$,#94,.T.);
+#974=CARTESIAN_POINT($,(298.96574017642,622.597760705679,-0));
+#975=DIRECTION($,(0,0,1));
+#976=VECTOR($,#975,1);
+#977=LINE($,#974,#976);
+#978=EDGE_CURVE($,#89,#485,#977,.T.);
+#979=ORIENTED_EDGE($,$,$,#978,.T.);
+#980=ORIENTED_EDGE($,$,$,#490,.F.);
+#981=ORIENTED_EDGE($,$,$,#961,.F.);
+#982=EDGE_LOOP($,(#973,#979,#980,#981));
+#983=FACE_OUTER_BOUND('',#982,.T.);
+#984=ADVANCED_FACE('',(#983),#972,.T.);
+#985=CARTESIAN_POINT($,(298.96574017642,622.597760705679,0));
+#986=DIRECTION($,(0,1,0));
+#987=DIRECTION($,(0,0,1));
+#988=AXIS2_PLACEMENT_3D($,#985,#986,#987);
+#989=PLANE($,#988);
+#990=ORIENTED_EDGE($,$,$,#102,.T.);
+#991=CARTESIAN_POINT($,(74.1757401764197,622.597760705679,-0));
+#992=DIRECTION($,(0,0,1));
+#993=VECTOR($,#992,1);
+#994=LINE($,#991,#993);
+#995=EDGE_CURVE($,#97,#493,#994,.T.);
+#996=ORIENTED_EDGE($,$,$,#995,.T.);
+#997=ORIENTED_EDGE($,$,$,#498,.F.);
+#998=ORIENTED_EDGE($,$,$,#978,.F.);
+#999=EDGE_LOOP($,(#990,#996,#997,#998));
+#1000=FACE_OUTER_BOUND('',#999,.T.);
+#1001=ADVANCED_FACE('',(#1000),#989,.T.);
+#1002=CARTESIAN_POINT($,(74.1757401764197,622.597760705679,0));
+#1003=DIRECTION($,(-1,0,0));
+#1004=DIRECTION($,(0,0,1));
+#1005=AXIS2_PLACEMENT_3D($,#1002,#1003,#1004);
+#1006=PLANE($,#1005);
+#1007=ORIENTED_EDGE($,$,$,#110,.T.);
+#1008=CARTESIAN_POINT($,(74.1757401764197,578.147760705679,0));
+#1009=DIRECTION($,(0,0,1));
+#1010=VECTOR($,#1009,1);
+#1011=LINE($,#1008,#1010);
+#1012=EDGE_CURVE($,#105,#501,#1011,.T.);
+#1013=ORIENTED_EDGE($,$,$,#1012,.T.);
+#1014=ORIENTED_EDGE($,$,$,#506,.F.);
+#1015=ORIENTED_EDGE($,$,$,#995,.F.);
+#1016=EDGE_LOOP($,(#1007,#1013,#1014,#1015));
+#1017=FACE_OUTER_BOUND('',#1016,.T.);
+#1018=ADVANCED_FACE('',(#1017),#1006,.T.);
+#1019=CARTESIAN_POINT($,(74.1757401764197,578.147760705679,0));
+#1020=DIRECTION($,(-1,0,0));
+#1021=DIRECTION($,(0,0,1));
+#1022=AXIS2_PLACEMENT_3D($,#1019,#1020,#1021);
+#1023=PLANE($,#1022);
+#1024=ORIENTED_EDGE($,$,$,#118,.T.);
+#1025=CARTESIAN_POINT($,(74.1757401764197,566.677020529259,0));
+#1026=DIRECTION($,(0,0,1));
+#1027=VECTOR($,#1026,1);
+#1028=LINE($,#1025,#1027);
+#1029=EDGE_CURVE($,#113,#509,#1028,.T.);
+#1030=ORIENTED_EDGE($,$,$,#1029,.T.);
+#1031=ORIENTED_EDGE($,$,$,#514,.F.);
+#1032=ORIENTED_EDGE($,$,$,#1012,.F.);
+#1033=EDGE_LOOP($,(#1024,#1030,#1031,#1032));
+#1034=FACE_OUTER_BOUND('',#1033,.T.);
+#1035=ADVANCED_FACE('',(#1034),#1023,.T.);
+#1036=CARTESIAN_POINT($,(74.1757401764197,566.677020529259,0));
+#1037=DIRECTION($,(-1,0,0));
+#1038=DIRECTION($,(0,0,1));
+#1039=AXIS2_PLACEMENT_3D($,#1036,#1037,#1038);
+#1040=PLANE($,#1039);
+#1041=ORIENTED_EDGE($,$,$,#126,.T.);
+#1042=CARTESIAN_POINT($,(74.1757401764197,505.084480529259,0));
+#1043=DIRECTION($,(0,0,1));
+#1044=VECTOR($,#1043,1);
+#1045=LINE($,#1042,#1044);
+#1046=EDGE_CURVE($,#121,#517,#1045,.T.);
+#1047=ORIENTED_EDGE($,$,$,#1046,.T.);
+#1048=ORIENTED_EDGE($,$,$,#522,.F.);
+#1049=ORIENTED_EDGE($,$,$,#1029,.F.);
+#1050=EDGE_LOOP($,(#1041,#1047,#1048,#1049));
+#1051=FACE_OUTER_BOUND('',#1050,.T.);
+#1052=ADVANCED_FACE('',(#1051),#1040,.T.);
+#1053=CARTESIAN_POINT($,(74.1757401764197,505.084480529259,0));
+#1054=DIRECTION($,(-1,0,0));
+#1055=DIRECTION($,(0,0,1));
+#1056=AXIS2_PLACEMENT_3D($,#1053,#1054,#1055);
+#1057=PLANE($,#1056);
+#1058=ORIENTED_EDGE($,$,$,#134,.T.);
+#1059=CARTESIAN_POINT($,(74.1757401764197,493.613740352839,0));
+#1060=DIRECTION($,(0,0,1));
+#1061=VECTOR($,#1060,1);
+#1062=LINE($,#1059,#1061);
+#1063=EDGE_CURVE($,#129,#525,#1062,.T.);
+#1064=ORIENTED_EDGE($,$,$,#1063,.T.);
+#1065=ORIENTED_EDGE($,$,$,#530,.F.);
+#1066=ORIENTED_EDGE($,$,$,#1046,.F.);
+#1067=EDGE_LOOP($,(#1058,#1064,#1065,#1066));
+#1068=FACE_OUTER_BOUND('',#1067,.T.);
+#1069=ADVANCED_FACE('',(#1068),#1057,.T.);
+#1070=CARTESIAN_POINT($,(74.1757401764197,493.613740352839,0));
+#1071=DIRECTION($,(0,1,0));
+#1072=DIRECTION($,(0,0,1));
+#1073=AXIS2_PLACEMENT_3D($,#1070,#1071,#1072);
+#1074=PLANE($,#1073);
+#1075=ORIENTED_EDGE($,$,$,#142,.T.);
+#1076=CARTESIAN_POINT($,(65.9207401764197,493.613740352839,-0));
+#1077=DIRECTION($,(0,0,1));
+#1078=VECTOR($,#1077,1);
+#1079=LINE($,#1076,#1078);
+#1080=EDGE_CURVE($,#137,#533,#1079,.T.);
+#1081=ORIENTED_EDGE($,$,$,#1080,.T.);
+#1082=ORIENTED_EDGE($,$,$,#538,.F.);
+#1083=ORIENTED_EDGE($,$,$,#1063,.F.);
+#1084=EDGE_LOOP($,(#1075,#1081,#1082,#1083));
+#1085=FACE_OUTER_BOUND('',#1084,.T.);
+#1086=ADVANCED_FACE('',(#1085),#1074,.T.);
+#1087=CARTESIAN_POINT($,(65.9207401764197,493.613740352839,0));
+#1088=DIRECTION($,(-1,0,0));
+#1089=DIRECTION($,(0,0,1));
+#1090=AXIS2_PLACEMENT_3D($,#1087,#1088,#1089);
+#1091=PLANE($,#1090);
+#1092=ORIENTED_EDGE($,$,$,#150,.T.);
+#1093=CARTESIAN_POINT($,(65.9207401764197,485.35874035284,0));
+#1094=DIRECTION($,(0,0,1));
+#1095=VECTOR($,#1094,1);
+#1096=LINE($,#1093,#1095);
+#1097=EDGE_CURVE($,#145,#541,#1096,.T.);
+#1098=ORIENTED_EDGE($,$,$,#1097,.T.);
+#1099=ORIENTED_EDGE($,$,$,#546,.F.);
+#1100=ORIENTED_EDGE($,$,$,#1080,.F.);
+#1101=EDGE_LOOP($,(#1092,#1098,#1099,#1100));
+#1102=FACE_OUTER_BOUND('',#1101,.T.);
+#1103=ADVANCED_FACE('',(#1102),#1091,.T.);
+#1104=CARTESIAN_POINT($,(65.9207401764197,485.35874035284,0));
+#1105=DIRECTION($,(0,1,0));
+#1106=DIRECTION($,(0,0,1));
+#1107=AXIS2_PLACEMENT_3D($,#1104,#1105,#1106);
+#1108=PLANE($,#1107);
+#1109=ORIENTED_EDGE($,$,$,#158,.T.);
+#1110=CARTESIAN_POINT($,(54.45,485.35874035284,0));
+#1111=DIRECTION($,(0,0,1));
+#1112=VECTOR($,#1111,1);
+#1113=LINE($,#1110,#1112);
+#1114=EDGE_CURVE($,#153,#549,#1113,.T.);
+#1115=ORIENTED_EDGE($,$,$,#1114,.T.);
+#1116=ORIENTED_EDGE($,$,$,#554,.F.);
+#1117=ORIENTED_EDGE($,$,$,#1097,.F.);
+#1118=EDGE_LOOP($,(#1109,#1115,#1116,#1117));
+#1119=FACE_OUTER_BOUND('',#1118,.T.);
+#1120=ADVANCED_FACE('',(#1119),#1108,.T.);
+#1121=CARTESIAN_POINT($,(54.45,485.35874035284,0));
+#1122=DIRECTION($,(0,1,0));
+#1123=DIRECTION($,(0,0,1));
+#1124=AXIS2_PLACEMENT_3D($,#1121,#1122,#1123);
+#1125=PLANE($,#1124);
+#1126=ORIENTED_EDGE($,$,$,#166,.T.);
+#1127=CARTESIAN_POINT($,(10,485.35874035284,-0));
+#1128=DIRECTION($,(0,0,1));
+#1129=VECTOR($,#1128,1);
+#1130=LINE($,#1127,#1129);
+#1131=EDGE_CURVE($,#161,#557,#1130,.T.);
+#1132=ORIENTED_EDGE($,$,$,#1131,.T.);
+#1133=ORIENTED_EDGE($,$,$,#562,.F.);
+#1134=ORIENTED_EDGE($,$,$,#1114,.F.);
+#1135=EDGE_LOOP($,(#1126,#1132,#1133,#1134));
+#1136=FACE_OUTER_BOUND('',#1135,.T.);
+#1137=ADVANCED_FACE('',(#1136),#1125,.T.);
+#1138=CARTESIAN_POINT($,(10,485.35874035284,0));
+#1139=DIRECTION($,(-1,0,0));
+#1140=DIRECTION($,(0,0,1));
+#1141=AXIS2_PLACEMENT_3D($,#1138,#1139,#1140);
+#1142=PLANE($,#1141);
+#1143=ORIENTED_EDGE($,$,$,#174,.T.);
+#1144=CARTESIAN_POINT($,(10,133.568740352839,-0));
+#1145=DIRECTION($,(0,0,1));
+#1146=VECTOR($,#1145,1);
+#1147=LINE($,#1144,#1146);
+#1148=EDGE_CURVE($,#169,#565,#1147,.T.);
+#1149=ORIENTED_EDGE($,$,$,#1148,.T.);
+#1150=ORIENTED_EDGE($,$,$,#570,.F.);
+#1151=ORIENTED_EDGE($,$,$,#1131,.F.);
+#1152=EDGE_LOOP($,(#1143,#1149,#1150,#1151));
+#1153=FACE_OUTER_BOUND('',#1152,.T.);
+#1154=ADVANCED_FACE('',(#1153),#1142,.T.);
+#1155=CARTESIAN_POINT($,(10,133.568740352839,0));
+#1156=DIRECTION($,(0,-1,0));
+#1157=DIRECTION($,(0,0,1));
+#1158=AXIS2_PLACEMENT_3D($,#1155,#1156,#1157);
+#1159=PLANE($,#1158);
+#1160=ORIENTED_EDGE($,$,$,#182,.T.);
+#1161=CARTESIAN_POINT($,(54.45,133.568740352839,0));
+#1162=DIRECTION($,(0,0,1));
+#1163=VECTOR($,#1162,1);
+#1164=LINE($,#1161,#1163);
+#1165=EDGE_CURVE($,#177,#573,#1164,.T.);
+#1166=ORIENTED_EDGE($,$,$,#1165,.T.);
+#1167=ORIENTED_EDGE($,$,$,#578,.F.);
+#1168=ORIENTED_EDGE($,$,$,#1148,.F.);
+#1169=EDGE_LOOP($,(#1160,#1166,#1167,#1168));
+#1170=FACE_OUTER_BOUND('',#1169,.T.);
+#1171=ADVANCED_FACE('',(#1170),#1159,.T.);
+#1172=CARTESIAN_POINT($,(54.45,133.568740352839,0));
+#1173=DIRECTION($,(0,-1,0));
+#1174=DIRECTION($,(0,0,1));
+#1175=AXIS2_PLACEMENT_3D($,#1172,#1173,#1174);
+#1176=PLANE($,#1175);
+#1177=ORIENTED_EDGE($,$,$,#190,.T.);
+#1178=CARTESIAN_POINT($,(65.9207401764197,133.568740352839,0));
+#1179=DIRECTION($,(0,0,1));
+#1180=VECTOR($,#1179,1);
+#1181=LINE($,#1178,#1180);
+#1182=EDGE_CURVE($,#185,#581,#1181,.T.);
+#1183=ORIENTED_EDGE($,$,$,#1182,.T.);
+#1184=ORIENTED_EDGE($,$,$,#586,.F.);
+#1185=ORIENTED_EDGE($,$,$,#1165,.F.);
+#1186=EDGE_LOOP($,(#1177,#1183,#1184,#1185));
+#1187=FACE_OUTER_BOUND('',#1186,.T.);
+#1188=ADVANCED_FACE('',(#1187),#1176,.T.);
+#1189=CARTESIAN_POINT($,(65.9207401764197,133.568740352839,0));
+#1190=DIRECTION($,(-1,0,0));
+#1191=DIRECTION($,(0,0,1));
+#1192=AXIS2_PLACEMENT_3D($,#1189,#1190,#1191);
+#1193=PLANE($,#1192);
+#1194=ORIENTED_EDGE($,$,$,#198,.T.);
+#1195=CARTESIAN_POINT($,(65.9207401764197,125.313740352839,-0));
+#1196=DIRECTION($,(0,0,1));
+#1197=VECTOR($,#1196,1);
+#1198=LINE($,#1195,#1197);
+#1199=EDGE_CURVE($,#193,#589,#1198,.T.);
+#1200=ORIENTED_EDGE($,$,$,#1199,.T.);
+#1201=ORIENTED_EDGE($,$,$,#594,.F.);
+#1202=ORIENTED_EDGE($,$,$,#1182,.F.);
+#1203=EDGE_LOOP($,(#1194,#1200,#1201,#1202));
+#1204=FACE_OUTER_BOUND('',#1203,.T.);
+#1205=ADVANCED_FACE('',(#1204),#1193,.T.);
+#1206=CARTESIAN_POINT($,(65.9207401764197,125.313740352839,0));
+#1207=DIRECTION($,(0,-1,0));
+#1208=DIRECTION($,(0,0,1));
+#1209=AXIS2_PLACEMENT_3D($,#1206,#1207,#1208);
+#1210=PLANE($,#1209);
+#1211=ORIENTED_EDGE($,$,$,#206,.T.);
+#1212=CARTESIAN_POINT($,(74.1757401764197,125.313740352839,0));
+#1213=DIRECTION($,(0,0,1));
+#1214=VECTOR($,#1213,1);
+#1215=LINE($,#1212,#1214);
+#1216=EDGE_CURVE($,#201,#597,#1215,.T.);
+#1217=ORIENTED_EDGE($,$,$,#1216,.T.);
+#1218=ORIENTED_EDGE($,$,$,#602,.F.);
+#1219=ORIENTED_EDGE($,$,$,#1199,.F.);
+#1220=EDGE_LOOP($,(#1211,#1217,#1218,#1219));
+#1221=FACE_OUTER_BOUND('',#1220,.T.);
+#1222=ADVANCED_FACE('',(#1221),#1210,.T.);
+#1223=CARTESIAN_POINT($,(74.1757401764197,125.313740352839,0));
+#1224=DIRECTION($,(-1,0,0));
+#1225=DIRECTION($,(0,0,1));
+#1226=AXIS2_PLACEMENT_3D($,#1223,#1224,#1225);
+#1227=PLANE($,#1226);
+#1228=ORIENTED_EDGE($,$,$,#214,.T.);
+#1229=CARTESIAN_POINT($,(74.1757401764197,113.84300017642,0));
+#1230=DIRECTION($,(0,0,1));
+#1231=VECTOR($,#1230,1);
+#1232=LINE($,#1229,#1231);
+#1233=EDGE_CURVE($,#209,#605,#1232,.T.);
+#1234=ORIENTED_EDGE($,$,$,#1233,.T.);
+#1235=ORIENTED_EDGE($,$,$,#610,.F.);
+#1236=ORIENTED_EDGE($,$,$,#1216,.F.);
+#1237=EDGE_LOOP($,(#1228,#1234,#1235,#1236));
+#1238=FACE_OUTER_BOUND('',#1237,.T.);
+#1239=ADVANCED_FACE('',(#1238),#1227,.T.);
+#1240=CARTESIAN_POINT($,(74.1757401764197,113.84300017642,0));
+#1241=DIRECTION($,(-1,0,0));
+#1242=DIRECTION($,(0,0,1));
+#1243=AXIS2_PLACEMENT_3D($,#1240,#1241,#1242);
+#1244=PLANE($,#1243);
+#1245=ORIENTED_EDGE($,$,$,#222,.T.);
+#1246=CARTESIAN_POINT($,(74.1757401764197,52.2504601764197,0));
+#1247=DIRECTION($,(0,0,1));
+#1248=VECTOR($,#1247,1);
+#1249=LINE($,#1246,#1248);
+#1250=EDGE_CURVE($,#217,#613,#1249,.T.);
+#1251=ORIENTED_EDGE($,$,$,#1250,.T.);
+#1252=ORIENTED_EDGE($,$,$,#618,.F.);
+#1253=ORIENTED_EDGE($,$,$,#1233,.F.);
+#1254=EDGE_LOOP($,(#1245,#1251,#1252,#1253));
+#1255=FACE_OUTER_BOUND('',#1254,.T.);
+#1256=ADVANCED_FACE('',(#1255),#1244,.T.);
+#1257=CARTESIAN_POINT($,(74.1757401764197,52.2504601764197,0));
+#1258=DIRECTION($,(-1,0,0));
+#1259=DIRECTION($,(0,0,1));
+#1260=AXIS2_PLACEMENT_3D($,#1257,#1258,#1259);
+#1261=PLANE($,#1260);
+#1262=ORIENTED_EDGE($,$,$,#230,.T.);
+#1263=CARTESIAN_POINT($,(74.1757401764197,40.77972,0));
+#1264=DIRECTION($,(0,0,1));
+#1265=VECTOR($,#1264,1);
+#1266=LINE($,#1263,#1265);
+#1267=EDGE_CURVE($,#225,#621,#1266,.T.);
+#1268=ORIENTED_EDGE($,$,$,#1267,.T.);
+#1269=ORIENTED_EDGE($,$,$,#626,.F.);
+#1270=ORIENTED_EDGE($,$,$,#1250,.F.);
+#1271=EDGE_LOOP($,(#1262,#1268,#1269,#1270));
+#1272=FACE_OUTER_BOUND('',#1271,.T.);
+#1273=ADVANCED_FACE('',(#1272),#1261,.T.);
+#1274=CARTESIAN_POINT($,(74.1757401764197,40.77972,0));
+#1275=DIRECTION($,(-1,0,0));
+#1276=DIRECTION($,(0,0,1));
+#1277=AXIS2_PLACEMENT_3D($,#1274,#1275,#1276);
+#1278=PLANE($,#1277);
+#1279=ORIENTED_EDGE($,$,$,#238,.T.);
+#1280=CARTESIAN_POINT($,(74.1757401764197,10,-0));
+#1281=DIRECTION($,(0,0,1));
+#1282=VECTOR($,#1281,1);
+#1283=LINE($,#1280,#1282);
+#1284=EDGE_CURVE($,#233,#629,#1283,.T.);
+#1285=ORIENTED_EDGE($,$,$,#1284,.T.);
+#1286=ORIENTED_EDGE($,$,$,#634,.F.);
+#1287=ORIENTED_EDGE($,$,$,#1267,.F.);
+#1288=EDGE_LOOP($,(#1279,#1285,#1286,#1287));
+#1289=FACE_OUTER_BOUND('',#1288,.T.);
+#1290=ADVANCED_FACE('',(#1289),#1278,.T.);
+#1291=CARTESIAN_POINT($,(74.1757401764197,10,0));
+#1292=DIRECTION($,(0,-1,0));
+#1293=DIRECTION($,(0,0,1));
+#1294=AXIS2_PLACEMENT_3D($,#1291,#1292,#1293);
+#1295=PLANE($,#1294);
+#1296=ORIENTED_EDGE($,$,$,#246,.T.);
+#1297=CARTESIAN_POINT($,(298.96574017642,10,-0));
+#1298=DIRECTION($,(0,0,1));
+#1299=VECTOR($,#1298,1);
+#1300=LINE($,#1297,#1299);
+#1301=EDGE_CURVE($,#241,#637,#1300,.T.);
+#1302=ORIENTED_EDGE($,$,$,#1301,.T.);
+#1303=ORIENTED_EDGE($,$,$,#642,.F.);
+#1304=ORIENTED_EDGE($,$,$,#1284,.F.);
+#1305=EDGE_LOOP($,(#1296,#1302,#1303,#1304));
+#1306=FACE_OUTER_BOUND('',#1305,.T.);
+#1307=ADVANCED_FACE('',(#1306),#1295,.T.);
+#1308=CARTESIAN_POINT($,(298.96574017642,10,0));
+#1309=DIRECTION($,(1,0,0));
+#1310=DIRECTION($,(0,0,1));
+#1311=AXIS2_PLACEMENT_3D($,#1308,#1309,#1310);
+#1312=PLANE($,#1311);
+#1313=ORIENTED_EDGE($,$,$,#254,.T.);
+#1314=CARTESIAN_POINT($,(298.96574017642,40.77972,0));
+#1315=DIRECTION($,(0,0,1));
+#1316=VECTOR($,#1315,1);
+#1317=LINE($,#1314,#1316);
+#1318=EDGE_CURVE($,#249,#645,#1317,.T.);
+#1319=ORIENTED_EDGE($,$,$,#1318,.T.);
+#1320=ORIENTED_EDGE($,$,$,#650,.F.);
+#1321=ORIENTED_EDGE($,$,$,#1301,.F.);
+#1322=EDGE_LOOP($,(#1313,#1319,#1320,#1321));
+#1323=FACE_OUTER_BOUND('',#1322,.T.);
+#1324=ADVANCED_FACE('',(#1323),#1312,.T.);
+#1325=CARTESIAN_POINT($,(298.96574017642,40.77972,0));
+#1326=DIRECTION($,(1,0,0));
+#1327=DIRECTION($,(0,0,1));
+#1328=AXIS2_PLACEMENT_3D($,#1325,#1326,#1327);
+#1329=PLANE($,#1328);
+#1330=ORIENTED_EDGE($,$,$,#262,.T.);
+#1331=CARTESIAN_POINT($,(298.96574017642,52.2504601764197,0));
+#1332=DIRECTION($,(0,0,1));
+#1333=VECTOR($,#1332,1);
+#1334=LINE($,#1331,#1333);
+#1335=EDGE_CURVE($,#257,#653,#1334,.T.);
+#1336=ORIENTED_EDGE($,$,$,#1335,.T.);
+#1337=ORIENTED_EDGE($,$,$,#658,.F.);
+#1338=ORIENTED_EDGE($,$,$,#1318,.F.);
+#1339=EDGE_LOOP($,(#1330,#1336,#1337,#1338));
+#1340=FACE_OUTER_BOUND('',#1339,.T.);
+#1341=ADVANCED_FACE('',(#1340),#1329,.T.);
+#1342=CARTESIAN_POINT($,(298.96574017642,52.2504601764197,0));
+#1343=DIRECTION($,(1,0,0));
+#1344=DIRECTION($,(0,0,1));
+#1345=AXIS2_PLACEMENT_3D($,#1342,#1343,#1344);
+#1346=PLANE($,#1345);
+#1347=ORIENTED_EDGE($,$,$,#270,.T.);
+#1348=CARTESIAN_POINT($,(298.96574017642,113.84300017642,0));
+#1349=DIRECTION($,(0,0,1));
+#1350=VECTOR($,#1349,1);
+#1351=LINE($,#1348,#1350);
+#1352=EDGE_CURVE($,#265,#661,#1351,.T.);
+#1353=ORIENTED_EDGE($,$,$,#1352,.T.);
+#1354=ORIENTED_EDGE($,$,$,#666,.F.);
+#1355=ORIENTED_EDGE($,$,$,#1335,.F.);
+#1356=EDGE_LOOP($,(#1347,#1353,#1354,#1355));
+#1357=FACE_OUTER_BOUND('',#1356,.T.);
+#1358=ADVANCED_FACE('',(#1357),#1346,.T.);
+#1359=CARTESIAN_POINT($,(298.96574017642,113.84300017642,0));
+#1360=DIRECTION($,(1,0,0));
+#1361=DIRECTION($,(0,0,1));
+#1362=AXIS2_PLACEMENT_3D($,#1359,#1360,#1361);
+#1363=PLANE($,#1362);
+#1364=ORIENTED_EDGE($,$,$,#278,.T.);
+#1365=CARTESIAN_POINT($,(298.96574017642,125.313740352839,0));
+#1366=DIRECTION($,(0,0,1));
+#1367=VECTOR($,#1366,1);
+#1368=LINE($,#1365,#1367);
+#1369=EDGE_CURVE($,#273,#669,#1368,.T.);
+#1370=ORIENTED_EDGE($,$,$,#1369,.T.);
+#1371=ORIENTED_EDGE($,$,$,#674,.F.);
+#1372=ORIENTED_EDGE($,$,$,#1352,.F.);
+#1373=EDGE_LOOP($,(#1364,#1370,#1371,#1372));
+#1374=FACE_OUTER_BOUND('',#1373,.T.);
+#1375=ADVANCED_FACE('',(#1374),#1363,.T.);
+#1376=CARTESIAN_POINT($,(298.96574017642,125.313740352839,0));
+#1377=DIRECTION($,(0,-1,0));
+#1378=DIRECTION($,(0,0,1));
+#1379=AXIS2_PLACEMENT_3D($,#1376,#1377,#1378);
+#1380=PLANE($,#1379);
+#1381=ORIENTED_EDGE($,$,$,#286,.T.);
+#1382=CARTESIAN_POINT($,(307.22074017642,125.313740352839,-0));
+#1383=DIRECTION($,(0,0,1));
+#1384=VECTOR($,#1383,1);
+#1385=LINE($,#1382,#1384);
+#1386=EDGE_CURVE($,#281,#677,#1385,.T.);
+#1387=ORIENTED_EDGE($,$,$,#1386,.T.);
+#1388=ORIENTED_EDGE($,$,$,#682,.F.);
+#1389=ORIENTED_EDGE($,$,$,#1369,.F.);
+#1390=EDGE_LOOP($,(#1381,#1387,#1388,#1389));
+#1391=FACE_OUTER_BOUND('',#1390,.T.);
+#1392=ADVANCED_FACE('',(#1391),#1380,.T.);
+#1393=CARTESIAN_POINT($,(307.22074017642,125.313740352839,0));
+#1394=DIRECTION($,(1,0,0));
+#1395=DIRECTION($,(0,0,1));
+#1396=AXIS2_PLACEMENT_3D($,#1393,#1394,#1395);
+#1397=PLANE($,#1396);
+#1398=ORIENTED_EDGE($,$,$,#294,.T.);
+#1399=CARTESIAN_POINT($,(307.22074017642,133.568740352839,0));
+#1400=DIRECTION($,(0,0,1));
+#1401=VECTOR($,#1400,1);
+#1402=LINE($,#1399,#1401);
+#1403=EDGE_CURVE($,#289,#685,#1402,.T.);
+#1404=ORIENTED_EDGE($,$,$,#1403,.T.);
+#1405=ORIENTED_EDGE($,$,$,#690,.F.);
+#1406=ORIENTED_EDGE($,$,$,#1386,.F.);
+#1407=EDGE_LOOP($,(#1398,#1404,#1405,#1406));
+#1408=FACE_OUTER_BOUND('',#1407,.T.);
+#1409=ADVANCED_FACE('',(#1408),#1397,.T.);
+#1410=CARTESIAN_POINT($,(307.22074017642,133.568740352839,0));
+#1411=DIRECTION($,(0,-1,0));
+#1412=DIRECTION($,(0,0,1));
+#1413=AXIS2_PLACEMENT_3D($,#1410,#1411,#1412);
+#1414=PLANE($,#1413);
+#1415=ORIENTED_EDGE($,$,$,#302,.T.);
+#1416=CARTESIAN_POINT($,(318.691480352839,133.568740352839,0));
+#1417=DIRECTION($,(0,0,1));
+#1418=VECTOR($,#1417,1);
+#1419=LINE($,#1416,#1418);
+#1420=EDGE_CURVE($,#297,#693,#1419,.T.);
+#1421=ORIENTED_EDGE($,$,$,#1420,.T.);
+#1422=ORIENTED_EDGE($,$,$,#698,.F.);
+#1423=ORIENTED_EDGE($,$,$,#1403,.F.);
+#1424=EDGE_LOOP($,(#1415,#1421,#1422,#1423));
+#1425=FACE_OUTER_BOUND('',#1424,.T.);
+#1426=ADVANCED_FACE('',(#1425),#1414,.T.);
+#1427=CARTESIAN_POINT($,(318.691480352839,133.568740352839,0));
+#1428=DIRECTION($,(0,-1,0));
+#1429=DIRECTION($,(0,0,1));
+#1430=AXIS2_PLACEMENT_3D($,#1427,#1428,#1429);
+#1431=PLANE($,#1430);
+#1432=ORIENTED_EDGE($,$,$,#310,.T.);
+#1433=CARTESIAN_POINT($,(347.802420352839,133.568740352839,0));
+#1434=DIRECTION($,(0,0,1));
+#1435=VECTOR($,#1434,1);
+#1436=LINE($,#1433,#1435);
+#1437=EDGE_CURVE($,#305,#701,#1436,.T.);
+#1438=ORIENTED_EDGE($,$,$,#1437,.T.);
+#1439=ORIENTED_EDGE($,$,$,#706,.F.);
+#1440=ORIENTED_EDGE($,$,$,#1420,.F.);
+#1441=EDGE_LOOP($,(#1432,#1438,#1439,#1440));
+#1442=FACE_OUTER_BOUND('',#1441,.T.);
+#1443=ADVANCED_FACE('',(#1442),#1431,.T.);
+#1444=CARTESIAN_POINT($,(347.802420352839,133.568740352839,0));
+#1445=DIRECTION($,(0,-1,0));
+#1446=DIRECTION($,(0,0,1));
+#1447=AXIS2_PLACEMENT_3D($,#1444,#1445,#1446);
+#1448=PLANE($,#1447);
+#1449=ORIENTED_EDGE($,$,$,#318,.T.);
+#1450=CARTESIAN_POINT($,(353.537790441049,133.568740352839,0));
+#1451=DIRECTION($,(0,0,1));
+#1452=VECTOR($,#1451,1);
+#1453=LINE($,#1450,#1452);
+#1454=EDGE_CURVE($,#313,#709,#1453,.T.);
+#1455=ORIENTED_EDGE($,$,$,#1454,.T.);
+#1456=ORIENTED_EDGE($,$,$,#714,.F.);
+#1457=ORIENTED_EDGE($,$,$,#1437,.F.);
+#1458=EDGE_LOOP($,(#1449,#1455,#1456,#1457));
+#1459=FACE_OUTER_BOUND('',#1458,.T.);
+#1460=ADVANCED_FACE('',(#1459),#1448,.T.);
+#1461=CARTESIAN_POINT($,(353.537790441049,133.568740352839,0));
+#1462=DIRECTION($,(0,-1,0));
+#1463=DIRECTION($,(0,0,1));
+#1464=AXIS2_PLACEMENT_3D($,#1461,#1462,#1463);
+#1465=PLANE($,#1464);
+#1466=ORIENTED_EDGE($,$,$,#324,.T.);
+#1467=ORIENTED_EDGE($,$,$,#810,.T.);
+#1468=ORIENTED_EDGE($,$,$,#720,.F.);
+#1469=ORIENTED_EDGE($,$,$,#1454,.F.);
+#1470=EDGE_LOOP($,(#1466,#1467,#1468,#1469));
+#1471=FACE_OUTER_BOUND('',#1470,.T.);
+#1472=ADVANCED_FACE('',(#1471),#1465,.T.);
+#1473=CARTESIAN_POINT($,(126.72834017642,189.298880352839,0));
+#1474=DIRECTION($,(-1,0,0));
+#1475=DIRECTION($,(0,0,1));
+#1476=AXIS2_PLACEMENT_3D($,#1473,#1474,#1475);
+#1477=PLANE($,#1476);
+#1478=ORIENTED_EDGE($,$,$,#358,.T.);
+#1479=CARTESIAN_POINT($,(126.72834017642,278.198880352839,-0));
+#1480=DIRECTION($,(0,0,1));
+#1481=VECTOR($,#1480,1);
+#1482=LINE($,#1479,#1481);
+#1483=EDGE_CURVE($,#347,#743,#1482,.T.);
+#1484=ORIENTED_EDGE($,$,$,#1483,.T.);
+#1485=ORIENTED_EDGE($,$,$,#754,.F.);
+#1486=CARTESIAN_POINT($,(126.72834017642,189.298880352839,0));
+#1487=DIRECTION($,(0,0,1));
+#1488=VECTOR($,#1487,1);
+#1489=LINE($,#1486,#1488);
+#1490=EDGE_CURVE($,#331,#727,#1489,.T.);
+#1491=ORIENTED_EDGE($,$,$,#1490,.F.);
+#1492=EDGE_LOOP($,(#1478,#1484,#1485,#1491));
+#1493=FACE_OUTER_BOUND('',#1492,.T.);
+#1494=ADVANCED_FACE('',(#1493),#1477,.T.);
+#1495=CARTESIAN_POINT($,(126.72834017642,278.198880352839,0));
+#1496=DIRECTION($,(0,-1,0));
+#1497=DIRECTION($,(0,0,1));
+#1498=AXIS2_PLACEMENT_3D($,#1495,#1496,#1497);
+#1499=PLANE($,#1498);
+#1500=ORIENTED_EDGE($,$,$,#352,.T.);
+#1501=CARTESIAN_POINT($,(107.67834017642,278.198880352839,-0));
+#1502=DIRECTION($,(0,0,1));
+#1503=VECTOR($,#1502,1);
+#1504=LINE($,#1501,#1503);
+#1505=EDGE_CURVE($,#339,#735,#1504,.T.);
+#1506=ORIENTED_EDGE($,$,$,#1505,.T.);
+#1507=ORIENTED_EDGE($,$,$,#748,.F.);
+#1508=ORIENTED_EDGE($,$,$,#1483,.F.);
+#1509=EDGE_LOOP($,(#1500,#1506,#1507,#1508));
+#1510=FACE_OUTER_BOUND('',#1509,.T.);
+#1511=ADVANCED_FACE('',(#1510),#1499,.T.);
+#1512=CARTESIAN_POINT($,(107.67834017642,278.198880352839,0));
+#1513=DIRECTION($,(1,0,0));
+#1514=DIRECTION($,(0,0,1));
+#1515=AXIS2_PLACEMENT_3D($,#1512,#1513,#1514);
+#1516=PLANE($,#1515);
+#1517=ORIENTED_EDGE($,$,$,#344,.T.);
+#1518=CARTESIAN_POINT($,(107.67834017642,189.298880352839,-0));
+#1519=DIRECTION($,(0,0,1));
+#1520=VECTOR($,#1519,1);
+#1521=LINE($,#1518,#1520);
+#1522=EDGE_CURVE($,#329,#725,#1521,.T.);
+#1523=ORIENTED_EDGE($,$,$,#1522,.T.);
+#1524=ORIENTED_EDGE($,$,$,#740,.F.);
+#1525=ORIENTED_EDGE($,$,$,#1505,.F.);
+#1526=EDGE_LOOP($,(#1517,#1523,#1524,#1525));
+#1527=FACE_OUTER_BOUND('',#1526,.T.);
+#1528=ADVANCED_FACE('',(#1527),#1516,.T.);
+#1529=CARTESIAN_POINT($,(107.67834017642,189.298880352839,0));
+#1530=DIRECTION($,(0,1,0));
+#1531=DIRECTION($,(0,0,1));
+#1532=AXIS2_PLACEMENT_3D($,#1529,#1530,#1531);
+#1533=PLANE($,#1532);
+#1534=ORIENTED_EDGE($,$,$,#336,.T.);
+#1535=ORIENTED_EDGE($,$,$,#1490,.T.);
+#1536=ORIENTED_EDGE($,$,$,#732,.F.);
+#1537=ORIENTED_EDGE($,$,$,#1522,.F.);
+#1538=EDGE_LOOP($,(#1534,#1535,#1536,#1537));
+#1539=FACE_OUTER_BOUND('',#1538,.T.);
+#1540=ADVANCED_FACE('',(#1539),#1533,.T.);
+#1541=CARTESIAN_POINT($,(190.22834017642,189.298880352839,0));
+#1542=DIRECTION($,(-1,0,0));
+#1543=DIRECTION($,(0,0,1));
+#1544=AXIS2_PLACEMENT_3D($,#1541,#1542,#1543);
+#1545=PLANE($,#1544);
+#1546=ORIENTED_EDGE($,$,$,#392,.T.);
+#1547=CARTESIAN_POINT($,(190.22834017642,278.198880352839,-0));
+#1548=DIRECTION($,(0,0,1));
+#1549=VECTOR($,#1548,1);
+#1550=LINE($,#1547,#1549);
+#1551=EDGE_CURVE($,#381,#777,#1550,.T.);
+#1552=ORIENTED_EDGE($,$,$,#1551,.T.);
+#1553=ORIENTED_EDGE($,$,$,#788,.F.);
+#1554=CARTESIAN_POINT($,(190.22834017642,189.298880352839,0));
+#1555=DIRECTION($,(0,0,1));
+#1556=VECTOR($,#1555,1);
+#1557=LINE($,#1554,#1556);
+#1558=EDGE_CURVE($,#365,#761,#1557,.T.);
+#1559=ORIENTED_EDGE($,$,$,#1558,.F.);
+#1560=EDGE_LOOP($,(#1546,#1552,#1553,#1559));
+#1561=FACE_OUTER_BOUND('',#1560,.T.);
+#1562=ADVANCED_FACE('',(#1561),#1545,.T.);
+#1563=CARTESIAN_POINT($,(190.22834017642,278.198880352839,0));
+#1564=DIRECTION($,(0,-1,0));
+#1565=DIRECTION($,(0,0,1));
+#1566=AXIS2_PLACEMENT_3D($,#1563,#1564,#1565);
+#1567=PLANE($,#1566);
+#1568=ORIENTED_EDGE($,$,$,#386,.T.);
+#1569=CARTESIAN_POINT($,(171.17834017642,278.198880352839,-0));
+#1570=DIRECTION($,(0,0,1));
+#1571=VECTOR($,#1570,1);
+#1572=LINE($,#1569,#1571);
+#1573=EDGE_CURVE($,#373,#769,#1572,.T.);
+#1574=ORIENTED_EDGE($,$,$,#1573,.T.);
+#1575=ORIENTED_EDGE($,$,$,#782,.F.);
+#1576=ORIENTED_EDGE($,$,$,#1551,.F.);
+#1577=EDGE_LOOP($,(#1568,#1574,#1575,#1576));
+#1578=FACE_OUTER_BOUND('',#1577,.T.);
+#1579=ADVANCED_FACE('',(#1578),#1567,.T.);
+#1580=CARTESIAN_POINT($,(171.17834017642,278.198880352839,0));
+#1581=DIRECTION($,(1,0,0));
+#1582=DIRECTION($,(0,0,1));
+#1583=AXIS2_PLACEMENT_3D($,#1580,#1581,#1582);
+#1584=PLANE($,#1583);
+#1585=ORIENTED_EDGE($,$,$,#378,.T.);
+#1586=CARTESIAN_POINT($,(171.17834017642,189.298880352839,-0));
+#1587=DIRECTION($,(0,0,1));
+#1588=VECTOR($,#1587,1);
+#1589=LINE($,#1586,#1588);
+#1590=EDGE_CURVE($,#363,#759,#1589,.T.);
+#1591=ORIENTED_EDGE($,$,$,#1590,.T.);
+#1592=ORIENTED_EDGE($,$,$,#774,.F.);
+#1593=ORIENTED_EDGE($,$,$,#1573,.F.);
+#1594=EDGE_LOOP($,(#1585,#1591,#1592,#1593));
+#1595=FACE_OUTER_BOUND('',#1594,.T.);
+#1596=ADVANCED_FACE('',(#1595),#1584,.T.);
+#1597=CARTESIAN_POINT($,(171.17834017642,189.298880352839,0));
+#1598=DIRECTION($,(0,1,0));
+#1599=DIRECTION($,(0,0,1));
+#1600=AXIS2_PLACEMENT_3D($,#1597,#1598,#1599);
+#1601=PLANE($,#1600);
+#1602=ORIENTED_EDGE($,$,$,#370,.T.);
+#1603=ORIENTED_EDGE($,$,$,#1558,.T.);
+#1604=ORIENTED_EDGE($,$,$,#766,.F.);
+#1605=ORIENTED_EDGE($,$,$,#1590,.F.);
+#1606=EDGE_LOOP($,(#1602,#1603,#1604,#1605));
+#1607=FACE_OUTER_BOUND('',#1606,.T.);
+#1608=ADVANCED_FACE('',(#1607),#1601,.T.);
+#1609=CLOSED_SHELL($,(#396,#792,#814,#831,#848,#865,#882,#899,#916,#933,#950,#967,#984,#1001,#1018,#1035,#1052,#1069,#1086,#1103,#1120,#1137,#1154,#1171,#1188,#1205,#1222,#1239,#1256,#1273,#1290,#1307,#1324,#1341,#1358,#1375,#1392,#1409,#1426,#1443,#1460,#1472,#1494,#1511,#1528,#1540,#1562,#1579,#1596,#1608));
+#1610=MANIFOLD_SOLID_BREP('sheetmetal-Ctc03 flat pattern',#1609);
+#1611=APPLICATION_CONTEXT('mechanical design');
+#1612=PRODUCT_CONTEXT('',#1611,'mechanical');
+#1613=PRODUCT('sheetmetal_Ctc03_flat','sheetmetal-Ctc03 flat pattern','',(#1612));
+#1614=PRODUCT_DEFINITION_FORMATION('','',#1613);
+#1615=PRODUCT_DEFINITION_CONTEXT('design',#1611,'design');
+#1616=PRODUCT_DEFINITION('','',#1614,#1615);
+#1617=PRODUCT_DEFINITION_SHAPE('','',#1616);
+#1618=(LENGTH_UNIT()NAMED_UNIT(*)SI_UNIT(.MILLI.,.METRE.));
+#1619=(NAMED_UNIT(*)PLANE_ANGLE_UNIT()SI_UNIT($,.RADIAN.));
+#1620=(NAMED_UNIT(*)SI_UNIT($,.STERADIAN.)SOLID_ANGLE_UNIT());
+#1621=(GEOMETRIC_REPRESENTATION_CONTEXT(3)GLOBAL_UNIT_ASSIGNED_CONTEXT((#1618,#1619,#1620))REPRESENTATION_CONTEXT('3','3D'));
+#1622=SHAPE_REPRESENTATION('sheetmetal-Ctc03 flat pattern',(#1610),#1621);
+#1623=SHAPE_DEFINITION_REPRESENTATION(#1617,#1622);
+ENDSEC;
+END-ISO-10303-21;
diff --git a/docs/modules/sheetmetal/artifacts/m3/ctc03-m3-flat.svg b/docs/modules/sheetmetal/artifacts/m3/ctc03-m3-flat.svg
new file mode 100644
index 00000000..af166a19
--- /dev/null
+++ b/docs/modules/sheetmetal/artifacts/m3/ctc03-m3-flat.svg
@@ -0,0 +1,51 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<svg xmlns="http://www.w3.org/2000/svg" width="416.052mm" height="636.598mm" viewBox="0 0 416.052 636.598">
+<rect width="100%" height="100%" fill="white"/>
+<g id="sheet-regions" fill="#dbeafe" fill-opacity="0.55" stroke="#0f172a" stroke-width="0.45">
+<polygon id="flat-AngledServiceFlange" points="355.538,501.029 355.538,149.239 404.052,149.239 404.052,501.029"/>
+<polygon id="flat-AngledServiceFlangeBend" points="349.802,501.029 349.802,149.239 355.538,149.239 355.538,501.029"/>
+<polygon id="flat-FrontMountingFlange" points="76.176,593.818 300.966,593.818 300.966,624.598 76.176,624.598"/>
+<polygon id="flat-FrontMountingFlangeBend" points="76.176,582.347 300.966,582.347 300.966,593.818 76.176,593.818"/>
+<polygon id="flat-FrontWall" points="76.176,520.755 300.966,520.755 300.966,582.347 76.176,582.347"/>
+<polygon id="flat-FrontWallBend" points="76.176,509.284 300.966,509.284 300.966,520.755 76.176,520.755"/>
+<polygon id="flat-LeftWall" points="56.45,149.239 56.45,501.029 12,501.029 12,149.239"/>
+<polygon id="flat-LeftWallBend" points="67.921,149.239 67.921,501.029 56.45,501.029 56.45,149.239"/>
+<polygon id="flat-MainDeck" points="67.921,509.284 76.176,509.284 300.966,509.284 309.221,509.284 309.221,501.029 309.221,149.239 309.221,140.984 300.966,140.984 76.176,140.984 67.921,140.984 67.921,149.239 67.921,501.029"/>
+<polygon id="flat-RearMountingFlange" points="300.966,56.45 76.176,56.45 76.176,12 300.966,12"/>
+<polygon id="flat-RearMountingFlangeBend" points="300.966,67.921 76.176,67.921 76.176,56.45 300.966,56.45"/>
+<polygon id="flat-RearWall" points="300.966,129.513 76.176,129.513 76.176,67.921 300.966,67.921"/>
+<polygon id="flat-RearWallBend" points="300.966,140.984 76.176,140.984 76.176,129.513 300.966,129.513"/>
+<polygon id="flat-RightWall" points="320.691,501.029 320.691,149.239 349.802,149.239 349.802,501.029"/>
+<polygon id="flat-RightWallBend" points="309.221,501.029 309.221,149.239 320.691,149.239 320.691,501.029"/>
+</g>
+<g id="cut-contours" fill="white" stroke="#dc2626" stroke-width="0.5">
+<polygon id="VentSlotLeft" points="109.678,445.299 128.728,445.299 128.728,356.399 109.678,356.399"/>
+<polygon id="VentSlotRight" points="173.178,445.299 192.228,445.299 192.228,356.399 173.178,356.399"/>
+</g>
+<g id="bend-lines" fill="none" stroke="#2563eb" stroke-width="0.45" stroke-dasharray="3 2">
+<line x1="352.67" y1="501.029" x2="352.67" y2="149.239"/>
+<line x1="76.176" y1="588.083" x2="300.966" y2="588.083"/>
+<line x1="76.176" y1="515.019" x2="300.966" y2="515.019"/>
+<line x1="62.185" y1="149.239" x2="62.185" y2="501.029"/>
+<line x1="300.966" y1="62.185" x2="76.176" y2="62.185"/>
+<line x1="300.966" y1="135.249" x2="76.176" y2="135.249"/>
+<line x1="314.956" y1="501.029" x2="314.956" y2="149.239"/>
+</g>
+<g id="bend-labels" stroke="none" font-family="Inter, 'Segoe UI', Arial, sans-serif" font-size="3" text-anchor="middle" dominant-baseline="central">
+<rect x="344.42" y="322.934" width="24.5" height="4.4" rx="0.8" fill="white" fill-opacity="0.88"/>
+<text x="356.67" y="325.134" fill="#1d4ed8">Down 45° R6.35</text>
+<rect x="177.971" y="589.883" width="21.2" height="4.4" rx="0.8" fill="white" fill-opacity="0.88"/>
+<text x="188.571" y="592.083" fill="#1d4ed8">Up 90° R6.35</text>
+<rect x="176.321" y="516.819" width="24.5" height="4.4" rx="0.8" fill="white" fill-opacity="0.88"/>
+<text x="188.571" y="519.019" fill="#1d4ed8">Down 90° R6.35</text>
+<rect x="47.585" y="322.934" width="21.2" height="4.4" rx="0.8" fill="white" fill-opacity="0.88"/>
+<text x="58.185" y="325.134" fill="#1d4ed8">Up 90° R6.35</text>
+<rect x="177.971" y="55.985" width="21.2" height="4.4" rx="0.8" fill="white" fill-opacity="0.88"/>
+<text x="188.571" y="58.185" fill="#1d4ed8">Up 90° R6.35</text>
+<rect x="176.321" y="129.049" width="24.5" height="4.4" rx="0.8" fill="white" fill-opacity="0.88"/>
+<text x="188.571" y="131.249" fill="#1d4ed8">Down 90° R6.35</text>
+<rect x="308.356" y="322.934" width="21.2" height="4.4" rx="0.8" fill="white" fill-opacity="0.88"/>
+<text x="318.956" y="325.134" fill="#1d4ed8">Up 90° R6.35</text>
+</g>
+<text x="4" y="6" font-family="sans-serif" font-size="3" fill="#334155">Valid · K=0.5 · SHA-256 d812b205f1d6</text>
+</svg>
diff --git a/docs/modules/sheetmetal/artifacts/m3/ctc03-m3-formed.step b/docs/modules/sheetmetal/artifacts/m3/ctc03-m3-formed.step
new file mode 100644
index 00000000..3a98f166
--- /dev/null
+++ b/docs/modules/sheetmetal/artifacts/m3/ctc03-m3-formed.step
@@ -0,0 +1,2108 @@
+ISO-10303-21;
+HEADER;
+FILE_DESCRIPTION(('Aetheris AP242 subset export'),'2;1');
+FILE_NAME('aetheris_export.step','1970-01-01T00:00:00',('Aetheris'),('Aetheris'),'Aetheris.Kernel','Aetheris.Kernel','');
+FILE_SCHEMA(('AP242_MANAGED_MODEL_BASED_3D_ENGINEERING_MIM_LF'));
+ENDSEC;
+DATA;
+#1=CARTESIAN_POINT($,(-241.3,58.08726,78.105));
+#2=DIRECTION($,(0,0,1));
+#3=DIRECTION($,(1,0,0));
+#4=AXIS2_PLACEMENT_3D($,#1,#2,#3);
+#5=PLANE($,#4);
+#6=CARTESIAN_POINT($,(-241.3,58.08726,78.105));
+#7=VERTEX_POINT($,#6);
+#8=CARTESIAN_POINT($,(-233.045,58.08726,78.105));
+#9=VERTEX_POINT($,#8);
+#10=CARTESIAN_POINT($,(-241.3,58.08726,78.105));
+#11=DIRECTION($,(1,0,0));
+#12=VECTOR($,#11,1);
+#13=LINE($,#10,#12);
+#14=EDGE_CURVE($,#7,#9,#13,.T.);
+#15=ORIENTED_EDGE($,$,$,#14,.T.);
+#16=CARTESIAN_POINT($,(-8.255,58.08726,78.105));
+#17=VERTEX_POINT($,#16);
+#18=CARTESIAN_POINT($,(-233.045,58.08726,78.105));
+#19=DIRECTION($,(1,0,0));
+#20=VECTOR($,#19,1);
+#21=LINE($,#18,#20);
+#22=EDGE_CURVE($,#9,#17,#21,.T.);
+#23=ORIENTED_EDGE($,$,$,#22,.T.);
+#24=CARTESIAN_POINT($,(0,58.08726,78.105));
+#25=VERTEX_POINT($,#24);
+#26=CARTESIAN_POINT($,(-8.255,58.08726,78.105));
+#27=DIRECTION($,(1,0,0));
+#28=VECTOR($,#27,1);
+#29=LINE($,#26,#28);
+#30=EDGE_CURVE($,#17,#25,#29,.T.);
+#31=ORIENTED_EDGE($,$,$,#30,.T.);
+#32=CARTESIAN_POINT($,(0,66.34226,78.105));
+#33=VERTEX_POINT($,#32);
+#34=CARTESIAN_POINT($,(0,58.08726,78.105));
+#35=DIRECTION($,(0,1,0));
+#36=VECTOR($,#35,1);
+#37=LINE($,#34,#36);
+#38=EDGE_CURVE($,#25,#33,#37,.T.);
+#39=ORIENTED_EDGE($,$,$,#38,.T.);
+#40=CARTESIAN_POINT($,(0,418.13226,78.105));
+#41=VERTEX_POINT($,#40);
+#42=CARTESIAN_POINT($,(0,66.34226,78.105));
+#43=DIRECTION($,(0,1,0));
+#44=VECTOR($,#43,1);
+#45=LINE($,#42,#44);
+#46=EDGE_CURVE($,#33,#41,#45,.T.);
+#47=ORIENTED_EDGE($,$,$,#46,.T.);
+#48=CARTESIAN_POINT($,(0,426.38726,78.105));
+#49=VERTEX_POINT($,#48);
+#50=CARTESIAN_POINT($,(0,418.13226,78.105));
+#51=DIRECTION($,(0,1,0));
+#52=VECTOR($,#51,1);
+#53=LINE($,#50,#52);
+#54=EDGE_CURVE($,#41,#49,#53,.T.);
+#55=ORIENTED_EDGE($,$,$,#54,.T.);
+#56=CARTESIAN_POINT($,(-8.255,426.38726,78.105));
+#57=VERTEX_POINT($,#56);
+#58=CARTESIAN_POINT($,(0,426.38726,78.105));
+#59=DIRECTION($,(-1,0,0));
+#60=VECTOR($,#59,1);
+#61=LINE($,#58,#60);
+#62=EDGE_CURVE($,#49,#57,#61,.T.);
+#63=ORIENTED_EDGE($,$,$,#62,.T.);
+#64=CARTESIAN_POINT($,(-233.045,426.38726,78.105));
+#65=VERTEX_POINT($,#64);
+#66=CARTESIAN_POINT($,(-8.255,426.38726,78.105));
+#67=DIRECTION($,(-1,0,0));
+#68=VECTOR($,#67,1);
+#69=LINE($,#66,#68);
+#70=EDGE_CURVE($,#57,#65,#69,.T.);
+#71=ORIENTED_EDGE($,$,$,#70,.T.);
+#72=CARTESIAN_POINT($,(-241.3,426.38726,78.105));
+#73=VERTEX_POINT($,#72);
+#74=CARTESIAN_POINT($,(-233.045,426.38726,78.105));
+#75=DIRECTION($,(-1,0,0));
+#76=VECTOR($,#75,1);
+#77=LINE($,#74,#76);
+#78=EDGE_CURVE($,#65,#73,#77,.T.);
+#79=ORIENTED_EDGE($,$,$,#78,.T.);
+#80=CARTESIAN_POINT($,(-241.3,418.13226,78.105));
+#81=VERTEX_POINT($,#80);
+#82=CARTESIAN_POINT($,(-241.3,426.38726,78.105));
+#83=DIRECTION($,(0,-1,0));
+#84=VECTOR($,#83,1);
+#85=LINE($,#82,#84);
+#86=EDGE_CURVE($,#73,#81,#85,.T.);
+#87=ORIENTED_EDGE($,$,$,#86,.T.);
+#88=CARTESIAN_POINT($,(-241.3,66.34226,78.105));
+#89=VERTEX_POINT($,#88);
+#90=CARTESIAN_POINT($,(-241.3,418.13226,78.105));
+#91=DIRECTION($,(0,-1,0));
+#92=VECTOR($,#91,1);
+#93=LINE($,#90,#92);
+#94=EDGE_CURVE($,#81,#89,#93,.T.);
+#95=ORIENTED_EDGE($,$,$,#94,.T.);
+#96=CARTESIAN_POINT($,(-241.3,66.34226,78.105));
+#97=DIRECTION($,(0,-1,0));
+#98=VECTOR($,#97,1);
+#99=LINE($,#96,#98);
+#100=EDGE_CURVE($,#89,#7,#99,.T.);
+#101=ORIENTED_EDGE($,$,$,#100,.T.);
+#102=EDGE_LOOP($,(#15,#23,#31,#39,#47,#55,#63,#71,#79,#87,#95,#101));
+#103=FACE_OUTER_BOUND('',#102,.T.);
+#104=CARTESIAN_POINT($,(-116.9924,210.9724,78.105));
+#105=VERTEX_POINT($,#104);
+#106=CARTESIAN_POINT($,(-136.0424,210.9724,78.105));
+#107=VERTEX_POINT($,#106);
+#108=CARTESIAN_POINT($,(-116.9924,210.9724,78.105));
+#109=DIRECTION($,(-1,0,0));
+#110=VECTOR($,#109,1);
+#111=LINE($,#108,#110);
+#112=EDGE_CURVE($,#105,#107,#111,.T.);
+#113=ORIENTED_EDGE($,$,$,#112,.F.);
+#114=CARTESIAN_POINT($,(-116.9924,122.0724,78.105));
+#115=VERTEX_POINT($,#114);
+#116=CARTESIAN_POINT($,(-116.9924,122.0724,78.105));
+#117=DIRECTION($,(0,1,0));
+#118=VECTOR($,#117,1);
+#119=LINE($,#116,#118);
+#120=EDGE_CURVE($,#115,#105,#119,.T.);
+#121=ORIENTED_EDGE($,$,$,#120,.F.);
+#122=CARTESIAN_POINT($,(-136.0424,122.0724,78.105));
+#123=VERTEX_POINT($,#122);
+#124=CARTESIAN_POINT($,(-136.0424,122.0724,78.105));
+#125=DIRECTION($,(1,0,0));
+#126=VECTOR($,#125,1);
+#127=LINE($,#124,#126);
+#128=EDGE_CURVE($,#123,#115,#127,.T.);
+#129=ORIENTED_EDGE($,$,$,#128,.F.);
+#130=CARTESIAN_POINT($,(-136.0424,210.9724,78.105));
+#131=DIRECTION($,(0,-1,0));
+#132=VECTOR($,#131,1);
+#133=LINE($,#130,#132);
+#134=EDGE_CURVE($,#107,#123,#133,.T.);
+#135=ORIENTED_EDGE($,$,$,#134,.F.);
+#136=EDGE_LOOP($,(#113,#121,#129,#135));
+#137=FACE_BOUND('',#136,.T.);
+#138=CARTESIAN_POINT($,(-180.4924,210.9724,78.105));
+#139=VERTEX_POINT($,#138);
+#140=CARTESIAN_POINT($,(-199.5424,210.9724,78.105));
+#141=VERTEX_POINT($,#140);
+#142=CARTESIAN_POINT($,(-180.4924,210.9724,78.105));
+#143=DIRECTION($,(-1,0,0));
+#144=VECTOR($,#143,1);
+#145=LINE($,#142,#144);
+#146=EDGE_CURVE($,#139,#141,#145,.T.);
+#147=ORIENTED_EDGE($,$,$,#146,.F.);
+#148=CARTESIAN_POINT($,(-180.4924,122.0724,78.105));
+#149=VERTEX_POINT($,#148);
+#150=CARTESIAN_POINT($,(-180.4924,122.0724,78.105));
+#151=DIRECTION($,(0,1,0));
+#152=VECTOR($,#151,1);
+#153=LINE($,#150,#152);
+#154=EDGE_CURVE($,#149,#139,#153,.T.);
+#155=ORIENTED_EDGE($,$,$,#154,.F.);
+#156=CARTESIAN_POINT($,(-199.5424,122.0724,78.105));
+#157=VERTEX_POINT($,#156);
+#158=CARTESIAN_POINT($,(-199.5424,122.0724,78.105));
+#159=DIRECTION($,(1,0,0));
+#160=VECTOR($,#159,1);
+#161=LINE($,#158,#160);
+#162=EDGE_CURVE($,#157,#149,#161,.T.);
+#163=ORIENTED_EDGE($,$,$,#162,.F.);
+#164=CARTESIAN_POINT($,(-199.5424,210.9724,78.105));
+#165=DIRECTION($,(0,-1,0));
+#166=VECTOR($,#165,1);
+#167=LINE($,#164,#166);
+#168=EDGE_CURVE($,#141,#157,#167,.T.);
+#169=ORIENTED_EDGE($,$,$,#168,.F.);
+#170=EDGE_LOOP($,(#147,#155,#163,#169));
+#171=FACE_BOUND('',#170,.T.);
+#172=ADVANCED_FACE('',(#103,#137,#171),#5,.T.);
+#173=CARTESIAN_POINT($,(-241.3,58.08726,76.2));
+#174=DIRECTION($,(-0,-0,-1));
+#175=DIRECTION($,(1,0,0));
+#176=AXIS2_PLACEMENT_3D($,#173,#174,#175);
+#177=PLANE($,#176);
+#178=CARTESIAN_POINT($,(-241.3,66.34226,76.2));
+#179=VERTEX_POINT($,#178);
+#180=CARTESIAN_POINT($,(-241.3,418.13226,76.2));
+#181=VERTEX_POINT($,#180);
+#182=CARTESIAN_POINT($,(-241.3,66.34226,76.2));
+#183=DIRECTION($,(0,1,0));
+#184=VECTOR($,#183,1);
+#185=LINE($,#182,#184);
+#186=EDGE_CURVE($,#179,#181,#185,.T.);
+#187=ORIENTED_EDGE($,$,$,#186,.T.);
+#188=CARTESIAN_POINT($,(-241.3,426.38726,76.2));
+#189=VERTEX_POINT($,#188);
+#190=CARTESIAN_POINT($,(-241.3,418.13226,76.2));
+#191=DIRECTION($,(0,1,0));
+#192=VECTOR($,#191,1);
+#193=LINE($,#190,#192);
+#194=EDGE_CURVE($,#181,#189,#193,.T.);
+#195=ORIENTED_EDGE($,$,$,#194,.T.);
+#196=CARTESIAN_POINT($,(-233.045,426.38726,76.2));
+#197=VERTEX_POINT($,#196);
+#198=CARTESIAN_POINT($,(-241.3,426.38726,76.2));
+#199=DIRECTION($,(1,0,0));
+#200=VECTOR($,#199,1);
+#201=LINE($,#198,#200);
+#202=EDGE_CURVE($,#189,#197,#201,.T.);
+#203=ORIENTED_EDGE($,$,$,#202,.T.);
+#204=CARTESIAN_POINT($,(-8.255,426.38726,76.2));
+#205=VERTEX_POINT($,#204);
+#206=CARTESIAN_POINT($,(-233.045,426.38726,76.2));
+#207=DIRECTION($,(1,0,0));
+#208=VECTOR($,#207,1);
+#209=LINE($,#206,#208);
+#210=EDGE_CURVE($,#197,#205,#209,.T.);
+#211=ORIENTED_EDGE($,$,$,#210,.T.);
+#212=CARTESIAN_POINT($,(-0,426.38726,76.2));
+#213=VERTEX_POINT($,#212);
+#214=CARTESIAN_POINT($,(-8.255,426.38726,76.2));
+#215=DIRECTION($,(1,0,0));
+#216=VECTOR($,#215,1);
+#217=LINE($,#214,#216);
+#218=EDGE_CURVE($,#205,#213,#217,.T.);
+#219=ORIENTED_EDGE($,$,$,#218,.T.);
+#220=CARTESIAN_POINT($,(0,418.13226,76.2));
+#221=VERTEX_POINT($,#220);
+#222=CARTESIAN_POINT($,(-0,426.38726,76.2));
+#223=DIRECTION($,(0,-1,0));
+#224=VECTOR($,#223,1);
+#225=LINE($,#222,#224);
+#226=EDGE_CURVE($,#213,#221,#225,.T.);
+#227=ORIENTED_EDGE($,$,$,#226,.T.);
+#228=CARTESIAN_POINT($,(0,66.34226,76.2));
+#229=VERTEX_POINT($,#228);
+#230=CARTESIAN_POINT($,(0,418.13226,76.2));
+#231=DIRECTION($,(0,-1,0));
+#232=VECTOR($,#231,1);
+#233=LINE($,#230,#232);
+#234=EDGE_CURVE($,#221,#229,#233,.T.);
+#235=ORIENTED_EDGE($,$,$,#234,.T.);
+#236=CARTESIAN_POINT($,(-0,58.08726,76.2));
+#237=VERTEX_POINT($,#236);
+#238=CARTESIAN_POINT($,(0,66.34226,76.2));
+#239=DIRECTION($,(0,-1,0));
+#240=VECTOR($,#239,1);
+#241=LINE($,#238,#240);
+#242=EDGE_CURVE($,#229,#237,#241,.T.);
+#243=ORIENTED_EDGE($,$,$,#242,.T.);
+#244=CARTESIAN_POINT($,(-8.255,58.08726,76.2));
+#245=VERTEX_POINT($,#244);
+#246=CARTESIAN_POINT($,(-0,58.08726,76.2));
+#247=DIRECTION($,(-1,0,0));
+#248=VECTOR($,#247,1);
+#249=LINE($,#246,#248);
+#250=EDGE_CURVE($,#237,#245,#249,.T.);
+#251=ORIENTED_EDGE($,$,$,#250,.T.);
+#252=CARTESIAN_POINT($,(-233.045,58.08726,76.2));
+#253=VERTEX_POINT($,#252);
+#254=CARTESIAN_POINT($,(-8.255,58.08726,76.2));
+#255=DIRECTION($,(-1,0,0));
+#256=VECTOR($,#255,1);
+#257=LINE($,#254,#256);
+#258=EDGE_CURVE($,#245,#253,#257,.T.);
+#259=ORIENTED_EDGE($,$,$,#258,.T.);
+#260=CARTESIAN_POINT($,(-241.3,58.08726,76.2));
+#261=VERTEX_POINT($,#260);
+#262=CARTESIAN_POINT($,(-233.045,58.08726,76.2));
+#263=DIRECTION($,(-1,0,0));
+#264=VECTOR($,#263,1);
+#265=LINE($,#262,#264);
+#266=EDGE_CURVE($,#253,#261,#265,.T.);
+#267=ORIENTED_EDGE($,$,$,#266,.T.);
+#268=CARTESIAN_POINT($,(-241.3,58.08726,76.2));
+#269=DIRECTION($,(0,1,0));
+#270=VECTOR($,#269,1);
+#271=LINE($,#268,#270);
+#272=EDGE_CURVE($,#261,#179,#271,.T.);
+#273=ORIENTED_EDGE($,$,$,#272,.T.);
+#274=EDGE_LOOP($,(#187,#195,#203,#211,#219,#227,#235,#243,#251,#259,#267,#273));
+#275=FACE_OUTER_BOUND('',#274,.T.);
+#276=CARTESIAN_POINT($,(-136.0424,122.0724,76.2));
+#277=VERTEX_POINT($,#276);
+#278=CARTESIAN_POINT($,(-116.9924,122.0724,76.2));
+#279=VERTEX_POINT($,#278);
+#280=CARTESIAN_POINT($,(-136.0424,122.0724,76.2));
+#281=DIRECTION($,(1,0,0));
+#282=VECTOR($,#281,1);
+#283=LINE($,#280,#282);
+#284=EDGE_CURVE($,#277,#279,#283,.T.);
+#285=ORIENTED_EDGE($,$,$,#284,.T.);
+#286=CARTESIAN_POINT($,(-116.9924,210.9724,76.2));
+#287=VERTEX_POINT($,#286);
+#288=CARTESIAN_POINT($,(-116.9924,122.0724,76.2));
+#289=DIRECTION($,(0,1,0));
+#290=VECTOR($,#289,1);
+#291=LINE($,#288,#290);
+#292=EDGE_CURVE($,#279,#287,#291,.T.);
+#293=ORIENTED_EDGE($,$,$,#292,.T.);
+#294=CARTESIAN_POINT($,(-136.0424,210.9724,76.2));
+#295=VERTEX_POINT($,#294);
+#296=CARTESIAN_POINT($,(-116.9924,210.9724,76.2));
+#297=DIRECTION($,(-1,0,0));
+#298=VECTOR($,#297,1);
+#299=LINE($,#296,#298);
+#300=EDGE_CURVE($,#287,#295,#299,.T.);
+#301=ORIENTED_EDGE($,$,$,#300,.T.);
+#302=CARTESIAN_POINT($,(-136.0424,210.9724,76.2));
+#303=DIRECTION($,(0,-1,0));
+#304=VECTOR($,#303,1);
+#305=LINE($,#302,#304);
+#306=EDGE_CURVE($,#295,#277,#305,.T.);
+#307=ORIENTED_EDGE($,$,$,#306,.T.);
+#308=EDGE_LOOP($,(#285,#293,#301,#307));
+#309=FACE_BOUND('',#308,.T.);
+#310=CARTESIAN_POINT($,(-199.5424,122.0724,76.2));
+#311=VERTEX_POINT($,#310);
+#312=CARTESIAN_POINT($,(-180.4924,122.0724,76.2));
+#313=VERTEX_POINT($,#312);
+#314=CARTESIAN_POINT($,(-199.5424,122.0724,76.2));
+#315=DIRECTION($,(1,0,0));
+#316=VECTOR($,#315,1);
+#317=LINE($,#314,#316);
+#318=EDGE_CURVE($,#311,#313,#317,.T.);
+#319=ORIENTED_EDGE($,$,$,#318,.T.);
+#320=CARTESIAN_POINT($,(-180.4924,210.9724,76.2));
+#321=VERTEX_POINT($,#320);
+#322=CARTESIAN_POINT($,(-180.4924,122.0724,76.2));
+#323=DIRECTION($,(0,1,0));
+#324=VECTOR($,#323,1);
+#325=LINE($,#322,#324);
+#326=EDGE_CURVE($,#313,#321,#325,.T.);
+#327=ORIENTED_EDGE($,$,$,#326,.T.);
+#328=CARTESIAN_POINT($,(-199.5424,210.9724,76.2));
+#329=VERTEX_POINT($,#328);
+#330=CARTESIAN_POINT($,(-180.4924,210.9724,76.2));
+#331=DIRECTION($,(-1,0,0));
+#332=VECTOR($,#331,1);
+#333=LINE($,#330,#332);
+#334=EDGE_CURVE($,#321,#329,#333,.T.);
+#335=ORIENTED_EDGE($,$,$,#334,.T.);
+#336=CARTESIAN_POINT($,(-199.5424,210.9724,76.2));
+#337=DIRECTION($,(0,-1,0));
+#338=VECTOR($,#337,1);
+#339=LINE($,#336,#338);
+#340=EDGE_CURVE($,#329,#311,#339,.T.);
+#341=ORIENTED_EDGE($,$,$,#340,.T.);
+#342=EDGE_LOOP($,(#319,#327,#335,#341));
+#343=FACE_BOUND('',#342,.T.);
+#344=ADVANCED_FACE('',(#275,#309,#343),#177,.F.);
+#345=CARTESIAN_POINT($,(-233.045,49.83226,69.85));
+#346=DIRECTION($,(0,-1,0));
+#347=DIRECTION($,(1,0,0));
+#348=AXIS2_PLACEMENT_3D($,#345,#346,#347);
+#349=PLANE($,#348);
+#350=CARTESIAN_POINT($,(-233.045,49.83226,69.85));
+#351=VERTEX_POINT($,#350);
+#352=CARTESIAN_POINT($,(-8.255,49.83226,69.85));
+#353=VERTEX_POINT($,#352);
+#354=CARTESIAN_POINT($,(-233.045,49.83226,69.85));
+#355=DIRECTION($,(1,0,0));
+#356=VECTOR($,#355,1);
+#357=LINE($,#354,#356);
+#358=EDGE_CURVE($,#351,#353,#357,.T.);
+#359=ORIENTED_EDGE($,$,$,#358,.T.);
+#360=CARTESIAN_POINT($,(-8.255,49.83226,8.25746000000001));
+#361=VERTEX_POINT($,#360);
+#362=CARTESIAN_POINT($,(-8.255,49.83226,69.85));
+#363=DIRECTION($,(0,-0,-1));
+#364=VECTOR($,#363,1);
+#365=LINE($,#362,#364);
+#366=EDGE_CURVE($,#353,#361,#365,.T.);
+#367=ORIENTED_EDGE($,$,$,#366,.T.);
+#368=CARTESIAN_POINT($,(-233.045,49.83226,8.25746000000001));
+#369=VERTEX_POINT($,#368);
+#370=CARTESIAN_POINT($,(-8.255,49.83226,8.25746000000001));
+#371=DIRECTION($,(-1,0,0));
+#372=VECTOR($,#371,1);
+#373=LINE($,#370,#372);
+#374=EDGE_CURVE($,#361,#369,#373,.T.);
+#375=ORIENTED_EDGE($,$,$,#374,.T.);
+#376=CARTESIAN_POINT($,(-233.045,49.83226,8.25746000000001));
+#377=DIRECTION($,(0,0,1));
+#378=VECTOR($,#377,1);
+#379=LINE($,#376,#378);
+#380=EDGE_CURVE($,#369,#351,#379,.T.);
+#381=ORIENTED_EDGE($,$,$,#380,.T.);
+#382=EDGE_LOOP($,(#359,#367,#375,#381));
+#383=FACE_OUTER_BOUND('',#382,.T.);
+#384=ADVANCED_FACE('',(#383),#349,.T.);
+#385=CARTESIAN_POINT($,(-233.045,51.73726,69.85));
+#386=DIRECTION($,(-0,1,-0));
+#387=DIRECTION($,(1,0,0));
+#388=AXIS2_PLACEMENT_3D($,#385,#386,#387);
+#389=PLANE($,#388);
+#390=CARTESIAN_POINT($,(-233.045,51.73726,8.25746000000001));
+#391=VERTEX_POINT($,#390);
+#392=CARTESIAN_POINT($,(-8.255,51.73726,8.25746000000001));
+#393=VERTEX_POINT($,#392);
+#394=CARTESIAN_POINT($,(-233.045,51.73726,8.25746000000001));
+#395=DIRECTION($,(1,0,0));
+#396=VECTOR($,#395,1);
+#397=LINE($,#394,#396);
+#398=EDGE_CURVE($,#391,#393,#397,.T.);
+#399=ORIENTED_EDGE($,$,$,#398,.T.);
+#400=CARTESIAN_POINT($,(-8.255,51.73726,69.85));
+#401=VERTEX_POINT($,#400);
+#402=CARTESIAN_POINT($,(-8.255,51.73726,8.25746000000001));
+#403=DIRECTION($,(0,0,1));
+#404=VECTOR($,#403,1);
+#405=LINE($,#402,#404);
+#406=EDGE_CURVE($,#393,#401,#405,.T.);
+#407=ORIENTED_EDGE($,$,$,#406,.T.);
+#408=CARTESIAN_POINT($,(-233.045,51.73726,69.85));
+#409=VERTEX_POINT($,#408);
+#410=CARTESIAN_POINT($,(-8.255,51.73726,69.85));
+#411=DIRECTION($,(-1,0,0));
+#412=VECTOR($,#411,1);
+#413=LINE($,#410,#412);
+#414=EDGE_CURVE($,#401,#409,#413,.T.);
+#415=ORIENTED_EDGE($,$,$,#414,.T.);
+#416=CARTESIAN_POINT($,(-233.045,51.73726,69.85));
+#417=DIRECTION($,(0,-0,-1));
+#418=VECTOR($,#417,1);
+#419=LINE($,#416,#418);
+#420=EDGE_CURVE($,#409,#391,#419,.T.);
+#421=ORIENTED_EDGE($,$,$,#420,.T.);
+#422=EDGE_LOOP($,(#399,#407,#415,#421));
+#423=FACE_OUTER_BOUND('',#422,.T.);
+#424=ADVANCED_FACE('',(#423),#389,.F.);
+#425=CARTESIAN_POINT($,(-233.045,58.08726,69.85));
+#426=DIRECTION($,(1,0,0));
+#427=DIRECTION($,(0,0,1));
+#428=AXIS2_PLACEMENT_3D($,#425,#426,#427);
+#429=CYLINDRICAL_SURFACE($,#428,8.255);
+#430=ORIENTED_EDGE($,$,$,#22,.T.);
+#431=CARTESIAN_POINT($,(-8.255,58.08726,69.85));
+#432=DIRECTION($,(1,0,0));
+#433=DIRECTION($,(0,0,1));
+#434=AXIS2_PLACEMENT_3D($,#431,#432,#433);
+#435=CIRCLE($,#434,8.255);
+#436=TRIMMED_CURVE($,#435,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(1.5707963267949)),.T.,.PARAMETER.);
+#437=EDGE_CURVE($,#17,#353,#436,.T.);
+#438=ORIENTED_EDGE($,$,$,#437,.T.);
+#439=ORIENTED_EDGE($,$,$,#358,.F.);
+#440=CARTESIAN_POINT($,(-233.045,58.08726,69.85));
+#441=DIRECTION($,(-1,-0,-0));
+#442=DIRECTION($,(0,-1,0));
+#443=AXIS2_PLACEMENT_3D($,#440,#441,#442);
+#444=CIRCLE($,#443,8.255);
+#445=TRIMMED_CURVE($,#444,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(1.5707963267949)),.T.,.PARAMETER.);
+#446=EDGE_CURVE($,#351,#9,#445,.T.);
+#447=ORIENTED_EDGE($,$,$,#446,.T.);
+#448=EDGE_LOOP($,(#430,#438,#439,#447));
+#449=FACE_OUTER_BOUND('',#448,.T.);
+#450=ADVANCED_FACE('',(#449),#429,.T.);
+#451=CARTESIAN_POINT($,(-233.045,58.08726,69.85));
+#452=DIRECTION($,(1,0,0));
+#453=DIRECTION($,(0,0,1));
+#454=AXIS2_PLACEMENT_3D($,#451,#452,#453);
+#455=CYLINDRICAL_SURFACE($,#454,6.34999999999999);
+#456=ORIENTED_EDGE($,$,$,#414,.F.);
+#457=CARTESIAN_POINT($,(-8.255,58.08726,69.85));
+#458=DIRECTION($,(-1,-0,-0));
+#459=DIRECTION($,(0,-1,0));
+#460=AXIS2_PLACEMENT_3D($,#457,#458,#459);
+#461=CIRCLE($,#460,6.35);
+#462=TRIMMED_CURVE($,#461,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(1.5707963267949)),.T.,.PARAMETER.);
+#463=EDGE_CURVE($,#401,#245,#462,.T.);
+#464=ORIENTED_EDGE($,$,$,#463,.T.);
+#465=ORIENTED_EDGE($,$,$,#258,.T.);
+#466=CARTESIAN_POINT($,(-233.045,58.08726,69.85));
+#467=DIRECTION($,(1,0,0));
+#468=DIRECTION($,(0,0,1));
+#469=AXIS2_PLACEMENT_3D($,#466,#467,#468);
+#470=CIRCLE($,#469,6.34999999999999);
+#471=TRIMMED_CURVE($,#470,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(1.5707963267949)),.T.,.PARAMETER.);
+#472=EDGE_CURVE($,#253,#409,#471,.T.);
+#473=ORIENTED_EDGE($,$,$,#472,.T.);
+#474=EDGE_LOOP($,(#456,#464,#465,#473));
+#475=FACE_OUTER_BOUND('',#474,.T.);
+#476=ADVANCED_FACE('',(#475),#455,.F.);
+#477=CARTESIAN_POINT($,(-8.255,434.64226,69.85));
+#478=DIRECTION($,(0,1,0));
+#479=DIRECTION($,(-1,0,0));
+#480=AXIS2_PLACEMENT_3D($,#477,#478,#479);
+#481=PLANE($,#480);
+#482=CARTESIAN_POINT($,(-8.255,434.64226,69.85));
+#483=VERTEX_POINT($,#482);
+#484=CARTESIAN_POINT($,(-233.045,434.64226,69.85));
+#485=VERTEX_POINT($,#484);
+#486=CARTESIAN_POINT($,(-8.255,434.64226,69.85));
+#487=DIRECTION($,(-1,0,0));
+#488=VECTOR($,#487,1);
+#489=LINE($,#486,#488);
+#490=EDGE_CURVE($,#483,#485,#489,.T.);
+#491=ORIENTED_EDGE($,$,$,#490,.T.);
+#492=CARTESIAN_POINT($,(-233.045,434.64226,8.25746000000001));
+#493=VERTEX_POINT($,#492);
+#494=CARTESIAN_POINT($,(-233.045,434.64226,69.85));
+#495=DIRECTION($,(0,0,-1));
+#496=VECTOR($,#495,1);
+#497=LINE($,#494,#496);
+#498=EDGE_CURVE($,#485,#493,#497,.T.);
+#499=ORIENTED_EDGE($,$,$,#498,.T.);
+#500=CARTESIAN_POINT($,(-8.255,434.64226,8.25746000000001));
+#501=VERTEX_POINT($,#500);
+#502=CARTESIAN_POINT($,(-233.045,434.64226,8.25746000000001));
+#503=DIRECTION($,(1,0,0));
+#504=VECTOR($,#503,1);
+#505=LINE($,#502,#504);
+#506=EDGE_CURVE($,#493,#501,#505,.T.);
+#507=ORIENTED_EDGE($,$,$,#506,.T.);
+#508=CARTESIAN_POINT($,(-8.255,434.64226,8.25746000000001));
+#509=DIRECTION($,(0,0,1));
+#510=VECTOR($,#509,1);
+#511=LINE($,#508,#510);
+#512=EDGE_CURVE($,#501,#483,#511,.T.);
+#513=ORIENTED_EDGE($,$,$,#512,.T.);
+#514=EDGE_LOOP($,(#491,#499,#507,#513));
+#515=FACE_OUTER_BOUND('',#514,.T.);
+#516=ADVANCED_FACE('',(#515),#481,.T.);
+#517=CARTESIAN_POINT($,(-8.255,432.73726,69.85));
+#518=DIRECTION($,(-0,-1,-0));
+#519=DIRECTION($,(-1,0,0));
+#520=AXIS2_PLACEMENT_3D($,#517,#518,#519);
+#521=PLANE($,#520);
+#522=CARTESIAN_POINT($,(-8.255,432.73726,8.25746000000001));
+#523=VERTEX_POINT($,#522);
+#524=CARTESIAN_POINT($,(-233.045,432.73726,8.25746000000001));
+#525=VERTEX_POINT($,#524);
+#526=CARTESIAN_POINT($,(-8.255,432.73726,8.25746000000001));
+#527=DIRECTION($,(-1,0,0));
+#528=VECTOR($,#527,1);
+#529=LINE($,#526,#528);
+#530=EDGE_CURVE($,#523,#525,#529,.T.);
+#531=ORIENTED_EDGE($,$,$,#530,.T.);
+#532=CARTESIAN_POINT($,(-233.045,432.73726,69.85));
+#533=VERTEX_POINT($,#532);
+#534=CARTESIAN_POINT($,(-233.045,432.73726,8.25746000000001));
+#535=DIRECTION($,(0,0,1));
+#536=VECTOR($,#535,1);
+#537=LINE($,#534,#536);
+#538=EDGE_CURVE($,#525,#533,#537,.T.);
+#539=ORIENTED_EDGE($,$,$,#538,.T.);
+#540=CARTESIAN_POINT($,(-8.255,432.73726,69.85));
+#541=VERTEX_POINT($,#540);
+#542=CARTESIAN_POINT($,(-233.045,432.73726,69.85));
+#543=DIRECTION($,(1,0,0));
+#544=VECTOR($,#543,1);
+#545=LINE($,#542,#544);
+#546=EDGE_CURVE($,#533,#541,#545,.T.);
+#547=ORIENTED_EDGE($,$,$,#546,.T.);
+#548=CARTESIAN_POINT($,(-8.255,432.73726,69.85));
+#549=DIRECTION($,(0,0,-1));
+#550=VECTOR($,#549,1);
+#551=LINE($,#548,#550);
+#552=EDGE_CURVE($,#541,#523,#551,.T.);
+#553=ORIENTED_EDGE($,$,$,#552,.T.);
+#554=EDGE_LOOP($,(#531,#539,#547,#553));
+#555=FACE_OUTER_BOUND('',#554,.T.);
+#556=ADVANCED_FACE('',(#555),#521,.F.);
+#557=CARTESIAN_POINT($,(-8.255,426.38726,69.85));
+#558=DIRECTION($,(-1,0,0));
+#559=DIRECTION($,(0,0,1));
+#560=AXIS2_PLACEMENT_3D($,#557,#558,#559);
+#561=CYLINDRICAL_SURFACE($,#560,8.255);
+#562=ORIENTED_EDGE($,$,$,#70,.T.);
+#563=CARTESIAN_POINT($,(-233.045,426.38726,69.85));
+#564=DIRECTION($,(-1,0,0));
+#565=DIRECTION($,(0,0,1));
+#566=AXIS2_PLACEMENT_3D($,#563,#564,#565);
+#567=CIRCLE($,#566,8.255);
+#568=TRIMMED_CURVE($,#567,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(1.5707963267949)),.T.,.PARAMETER.);
+#569=EDGE_CURVE($,#65,#485,#568,.T.);
+#570=ORIENTED_EDGE($,$,$,#569,.T.);
+#571=ORIENTED_EDGE($,$,$,#490,.F.);
+#572=CARTESIAN_POINT($,(-8.255,426.38726,69.85));
+#573=DIRECTION($,(1,-0,-0));
+#574=DIRECTION($,(0,1,0));
+#575=AXIS2_PLACEMENT_3D($,#572,#573,#574);
+#576=CIRCLE($,#575,8.255);
+#577=TRIMMED_CURVE($,#576,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(1.5707963267949)),.T.,.PARAMETER.);
+#578=EDGE_CURVE($,#483,#57,#577,.T.);
+#579=ORIENTED_EDGE($,$,$,#578,.T.);
+#580=EDGE_LOOP($,(#562,#570,#571,#579));
+#581=FACE_OUTER_BOUND('',#580,.T.);
+#582=ADVANCED_FACE('',(#581),#561,.T.);
+#583=CARTESIAN_POINT($,(-8.255,426.38726,69.85));
+#584=DIRECTION($,(-1,0,0));
+#585=DIRECTION($,(0,0,1));
+#586=AXIS2_PLACEMENT_3D($,#583,#584,#585);
+#587=CYLINDRICAL_SURFACE($,#586,6.34999999999999);
+#588=ORIENTED_EDGE($,$,$,#546,.F.);
+#589=CARTESIAN_POINT($,(-233.045,426.38726,69.85));
+#590=DIRECTION($,(1,-0,-0));
+#591=DIRECTION($,(0,1,0));
+#592=AXIS2_PLACEMENT_3D($,#589,#590,#591);
+#593=CIRCLE($,#592,6.35000000000002);
+#594=TRIMMED_CURVE($,#593,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(1.5707963267949)),.T.,.PARAMETER.);
+#595=EDGE_CURVE($,#533,#197,#594,.T.);
+#596=ORIENTED_EDGE($,$,$,#595,.T.);
+#597=ORIENTED_EDGE($,$,$,#210,.T.);
+#598=CARTESIAN_POINT($,(-8.255,426.38726,69.85));
+#599=DIRECTION($,(-1,0,0));
+#600=DIRECTION($,(0,0,1));
+#601=AXIS2_PLACEMENT_3D($,#598,#599,#600);
+#602=CIRCLE($,#601,6.34999999999999);
+#603=TRIMMED_CURVE($,#602,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(1.5707963267949)),.T.,.PARAMETER.);
+#604=EDGE_CURVE($,#205,#541,#603,.T.);
+#605=ORIENTED_EDGE($,$,$,#604,.T.);
+#606=EDGE_LOOP($,(#588,#596,#597,#605));
+#607=FACE_OUTER_BOUND('',#606,.T.);
+#608=ADVANCED_FACE('',(#607),#587,.F.);
+#609=CARTESIAN_POINT($,(-247.65,418.13226,84.455));
+#610=DIRECTION($,(1,0,0));
+#611=DIRECTION($,(0,-1,0));
+#612=AXIS2_PLACEMENT_3D($,#609,#610,#611);
+#613=PLANE($,#612);
+#614=CARTESIAN_POINT($,(-247.65,418.13226,84.455));
+#615=VERTEX_POINT($,#614);
+#616=CARTESIAN_POINT($,(-247.65,66.34226,84.455));
+#617=VERTEX_POINT($,#616);
+#618=CARTESIAN_POINT($,(-247.65,418.13226,84.455));
+#619=DIRECTION($,(0,-1,0));
+#620=VECTOR($,#619,1);
+#621=LINE($,#618,#620);
+#622=EDGE_CURVE($,#615,#617,#621,.T.);
+#623=ORIENTED_EDGE($,$,$,#622,.T.);
+#624=CARTESIAN_POINT($,(-247.65,66.34226,128.905));
+#625=VERTEX_POINT($,#624);
+#626=CARTESIAN_POINT($,(-247.65,66.34226,84.455));
+#627=DIRECTION($,(0,0,1));
+#628=VECTOR($,#627,1);
+#629=LINE($,#626,#628);
+#630=EDGE_CURVE($,#617,#625,#629,.T.);
+#631=ORIENTED_EDGE($,$,$,#630,.T.);
+#632=CARTESIAN_POINT($,(-247.65,418.13226,128.905));
+#633=VERTEX_POINT($,#632);
+#634=CARTESIAN_POINT($,(-247.65,66.34226,128.905));
+#635=DIRECTION($,(0,1,0));
+#636=VECTOR($,#635,1);
+#637=LINE($,#634,#636);
+#638=EDGE_CURVE($,#625,#633,#637,.T.);
+#639=ORIENTED_EDGE($,$,$,#638,.T.);
+#640=CARTESIAN_POINT($,(-247.65,418.13226,128.905));
+#641=DIRECTION($,(0,0,-1));
+#642=VECTOR($,#641,1);
+#643=LINE($,#640,#642);
+#644=EDGE_CURVE($,#633,#615,#643,.T.);
+#645=ORIENTED_EDGE($,$,$,#644,.T.);
+#646=EDGE_LOOP($,(#623,#631,#639,#645));
+#647=FACE_OUTER_BOUND('',#646,.T.);
+#648=ADVANCED_FACE('',(#647),#613,.T.);
+#649=CARTESIAN_POINT($,(-249.555,418.13226,84.455));
+#650=DIRECTION($,(-1,-0,-0));
+#651=DIRECTION($,(0,-1,0));
+#652=AXIS2_PLACEMENT_3D($,#649,#650,#651);
+#653=PLANE($,#652);
+#654=CARTESIAN_POINT($,(-249.555,418.13226,128.905));
+#655=VERTEX_POINT($,#654);
+#656=CARTESIAN_POINT($,(-249.555,66.34226,128.905));
+#657=VERTEX_POINT($,#656);
+#658=CARTESIAN_POINT($,(-249.555,418.13226,128.905));
+#659=DIRECTION($,(0,-1,0));
+#660=VECTOR($,#659,1);
+#661=LINE($,#658,#660);
+#662=EDGE_CURVE($,#655,#657,#661,.T.);
+#663=ORIENTED_EDGE($,$,$,#662,.T.);
+#664=CARTESIAN_POINT($,(-249.555,66.34226,84.455));
+#665=VERTEX_POINT($,#664);
+#666=CARTESIAN_POINT($,(-249.555,66.34226,128.905));
+#667=DIRECTION($,(0,0,-1));
+#668=VECTOR($,#667,1);
+#669=LINE($,#666,#668);
+#670=EDGE_CURVE($,#657,#665,#669,.T.);
+#671=ORIENTED_EDGE($,$,$,#670,.T.);
+#672=CARTESIAN_POINT($,(-249.555,418.13226,84.455));
+#673=VERTEX_POINT($,#672);
+#674=CARTESIAN_POINT($,(-249.555,66.34226,84.455));
+#675=DIRECTION($,(0,1,0));
+#676=VECTOR($,#675,1);
+#677=LINE($,#674,#676);
+#678=EDGE_CURVE($,#665,#673,#677,.T.);
+#679=ORIENTED_EDGE($,$,$,#678,.T.);
+#680=CARTESIAN_POINT($,(-249.555,418.13226,84.455));
+#681=DIRECTION($,(0,0,1));
+#682=VECTOR($,#681,1);
+#683=LINE($,#680,#682);
+#684=EDGE_CURVE($,#673,#655,#683,.T.);
+#685=ORIENTED_EDGE($,$,$,#684,.T.);
+#686=EDGE_LOOP($,(#663,#671,#679,#685));
+#687=FACE_OUTER_BOUND('',#686,.T.);
+#688=ADVANCED_FACE('',(#687),#653,.F.);
+#689=CARTESIAN_POINT($,(-241.3,418.13226,84.455));
+#690=DIRECTION($,(0,-1,0));
+#691=DIRECTION($,(0,0,-1));
+#692=AXIS2_PLACEMENT_3D($,#689,#690,#691);
+#693=CYLINDRICAL_SURFACE($,#692,6.34999999999999);
+#694=ORIENTED_EDGE($,$,$,#94,.T.);
+#695=CARTESIAN_POINT($,(-241.3,66.34226,84.455));
+#696=DIRECTION($,(-0,1,-0));
+#697=DIRECTION($,(0,0,-1));
+#698=AXIS2_PLACEMENT_3D($,#695,#696,#697);
+#699=CIRCLE($,#698,6.34999999999999);
+#700=TRIMMED_CURVE($,#699,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(1.5707963267949)),.T.,.PARAMETER.);
+#701=EDGE_CURVE($,#89,#617,#700,.T.);
+#702=ORIENTED_EDGE($,$,$,#701,.T.);
+#703=ORIENTED_EDGE($,$,$,#622,.F.);
+#704=CARTESIAN_POINT($,(-241.3,418.13226,84.455));
+#705=DIRECTION($,(0,-1,0));
+#706=DIRECTION($,(-1,0,0));
+#707=AXIS2_PLACEMENT_3D($,#704,#705,#706);
+#708=CIRCLE($,#707,6.35000000000002);
+#709=TRIMMED_CURVE($,#708,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(1.5707963267949)),.T.,.PARAMETER.);
+#710=EDGE_CURVE($,#615,#81,#709,.T.);
+#711=ORIENTED_EDGE($,$,$,#710,.T.);
+#712=EDGE_LOOP($,(#694,#702,#703,#711));
+#713=FACE_OUTER_BOUND('',#712,.T.);
+#714=ADVANCED_FACE('',(#713),#693,.T.);
+#715=CARTESIAN_POINT($,(-241.3,418.13226,84.455));
+#716=DIRECTION($,(0,-1,0));
+#717=DIRECTION($,(0,0,-1));
+#718=AXIS2_PLACEMENT_3D($,#715,#716,#717);
+#719=CYLINDRICAL_SURFACE($,#718,8.255);
+#720=ORIENTED_EDGE($,$,$,#678,.F.);
+#721=CARTESIAN_POINT($,(-241.3,66.34226,84.455));
+#722=DIRECTION($,(0,-1,0));
+#723=DIRECTION($,(-1,0,0));
+#724=AXIS2_PLACEMENT_3D($,#721,#722,#723);
+#725=CIRCLE($,#724,8.255);
+#726=TRIMMED_CURVE($,#725,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(1.5707963267949)),.T.,.PARAMETER.);
+#727=EDGE_CURVE($,#665,#179,#726,.T.);
+#728=ORIENTED_EDGE($,$,$,#727,.T.);
+#729=ORIENTED_EDGE($,$,$,#186,.T.);
+#730=CARTESIAN_POINT($,(-241.3,418.13226,84.455));
+#731=DIRECTION($,(-0,1,-0));
+#732=DIRECTION($,(0,0,-1));
+#733=AXIS2_PLACEMENT_3D($,#730,#731,#732);
+#734=CIRCLE($,#733,8.255);
+#735=TRIMMED_CURVE($,#734,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(1.5707963267949)),.T.,.PARAMETER.);
+#736=EDGE_CURVE($,#181,#673,#735,.T.);
+#737=ORIENTED_EDGE($,$,$,#736,.T.);
+#738=EDGE_LOOP($,(#720,#728,#729,#737));
+#739=FACE_OUTER_BOUND('',#738,.T.);
+#740=ADVANCED_FACE('',(#739),#719,.F.);
+#741=CARTESIAN_POINT($,(6.35,66.34226,84.455));
+#742=DIRECTION($,(-1,0,0));
+#743=DIRECTION($,(0,1,0));
+#744=AXIS2_PLACEMENT_3D($,#741,#742,#743);
+#745=PLANE($,#744);
+#746=CARTESIAN_POINT($,(6.35,66.34226,84.455));
+#747=VERTEX_POINT($,#746);
+#748=CARTESIAN_POINT($,(6.35,418.13226,84.455));
+#749=VERTEX_POINT($,#748);
+#750=CARTESIAN_POINT($,(6.35,66.34226,84.455));
+#751=DIRECTION($,(0,1,0));
+#752=VECTOR($,#751,1);
+#753=LINE($,#750,#752);
+#754=EDGE_CURVE($,#747,#749,#753,.T.);
+#755=ORIENTED_EDGE($,$,$,#754,.T.);
+#756=CARTESIAN_POINT($,(6.35,418.13226,113.56594));
+#757=VERTEX_POINT($,#756);
+#758=CARTESIAN_POINT($,(6.35,418.13226,84.455));
+#759=DIRECTION($,(0,0,1));
+#760=VECTOR($,#759,1);
+#761=LINE($,#758,#760);
+#762=EDGE_CURVE($,#749,#757,#761,.T.);
+#763=ORIENTED_EDGE($,$,$,#762,.T.);
+#764=CARTESIAN_POINT($,(6.35,66.34226,113.56594));
+#765=VERTEX_POINT($,#764);
+#766=CARTESIAN_POINT($,(6.35,418.13226,113.56594));
+#767=DIRECTION($,(0,-1,0));
+#768=VECTOR($,#767,1);
+#769=LINE($,#766,#768);
+#770=EDGE_CURVE($,#757,#765,#769,.T.);
+#771=ORIENTED_EDGE($,$,$,#770,.T.);
+#772=CARTESIAN_POINT($,(6.35,66.34226,113.56594));
+#773=DIRECTION($,(-0,0,-1));
+#774=VECTOR($,#773,1);
+#775=LINE($,#772,#774);
+#776=EDGE_CURVE($,#765,#747,#775,.T.);
+#777=ORIENTED_EDGE($,$,$,#776,.T.);
+#778=EDGE_LOOP($,(#755,#763,#771,#777));
+#779=FACE_OUTER_BOUND('',#778,.T.);
+#780=ADVANCED_FACE('',(#779),#745,.T.);
+#781=CARTESIAN_POINT($,(8.255,66.34226,84.455));
+#782=DIRECTION($,(1,-0,-0));
+#783=DIRECTION($,(0,1,0));
+#784=AXIS2_PLACEMENT_3D($,#781,#782,#783);
+#785=PLANE($,#784);
+#786=CARTESIAN_POINT($,(8.255,66.34226,113.56594));
+#787=VERTEX_POINT($,#786);
+#788=CARTESIAN_POINT($,(8.255,418.13226,113.56594));
+#789=VERTEX_POINT($,#788);
+#790=CARTESIAN_POINT($,(8.255,66.34226,113.56594));
+#791=DIRECTION($,(0,1,0));
+#792=VECTOR($,#791,1);
+#793=LINE($,#790,#792);
+#794=EDGE_CURVE($,#787,#789,#793,.T.);
+#795=ORIENTED_EDGE($,$,$,#794,.T.);
+#796=CARTESIAN_POINT($,(8.255,418.13226,84.455));
+#797=VERTEX_POINT($,#796);
+#798=CARTESIAN_POINT($,(8.255,418.13226,113.56594));
+#799=DIRECTION($,(-0,0,-1));
+#800=VECTOR($,#799,1);
+#801=LINE($,#798,#800);
+#802=EDGE_CURVE($,#789,#797,#801,.T.);
+#803=ORIENTED_EDGE($,$,$,#802,.T.);
+#804=CARTESIAN_POINT($,(8.255,66.34226,84.455));
+#805=VERTEX_POINT($,#804);
+#806=CARTESIAN_POINT($,(8.255,418.13226,84.455));
+#807=DIRECTION($,(0,-1,0));
+#808=VECTOR($,#807,1);
+#809=LINE($,#806,#808);
+#810=EDGE_CURVE($,#797,#805,#809,.T.);
+#811=ORIENTED_EDGE($,$,$,#810,.T.);
+#812=CARTESIAN_POINT($,(8.255,66.34226,84.455));
+#813=DIRECTION($,(0,0,1));
+#814=VECTOR($,#813,1);
+#815=LINE($,#812,#814);
+#816=EDGE_CURVE($,#805,#787,#815,.T.);
+#817=ORIENTED_EDGE($,$,$,#816,.T.);
+#818=EDGE_LOOP($,(#795,#803,#811,#817));
+#819=FACE_OUTER_BOUND('',#818,.T.);
+#820=ADVANCED_FACE('',(#819),#785,.F.);
+#821=CARTESIAN_POINT($,(0,66.34226,84.455));
+#822=DIRECTION($,(0,1,0));
+#823=DIRECTION($,(0,0,-1));
+#824=AXIS2_PLACEMENT_3D($,#821,#822,#823);
+#825=CYLINDRICAL_SURFACE($,#824,6.34999999999999);
+#826=ORIENTED_EDGE($,$,$,#46,.T.);
+#827=CARTESIAN_POINT($,(0,418.13226,84.455));
+#828=DIRECTION($,(-0,-1,-0));
+#829=DIRECTION($,(0,0,-1));
+#830=AXIS2_PLACEMENT_3D($,#827,#828,#829);
+#831=CIRCLE($,#830,6.34999999999999);
+#832=TRIMMED_CURVE($,#831,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(1.5707963267949)),.T.,.PARAMETER.);
+#833=EDGE_CURVE($,#41,#749,#832,.T.);
+#834=ORIENTED_EDGE($,$,$,#833,.T.);
+#835=ORIENTED_EDGE($,$,$,#754,.F.);
+#836=CARTESIAN_POINT($,(0,66.34226,84.455));
+#837=DIRECTION($,(0,1,0));
+#838=DIRECTION($,(1,0,0));
+#839=AXIS2_PLACEMENT_3D($,#836,#837,#838);
+#840=CIRCLE($,#839,6.35);
+#841=TRIMMED_CURVE($,#840,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(1.5707963267949)),.T.,.PARAMETER.);
+#842=EDGE_CURVE($,#747,#33,#841,.T.);
+#843=ORIENTED_EDGE($,$,$,#842,.T.);
+#844=EDGE_LOOP($,(#826,#834,#835,#843));
+#845=FACE_OUTER_BOUND('',#844,.T.);
+#846=ADVANCED_FACE('',(#845),#825,.T.);
+#847=CARTESIAN_POINT($,(0,66.34226,84.455));
+#848=DIRECTION($,(0,1,0));
+#849=DIRECTION($,(0,0,-1));
+#850=AXIS2_PLACEMENT_3D($,#847,#848,#849);
+#851=CYLINDRICAL_SURFACE($,#850,8.255);
+#852=ORIENTED_EDGE($,$,$,#810,.F.);
+#853=CARTESIAN_POINT($,(0,418.13226,84.455));
+#854=DIRECTION($,(0,1,0));
+#855=DIRECTION($,(1,0,0));
+#856=AXIS2_PLACEMENT_3D($,#853,#854,#855);
+#857=CIRCLE($,#856,8.255);
+#858=TRIMMED_CURVE($,#857,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(1.5707963267949)),.T.,.PARAMETER.);
+#859=EDGE_CURVE($,#797,#221,#858,.T.);
+#860=ORIENTED_EDGE($,$,$,#859,.T.);
+#861=ORIENTED_EDGE($,$,$,#234,.T.);
+#862=CARTESIAN_POINT($,(0,66.34226,84.455));
+#863=DIRECTION($,(-0,-1,-0));
+#864=DIRECTION($,(0,0,-1));
+#865=AXIS2_PLACEMENT_3D($,#862,#863,#864);
+#866=CIRCLE($,#865,8.255);
+#867=TRIMMED_CURVE($,#866,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(1.5707963267949)),.T.,.PARAMETER.);
+#868=EDGE_CURVE($,#229,#805,#867,.T.);
+#869=ORIENTED_EDGE($,$,$,#868,.T.);
+#870=EDGE_LOOP($,(#852,#860,#861,#869));
+#871=FACE_OUTER_BOUND('',#870,.T.);
+#872=ADVANCED_FACE('',(#871),#851,.F.);
+#873=CARTESIAN_POINT($,(-233.045,43.48226,1.90746000000001));
+#874=DIRECTION($,(0,0,1));
+#875=DIRECTION($,(1,0,0));
+#876=AXIS2_PLACEMENT_3D($,#873,#874,#875);
+#877=PLANE($,#876);
+#878=CARTESIAN_POINT($,(-233.045,43.48226,1.90746000000001));
+#879=VERTEX_POINT($,#878);
+#880=CARTESIAN_POINT($,(-8.255,43.48226,1.90746000000001));
+#881=VERTEX_POINT($,#880);
+#882=CARTESIAN_POINT($,(-233.045,43.48226,1.90746000000001));
+#883=DIRECTION($,(1,0,0));
+#884=VECTOR($,#883,1);
+#885=LINE($,#882,#884);
+#886=EDGE_CURVE($,#879,#881,#885,.T.);
+#887=ORIENTED_EDGE($,$,$,#886,.T.);
+#888=CARTESIAN_POINT($,(-8.255,12.70254,1.90746000000001));
+#889=VERTEX_POINT($,#888);
+#890=CARTESIAN_POINT($,(-8.255,43.48226,1.90746000000001));
+#891=DIRECTION($,(0,-1,0));
+#892=VECTOR($,#891,1);
+#893=LINE($,#890,#892);
+#894=EDGE_CURVE($,#881,#889,#893,.T.);
+#895=ORIENTED_EDGE($,$,$,#894,.T.);
+#896=CARTESIAN_POINT($,(-233.045,12.70254,1.90746000000001));
+#897=VERTEX_POINT($,#896);
+#898=CARTESIAN_POINT($,(-8.255,12.70254,1.90746000000001));
+#899=DIRECTION($,(-1,0,0));
+#900=VECTOR($,#899,1);
+#901=LINE($,#898,#900);
+#902=EDGE_CURVE($,#889,#897,#901,.T.);
+#903=ORIENTED_EDGE($,$,$,#902,.T.);
+#904=CARTESIAN_POINT($,(-233.045,12.70254,1.90746000000001));
+#905=DIRECTION($,(0,1,0));
+#906=VECTOR($,#905,1);
+#907=LINE($,#904,#906);
+#908=EDGE_CURVE($,#897,#879,#907,.T.);
+#909=ORIENTED_EDGE($,$,$,#908,.T.);
+#910=EDGE_LOOP($,(#887,#895,#903,#909));
+#911=FACE_OUTER_BOUND('',#910,.T.);
+#912=ADVANCED_FACE('',(#911),#877,.T.);
+#913=CARTESIAN_POINT($,(-233.045,43.48226,0.00246000000001));
+#914=DIRECTION($,(-0,-0,-1));
+#915=DIRECTION($,(1,0,0));
+#916=AXIS2_PLACEMENT_3D($,#913,#914,#915);
+#917=PLANE($,#916);
+#918=CARTESIAN_POINT($,(-233.045,12.70254,0.00246000000001));
+#919=VERTEX_POINT($,#918);
+#920=CARTESIAN_POINT($,(-8.255,12.70254,0.00246000000001));
+#921=VERTEX_POINT($,#920);
+#922=CARTESIAN_POINT($,(-233.045,12.70254,0.00246000000001));
+#923=DIRECTION($,(1,0,0));
+#924=VECTOR($,#923,1);
+#925=LINE($,#922,#924);
+#926=EDGE_CURVE($,#919,#921,#925,.T.);
+#927=ORIENTED_EDGE($,$,$,#926,.T.);
+#928=CARTESIAN_POINT($,(-8.255,43.48226,0.00246000000001));
+#929=VERTEX_POINT($,#928);
+#930=CARTESIAN_POINT($,(-8.255,12.70254,0.00246000000001));
+#931=DIRECTION($,(0,1,0));
+#932=VECTOR($,#931,1);
+#933=LINE($,#930,#932);
+#934=EDGE_CURVE($,#921,#929,#933,.T.);
+#935=ORIENTED_EDGE($,$,$,#934,.T.);
+#936=CARTESIAN_POINT($,(-233.045,43.48226,0.00246000000001));
+#937=VERTEX_POINT($,#936);
+#938=CARTESIAN_POINT($,(-8.255,43.48226,0.00246000000001));
+#939=DIRECTION($,(-1,0,0));
+#940=VECTOR($,#939,1);
+#941=LINE($,#938,#940);
+#942=EDGE_CURVE($,#929,#937,#941,.T.);
+#943=ORIENTED_EDGE($,$,$,#942,.T.);
+#944=CARTESIAN_POINT($,(-233.045,43.48226,0.00246000000001));
+#945=DIRECTION($,(0,-1,0));
+#946=VECTOR($,#945,1);
+#947=LINE($,#944,#946);
+#948=EDGE_CURVE($,#937,#919,#947,.T.);
+#949=ORIENTED_EDGE($,$,$,#948,.T.);
+#950=EDGE_LOOP($,(#927,#935,#943,#949));
+#951=FACE_OUTER_BOUND('',#950,.T.);
+#952=ADVANCED_FACE('',(#951),#917,.F.);
+#953=CARTESIAN_POINT($,(-233.045,43.48226,8.25746000000001));
+#954=DIRECTION($,(1,0,0));
+#955=DIRECTION($,(0,1,0));
+#956=AXIS2_PLACEMENT_3D($,#953,#954,#955);
+#957=CYLINDRICAL_SURFACE($,#956,6.35);
+#958=ORIENTED_EDGE($,$,$,#374,.F.);
+#959=CARTESIAN_POINT($,(-8.255,43.48226,8.25746000000001));
+#960=DIRECTION($,(-1,-0,-0));
+#961=DIRECTION($,(0,1,0));
+#962=AXIS2_PLACEMENT_3D($,#959,#960,#961);
+#963=CIRCLE($,#962,6.35);
+#964=TRIMMED_CURVE($,#963,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(1.5707963267949)),.T.,.PARAMETER.);
+#965=EDGE_CURVE($,#361,#881,#964,.T.);
+#966=ORIENTED_EDGE($,$,$,#965,.T.);
+#967=ORIENTED_EDGE($,$,$,#886,.F.);
+#968=CARTESIAN_POINT($,(-233.045,43.48226,8.25746000000001));
+#969=DIRECTION($,(1,0,0));
+#970=DIRECTION($,(0,0.000000000000001,-1));
+#971=AXIS2_PLACEMENT_3D($,#968,#969,#970);
+#972=CIRCLE($,#971,6.35);
+#973=TRIMMED_CURVE($,#972,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(1.5707963267949)),.T.,.PARAMETER.);
+#974=EDGE_CURVE($,#879,#369,#973,.T.);
+#975=ORIENTED_EDGE($,$,$,#974,.T.);
+#976=EDGE_LOOP($,(#958,#966,#967,#975));
+#977=FACE_OUTER_BOUND('',#976,.T.);
+#978=ADVANCED_FACE('',(#977),#957,.T.);
+#979=CARTESIAN_POINT($,(-233.045,43.48226,8.25746000000001));
+#980=DIRECTION($,(1,0,0));
+#981=DIRECTION($,(0,1,0));
+#982=AXIS2_PLACEMENT_3D($,#979,#980,#981);
+#983=CYLINDRICAL_SURFACE($,#982,8.255);
+#984=ORIENTED_EDGE($,$,$,#942,.F.);
+#985=CARTESIAN_POINT($,(-8.255,43.48226,8.25746000000001));
+#986=DIRECTION($,(1,0,0));
+#987=DIRECTION($,(0,0.000000000000001,-1));
+#988=AXIS2_PLACEMENT_3D($,#985,#986,#987);
+#989=CIRCLE($,#988,8.255);
+#990=TRIMMED_CURVE($,#989,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(1.5707963267949)),.T.,.PARAMETER.);
+#991=EDGE_CURVE($,#929,#393,#990,.T.);
+#992=ORIENTED_EDGE($,$,$,#991,.T.);
+#993=ORIENTED_EDGE($,$,$,#398,.F.);
+#994=CARTESIAN_POINT($,(-233.045,43.48226,8.25746000000001));
+#995=DIRECTION($,(-1,-0,-0));
+#996=DIRECTION($,(0,1,0));
+#997=AXIS2_PLACEMENT_3D($,#994,#995,#996);
+#998=CIRCLE($,#997,8.255);
+#999=TRIMMED_CURVE($,#998,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(1.5707963267949)),.T.,.PARAMETER.);
+#1000=EDGE_CURVE($,#391,#937,#999,.T.);
+#1001=ORIENTED_EDGE($,$,$,#1000,.T.);
+#1002=EDGE_LOOP($,(#984,#992,#993,#1001));
+#1003=FACE_OUTER_BOUND('',#1002,.T.);
+#1004=ADVANCED_FACE('',(#1003),#983,.F.);
+#1005=CARTESIAN_POINT($,(-8.255,440.99226,1.90746000000001));
+#1006=DIRECTION($,(0,0,1));
+#1007=DIRECTION($,(-1,0,0));
+#1008=AXIS2_PLACEMENT_3D($,#1005,#1006,#1007);
+#1009=PLANE($,#1008);
+#1010=CARTESIAN_POINT($,(-8.255,440.99226,1.90746000000001));
+#1011=VERTEX_POINT($,#1010);
+#1012=CARTESIAN_POINT($,(-233.045,440.99226,1.90746000000001));
+#1013=VERTEX_POINT($,#1012);
+#1014=CARTESIAN_POINT($,(-8.255,440.99226,1.90746000000001));
+#1015=DIRECTION($,(-1,0,0));
+#1016=VECTOR($,#1015,1);
+#1017=LINE($,#1014,#1016);
+#1018=EDGE_CURVE($,#1011,#1013,#1017,.T.);
+#1019=ORIENTED_EDGE($,$,$,#1018,.T.);
+#1020=CARTESIAN_POINT($,(-233.045,485.44226,1.90746000000001));
+#1021=VERTEX_POINT($,#1020);
+#1022=CARTESIAN_POINT($,(-233.045,440.99226,1.90746000000001));
+#1023=DIRECTION($,(0,1,0));
+#1024=VECTOR($,#1023,1);
+#1025=LINE($,#1022,#1024);
+#1026=EDGE_CURVE($,#1013,#1021,#1025,.T.);
+#1027=ORIENTED_EDGE($,$,$,#1026,.T.);
+#1028=CARTESIAN_POINT($,(-8.255,485.44226,1.90746000000001));
+#1029=VERTEX_POINT($,#1028);
+#1030=CARTESIAN_POINT($,(-233.045,485.44226,1.90746000000001));
+#1031=DIRECTION($,(1,0,0));
+#1032=VECTOR($,#1031,1);
+#1033=LINE($,#1030,#1032);
+#1034=EDGE_CURVE($,#1021,#1029,#1033,.T.);
+#1035=ORIENTED_EDGE($,$,$,#1034,.T.);
+#1036=CARTESIAN_POINT($,(-8.255,485.44226,1.90746000000001));
+#1037=DIRECTION($,(0,-1,0));
+#1038=VECTOR($,#1037,1);
+#1039=LINE($,#1036,#1038);
+#1040=EDGE_CURVE($,#1029,#1011,#1039,.T.);
+#1041=ORIENTED_EDGE($,$,$,#1040,.T.);
+#1042=EDGE_LOOP($,(#1019,#1027,#1035,#1041));
+#1043=FACE_OUTER_BOUND('',#1042,.T.);
+#1044=ADVANCED_FACE('',(#1043),#1009,.T.);
+#1045=CARTESIAN_POINT($,(-8.255,440.99226,0.00246000000001));
+#1046=DIRECTION($,(-0,-0,-1));
+#1047=DIRECTION($,(-1,0,0));
+#1048=AXIS2_PLACEMENT_3D($,#1045,#1046,#1047);
+#1049=PLANE($,#1048);
+#1050=CARTESIAN_POINT($,(-8.255,485.44226,0.00246000000001));
+#1051=VERTEX_POINT($,#1050);
+#1052=CARTESIAN_POINT($,(-233.045,485.44226,0.00246000000001));
+#1053=VERTEX_POINT($,#1052);
+#1054=CARTESIAN_POINT($,(-8.255,485.44226,0.00246000000001));
+#1055=DIRECTION($,(-1,0,0));
+#1056=VECTOR($,#1055,1);
+#1057=LINE($,#1054,#1056);
+#1058=EDGE_CURVE($,#1051,#1053,#1057,.T.);
+#1059=ORIENTED_EDGE($,$,$,#1058,.T.);
+#1060=CARTESIAN_POINT($,(-233.045,440.99226,0.00246000000001));
+#1061=VERTEX_POINT($,#1060);
+#1062=CARTESIAN_POINT($,(-233.045,485.44226,0.00246000000001));
+#1063=DIRECTION($,(0,-1,0));
+#1064=VECTOR($,#1063,1);
+#1065=LINE($,#1062,#1064);
+#1066=EDGE_CURVE($,#1053,#1061,#1065,.T.);
+#1067=ORIENTED_EDGE($,$,$,#1066,.T.);
+#1068=CARTESIAN_POINT($,(-8.255,440.99226,0.00246000000001));
+#1069=VERTEX_POINT($,#1068);
+#1070=CARTESIAN_POINT($,(-233.045,440.99226,0.00246000000001));
+#1071=DIRECTION($,(1,0,0));
+#1072=VECTOR($,#1071,1);
+#1073=LINE($,#1070,#1072);
+#1074=EDGE_CURVE($,#1061,#1069,#1073,.T.);
+#1075=ORIENTED_EDGE($,$,$,#1074,.T.);
+#1076=CARTESIAN_POINT($,(-8.255,440.99226,0.00246000000001));
+#1077=DIRECTION($,(0,1,0));
+#1078=VECTOR($,#1077,1);
+#1079=LINE($,#1076,#1078);
+#1080=EDGE_CURVE($,#1069,#1051,#1079,.T.);
+#1081=ORIENTED_EDGE($,$,$,#1080,.T.);
+#1082=EDGE_LOOP($,(#1059,#1067,#1075,#1081));
+#1083=FACE_OUTER_BOUND('',#1082,.T.);
+#1084=ADVANCED_FACE('',(#1083),#1049,.F.);
+#1085=CARTESIAN_POINT($,(-8.255,440.99226,8.25746000000001));
+#1086=DIRECTION($,(-1,0,0));
+#1087=DIRECTION($,(0,-1,0));
+#1088=AXIS2_PLACEMENT_3D($,#1085,#1086,#1087);
+#1089=CYLINDRICAL_SURFACE($,#1088,6.35000000000002);
+#1090=ORIENTED_EDGE($,$,$,#506,.F.);
+#1091=CARTESIAN_POINT($,(-233.045,440.99226,8.25746000000001));
+#1092=DIRECTION($,(1,-0,-0));
+#1093=DIRECTION($,(0,-1,0));
+#1094=AXIS2_PLACEMENT_3D($,#1091,#1092,#1093);
+#1095=CIRCLE($,#1094,6.35000000000002);
+#1096=TRIMMED_CURVE($,#1095,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(1.5707963267949)),.T.,.PARAMETER.);
+#1097=EDGE_CURVE($,#493,#1013,#1096,.T.);
+#1098=ORIENTED_EDGE($,$,$,#1097,.T.);
+#1099=ORIENTED_EDGE($,$,$,#1018,.F.);
+#1100=CARTESIAN_POINT($,(-8.255,440.99226,8.25746000000001));
+#1101=DIRECTION($,(-1,0,0));
+#1102=DIRECTION($,(0,0,-1));
+#1103=AXIS2_PLACEMENT_3D($,#1100,#1101,#1102);
+#1104=CIRCLE($,#1103,6.35);
+#1105=TRIMMED_CURVE($,#1104,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(1.5707963267949)),.T.,.PARAMETER.);
+#1106=EDGE_CURVE($,#1011,#501,#1105,.T.);
+#1107=ORIENTED_EDGE($,$,$,#1106,.T.);
+#1108=EDGE_LOOP($,(#1090,#1098,#1099,#1107));
+#1109=FACE_OUTER_BOUND('',#1108,.T.);
+#1110=ADVANCED_FACE('',(#1109),#1089,.T.);
+#1111=CARTESIAN_POINT($,(-8.255,440.99226,8.25746000000001));
+#1112=DIRECTION($,(-1,0,0));
+#1113=DIRECTION($,(0,-1,0));
+#1114=AXIS2_PLACEMENT_3D($,#1111,#1112,#1113);
+#1115=CYLINDRICAL_SURFACE($,#1114,8.255);
+#1116=ORIENTED_EDGE($,$,$,#1074,.F.);
+#1117=CARTESIAN_POINT($,(-233.045,440.99226,8.25746000000001));
+#1118=DIRECTION($,(-1,0,0));
+#1119=DIRECTION($,(0,0,-1));
+#1120=AXIS2_PLACEMENT_3D($,#1117,#1118,#1119);
+#1121=CIRCLE($,#1120,8.255);
+#1122=TRIMMED_CURVE($,#1121,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(1.5707963267949)),.T.,.PARAMETER.);
+#1123=EDGE_CURVE($,#1061,#525,#1122,.T.);
+#1124=ORIENTED_EDGE($,$,$,#1123,.T.);
+#1125=ORIENTED_EDGE($,$,$,#530,.F.);
+#1126=CARTESIAN_POINT($,(-8.255,440.99226,8.25746000000001));
+#1127=DIRECTION($,(1,-0,-0));
+#1128=DIRECTION($,(0,-1,0));
+#1129=AXIS2_PLACEMENT_3D($,#1126,#1127,#1128);
+#1130=CIRCLE($,#1129,8.255);
+#1131=TRIMMED_CURVE($,#1130,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(1.5707963267949)),.T.,.PARAMETER.);
+#1132=EDGE_CURVE($,#523,#1069,#1131,.T.);
+#1133=ORIENTED_EDGE($,$,$,#1132,.T.);
+#1134=EDGE_LOOP($,(#1116,#1124,#1125,#1133));
+#1135=FACE_OUTER_BOUND('',#1134,.T.);
+#1136=ADVANCED_FACE('',(#1135),#1115,.F.);
+#1137=CARTESIAN_POINT($,(8.76783352130505,66.34226,119.403106478695));
+#1138=DIRECTION($,(-0.707106781186548,0,0.707106781186548));
+#1139=DIRECTION($,(0,1,0));
+#1140=AXIS2_PLACEMENT_3D($,#1137,#1138,#1139);
+#1141=PLANE($,#1140);
+#1142=CARTESIAN_POINT($,(8.76783352130505,66.34226,119.403106478695));
+#1143=VERTEX_POINT($,#1142);
+#1144=CARTESIAN_POINT($,(8.76783352130505,418.13226,119.403106478695));
+#1145=VERTEX_POINT($,#1144);
+#1146=CARTESIAN_POINT($,(8.76783352130505,66.34226,119.403106478695));
+#1147=DIRECTION($,(0,1,0));
+#1148=VECTOR($,#1147,1);
+#1149=LINE($,#1146,#1148);
+#1150=EDGE_CURVE($,#1143,#1145,#1149,.T.);
+#1151=ORIENTED_EDGE($,$,$,#1150,.T.);
+#1152=CARTESIAN_POINT($,(43.0724119037892,418.13226,153.707684861179));
+#1153=VERTEX_POINT($,#1152);
+#1154=CARTESIAN_POINT($,(8.76783352130505,418.13226,119.403106478695));
+#1155=DIRECTION($,(0.707106781186548,0,0.707106781186548));
+#1156=VECTOR($,#1155,1);
+#1157=LINE($,#1154,#1156);
+#1158=EDGE_CURVE($,#1145,#1153,#1157,.T.);
+#1159=ORIENTED_EDGE($,$,$,#1158,.T.);
+#1160=CARTESIAN_POINT($,(43.0724119037892,66.34226,153.707684861179));
+#1161=VERTEX_POINT($,#1160);
+#1162=CARTESIAN_POINT($,(43.0724119037892,418.13226,153.707684861179));
+#1163=DIRECTION($,(0,-1,0));
+#1164=VECTOR($,#1163,1);
+#1165=LINE($,#1162,#1164);
+#1166=EDGE_CURVE($,#1153,#1161,#1165,.T.);
+#1167=ORIENTED_EDGE($,$,$,#1166,.T.);
+#1168=CARTESIAN_POINT($,(43.0724119037892,66.34226,153.707684861179));
+#1169=DIRECTION($,(-0.707106781186548,0,-0.707106781186548));
+#1170=VECTOR($,#1169,1);
+#1171=LINE($,#1168,#1170);
+#1172=EDGE_CURVE($,#1161,#1143,#1171,.T.);
+#1173=ORIENTED_EDGE($,$,$,#1172,.T.);
+#1174=EDGE_LOOP($,(#1151,#1159,#1167,#1173));
+#1175=FACE_OUTER_BOUND('',#1174,.T.);
+#1176=ADVANCED_FACE('',(#1175),#1141,.T.);
+#1177=CARTESIAN_POINT($,(10.1148719394654,66.34226,118.056068060535));
+#1178=DIRECTION($,(0.707106781186548,-0,-0.707106781186548));
+#1179=DIRECTION($,(0,1,0));
+#1180=AXIS2_PLACEMENT_3D($,#1177,#1178,#1179);
+#1181=PLANE($,#1180);
+#1182=CARTESIAN_POINT($,(44.4194503219496,66.34226,152.360646443019));
+#1183=VERTEX_POINT($,#1182);
+#1184=CARTESIAN_POINT($,(44.4194503219496,418.13226,152.360646443019));
+#1185=VERTEX_POINT($,#1184);
+#1186=CARTESIAN_POINT($,(44.4194503219496,66.34226,152.360646443019));
+#1187=DIRECTION($,(0,1,0));
+#1188=VECTOR($,#1187,1);
+#1189=LINE($,#1186,#1188);
+#1190=EDGE_CURVE($,#1183,#1185,#1189,.T.);
+#1191=ORIENTED_EDGE($,$,$,#1190,.T.);
+#1192=CARTESIAN_POINT($,(10.1148719394654,418.13226,118.056068060535));
+#1193=VERTEX_POINT($,#1192);
+#1194=CARTESIAN_POINT($,(44.4194503219496,418.13226,152.360646443019));
+#1195=DIRECTION($,(-0.707106781186547,0,-0.707106781186548));
+#1196=VECTOR($,#1195,1);
+#1197=LINE($,#1194,#1196);
+#1198=EDGE_CURVE($,#1185,#1193,#1197,.T.);
+#1199=ORIENTED_EDGE($,$,$,#1198,.T.);
+#1200=CARTESIAN_POINT($,(10.1148719394654,66.34226,118.056068060535));
+#1201=VERTEX_POINT($,#1200);
+#1202=CARTESIAN_POINT($,(10.1148719394654,418.13226,118.056068060535));
+#1203=DIRECTION($,(0,-1,0));
+#1204=VECTOR($,#1203,1);
+#1205=LINE($,#1202,#1204);
+#1206=EDGE_CURVE($,#1193,#1201,#1205,.T.);
+#1207=ORIENTED_EDGE($,$,$,#1206,.T.);
+#1208=CARTESIAN_POINT($,(10.1148719394654,66.34226,118.056068060535));
+#1209=DIRECTION($,(0.707106781186547,0,0.707106781186548));
+#1210=VECTOR($,#1209,1);
+#1211=LINE($,#1208,#1210);
+#1212=EDGE_CURVE($,#1201,#1183,#1211,.T.);
+#1213=ORIENTED_EDGE($,$,$,#1212,.T.);
+#1214=EDGE_LOOP($,(#1191,#1199,#1207,#1213));
+#1215=FACE_OUTER_BOUND('',#1214,.T.);
+#1216=ADVANCED_FACE('',(#1215),#1181,.F.);
+#1217=CARTESIAN_POINT($,(14.605,66.34226,113.56594));
+#1218=DIRECTION($,(0,1,0));
+#1219=DIRECTION($,(-1,0,0));
+#1220=AXIS2_PLACEMENT_3D($,#1217,#1218,#1219);
+#1221=CYLINDRICAL_SURFACE($,#1220,8.255);
+#1222=ORIENTED_EDGE($,$,$,#770,.F.);
+#1223=CARTESIAN_POINT($,(14.605,418.13226,113.56594));
+#1224=DIRECTION($,(0,1,0));
+#1225=DIRECTION($,(-1,0,0));
+#1226=AXIS2_PLACEMENT_3D($,#1223,#1224,#1225);
+#1227=CIRCLE($,#1226,8.255);
+#1228=TRIMMED_CURVE($,#1227,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(0.785398163397449)),.T.,.PARAMETER.);
+#1229=EDGE_CURVE($,#757,#1145,#1228,.T.);
+#1230=ORIENTED_EDGE($,$,$,#1229,.T.);
+#1231=ORIENTED_EDGE($,$,$,#1150,.F.);
+#1232=CARTESIAN_POINT($,(14.605,66.34226,113.56594));
+#1233=DIRECTION($,(-0,-1,-0));
+#1234=DIRECTION($,(-0.707106781186547,0,0.707106781186548));
+#1235=AXIS2_PLACEMENT_3D($,#1232,#1233,#1234);
+#1236=CIRCLE($,#1235,8.255);
+#1237=TRIMMED_CURVE($,#1236,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(0.785398163397449)),.T.,.PARAMETER.);
+#1238=EDGE_CURVE($,#1143,#765,#1237,.T.);
+#1239=ORIENTED_EDGE($,$,$,#1238,.T.);
+#1240=EDGE_LOOP($,(#1222,#1230,#1231,#1239));
+#1241=FACE_OUTER_BOUND('',#1240,.T.);
+#1242=ADVANCED_FACE('',(#1241),#1221,.T.);
+#1243=CARTESIAN_POINT($,(14.605,66.34226,113.56594));
+#1244=DIRECTION($,(0,1,0));
+#1245=DIRECTION($,(-1,0,0));
+#1246=AXIS2_PLACEMENT_3D($,#1243,#1244,#1245);
+#1247=CYLINDRICAL_SURFACE($,#1246,6.35);
+#1248=ORIENTED_EDGE($,$,$,#1206,.F.);
+#1249=CARTESIAN_POINT($,(14.605,418.13226,113.56594));
+#1250=DIRECTION($,(-0,-1,-0));
+#1251=DIRECTION($,(-0.707106781186547,0,0.707106781186548));
+#1252=AXIS2_PLACEMENT_3D($,#1249,#1250,#1251);
+#1253=CIRCLE($,#1252,6.35000000000001);
+#1254=TRIMMED_CURVE($,#1253,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(0.78539816339745)),.T.,.PARAMETER.);
+#1255=EDGE_CURVE($,#1193,#789,#1254,.T.);
+#1256=ORIENTED_EDGE($,$,$,#1255,.T.);
+#1257=ORIENTED_EDGE($,$,$,#794,.F.);
+#1258=CARTESIAN_POINT($,(14.605,66.34226,113.56594));
+#1259=DIRECTION($,(0,1,0));
+#1260=DIRECTION($,(-1,0,0));
+#1261=AXIS2_PLACEMENT_3D($,#1258,#1259,#1260);
+#1262=CIRCLE($,#1261,6.35);
+#1263=TRIMMED_CURVE($,#1262,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(0.78539816339745)),.T.,.PARAMETER.);
+#1264=EDGE_CURVE($,#787,#1201,#1263,.T.);
+#1265=ORIENTED_EDGE($,$,$,#1264,.T.);
+#1266=EDGE_LOOP($,(#1248,#1256,#1257,#1265));
+#1267=FACE_OUTER_BOUND('',#1266,.T.);
+#1268=ADVANCED_FACE('',(#1267),#1247,.F.);
+#1269=CARTESIAN_POINT($,(-241.3,58.08726,78.105));
+#1270=DIRECTION($,(-0,1,0));
+#1271=DIRECTION($,(1,0,0));
+#1272=AXIS2_PLACEMENT_3D($,#1269,#1270,#1271);
+#1273=PLANE($,#1272);
+#1274=ORIENTED_EDGE($,$,$,#14,.T.);
+#1275=CARTESIAN_POINT($,(-233.045,58.08726,78.105));
+#1276=DIRECTION($,(0,0,-1));
+#1277=VECTOR($,#1276,1);
+#1278=LINE($,#1275,#1277);
+#1279=EDGE_CURVE($,#9,#253,#1278,.T.);
+#1280=ORIENTED_EDGE($,$,$,#1279,.T.);
+#1281=ORIENTED_EDGE($,$,$,#266,.T.);
+#1282=CARTESIAN_POINT($,(-241.3,58.08726,76.2));
+#1283=DIRECTION($,(0,0,1));
+#1284=VECTOR($,#1283,1);
+#1285=LINE($,#1282,#1284);
+#1286=EDGE_CURVE($,#261,#7,#1285,.T.);
+#1287=ORIENTED_EDGE($,$,$,#1286,.T.);
+#1288=EDGE_LOOP($,(#1274,#1280,#1281,#1287));
+#1289=FACE_OUTER_BOUND('',#1288,.T.);
+#1290=ADVANCED_FACE('',(#1289),#1273,.T.);
+#1291=CARTESIAN_POINT($,(-8.255,58.08726,78.105));
+#1292=DIRECTION($,(-0,1,0));
+#1293=DIRECTION($,(1,0,0));
+#1294=AXIS2_PLACEMENT_3D($,#1291,#1292,#1293);
+#1295=PLANE($,#1294);
+#1296=ORIENTED_EDGE($,$,$,#30,.T.);
+#1297=CARTESIAN_POINT($,(0,58.08726,78.105));
+#1298=DIRECTION($,(0,0,-1));
+#1299=VECTOR($,#1298,1);
+#1300=LINE($,#1297,#1299);
+#1301=EDGE_CURVE($,#25,#237,#1300,.T.);
+#1302=ORIENTED_EDGE($,$,$,#1301,.T.);
+#1303=ORIENTED_EDGE($,$,$,#250,.T.);
+#1304=CARTESIAN_POINT($,(-8.255,58.08726,76.2));
+#1305=DIRECTION($,(0,0,1));
+#1306=VECTOR($,#1305,1);
+#1307=LINE($,#1304,#1306);
+#1308=EDGE_CURVE($,#245,#17,#1307,.T.);
+#1309=ORIENTED_EDGE($,$,$,#1308,.T.);
+#1310=EDGE_LOOP($,(#1296,#1302,#1303,#1309));
+#1311=FACE_OUTER_BOUND('',#1310,.T.);
+#1312=ADVANCED_FACE('',(#1311),#1295,.T.);
+#1313=CARTESIAN_POINT($,(0,58.08726,78.105));
+#1314=DIRECTION($,(-1,0,0));
+#1315=DIRECTION($,(0,1,0));
+#1316=AXIS2_PLACEMENT_3D($,#1313,#1314,#1315);
+#1317=PLANE($,#1316);
+#1318=ORIENTED_EDGE($,$,$,#38,.T.);
+#1319=CARTESIAN_POINT($,(0,66.34226,78.105));
+#1320=DIRECTION($,(0,0,-1));
+#1321=VECTOR($,#1320,1);
+#1322=LINE($,#1319,#1321);
+#1323=EDGE_CURVE($,#33,#229,#1322,.T.);
+#1324=ORIENTED_EDGE($,$,$,#1323,.T.);
+#1325=ORIENTED_EDGE($,$,$,#242,.T.);
+#1326=ORIENTED_EDGE($,$,$,#1301,.F.);
+#1327=EDGE_LOOP($,(#1318,#1324,#1325,#1326));
+#1328=FACE_OUTER_BOUND('',#1327,.T.);
+#1329=ADVANCED_FACE('',(#1328),#1317,.T.);
+#1330=CARTESIAN_POINT($,(0,418.13226,78.105));
+#1331=DIRECTION($,(-1,0,0));
+#1332=DIRECTION($,(0,1,0));
+#1333=AXIS2_PLACEMENT_3D($,#1330,#1331,#1332);
+#1334=PLANE($,#1333);
+#1335=ORIENTED_EDGE($,$,$,#54,.T.);
+#1336=CARTESIAN_POINT($,(0,426.38726,78.105));
+#1337=DIRECTION($,(0,0,-1));
+#1338=VECTOR($,#1337,1);
+#1339=LINE($,#1336,#1338);
+#1340=EDGE_CURVE($,#49,#213,#1339,.T.);
+#1341=ORIENTED_EDGE($,$,$,#1340,.T.);
+#1342=ORIENTED_EDGE($,$,$,#226,.T.);
+#1343=CARTESIAN_POINT($,(0,418.13226,76.2));
+#1344=DIRECTION($,(0,0,1));
+#1345=VECTOR($,#1344,1);
+#1346=LINE($,#1343,#1345);
+#1347=EDGE_CURVE($,#221,#41,#1346,.T.);
+#1348=ORIENTED_EDGE($,$,$,#1347,.T.);
+#1349=EDGE_LOOP($,(#1335,#1341,#1342,#1348));
+#1350=FACE_OUTER_BOUND('',#1349,.T.);
+#1351=ADVANCED_FACE('',(#1350),#1334,.T.);
+#1352=CARTESIAN_POINT($,(0,426.38726,78.105));
+#1353=DIRECTION($,(-0,-1,-0));
+#1354=DIRECTION($,(-1,0,0));
+#1355=AXIS2_PLACEMENT_3D($,#1352,#1353,#1354);
+#1356=PLANE($,#1355);
+#1357=ORIENTED_EDGE($,$,$,#62,.T.);
+#1358=CARTESIAN_POINT($,(-8.255,426.38726,78.105));
+#1359=DIRECTION($,(0,0,-1));
+#1360=VECTOR($,#1359,1);
+#1361=LINE($,#1358,#1360);
+#1362=EDGE_CURVE($,#57,#205,#1361,.T.);
+#1363=ORIENTED_EDGE($,$,$,#1362,.T.);
+#1364=ORIENTED_EDGE($,$,$,#218,.T.);
+#1365=ORIENTED_EDGE($,$,$,#1340,.F.);
+#1366=EDGE_LOOP($,(#1357,#1363,#1364,#1365));
+#1367=FACE_OUTER_BOUND('',#1366,.T.);
+#1368=ADVANCED_FACE('',(#1367),#1356,.T.);
+#1369=CARTESIAN_POINT($,(-233.045,426.38726,78.105));
+#1370=DIRECTION($,(-0,-1,-0));
+#1371=DIRECTION($,(-1,0,0));
+#1372=AXIS2_PLACEMENT_3D($,#1369,#1370,#1371);
+#1373=PLANE($,#1372);
+#1374=ORIENTED_EDGE($,$,$,#78,.T.);
+#1375=CARTESIAN_POINT($,(-241.3,426.38726,78.105));
+#1376=DIRECTION($,(0,0,-1));
+#1377=VECTOR($,#1376,1);
+#1378=LINE($,#1375,#1377);
+#1379=EDGE_CURVE($,#73,#189,#1378,.T.);
+#1380=ORIENTED_EDGE($,$,$,#1379,.T.);
+#1381=ORIENTED_EDGE($,$,$,#202,.T.);
+#1382=CARTESIAN_POINT($,(-233.045,426.38726,76.2));
+#1383=DIRECTION($,(0,0,1));
+#1384=VECTOR($,#1383,1);
+#1385=LINE($,#1382,#1384);
+#1386=EDGE_CURVE($,#197,#65,#1385,.T.);
+#1387=ORIENTED_EDGE($,$,$,#1386,.T.);
+#1388=EDGE_LOOP($,(#1374,#1380,#1381,#1387));
+#1389=FACE_OUTER_BOUND('',#1388,.T.);
+#1390=ADVANCED_FACE('',(#1389),#1373,.T.);
+#1391=CARTESIAN_POINT($,(-241.3,426.38726,78.105));
+#1392=DIRECTION($,(1,0,0));
+#1393=DIRECTION($,(0,-1,0));
+#1394=AXIS2_PLACEMENT_3D($,#1391,#1392,#1393);
+#1395=PLANE($,#1394);
+#1396=ORIENTED_EDGE($,$,$,#86,.T.);
+#1397=CARTESIAN_POINT($,(-241.3,418.13226,78.105));
+#1398=DIRECTION($,(0,0,-1));
+#1399=VECTOR($,#1398,1);
+#1400=LINE($,#1397,#1399);
+#1401=EDGE_CURVE($,#81,#181,#1400,.T.);
+#1402=ORIENTED_EDGE($,$,$,#1401,.T.);
+#1403=ORIENTED_EDGE($,$,$,#194,.T.);
+#1404=ORIENTED_EDGE($,$,$,#1379,.F.);
+#1405=EDGE_LOOP($,(#1396,#1402,#1403,#1404));
+#1406=FACE_OUTER_BOUND('',#1405,.T.);
+#1407=ADVANCED_FACE('',(#1406),#1395,.T.);
+#1408=CARTESIAN_POINT($,(-241.3,66.34226,78.105));
+#1409=DIRECTION($,(1,0,0));
+#1410=DIRECTION($,(0,-1,0));
+#1411=AXIS2_PLACEMENT_3D($,#1408,#1409,#1410);
+#1412=PLANE($,#1411);
+#1413=ORIENTED_EDGE($,$,$,#100,.T.);
+#1414=ORIENTED_EDGE($,$,$,#1286,.F.);
+#1415=ORIENTED_EDGE($,$,$,#272,.T.);
+#1416=CARTESIAN_POINT($,(-241.3,66.34226,76.2));
+#1417=DIRECTION($,(0,0,1));
+#1418=VECTOR($,#1417,1);
+#1419=LINE($,#1416,#1418);
+#1420=EDGE_CURVE($,#179,#89,#1419,.T.);
+#1421=ORIENTED_EDGE($,$,$,#1420,.T.);
+#1422=EDGE_LOOP($,(#1413,#1414,#1415,#1421));
+#1423=FACE_OUTER_BOUND('',#1422,.T.);
+#1424=ADVANCED_FACE('',(#1423),#1412,.T.);
+#1425=CARTESIAN_POINT($,(-8.255,49.83226,69.85));
+#1426=DIRECTION($,(1,-0,0));
+#1427=DIRECTION($,(0,-0,-1));
+#1428=AXIS2_PLACEMENT_3D($,#1425,#1426,#1427);
+#1429=PLANE($,#1428);
+#1430=ORIENTED_EDGE($,$,$,#366,.T.);
+#1431=CARTESIAN_POINT($,(-8.255,49.83226,8.25746000000001));
+#1432=DIRECTION($,(0,1,0));
+#1433=VECTOR($,#1432,1);
+#1434=LINE($,#1431,#1433);
+#1435=EDGE_CURVE($,#361,#393,#1434,.T.);
+#1436=ORIENTED_EDGE($,$,$,#1435,.T.);
+#1437=ORIENTED_EDGE($,$,$,#406,.T.);
+#1438=CARTESIAN_POINT($,(-8.255,51.73726,69.85));
+#1439=DIRECTION($,(0,-1,0));
+#1440=VECTOR($,#1439,1);
+#1441=LINE($,#1438,#1440);
+#1442=EDGE_CURVE($,#401,#353,#1441,.T.);
+#1443=ORIENTED_EDGE($,$,$,#1442,.T.);
+#1444=EDGE_LOOP($,(#1430,#1436,#1437,#1443));
+#1445=FACE_OUTER_BOUND('',#1444,.T.);
+#1446=ADVANCED_FACE('',(#1445),#1429,.T.);
+#1447=CARTESIAN_POINT($,(-233.045,49.83226,8.25746000000001));
+#1448=DIRECTION($,(-1,0,0));
+#1449=DIRECTION($,(0,0,1));
+#1450=AXIS2_PLACEMENT_3D($,#1447,#1448,#1449);
+#1451=PLANE($,#1450);
+#1452=ORIENTED_EDGE($,$,$,#380,.T.);
+#1453=CARTESIAN_POINT($,(-233.045,49.83226,69.85));
+#1454=DIRECTION($,(0,1,0));
+#1455=VECTOR($,#1454,1);
+#1456=LINE($,#1453,#1455);
+#1457=EDGE_CURVE($,#351,#409,#1456,.T.);
+#1458=ORIENTED_EDGE($,$,$,#1457,.T.);
+#1459=ORIENTED_EDGE($,$,$,#420,.T.);
+#1460=CARTESIAN_POINT($,(-233.045,51.73726,8.25746000000001));
+#1461=DIRECTION($,(0,-1,0));
+#1462=VECTOR($,#1461,1);
+#1463=LINE($,#1460,#1462);
+#1464=EDGE_CURVE($,#391,#369,#1463,.T.);
+#1465=ORIENTED_EDGE($,$,$,#1464,.T.);
+#1466=EDGE_LOOP($,(#1452,#1458,#1459,#1465));
+#1467=FACE_OUTER_BOUND('',#1466,.T.);
+#1468=ADVANCED_FACE('',(#1467),#1451,.T.);
+#1469=CARTESIAN_POINT($,(-8.255,58.08726,78.105));
+#1470=DIRECTION($,(1,0,0));
+#1471=DIRECTION($,(0,-0.707106781186548,-0.707106781186547));
+#1472=AXIS2_PLACEMENT_3D($,#1469,#1470,#1471);
+#1473=PLANE($,#1472);
+#1474=ORIENTED_EDGE($,$,$,#437,.T.);
+#1475=ORIENTED_EDGE($,$,$,#1442,.F.);
+#1476=ORIENTED_EDGE($,$,$,#463,.T.);
+#1477=ORIENTED_EDGE($,$,$,#1308,.T.);
+#1478=EDGE_LOOP($,(#1474,#1475,#1476,#1477));
+#1479=FACE_OUTER_BOUND('',#1478,.T.);
+#1480=ADVANCED_FACE('',(#1479),#1473,.T.);
+#1481=CARTESIAN_POINT($,(-233.045,49.83226,69.85));
+#1482=DIRECTION($,(-1,0,0));
+#1483=DIRECTION($,(0,0.707106781186548,0.707106781186547));
+#1484=AXIS2_PLACEMENT_3D($,#1481,#1482,#1483);
+#1485=PLANE($,#1484);
+#1486=ORIENTED_EDGE($,$,$,#446,.T.);
+#1487=ORIENTED_EDGE($,$,$,#1279,.T.);
+#1488=ORIENTED_EDGE($,$,$,#472,.T.);
+#1489=ORIENTED_EDGE($,$,$,#1457,.F.);
+#1490=EDGE_LOOP($,(#1486,#1487,#1488,#1489));
+#1491=FACE_OUTER_BOUND('',#1490,.T.);
+#1492=ADVANCED_FACE('',(#1491),#1485,.T.);
+#1493=CARTESIAN_POINT($,(-233.045,434.64226,69.85));
+#1494=DIRECTION($,(-1,-0,-0));
+#1495=DIRECTION($,(0,0,-1));
+#1496=AXIS2_PLACEMENT_3D($,#1493,#1494,#1495);
+#1497=PLANE($,#1496);
+#1498=ORIENTED_EDGE($,$,$,#498,.T.);
+#1499=CARTESIAN_POINT($,(-233.045,434.64226,8.25746000000001));
+#1500=DIRECTION($,(0,-1,0));
+#1501=VECTOR($,#1500,1);
+#1502=LINE($,#1499,#1501);
+#1503=EDGE_CURVE($,#493,#525,#1502,.T.);
+#1504=ORIENTED_EDGE($,$,$,#1503,.T.);
+#1505=ORIENTED_EDGE($,$,$,#538,.T.);
+#1506=CARTESIAN_POINT($,(-233.045,432.73726,69.85));
+#1507=DIRECTION($,(0,1,0));
+#1508=VECTOR($,#1507,1);
+#1509=LINE($,#1506,#1508);
+#1510=EDGE_CURVE($,#533,#485,#1509,.T.);
+#1511=ORIENTED_EDGE($,$,$,#1510,.T.);
+#1512=EDGE_LOOP($,(#1498,#1504,#1505,#1511));
+#1513=FACE_OUTER_BOUND('',#1512,.T.);
+#1514=ADVANCED_FACE('',(#1513),#1497,.T.);
+#1515=CARTESIAN_POINT($,(-8.255,434.64226,8.25746000000001));
+#1516=DIRECTION($,(1,0,-0));
+#1517=DIRECTION($,(0,0,1));
+#1518=AXIS2_PLACEMENT_3D($,#1515,#1516,#1517);
+#1519=PLANE($,#1518);
+#1520=ORIENTED_EDGE($,$,$,#512,.T.);
+#1521=CARTESIAN_POINT($,(-8.255,434.64226,69.85));
+#1522=DIRECTION($,(0,-1,0));
+#1523=VECTOR($,#1522,1);
+#1524=LINE($,#1521,#1523);
+#1525=EDGE_CURVE($,#483,#541,#1524,.T.);
+#1526=ORIENTED_EDGE($,$,$,#1525,.T.);
+#1527=ORIENTED_EDGE($,$,$,#552,.T.);
+#1528=CARTESIAN_POINT($,(-8.255,432.73726,8.25746000000001));
+#1529=DIRECTION($,(0,1,0));
+#1530=VECTOR($,#1529,1);
+#1531=LINE($,#1528,#1530);
+#1532=EDGE_CURVE($,#523,#501,#1531,.T.);
+#1533=ORIENTED_EDGE($,$,$,#1532,.T.);
+#1534=EDGE_LOOP($,(#1520,#1526,#1527,#1533));
+#1535=FACE_OUTER_BOUND('',#1534,.T.);
+#1536=ADVANCED_FACE('',(#1535),#1519,.T.);
+#1537=CARTESIAN_POINT($,(-233.045,426.38726,78.105));
+#1538=DIRECTION($,(-1,0,0));
+#1539=DIRECTION($,(0,0.707106781186548,-0.707106781186548));
+#1540=AXIS2_PLACEMENT_3D($,#1537,#1538,#1539);
+#1541=PLANE($,#1540);
+#1542=ORIENTED_EDGE($,$,$,#569,.T.);
+#1543=ORIENTED_EDGE($,$,$,#1510,.F.);
+#1544=ORIENTED_EDGE($,$,$,#595,.T.);
+#1545=ORIENTED_EDGE($,$,$,#1386,.T.);
+#1546=EDGE_LOOP($,(#1542,#1543,#1544,#1545));
+#1547=FACE_OUTER_BOUND('',#1546,.T.);
+#1548=ADVANCED_FACE('',(#1547),#1541,.T.);
+#1549=CARTESIAN_POINT($,(-8.255,434.64226,69.85));
+#1550=DIRECTION($,(1,0,0));
+#1551=DIRECTION($,(0,-0.707106781186548,0.707106781186548));
+#1552=AXIS2_PLACEMENT_3D($,#1549,#1550,#1551);
+#1553=PLANE($,#1552);
+#1554=ORIENTED_EDGE($,$,$,#578,.T.);
+#1555=ORIENTED_EDGE($,$,$,#1362,.T.);
+#1556=ORIENTED_EDGE($,$,$,#604,.T.);
+#1557=ORIENTED_EDGE($,$,$,#1525,.F.);
+#1558=EDGE_LOOP($,(#1554,#1555,#1556,#1557));
+#1559=FACE_OUTER_BOUND('',#1558,.T.);
+#1560=ADVANCED_FACE('',(#1559),#1553,.T.);
+#1561=CARTESIAN_POINT($,(-247.65,66.34226,84.455));
+#1562=DIRECTION($,(0,-1,0));
+#1563=DIRECTION($,(0,0,1));
+#1564=AXIS2_PLACEMENT_3D($,#1561,#1562,#1563);
+#1565=PLANE($,#1564);
+#1566=ORIENTED_EDGE($,$,$,#630,.T.);
+#1567=CARTESIAN_POINT($,(-247.65,66.34226,128.905));
+#1568=DIRECTION($,(-1,0,0));
+#1569=VECTOR($,#1568,1);
+#1570=LINE($,#1567,#1569);
+#1571=EDGE_CURVE($,#625,#657,#1570,.T.);
+#1572=ORIENTED_EDGE($,$,$,#1571,.T.);
+#1573=ORIENTED_EDGE($,$,$,#670,.T.);
+#1574=CARTESIAN_POINT($,(-249.555,66.34226,84.455));
+#1575=DIRECTION($,(1,0,0));
+#1576=VECTOR($,#1575,1);
+#1577=LINE($,#1574,#1576);
+#1578=EDGE_CURVE($,#665,#617,#1577,.T.);
+#1579=ORIENTED_EDGE($,$,$,#1578,.T.);
+#1580=EDGE_LOOP($,(#1566,#1572,#1573,#1579));
+#1581=FACE_OUTER_BOUND('',#1580,.T.);
+#1582=ADVANCED_FACE('',(#1581),#1565,.T.);
+#1583=CARTESIAN_POINT($,(-247.65,66.34226,128.905));
+#1584=DIRECTION($,(0,-0,1));
+#1585=DIRECTION($,(0,1,0));
+#1586=AXIS2_PLACEMENT_3D($,#1583,#1584,#1585);
+#1587=PLANE($,#1586);
+#1588=ORIENTED_EDGE($,$,$,#638,.T.);
+#1589=CARTESIAN_POINT($,(-247.65,418.13226,128.905));
+#1590=DIRECTION($,(-1,0,0));
+#1591=VECTOR($,#1590,1);
+#1592=LINE($,#1589,#1591);
+#1593=EDGE_CURVE($,#633,#655,#1592,.T.);
+#1594=ORIENTED_EDGE($,$,$,#1593,.T.);
+#1595=ORIENTED_EDGE($,$,$,#662,.T.);
+#1596=ORIENTED_EDGE($,$,$,#1571,.F.);
+#1597=EDGE_LOOP($,(#1588,#1594,#1595,#1596));
+#1598=FACE_OUTER_BOUND('',#1597,.T.);
+#1599=ADVANCED_FACE('',(#1598),#1587,.T.);
+#1600=CARTESIAN_POINT($,(-247.65,418.13226,128.905));
+#1601=DIRECTION($,(0,1,0));
+#1602=DIRECTION($,(0,0,-1));
+#1603=AXIS2_PLACEMENT_3D($,#1600,#1601,#1602);
+#1604=PLANE($,#1603);
+#1605=ORIENTED_EDGE($,$,$,#644,.T.);
+#1606=CARTESIAN_POINT($,(-247.65,418.13226,84.455));
+#1607=DIRECTION($,(-1,0,0));
+#1608=VECTOR($,#1607,1);
+#1609=LINE($,#1606,#1608);
+#1610=EDGE_CURVE($,#615,#673,#1609,.T.);
+#1611=ORIENTED_EDGE($,$,$,#1610,.T.);
+#1612=ORIENTED_EDGE($,$,$,#684,.T.);
+#1613=ORIENTED_EDGE($,$,$,#1593,.F.);
+#1614=EDGE_LOOP($,(#1605,#1611,#1612,#1613));
+#1615=FACE_OUTER_BOUND('',#1614,.T.);
+#1616=ADVANCED_FACE('',(#1615),#1604,.T.);
+#1617=CARTESIAN_POINT($,(-241.3,66.34226,78.105));
+#1618=DIRECTION($,(-0,-1,-0));
+#1619=DIRECTION($,(-0.707106781186549,0,0.707106781186546));
+#1620=AXIS2_PLACEMENT_3D($,#1617,#1618,#1619);
+#1621=PLANE($,#1620);
+#1622=ORIENTED_EDGE($,$,$,#701,.T.);
+#1623=ORIENTED_EDGE($,$,$,#1578,.F.);
+#1624=ORIENTED_EDGE($,$,$,#727,.T.);
+#1625=ORIENTED_EDGE($,$,$,#1420,.T.);
+#1626=EDGE_LOOP($,(#1622,#1623,#1624,#1625));
+#1627=FACE_OUTER_BOUND('',#1626,.T.);
+#1628=ADVANCED_FACE('',(#1627),#1621,.T.);
+#1629=CARTESIAN_POINT($,(-247.65,418.13226,84.455));
+#1630=DIRECTION($,(0,1,0));
+#1631=DIRECTION($,(0.707106781186549,0,-0.707106781186546));
+#1632=AXIS2_PLACEMENT_3D($,#1629,#1630,#1631);
+#1633=PLANE($,#1632);
+#1634=ORIENTED_EDGE($,$,$,#710,.T.);
+#1635=ORIENTED_EDGE($,$,$,#1401,.T.);
+#1636=ORIENTED_EDGE($,$,$,#736,.T.);
+#1637=ORIENTED_EDGE($,$,$,#1610,.F.);
+#1638=EDGE_LOOP($,(#1634,#1635,#1636,#1637));
+#1639=FACE_OUTER_BOUND('',#1638,.T.);
+#1640=ADVANCED_FACE('',(#1639),#1633,.T.);
+#1641=CARTESIAN_POINT($,(6.35,418.13226,84.455));
+#1642=DIRECTION($,(0,1,0));
+#1643=DIRECTION($,(0,0,1));
+#1644=AXIS2_PLACEMENT_3D($,#1641,#1642,#1643);
+#1645=PLANE($,#1644);
+#1646=ORIENTED_EDGE($,$,$,#762,.T.);
+#1647=CARTESIAN_POINT($,(6.35,418.13226,113.56594));
+#1648=DIRECTION($,(1,0,0));
+#1649=VECTOR($,#1648,1);
+#1650=LINE($,#1647,#1649);
+#1651=EDGE_CURVE($,#757,#789,#1650,.T.);
+#1652=ORIENTED_EDGE($,$,$,#1651,.T.);
+#1653=ORIENTED_EDGE($,$,$,#802,.T.);
+#1654=CARTESIAN_POINT($,(8.255,418.13226,84.455));
+#1655=DIRECTION($,(-1,0,0));
+#1656=VECTOR($,#1655,1);
+#1657=LINE($,#1654,#1656);
+#1658=EDGE_CURVE($,#797,#749,#1657,.T.);
+#1659=ORIENTED_EDGE($,$,$,#1658,.T.);
+#1660=EDGE_LOOP($,(#1646,#1652,#1653,#1659));
+#1661=FACE_OUTER_BOUND('',#1660,.T.);
+#1662=ADVANCED_FACE('',(#1661),#1645,.T.);
+#1663=CARTESIAN_POINT($,(6.35,66.34226,113.56594));
+#1664=DIRECTION($,(0,-1,-0));
+#1665=DIRECTION($,(-0,0,-1));
+#1666=AXIS2_PLACEMENT_3D($,#1663,#1664,#1665);
+#1667=PLANE($,#1666);
+#1668=ORIENTED_EDGE($,$,$,#776,.T.);
+#1669=CARTESIAN_POINT($,(6.35,66.34226,84.455));
+#1670=DIRECTION($,(1,0,0));
+#1671=VECTOR($,#1670,1);
+#1672=LINE($,#1669,#1671);
+#1673=EDGE_CURVE($,#747,#805,#1672,.T.);
+#1674=ORIENTED_EDGE($,$,$,#1673,.T.);
+#1675=ORIENTED_EDGE($,$,$,#816,.T.);
+#1676=CARTESIAN_POINT($,(8.255,66.34226,113.56594));
+#1677=DIRECTION($,(-1,0,0));
+#1678=VECTOR($,#1677,1);
+#1679=LINE($,#1676,#1678);
+#1680=EDGE_CURVE($,#787,#765,#1679,.T.);
+#1681=ORIENTED_EDGE($,$,$,#1680,.T.);
+#1682=EDGE_LOOP($,(#1668,#1674,#1675,#1681));
+#1683=FACE_OUTER_BOUND('',#1682,.T.);
+#1684=ADVANCED_FACE('',(#1683),#1667,.T.);
+#1685=CARTESIAN_POINT($,(0,418.13226,78.105));
+#1686=DIRECTION($,(-0,1,0));
+#1687=DIRECTION($,(0.707106781186548,0,0.707106781186547));
+#1688=AXIS2_PLACEMENT_3D($,#1685,#1686,#1687);
+#1689=PLANE($,#1688);
+#1690=ORIENTED_EDGE($,$,$,#833,.T.);
+#1691=ORIENTED_EDGE($,$,$,#1658,.F.);
+#1692=ORIENTED_EDGE($,$,$,#859,.T.);
+#1693=ORIENTED_EDGE($,$,$,#1347,.T.);
+#1694=EDGE_LOOP($,(#1690,#1691,#1692,#1693));
+#1695=FACE_OUTER_BOUND('',#1694,.T.);
+#1696=ADVANCED_FACE('',(#1695),#1689,.T.);
+#1697=CARTESIAN_POINT($,(6.35,66.34226,84.455));
+#1698=DIRECTION($,(0,-1,-0));
+#1699=DIRECTION($,(-0.707106781186548,0,-0.707106781186547));
+#1700=AXIS2_PLACEMENT_3D($,#1697,#1698,#1699);
+#1701=PLANE($,#1700);
+#1702=ORIENTED_EDGE($,$,$,#842,.T.);
+#1703=ORIENTED_EDGE($,$,$,#1323,.T.);
+#1704=ORIENTED_EDGE($,$,$,#868,.T.);
+#1705=ORIENTED_EDGE($,$,$,#1673,.F.);
+#1706=EDGE_LOOP($,(#1702,#1703,#1704,#1705));
+#1707=FACE_OUTER_BOUND('',#1706,.T.);
+#1708=ADVANCED_FACE('',(#1707),#1701,.T.);
+#1709=CARTESIAN_POINT($,(-8.255,43.48226,1.90746000000001));
+#1710=DIRECTION($,(1,0,0));
+#1711=DIRECTION($,(0,-1,0));
+#1712=AXIS2_PLACEMENT_3D($,#1709,#1710,#1711);
+#1713=PLANE($,#1712);
+#1714=ORIENTED_EDGE($,$,$,#894,.T.);
+#1715=CARTESIAN_POINT($,(-8.255,12.70254,1.90746000000001));
+#1716=DIRECTION($,(0,0,-1));
+#1717=VECTOR($,#1716,1);
+#1718=LINE($,#1715,#1717);
+#1719=EDGE_CURVE($,#889,#921,#1718,.T.);
+#1720=ORIENTED_EDGE($,$,$,#1719,.T.);
+#1721=ORIENTED_EDGE($,$,$,#934,.T.);
+#1722=CARTESIAN_POINT($,(-8.255,43.48226,0.00246000000001));
+#1723=DIRECTION($,(0,0,1));
+#1724=VECTOR($,#1723,1);
+#1725=LINE($,#1722,#1724);
+#1726=EDGE_CURVE($,#929,#881,#1725,.T.);
+#1727=ORIENTED_EDGE($,$,$,#1726,.T.);
+#1728=EDGE_LOOP($,(#1714,#1720,#1721,#1727));
+#1729=FACE_OUTER_BOUND('',#1728,.T.);
+#1730=ADVANCED_FACE('',(#1729),#1713,.T.);
+#1731=CARTESIAN_POINT($,(-8.255,12.70254,1.90746000000001));
+#1732=DIRECTION($,(-0,-1,-0));
+#1733=DIRECTION($,(-1,0,0));
+#1734=AXIS2_PLACEMENT_3D($,#1731,#1732,#1733);
+#1735=PLANE($,#1734);
+#1736=ORIENTED_EDGE($,$,$,#902,.T.);
+#1737=CARTESIAN_POINT($,(-233.045,12.70254,1.90746000000001));
+#1738=DIRECTION($,(0,0,-1));
+#1739=VECTOR($,#1738,1);
+#1740=LINE($,#1737,#1739);
+#1741=EDGE_CURVE($,#897,#919,#1740,.T.);
+#1742=ORIENTED_EDGE($,$,$,#1741,.T.);
+#1743=ORIENTED_EDGE($,$,$,#926,.T.);
+#1744=ORIENTED_EDGE($,$,$,#1719,.F.);
+#1745=EDGE_LOOP($,(#1736,#1742,#1743,#1744));
+#1746=FACE_OUTER_BOUND('',#1745,.T.);
+#1747=ADVANCED_FACE('',(#1746),#1735,.T.);
+#1748=CARTESIAN_POINT($,(-233.045,12.70254,1.90746000000001));
+#1749=DIRECTION($,(-1,0,0));
+#1750=DIRECTION($,(0,1,0));
+#1751=AXIS2_PLACEMENT_3D($,#1748,#1749,#1750);
+#1752=PLANE($,#1751);
+#1753=ORIENTED_EDGE($,$,$,#908,.T.);
+#1754=CARTESIAN_POINT($,(-233.045,43.48226,1.90746000000001));
+#1755=DIRECTION($,(0,0,-1));
+#1756=VECTOR($,#1755,1);
+#1757=LINE($,#1754,#1756);
+#1758=EDGE_CURVE($,#879,#937,#1757,.T.);
+#1759=ORIENTED_EDGE($,$,$,#1758,.T.);
+#1760=ORIENTED_EDGE($,$,$,#948,.T.);
+#1761=ORIENTED_EDGE($,$,$,#1741,.F.);
+#1762=EDGE_LOOP($,(#1753,#1759,#1760,#1761));
+#1763=FACE_OUTER_BOUND('',#1762,.T.);
+#1764=ADVANCED_FACE('',(#1763),#1752,.T.);
+#1765=CARTESIAN_POINT($,(-8.255,49.83226,8.25746000000001));
+#1766=DIRECTION($,(1,-0,0));
+#1767=DIRECTION($,(0,-0.707106781186547,-0.707106781186548));
+#1768=AXIS2_PLACEMENT_3D($,#1765,#1766,#1767);
+#1769=PLANE($,#1768);
+#1770=ORIENTED_EDGE($,$,$,#965,.T.);
+#1771=ORIENTED_EDGE($,$,$,#1726,.F.);
+#1772=ORIENTED_EDGE($,$,$,#991,.T.);
+#1773=ORIENTED_EDGE($,$,$,#1435,.F.);
+#1774=EDGE_LOOP($,(#1770,#1771,#1772,#1773));
+#1775=FACE_OUTER_BOUND('',#1774,.T.);
+#1776=ADVANCED_FACE('',(#1775),#1769,.T.);
+#1777=CARTESIAN_POINT($,(-233.045,43.48226,1.90746000000001));
+#1778=DIRECTION($,(-1,0,0));
+#1779=DIRECTION($,(0,0.707106781186547,0.707106781186548));
+#1780=AXIS2_PLACEMENT_3D($,#1777,#1778,#1779);
+#1781=PLANE($,#1780);
+#1782=ORIENTED_EDGE($,$,$,#974,.T.);
+#1783=ORIENTED_EDGE($,$,$,#1464,.F.);
+#1784=ORIENTED_EDGE($,$,$,#1000,.T.);
+#1785=ORIENTED_EDGE($,$,$,#1758,.F.);
+#1786=EDGE_LOOP($,(#1782,#1783,#1784,#1785));
+#1787=FACE_OUTER_BOUND('',#1786,.T.);
+#1788=ADVANCED_FACE('',(#1787),#1781,.T.);
+#1789=CARTESIAN_POINT($,(-233.045,440.99226,1.90746000000001));
+#1790=DIRECTION($,(-1,0,0));
+#1791=DIRECTION($,(0,1,0));
+#1792=AXIS2_PLACEMENT_3D($,#1789,#1790,#1791);
+#1793=PLANE($,#1792);
+#1794=ORIENTED_EDGE($,$,$,#1026,.T.);
+#1795=CARTESIAN_POINT($,(-233.045,485.44226,1.90746000000001));
+#1796=DIRECTION($,(0,0,-1));
+#1797=VECTOR($,#1796,1);
+#1798=LINE($,#1795,#1797);
+#1799=EDGE_CURVE($,#1021,#1053,#1798,.T.);
+#1800=ORIENTED_EDGE($,$,$,#1799,.T.);
+#1801=ORIENTED_EDGE($,$,$,#1066,.T.);
+#1802=CARTESIAN_POINT($,(-233.045,440.99226,0.00246000000001));
+#1803=DIRECTION($,(0,0,1));
+#1804=VECTOR($,#1803,1);
+#1805=LINE($,#1802,#1804);
+#1806=EDGE_CURVE($,#1061,#1013,#1805,.T.);
+#1807=ORIENTED_EDGE($,$,$,#1806,.T.);
+#1808=EDGE_LOOP($,(#1794,#1800,#1801,#1807));
+#1809=FACE_OUTER_BOUND('',#1808,.T.);
+#1810=ADVANCED_FACE('',(#1809),#1793,.T.);
+#1811=CARTESIAN_POINT($,(-233.045,485.44226,1.90746000000001));
+#1812=DIRECTION($,(-0,1,0));
+#1813=DIRECTION($,(1,0,0));
+#1814=AXIS2_PLACEMENT_3D($,#1811,#1812,#1813);
+#1815=PLANE($,#1814);
+#1816=ORIENTED_EDGE($,$,$,#1034,.T.);
+#1817=CARTESIAN_POINT($,(-8.255,485.44226,1.90746000000001));
+#1818=DIRECTION($,(0,0,-1));
+#1819=VECTOR($,#1818,1);
+#1820=LINE($,#1817,#1819);
+#1821=EDGE_CURVE($,#1029,#1051,#1820,.T.);
+#1822=ORIENTED_EDGE($,$,$,#1821,.T.);
+#1823=ORIENTED_EDGE($,$,$,#1058,.T.);
+#1824=ORIENTED_EDGE($,$,$,#1799,.F.);
+#1825=EDGE_LOOP($,(#1816,#1822,#1823,#1824));
+#1826=FACE_OUTER_BOUND('',#1825,.T.);
+#1827=ADVANCED_FACE('',(#1826),#1815,.T.);
+#1828=CARTESIAN_POINT($,(-8.255,485.44226,1.90746000000001));
+#1829=DIRECTION($,(1,0,0));
+#1830=DIRECTION($,(0,-1,0));
+#1831=AXIS2_PLACEMENT_3D($,#1828,#1829,#1830);
+#1832=PLANE($,#1831);
+#1833=ORIENTED_EDGE($,$,$,#1040,.T.);
+#1834=CARTESIAN_POINT($,(-8.255,440.99226,1.90746000000001));
+#1835=DIRECTION($,(0,0,-1));
+#1836=VECTOR($,#1835,1);
+#1837=LINE($,#1834,#1836);
+#1838=EDGE_CURVE($,#1011,#1069,#1837,.T.);
+#1839=ORIENTED_EDGE($,$,$,#1838,.T.);
+#1840=ORIENTED_EDGE($,$,$,#1080,.T.);
+#1841=ORIENTED_EDGE($,$,$,#1821,.F.);
+#1842=EDGE_LOOP($,(#1833,#1839,#1840,#1841));
+#1843=FACE_OUTER_BOUND('',#1842,.T.);
+#1844=ADVANCED_FACE('',(#1843),#1832,.T.);
+#1845=CARTESIAN_POINT($,(-233.045,434.64226,8.25746000000001));
+#1846=DIRECTION($,(-1,-0,-0));
+#1847=DIRECTION($,(0,0.707106781186549,-0.707106781186546));
+#1848=AXIS2_PLACEMENT_3D($,#1845,#1846,#1847);
+#1849=PLANE($,#1848);
+#1850=ORIENTED_EDGE($,$,$,#1097,.T.);
+#1851=ORIENTED_EDGE($,$,$,#1806,.F.);
+#1852=ORIENTED_EDGE($,$,$,#1123,.T.);
+#1853=ORIENTED_EDGE($,$,$,#1503,.F.);
+#1854=EDGE_LOOP($,(#1850,#1851,#1852,#1853));
+#1855=FACE_OUTER_BOUND('',#1854,.T.);
+#1856=ADVANCED_FACE('',(#1855),#1849,.T.);
+#1857=CARTESIAN_POINT($,(-8.255,440.99226,1.90746000000001));
+#1858=DIRECTION($,(1,0,0));
+#1859=DIRECTION($,(0,-0.707106781186549,0.707106781186546));
+#1860=AXIS2_PLACEMENT_3D($,#1857,#1858,#1859);
+#1861=PLANE($,#1860);
+#1862=ORIENTED_EDGE($,$,$,#1106,.T.);
+#1863=ORIENTED_EDGE($,$,$,#1532,.F.);
+#1864=ORIENTED_EDGE($,$,$,#1132,.T.);
+#1865=ORIENTED_EDGE($,$,$,#1838,.F.);
+#1866=EDGE_LOOP($,(#1862,#1863,#1864,#1865));
+#1867=FACE_OUTER_BOUND('',#1866,.T.);
+#1868=ADVANCED_FACE('',(#1867),#1861,.T.);
+#1869=CARTESIAN_POINT($,(8.76783352130505,418.13226,119.403106478695));
+#1870=DIRECTION($,(-0,1,0));
+#1871=DIRECTION($,(0.707106781186548,0,0.707106781186548));
+#1872=AXIS2_PLACEMENT_3D($,#1869,#1870,#1871);
+#1873=PLANE($,#1872);
+#1874=ORIENTED_EDGE($,$,$,#1158,.T.);
+#1875=CARTESIAN_POINT($,(43.0724119037892,418.13226,153.707684861179));
+#1876=DIRECTION($,(0.707106781186548,0,-0.707106781186548));
+#1877=VECTOR($,#1876,1);
+#1878=LINE($,#1875,#1877);
+#1879=EDGE_CURVE($,#1153,#1185,#1878,.T.);
+#1880=ORIENTED_EDGE($,$,$,#1879,.T.);
+#1881=ORIENTED_EDGE($,$,$,#1198,.T.);
+#1882=CARTESIAN_POINT($,(10.1148719394654,418.13226,118.056068060535));
+#1883=DIRECTION($,(-0.707106781186549,0,0.707106781186546));
+#1884=VECTOR($,#1883,1);
+#1885=LINE($,#1882,#1884);
+#1886=EDGE_CURVE($,#1193,#1145,#1885,.T.);
+#1887=ORIENTED_EDGE($,$,$,#1886,.T.);
+#1888=EDGE_LOOP($,(#1874,#1880,#1881,#1887));
+#1889=FACE_OUTER_BOUND('',#1888,.T.);
+#1890=ADVANCED_FACE('',(#1889),#1873,.T.);
+#1891=CARTESIAN_POINT($,(43.0724119037892,418.13226,153.707684861179));
+#1892=DIRECTION($,(0.707106781186548,0,0.707106781186548));
+#1893=DIRECTION($,(0,-1,0));
+#1894=AXIS2_PLACEMENT_3D($,#1891,#1892,#1893);
+#1895=PLANE($,#1894);
+#1896=ORIENTED_EDGE($,$,$,#1166,.T.);
+#1897=CARTESIAN_POINT($,(43.0724119037892,66.34226,153.707684861179));
+#1898=DIRECTION($,(0.707106781186548,0,-0.707106781186548));
+#1899=VECTOR($,#1898,1);
+#1900=LINE($,#1897,#1899);
+#1901=EDGE_CURVE($,#1161,#1183,#1900,.T.);
+#1902=ORIENTED_EDGE($,$,$,#1901,.T.);
+#1903=ORIENTED_EDGE($,$,$,#1190,.T.);
+#1904=ORIENTED_EDGE($,$,$,#1879,.F.);
+#1905=EDGE_LOOP($,(#1896,#1902,#1903,#1904));
+#1906=FACE_OUTER_BOUND('',#1905,.T.);
+#1907=ADVANCED_FACE('',(#1906),#1895,.T.);
+#1908=CARTESIAN_POINT($,(43.0724119037892,66.34226,153.707684861179));
+#1909=DIRECTION($,(0,-1,-0));
+#1910=DIRECTION($,(-0.707106781186548,0,-0.707106781186548));
+#1911=AXIS2_PLACEMENT_3D($,#1908,#1909,#1910);
+#1912=PLANE($,#1911);
+#1913=ORIENTED_EDGE($,$,$,#1172,.T.);
+#1914=CARTESIAN_POINT($,(8.76783352130505,66.34226,119.403106478695));
+#1915=DIRECTION($,(0.707106781186549,0,-0.707106781186546));
+#1916=VECTOR($,#1915,1);
+#1917=LINE($,#1914,#1916);
+#1918=EDGE_CURVE($,#1143,#1201,#1917,.T.);
+#1919=ORIENTED_EDGE($,$,$,#1918,.T.);
+#1920=ORIENTED_EDGE($,$,$,#1212,.T.);
+#1921=ORIENTED_EDGE($,$,$,#1901,.F.);
+#1922=EDGE_LOOP($,(#1913,#1919,#1920,#1921));
+#1923=FACE_OUTER_BOUND('',#1922,.T.);
+#1924=ADVANCED_FACE('',(#1923),#1912,.T.);
+#1925=CARTESIAN_POINT($,(6.35,418.13226,113.56594));
+#1926=DIRECTION($,(0,1,0));
+#1927=DIRECTION($,(0.382683432365089,0,0.923879532511287));
+#1928=AXIS2_PLACEMENT_3D($,#1925,#1926,#1927);
+#1929=PLANE($,#1928);
+#1930=ORIENTED_EDGE($,$,$,#1229,.T.);
+#1931=ORIENTED_EDGE($,$,$,#1886,.F.);
+#1932=ORIENTED_EDGE($,$,$,#1255,.T.);
+#1933=ORIENTED_EDGE($,$,$,#1651,.F.);
+#1934=EDGE_LOOP($,(#1930,#1931,#1932,#1933));
+#1935=FACE_OUTER_BOUND('',#1934,.T.);
+#1936=ADVANCED_FACE('',(#1935),#1929,.T.);
+#1937=CARTESIAN_POINT($,(8.76783352130505,66.34226,119.403106478695));
+#1938=DIRECTION($,(0,-1,-0));
+#1939=DIRECTION($,(-0.382683432365089,0,-0.923879532511287));
+#1940=AXIS2_PLACEMENT_3D($,#1937,#1938,#1939);
+#1941=PLANE($,#1940);
+#1942=ORIENTED_EDGE($,$,$,#1238,.T.);
+#1943=ORIENTED_EDGE($,$,$,#1680,.F.);
+#1944=ORIENTED_EDGE($,$,$,#1264,.T.);
+#1945=ORIENTED_EDGE($,$,$,#1918,.F.);
+#1946=EDGE_LOOP($,(#1942,#1943,#1944,#1945));
+#1947=FACE_OUTER_BOUND('',#1946,.T.);
+#1948=ADVANCED_FACE('',(#1947),#1941,.T.);
+#1949=CARTESIAN_POINT($,(-136.0424,122.0724,78.105));
+#1950=DIRECTION($,(-0,1,0));
+#1951=DIRECTION($,(1,0,0));
+#1952=AXIS2_PLACEMENT_3D($,#1949,#1950,#1951);
+#1953=PLANE($,#1952);
+#1954=ORIENTED_EDGE($,$,$,#128,.T.);
+#1955=CARTESIAN_POINT($,(-116.9924,122.0724,78.105));
+#1956=DIRECTION($,(0,0,-1));
+#1957=VECTOR($,#1956,1);
+#1958=LINE($,#1955,#1957);
+#1959=EDGE_CURVE($,#115,#279,#1958,.T.);
+#1960=ORIENTED_EDGE($,$,$,#1959,.T.);
+#1961=ORIENTED_EDGE($,$,$,#284,.F.);
+#1962=CARTESIAN_POINT($,(-136.0424,122.0724,76.2));
+#1963=DIRECTION($,(0,0,1));
+#1964=VECTOR($,#1963,1);
+#1965=LINE($,#1962,#1964);
+#1966=EDGE_CURVE($,#277,#123,#1965,.T.);
+#1967=ORIENTED_EDGE($,$,$,#1966,.T.);
+#1968=EDGE_LOOP($,(#1954,#1960,#1961,#1967));
+#1969=FACE_OUTER_BOUND('',#1968,.T.);
+#1970=ADVANCED_FACE('',(#1969),#1953,.T.);
+#1971=CARTESIAN_POINT($,(-116.9924,122.0724,78.105));
+#1972=DIRECTION($,(-1,0,0));
+#1973=DIRECTION($,(0,1,0));
+#1974=AXIS2_PLACEMENT_3D($,#1971,#1972,#1973);
+#1975=PLANE($,#1974);
+#1976=ORIENTED_EDGE($,$,$,#120,.T.);
+#1977=CARTESIAN_POINT($,(-116.9924,210.9724,78.105));
+#1978=DIRECTION($,(0,0,-1));
+#1979=VECTOR($,#1978,1);
+#1980=LINE($,#1977,#1979);
+#1981=EDGE_CURVE($,#105,#287,#1980,.T.);
+#1982=ORIENTED_EDGE($,$,$,#1981,.T.);
+#1983=ORIENTED_EDGE($,$,$,#292,.F.);
+#1984=ORIENTED_EDGE($,$,$,#1959,.F.);
+#1985=EDGE_LOOP($,(#1976,#1982,#1983,#1984));
+#1986=FACE_OUTER_BOUND('',#1985,.T.);
+#1987=ADVANCED_FACE('',(#1986),#1975,.T.);
+#1988=CARTESIAN_POINT($,(-116.9924,210.9724,78.105));
+#1989=DIRECTION($,(-0,-1,-0));
+#1990=DIRECTION($,(-1,0,0));
+#1991=AXIS2_PLACEMENT_3D($,#1988,#1989,#1990);
+#1992=PLANE($,#1991);
+#1993=ORIENTED_EDGE($,$,$,#112,.T.);
+#1994=CARTESIAN_POINT($,(-136.0424,210.9724,78.105));
+#1995=DIRECTION($,(0,0,-1));
+#1996=VECTOR($,#1995,1);
+#1997=LINE($,#1994,#1996);
+#1998=EDGE_CURVE($,#107,#295,#1997,.T.);
+#1999=ORIENTED_EDGE($,$,$,#1998,.T.);
+#2000=ORIENTED_EDGE($,$,$,#300,.F.);
+#2001=ORIENTED_EDGE($,$,$,#1981,.F.);
+#2002=EDGE_LOOP($,(#1993,#1999,#2000,#2001));
+#2003=FACE_OUTER_BOUND('',#2002,.T.);
+#2004=ADVANCED_FACE('',(#2003),#1992,.T.);
+#2005=CARTESIAN_POINT($,(-136.0424,210.9724,78.105));
+#2006=DIRECTION($,(1,0,0));
+#2007=DIRECTION($,(0,-1,0));
+#2008=AXIS2_PLACEMENT_3D($,#2005,#2006,#2007);
+#2009=PLANE($,#2008);
+#2010=ORIENTED_EDGE($,$,$,#134,.T.);
+#2011=ORIENTED_EDGE($,$,$,#1966,.F.);
+#2012=ORIENTED_EDGE($,$,$,#306,.F.);
+#2013=ORIENTED_EDGE($,$,$,#1998,.F.);
+#2014=EDGE_LOOP($,(#2010,#2011,#2012,#2013));
+#2015=FACE_OUTER_BOUND('',#2014,.T.);
+#2016=ADVANCED_FACE('',(#2015),#2009,.T.);
+#2017=CARTESIAN_POINT($,(-199.5424,122.0724,78.105));
+#2018=DIRECTION($,(-0,1,0));
+#2019=DIRECTION($,(1,0,0));
+#2020=AXIS2_PLACEMENT_3D($,#2017,#2018,#2019);
+#2021=PLANE($,#2020);
+#2022=ORIENTED_EDGE($,$,$,#162,.T.);
+#2023=CARTESIAN_POINT($,(-180.4924,122.0724,78.105));
+#2024=DIRECTION($,(0,0,-1));
+#2025=VECTOR($,#2024,1);
+#2026=LINE($,#2023,#2025);
+#2027=EDGE_CURVE($,#149,#313,#2026,.T.);
+#2028=ORIENTED_EDGE($,$,$,#2027,.T.);
+#2029=ORIENTED_EDGE($,$,$,#318,.F.);
+#2030=CARTESIAN_POINT($,(-199.5424,122.0724,76.2));
+#2031=DIRECTION($,(0,0,1));
+#2032=VECTOR($,#2031,1);
+#2033=LINE($,#2030,#2032);
+#2034=EDGE_CURVE($,#311,#157,#2033,.T.);
+#2035=ORIENTED_EDGE($,$,$,#2034,.T.);
+#2036=EDGE_LOOP($,(#2022,#2028,#2029,#2035));
+#2037=FACE_OUTER_BOUND('',#2036,.T.);
+#2038=ADVANCED_FACE('',(#2037),#2021,.T.);
+#2039=CARTESIAN_POINT($,(-180.4924,122.0724,78.105));
+#2040=DIRECTION($,(-1,0,0));
+#2041=DIRECTION($,(0,1,0));
+#2042=AXIS2_PLACEMENT_3D($,#2039,#2040,#2041);
+#2043=PLANE($,#2042);
+#2044=ORIENTED_EDGE($,$,$,#154,.T.);
+#2045=CARTESIAN_POINT($,(-180.4924,210.9724,78.105));
+#2046=DIRECTION($,(0,0,-1));
+#2047=VECTOR($,#2046,1);
+#2048=LINE($,#2045,#2047);
+#2049=EDGE_CURVE($,#139,#321,#2048,.T.);
+#2050=ORIENTED_EDGE($,$,$,#2049,.T.);
+#2051=ORIENTED_EDGE($,$,$,#326,.F.);
+#2052=ORIENTED_EDGE($,$,$,#2027,.F.);
+#2053=EDGE_LOOP($,(#2044,#2050,#2051,#2052));
+#2054=FACE_OUTER_BOUND('',#2053,.T.);
+#2055=ADVANCED_FACE('',(#2054),#2043,.T.);
+#2056=CARTESIAN_POINT($,(-180.4924,210.9724,78.105));
+#2057=DIRECTION($,(-0,-1,-0));
+#2058=DIRECTION($,(-1,0,0));
+#2059=AXIS2_PLACEMENT_3D($,#2056,#2057,#2058);
+#2060=PLANE($,#2059);
+#2061=ORIENTED_EDGE($,$,$,#146,.T.);
+#2062=CARTESIAN_POINT($,(-199.5424,210.9724,78.105));
+#2063=DIRECTION($,(0,0,-1));
+#2064=VECTOR($,#2063,1);
+#2065=LINE($,#2062,#2064);
+#2066=EDGE_CURVE($,#141,#329,#2065,.T.);
+#2067=ORIENTED_EDGE($,$,$,#2066,.T.);
+#2068=ORIENTED_EDGE($,$,$,#334,.F.);
+#2069=ORIENTED_EDGE($,$,$,#2049,.F.);
+#2070=EDGE_LOOP($,(#2061,#2067,#2068,#2069));
+#2071=FACE_OUTER_BOUND('',#2070,.T.);
+#2072=ADVANCED_FACE('',(#2071),#2060,.T.);
+#2073=CARTESIAN_POINT($,(-199.5424,210.9724,78.105));
+#2074=DIRECTION($,(1,0,0));
+#2075=DIRECTION($,(0,-1,0));
+#2076=AXIS2_PLACEMENT_3D($,#2073,#2074,#2075);
+#2077=PLANE($,#2076);
+#2078=ORIENTED_EDGE($,$,$,#168,.T.);
+#2079=ORIENTED_EDGE($,$,$,#2034,.F.);
+#2080=ORIENTED_EDGE($,$,$,#340,.F.);
+#2081=ORIENTED_EDGE($,$,$,#2066,.F.);
+#2082=EDGE_LOOP($,(#2078,#2079,#2080,#2081));
+#2083=FACE_OUTER_BOUND('',#2082,.T.);
+#2084=ADVANCED_FACE('',(#2083),#2077,.T.);
+#2085=CLOSED_SHELL($,(#172,#344,#384,#424,#450,#476,#516,#556,#582,#608,#648,#688,#714,#740,#780,#820,#846,#872,#912,#952,#978,#1004,#1044,#1084,#1110,#1136,#1176,#1216,#1242,#1268,#1290,#1312,#1329,#1351,#1368,#1390,#1407,#1424,#1446,#1468,#1480,#1492,#1514,#1536,#1548,#1560,#1582,#1599,#1616,#1628,#1640,#1662,#1684,#1696,#1708,#1730,#1747,#1764,#1776,#1788,#1810,#1827,#1844,#1856,#1868,#1890,#1907,#1924,#1936,#1948,#1970,#1987,#2004,#2016,#2038,#2055,#2072,#2084));
+#2086=MANIFOLD_SOLID_BREP('AetherisBody',#2085);
+#2087=APPLICATION_CONTEXT('mechanical design');
+#2088=PRODUCT_CONTEXT('',#2087,'mechanical');
+#2089=PRODUCT('AETHERIS','AetherisBody','',(#2088));
+#2090=PRODUCT_DEFINITION_FORMATION('','',#2089);
+#2091=PRODUCT_DEFINITION_CONTEXT('design',#2087,'design');
+#2092=PRODUCT_DEFINITION('','',#2090,#2091);
+#2093=PRODUCT_DEFINITION_SHAPE('','',#2092);
+#2094=(LENGTH_UNIT()NAMED_UNIT(*)SI_UNIT(.MILLI.,.METRE.));
+#2095=(NAMED_UNIT(*)PLANE_ANGLE_UNIT()SI_UNIT($,.RADIAN.));
+#2096=(NAMED_UNIT(*)SI_UNIT($,.STERADIAN.)SOLID_ANGLE_UNIT());
+#2097=(GEOMETRIC_REPRESENTATION_CONTEXT(3)GLOBAL_UNIT_ASSIGNED_CONTEXT((#2094,#2095,#2096))REPRESENTATION_CONTEXT('3','3D'));
+#2098=SHAPE_REPRESENTATION('AetherisBody',(#2086),#2097);
+#2099=SHAPE_DEFINITION_REPRESENTATION(#2093,#2098);
+ENDSEC;
+END-ISO-10303-21;
diff --git a/docs/modules/sheetmetal/artifacts/m3/ctc03-source-independence.md b/docs/modules/sheetmetal/artifacts/m3/ctc03-source-independence.md
new file mode 100644
index 00000000..8c0fafa8
--- /dev/null
+++ b/docs/modules/sheetmetal/artifacts/m3/ctc03-source-independence.md
@@ -0,0 +1,5 @@
+# CTC-03 source independence
+
+`../m2/ctc03-idiomatic.firmament` contains no `EvidenceSource`, `FromEvidence`, source path, face ID, edge ID, or recovered polygon. The M3 test copies it to an isolated temporary directory and compiles there. Generation succeeds with 15 regions, seven bends, two cuts, a closed formed body, and a valid flat pattern.
+
+The generated part reports empty source-face bindings for every region and `sole construction authority` as its source authority. The imported NIST STEP enters only the subsequent `sheetmetal compare` invocation.
diff --git a/docs/modules/sheetmetal/artifacts/m3/dfm-summary.md b/docs/modules/sheetmetal/artifacts/m3/dfm-summary.md
new file mode 100644
index 00000000..c8ccce75
--- /dev/null
+++ b/docs/modules/sheetmetal/artifacts/m3/dfm-summary.md
@@ -0,0 +1,5 @@
+# DFM summary
+
+M3 retains positive-thickness, minimum R/t, cut-to-bend, cut-to-edge, and flat-overlap rules and adds semantic corner-resolution/relief sizing findings. Cuts reaching a region boundary or bend zone reject during compilation with `sheetmetal-cut-crosses-bend`. Duplicate flange ownership and disconnected graph references are typed failures.
+
+Electronics tray: all four R/t checks, four corner-resolution checks, two holes, two slots, and overlap check pass under the experimental policy. CTC-03: R/t = 3.333 on all seven bends; four auto-relief corner checks, both vent clearance checks, and flat overlap pass. Suggestions remain advisory and are never auto-applied.
diff --git a/docs/modules/sheetmetal/artifacts/m3/performance.md b/docs/modules/sheetmetal/artifacts/m3/performance.md
new file mode 100644
index 00000000..120a06a0
--- /dev/null
+++ b/docs/modules/sheetmetal/artifacts/m3/performance.md
@@ -0,0 +1,11 @@
+# Performance and determinism
+
+Representative CTC-03 in-process cold observation from the public CLI report: parse 9.41 ms, formed lowering/preflight 60.21 ms, first authored flat lowering 29.69 ms; the immediately repeated flat traversal was 0.42 ms. Whole `dotnet run --no-build` wall time is about 0.70-0.75 s and is dominated by CLI process startup.
+
+Generated artifact SHA-256 values:
+
+- formed STEP: `e026084f351dcf2011f5fd675ab63573d58380c04d7b3a8ec28e9348e5ae79f1`;
+- flat STEP: `73bd832b1fba07ea3a391c90300a488f491388ed50a48f9d78c6e330c1af1963`;
+- flat SVG: `1c2db51a3b83a346b253af77f047025da4e472cecf68a889deaab51e9bd2ef6b`.
+
+Stable semantic IDs, topology iteration, correspondence IDs, flat hash, SVG ordering, and STEP topology ordering are covered by repeated compilation tests.
diff --git a/docs/modules/sheetmetal/artifacts/m3/validation-report.md b/docs/modules/sheetmetal/artifacts/m3/validation-report.md
new file mode 100644
index 00000000..e85697a7
--- /dev/null
+++ b/docs/modules/sheetmetal/artifacts/m3/validation-report.md
@@ -0,0 +1,13 @@
+# M3 validation report
+
+- Focused `Aetheris.SheetMetal.Tests`: 23/23 pass.
+- Focused Sheet Metal CLI tests: 5/5 pass.
+- L-bracket: one bend; formed/flat STEP reimport and reference refold pass.
+- U-channel: two bends; formed/flat STEP reimport and reference refold pass.
+- Electronics tray: four bends, four cuts, four corners/reliefs; formed body 56 faces / 128 edges / 76 vertices; formed/flat STEP reimport and refold pass.
+- CTC-03 formed: one body/shell, 78 faces, 172 edges, 96 vertices; 64 planes and 14 cylinders; enclosed-manifold after STEP reimport.
+- CTC-03 flat: 392.051790 x 612.597761 x 1.905 mm; one body/shell, 50 planar faces, 144 edges, 96 vertices; enclosed-manifold after STEP reimport.
+- Throw-away-source gate passes from an isolated Firmament copy.
+- CTC-03 post-generation comparison: overall `NeedsReview`; all bends/cuts pass, global historical trims/flat contour do not.
+
+Full solution restore succeeds; full build succeeds with zero warnings/errors; 2,836 discovered tests pass. `Aetheris.FrictionLab.Tests` contains no discoverable tests, as before. No generic Boolean union was added to Sheet Metal lowering.
diff --git a/fixtures/FirmamentV2/SheetMetal/m3-electronics-tray.firmament b/fixtures/FirmamentV2/SheetMetal/m3-electronics-tray.firmament
new file mode 100644
index 00000000..5b40af43
--- /dev/null
+++ b/fixtures/FirmamentV2/SheetMetal/m3-electronics-tray.firmament
@@ -0,0 +1,15 @@
+// M3 dogfood: four adjacent walls, automatic relief semantics, holes and vent slots.
+SheetMetal ElectronicsTray {
+ Thickness: 1.2mm;
+ Material: "5052-H32 Aluminum";
+ KFactor: 0.42;
+ Base Main { Profile: Rectangle { Width: 240mm; Height: 180mm; }; }
+ Flange FrontWall { From: Main.Front; Height: 40mm; Angle: 90deg; Radius: 1.5mm; Relief: Auto; }
+ Flange RightWall { From: Main.Right; Height: 30mm; Angle: 90deg; Radius: 1.5mm; Relief: Auto; }
+ Flange RearWall { From: Main.Rear; Height: 40mm; Angle: 90deg; Radius: 1.5mm; Relief: Auto; }
+ Flange LeftWall { From: Main.Left; Height: 30mm; Angle: 90deg; Radius: 1.5mm; Relief: Auto; }
+ Hole MountA { On: Main; Center: (20mm, 20mm); Diameter: 4mm; }
+ Hole MountB { On: Main; Center: (220mm, 160mm); Diameter: 4mm; }
+ Cut VentA { On: Main; Profile: Slot { Length: 50mm; Width: 8mm; }; At: (90mm, 90mm); }
+ Cut VentB { On: Main; Profile: Slot { Length: 50mm; Width: 8mm; }; At: (150mm, 90mm); }
+}
diff --git a/fixtures/FirmamentV2/SheetMetal/m3-l-bracket.firmament b/fixtures/FirmamentV2/SheetMetal/m3-l-bracket.firmament
new file mode 100644
index 00000000..075cfeb5
--- /dev/null
+++ b/fixtures/FirmamentV2/SheetMetal/m3-l-bracket.firmament
@@ -0,0 +1,14 @@
+// M3 source-independent single-bend fixture.
+SheetMetal LBracket {
+ Thickness: 1.5mm;
+ Material: "5052-H32 Aluminum";
+ KFactor: 0.42;
+ Base Main { Profile: Rectangle { Width: 80mm; Height: 40mm; }; }
+ Flange Wall {
+ From: Main.Left;
+ Length: 25mm;
+ Angle: 90deg;
+ InsideRadius: 2mm;
+ Direction: Up;
+ }
+}
diff --git a/fixtures/FirmamentV2/SheetMetal/m3-u-channel.firmament b/fixtures/FirmamentV2/SheetMetal/m3-u-channel.firmament
new file mode 100644
index 00000000..3b7768be
--- /dev/null
+++ b/fixtures/FirmamentV2/SheetMetal/m3-u-channel.firmament
@@ -0,0 +1,8 @@
+// M3 source-independent two-bend fixture.
+SheetMetal UChannelM3 {
+ Thickness: 1.5mm;
+ KFactor: 0.42;
+ Base Main { Profile: Rectangle { Width: 100mm; Height: 60mm; }; }
+ Flange LeftWall { From: Main.Left; Length: 25mm; Angle: 90deg; Radius: 2mm; Direction: Up; }
+ Flange RightWall { From: Main.Right; Length: 20mm; Angle: 90deg; Radius: 2mm; Direction: Up; }
+}