Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel
Add import orchestrator with STEP connector and lane skeleton
Yuechen Li4bd90527f9b5
diff --git a/Aetheris.Kernel.Core.Tests/Step242/ImportOrchestratorTests.cs b/Aetheris.Kernel.Core.Tests/Step242/ImportOrchestratorTests.csnew file mode 100644index 00000000..d5a01831--- /dev/null+++ b/Aetheris.Kernel.Core.Tests/Step242/ImportOrchestratorTests.cs@@ -0,0 +1,46 @@+using Aetheris.Kernel.Core.Import;++namespace Aetheris.Kernel.Core.Tests.Step242;++public sealed class ImportOrchestratorTests+{+ [Fact]+ public void Import_Ap242ExactSource_SelectsStepConnectorAndExactLaneDeterministically()+ {+ var orchestrator = ImportOrchestrator.CreateDefault();+ var request = new ImportRequest(Step242FixtureCorpus.CanonicalBoxGolden);++ var first = orchestrator.Import(request);+ var second = orchestrator.Import(request);++ Assert.True(first.BodyResult.IsSuccess, string.Join(" | ", first.BodyResult.Diagnostics.Select(d => $"{d.Source}: {d.Message}")));+ Assert.True(second.BodyResult.IsSuccess, string.Join(" | ", second.BodyResult.Diagnostics.Select(d => $"{d.Source}: {d.Message}")));+ Assert.Equal("step-ap242-connector", first.Connector);+ Assert.Equal(ImportLaneKind.ExactBRep, first.Lane);+ Assert.Equal(first.Connector, second.Connector);+ Assert.Equal(first.Lane, second.Lane);+ }++ [Fact]+ public void Import_Ap242TessellatedSource_SelectsTessellatedLaneDeterministically()+ {+ var orchestrator = ImportOrchestrator.CreateDefault();+ var text = LoadFixture("testdata/step242/nist/FTC/nist_ftc_08_asme1_ap242-e1-tg.stp");++ var first = orchestrator.Import(new ImportRequest(text));+ var second = orchestrator.Import(new ImportRequest(text));++ Assert.True(first.BodyResult.IsSuccess, string.Join(" | ", first.BodyResult.Diagnostics.Select(d => $"{d.Source}: {d.Message}")));+ Assert.True(second.BodyResult.IsSuccess, string.Join(" | ", second.BodyResult.Diagnostics.Select(d => $"{d.Source}: {d.Message}")));+ Assert.Equal("step-ap242-connector", first.Connector);+ Assert.Equal(ImportLaneKind.Tessellated, first.Lane);+ Assert.Equal(first.Connector, second.Connector);+ Assert.Equal(first.Lane, second.Lane);+ }++ private static string LoadFixture(string relativePath)+ {+ var path = Path.Combine(Step242CorpusManifestRunner.RepoRoot(), relativePath.Replace('/', Path.DirectorySeparatorChar));+ return File.ReadAllText(path);+ }+}diff --git a/Aetheris.Kernel.Core/Import/ImportContracts.cs b/Aetheris.Kernel.Core/Import/ImportContracts.csnew file mode 100644index 00000000..fa820309--- /dev/null+++ b/Aetheris.Kernel.Core/Import/ImportContracts.cs@@ -0,0 +1,34 @@+using Aetheris.Kernel.Core.Brep;+using Aetheris.Kernel.Core.Diagnostics;+using Aetheris.Kernel.Core.Results;++namespace Aetheris.Kernel.Core.Import;++public enum ImportLaneKind+{+ Auto = 0,+ ExactBRep = 1,+ Tessellated = 2,+ Approximation = 3,+ Compatibility = 4+}++public sealed record ImportRequest(string SourceText, ImportPolicy? Policy = null);++public sealed record ImportPolicy(ImportLaneKind PreferredLane = ImportLaneKind.Auto);++public sealed record ImportResult(+ KernelResult<BrepBody> BodyResult,+ string Connector,+ ImportLaneKind Lane,+ string SourceFamily)+{+ public static ImportResult Failure(IReadOnlyList<KernelDiagnostic> diagnostics)+ {+ return new ImportResult(+ KernelResult<BrepBody>.Failure(diagnostics),+ Connector: "none",+ Lane: ImportLaneKind.Auto,+ SourceFamily: "unknown");+ }+}diff --git a/Aetheris.Kernel.Core/Import/ImportOrchestrator.cs b/Aetheris.Kernel.Core/Import/ImportOrchestrator.csnew file mode 100644index 00000000..828fb858--- /dev/null+++ b/Aetheris.Kernel.Core/Import/ImportOrchestrator.cs@@ -0,0 +1,101 @@+using Aetheris.Kernel.Core.Brep;+using Aetheris.Kernel.Core.Diagnostics;+using Aetheris.Kernel.Core.Results;++namespace Aetheris.Kernel.Core.Import;++public interface ISourceConnector+{+ string Name { get; }++ bool CanOpen(ImportRequest request);++ KernelResult<IParsedSourceDocument> Parse(ImportRequest request);+}++public interface IParsedSourceDocument+{+ string SourceFamily { get; }+}++public interface IImportLane+{+ string Name { get; }++ ImportLaneKind Kind { get; }++ bool CanImport(IParsedSourceDocument document, ImportPolicy policy);++ KernelResult<BrepBody> Import(IParsedSourceDocument document, ImportPolicy policy);+}++public sealed class ImportOrchestrator+{+ private readonly IReadOnlyList<ISourceConnector> _connectors;+ private readonly IReadOnlyList<IImportLane> _lanes;++ public ImportOrchestrator(IReadOnlyList<ISourceConnector> connectors, IReadOnlyList<IImportLane> lanes)+ {+ _connectors = connectors;+ _lanes = lanes;+ }++ public static ImportOrchestrator CreateDefault()+ {+ var stepConnector = new Step242.StepSourceConnector();+ return new ImportOrchestrator(+ connectors: [stepConnector],+ lanes:+ [+ new Step242.Step242ExactBRepImportLane(),+ new Step242.Step242TessellatedImportLane()+ ]);+ }++ public ImportResult Import(ImportRequest request)+ {+ var policy = request.Policy ?? new ImportPolicy();+ var connector = _connectors.FirstOrDefault(c => c.CanOpen(request));+ if (connector is null)+ {+ return ImportResult.Failure([+ new KernelDiagnostic(+ KernelDiagnosticCode.NotImplemented,+ KernelDiagnosticSeverity.Error,+ "No source connector recognized this import request.",+ "Import.Orchestrator.ConnectorSelection")+ ]);+ }++ var parseResult = connector.Parse(request);+ if (!parseResult.IsSuccess)+ {+ return ImportResult.Failure(parseResult.Diagnostics);+ }++ var lane = SelectLane(parseResult.Value, policy);+ if (lane is null)+ {+ return ImportResult.Failure([+ new KernelDiagnostic(+ KernelDiagnosticCode.NotImplemented,+ KernelDiagnosticSeverity.Error,+ $"No import lane can process source family '{parseResult.Value.SourceFamily}' with preference '{policy.PreferredLane}'.",+ "Import.Orchestrator.LaneSelection")+ ]);+ }++ var bodyResult = lane.Import(parseResult.Value, policy);+ return new ImportResult(bodyResult, connector.Name, lane.Kind, parseResult.Value.SourceFamily);+ }++ private IImportLane? SelectLane(IParsedSourceDocument document, ImportPolicy policy)+ {+ if (policy.PreferredLane != ImportLaneKind.Auto)+ {+ return _lanes.FirstOrDefault(l => l.Kind == policy.PreferredLane && l.CanImport(document, policy));+ }++ return _lanes.FirstOrDefault(l => l.CanImport(document, policy));+ }+}diff --git a/Aetheris.Kernel.Core/Step242/Step242Importer.cs b/Aetheris.Kernel.Core/Step242/Step242Importer.csindex 53c176e8..b8edf5ad 100644--- a/Aetheris.Kernel.Core/Step242/Step242Importer.cs+++ b/Aetheris.Kernel.Core/Step242/Step242Importer.cs@@ -3,6 +3,7 @@ using Aetheris.Kernel.Core.Diagnostics;using Aetheris.Kernel.Core.Geometry;using Aetheris.Kernel.Core.Geometry.Curves;using Aetheris.Kernel.Core.Geometry.Surfaces;+using Aetheris.Kernel.Core.Import;using Aetheris.Kernel.Core.Math;using Aetheris.Kernel.Core.Results;using Aetheris.Kernel.Core.Topology;@@ -52,15 +53,33 @@ public static class Step242Importerpublic static KernelResult<BrepBody> ImportBody(string stepText){- var parseResult = Step242SubsetParser.Parse(stepText);- if (!parseResult.IsSuccess)- {- return KernelResult<BrepBody>.Failure(parseResult.Diagnostics);- }+ var orchestrator = ImportOrchestrator.CreateDefault();+ var result = orchestrator.Import(new ImportRequest(stepText));+ return result.BodyResult;+ }++ internal static bool HasTessellatedSolid(Step242ParsedDocument document)+ {+ return document.Entities.Any(e => string.Equals(e.Name, "TESSELLATED_SOLID", StringComparison.OrdinalIgnoreCase));+ }+ internal static KernelResult<BrepBody> ImportParsedDocumentForLane(Step242ParsedDocument document, ImportLaneKind laneKind)+ {try{- return MapSubset(parseResult.Value);+ return laneKind switch+ {+ ImportLaneKind.Auto => ImportAuto(document),+ ImportLaneKind.ExactBRep => MapSubsetExact(document),+ ImportLaneKind.Tessellated => ImportTessellated(document),+ _ => KernelResult<BrepBody>.Failure([+ new KernelDiagnostic(+ KernelDiagnosticCode.InvalidArgument,+ KernelDiagnosticSeverity.Error,+ $"STEP/AP242 importer does not support lane '{laneKind}'.",+ "Importer.Lane.Unsupported")+ ])+ };}catch (Exception ex) when (ex is ArgumentException or InvalidOperationException){@@ -74,7 +93,18 @@ public static class Step242Importer}}- private static KernelResult<BrepBody> MapSubset(Step242ParsedDocument document)+ private static KernelResult<BrepBody> ImportAuto(Step242ParsedDocument document)+ {+ var tessellatedSolidResult = TryImportTessellatedSolid(document);+ if (tessellatedSolidResult is not null)+ {+ return tessellatedSolidResult;+ }++ return MapSubsetExact(document);+ }++ private static KernelResult<BrepBody> ImportTessellated(Step242ParsedDocument document){var tessellatedSolidResult = TryImportTessellatedSolid(document);if (tessellatedSolidResult is not null)@@ -82,6 +112,11 @@ public static class Step242Importerreturn tessellatedSolidResult;}+ return Failure("Requested tessellated import lane, but no TESSELLATED_SOLID root was found.", "Importer.TessellatedSolid.MissingRoot");+ }++ private static KernelResult<BrepBody> MapSubsetExact(Step242ParsedDocument document)+ {var manifoldSolidBreps = document.Entities.Where(e => string.Equals(e.Name, "MANIFOLD_SOLID_BREP", StringComparison.OrdinalIgnoreCase)).ToList();diff --git a/Aetheris.Kernel.Core/Step242/StepImportConnectorAndLanes.cs b/Aetheris.Kernel.Core/Step242/StepImportConnectorAndLanes.csnew file mode 100644index 00000000..27aa7815--- /dev/null+++ b/Aetheris.Kernel.Core/Step242/StepImportConnectorAndLanes.cs@@ -0,0 +1,80 @@+using Aetheris.Kernel.Core.Brep;+using Aetheris.Kernel.Core.Import;+using Aetheris.Kernel.Core.Results;++namespace Aetheris.Kernel.Core.Step242;++internal sealed class StepParsedSourceDocument(Step242ParsedDocument document) : IParsedSourceDocument+{+ public Step242ParsedDocument Document { get; } = document;++ public string SourceFamily => "STEP/AP242";+}++internal sealed class StepSourceConnector : ISourceConnector+{+ public string Name => "step-ap242-connector";++ public bool CanOpen(ImportRequest request)+ {+ return request.SourceText.Contains("ISO-10303-21", StringComparison.OrdinalIgnoreCase)+ || request.SourceText.Contains("DATA;", StringComparison.OrdinalIgnoreCase);+ }++ public KernelResult<IParsedSourceDocument> Parse(ImportRequest request)+ {+ var parseResult = Step242SubsetParser.Parse(request.SourceText);+ if (!parseResult.IsSuccess)+ {+ return KernelResult<IParsedSourceDocument>.Failure(parseResult.Diagnostics);+ }++ return KernelResult<IParsedSourceDocument>.Success(new StepParsedSourceDocument(parseResult.Value));+ }+}++internal sealed class Step242ExactBRepImportLane : IImportLane+{+ public string Name => "step-ap242-exact-brep";++ public ImportLaneKind Kind => ImportLaneKind.ExactBRep;++ public bool CanImport(IParsedSourceDocument document, ImportPolicy policy)+ {+ if (document is not StepParsedSourceDocument stepDocument)+ {+ return false;+ }++ return !Step242Importer.HasTessellatedSolid(stepDocument.Document);+ }++ public KernelResult<BrepBody> Import(IParsedSourceDocument document, ImportPolicy policy)+ {+ var stepDocument = (StepParsedSourceDocument)document;+ return Step242Importer.ImportParsedDocumentForLane(stepDocument.Document, Kind);+ }+}++internal sealed class Step242TessellatedImportLane : IImportLane+{+ public string Name => "step-ap242-tessellated";++ public ImportLaneKind Kind => ImportLaneKind.Tessellated;++ public bool CanImport(IParsedSourceDocument document, ImportPolicy policy)+ {+ if (document is not StepParsedSourceDocument stepDocument)+ {+ return false;+ }++ return Step242Importer.HasTessellatedSolid(stepDocument.Document);+ }++ public KernelResult<BrepBody> Import(IParsedSourceDocument document, ImportPolicy policy)+ {+ var stepDocument = (StepParsedSourceDocument)document;+ return Step242Importer.ImportParsedDocumentForLane(stepDocument.Document, Kind);+ }+}