Skip to content

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.cs
new file mode 100644
index 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.cs
new file mode 100644
index 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.cs
new file mode 100644
index 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.cs
index 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 Step242Importer
public 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 Step242Importer
return 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.cs
new file mode 100644
index 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);
+ }
+}