Skip to content

Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel

Emit specific deterministic diagnostics for non-normalizable inner loops

Yuechen Li3265a5412a97
diff --git a/Aetheris.Kernel.Core.Tests/Step242/Step242ConicalSurfaceRegressionTests.cs b/Aetheris.Kernel.Core.Tests/Step242/Step242ConicalSurfaceRegressionTests.cs
index aa7ba1b6..a2cad7d2 100644
--- a/Aetheris.Kernel.Core.Tests/Step242/Step242ConicalSurfaceRegressionTests.cs
+++ b/Aetheris.Kernel.Core.Tests/Step242/Step242ConicalSurfaceRegressionTests.cs
@@ -33,7 +33,7 @@ public sealed class Step242ConicalSurfaceRegressionTests
[Theory]
[InlineData("testdata/step242/nist/CTC/nist_ctc_01_asme1_ap242-e1.stp", "tessellator", "Viewer.Tessellation.CylinderTrimUnsupported", "Cylindrical face tessellation could not derive a bounded trim patch.")]
[InlineData("testdata/step242/nist/CTC/nist_ctc_02_asme1_ap242-e2.stp", "importer-geometry", "Importer.Geometry.CircleTrim", "Unable to compute circle trim from supplied vertices.")]
- [InlineData("testdata/step242/nist/CTC/nist_ctc_04_asme1_ap242-e1.stp", "importer-topology", "Importer.LoopRole.InnerNotContained", "Inner loop is not contained by outer loop.")]
+ [InlineData("testdata/step242/nist/CTC/nist_ctc_04_asme1_ap242-e1.stp", "importer-topology", "Importer.LoopRole.InnerCrossesOuterAfterNormalization", "Inner loop could not be normalized")]
[InlineData("testdata/step242/nist/FTC/nist_ftc_06_asme1_ap242-e2.stp", "tessellator", "", "Face 2 curved tessellation does not support this torus/revolved boundary topology yet. Observed")]
public void Step242_NistConicalTargets_AdvancePastConicalRadius_AndReportDeterministicNextBlocker(
string relativePath,
diff --git a/Aetheris.Kernel.Core.Tests/Step242/Step242LoopRoleNormalizationRegressionTests.cs b/Aetheris.Kernel.Core.Tests/Step242/Step242LoopRoleNormalizationRegressionTests.cs
new file mode 100644
index 00000000..2c8bebdc
--- /dev/null
+++ b/Aetheris.Kernel.Core.Tests/Step242/Step242LoopRoleNormalizationRegressionTests.cs
@@ -0,0 +1,49 @@
+using Aetheris.Kernel.Core.Step242;
+
+namespace Aetheris.Kernel.Core.Tests.Step242;
+
+public sealed class Step242LoopRoleNormalizationRegressionTests
+{
+ [Theory]
+ [InlineData("testdata/step242/nist/CTC/nist_ctc_04_asme1_ap242-e1.stp", "Importer.LoopRole.InnerCrossesOuterAfterNormalization", "Inner loop could not be normalized")]
+ [InlineData("testdata/step242/nist/CTC/nist_ctc_05_asme1_ap242-e1.stp", null, null)]
+ [InlineData("testdata/step242/nist/FTC/nist_ftc_07_asme1_ap242-e2.stp", null, null)]
+ [InlineData("testdata/step242/nist/FTC/nist_ftc_10_asme1_ap242-e2.stp", "Importer.LoopRole.InnerCrossesOuterAfterNormalization", "Inner loop could not be normalized")]
+ [InlineData("testdata/step242/nist/STC/nist_stc_06_asme1_ap242-e3.stp", null, null)]
+ [InlineData("testdata/step242/nist/STC/nist_stc_09_asme1_ap242-e3.stp", null, null)]
+ public void Step242_NistLoopRoleTargets_ProgressDeterministically_WithExplicitNormalizedBoundaries(
+ string relativePath,
+ string? expectedSource,
+ string? expectedMessagePrefix)
+ {
+ var entry = new Step242CorpusManifestEntry(
+ Id: Path.GetFileNameWithoutExtension(relativePath),
+ Path: relativePath,
+ Group: "nist-loop-role-regression",
+ Notes: "regression",
+ ExpectedFirstDiagnostic: null,
+ ExpectHashStableAfterCanonicalization: null,
+ ExpectTopologyCounts: null,
+ ExpectGeometryKinds: null);
+
+ var first = Step242CorpusManifestRunner.RunOne(entry);
+ var second = Step242CorpusManifestRunner.RunOne(entry);
+
+ if (expectedSource is null)
+ {
+ Assert.DoesNotContain("Loop projection is degenerate.", first.FirstDiagnostic.MessagePrefix, StringComparison.Ordinal);
+ Assert.DoesNotContain("Inner loop is not contained by outer loop.", first.FirstDiagnostic.MessagePrefix, StringComparison.Ordinal);
+ Assert.DoesNotContain("Importer.LoopRole.DegenerateLoop", first.FirstDiagnostic.Source, StringComparison.Ordinal);
+ Assert.DoesNotContain("Importer.LoopRole.InnerNotContained", first.FirstDiagnostic.Source, StringComparison.Ordinal);
+ }
+ else
+ {
+ Assert.Equal(expectedSource, first.FirstDiagnostic.Source);
+ Assert.StartsWith(expectedMessagePrefix!, first.FirstDiagnostic.MessagePrefix, StringComparison.Ordinal);
+ }
+
+ Assert.Equal(first.FirstFailureLayer, second.FirstFailureLayer);
+ Assert.Equal(first.FirstDiagnostic.Source, second.FirstDiagnostic.Source);
+ Assert.Equal(first.FirstDiagnostic.MessagePrefix, second.FirstDiagnostic.MessagePrefix);
+ }
+}
diff --git a/Aetheris.Kernel.Core/Step242/Step242Importer.cs b/Aetheris.Kernel.Core/Step242/Step242Importer.cs
index 8a8a134f..295a5b08 100644
--- a/Aetheris.Kernel.Core/Step242/Step242Importer.cs
+++ b/Aetheris.Kernel.Core/Step242/Step242Importer.cs
@@ -966,55 +966,92 @@ public static class Step242Importer
foreach (var loop in loops)
{
var projected = ProjectLoopToPlane(loop.Samples, plane);
- var uniqueCount = CountUniquePoints(projected);
- if (uniqueCount < 3)
+ var uniqueCount = CountUniquePoints(projected, ContainmentEps);
+ var area = ComputeSignedArea(projected);
+ if (uniqueCount < 3 || double.Abs(area) <= AreaEps)
{
- return LoopRoleFailure<IReadOnlyList<LoopBuildData>>("Loop projection is degenerate.", "Importer.LoopRole.DegenerateLoop");
+ continue;
}
- var area = ComputeSignedArea(projected);
infos.Add(new PlanarLoopInfo(loop, projected, area));
}
- var orderedByArea = infos
- .OrderByDescending(info => double.Abs(info.SignedArea))
+ if (infos.Count == 0)
+ {
+ return LoopRoleFailure<IReadOnlyList<LoopBuildData>>("Loop projection is degenerate and no non-degenerate boundary remained.", "Importer.LoopRole.DegenerateLoop");
+ }
+
+ var containmentTolerance = ComputeContainmentTolerance(infos.SelectMany(i => i.ProjectedPoints));
+ var areaTolerance = ComputeAreaTolerance(infos.SelectMany(i => i.ProjectedPoints));
+
+ var infosWithSamples = new List<PlanarLoopInfoWithSample>(infos.Count);
+ foreach (var info in infos)
+ {
+ var testPointResult = ChooseContainmentPoint(info.ProjectedPoints, containmentTolerance);
+ if (!testPointResult.IsSuccess)
+ {
+ return KernelResult<IReadOnlyList<LoopBuildData>>.Failure(testPointResult.Diagnostics);
+ }
+
+ infosWithSamples.Add(new PlanarLoopInfoWithSample(info, testPointResult.Value));
+ }
+
+ var orderedByContainmentThenArea = infosWithSamples
+ .Select(candidate =>
+ {
+ var containmentCount = infosWithSamples.Count(other => other.Info.Loop.LoopId != candidate.Info.Loop.LoopId
+ && IsPointInPolygon(other.SamplePoint, candidate.Info.ProjectedPoints, containmentTolerance));
+ return new PlanarLoopOuterCandidate(candidate.Info, candidate.SamplePoint, containmentCount);
+ })
+ .OrderByDescending(c => c.ContainmentCount)
+ .ThenByDescending(c => double.Abs(c.Info.SignedArea))
+ .ThenBy(c => c.Info.Loop.LoopId.Value)
.ToList();
- var outer = orderedByArea[0];
- if (orderedByArea.Count > 1 && double.Abs(double.Abs(outer.SignedArea) - double.Abs(orderedByArea[1].SignedArea)) <= AreaEps)
+ var outer = orderedByContainmentThenArea[0];
+ if (orderedByContainmentThenArea.Count > 1
+ && outer.ContainmentCount == orderedByContainmentThenArea[1].ContainmentCount
+ && double.Abs(double.Abs(outer.Info.SignedArea) - double.Abs(orderedByContainmentThenArea[1].Info.SignedArea)) <= areaTolerance)
{
return LoopRoleFailure<IReadOnlyList<LoopBuildData>>("Unable to choose a unique outer loop.", "Importer.LoopRole.AmbiguousOuter");
}
- foreach (var candidate in infos.Where(i => i.Loop.LoopId != outer.Loop.LoopId))
+ var containedInners = new List<PlanarLoopInfo>();
+
+ foreach (var candidate in infosWithSamples.Where(i => i.Info.Loop.LoopId != outer.Info.Loop.LoopId))
{
- var testPointResult = ChooseContainmentPoint(candidate.ProjectedPoints);
- if (!testPointResult.IsSuccess)
+ if (IsPointInPolygon(candidate.SamplePoint, outer.Info.ProjectedPoints, containmentTolerance))
{
- return KernelResult<IReadOnlyList<LoopBuildData>>.Failure(testPointResult.Diagnostics);
+ containedInners.Add(candidate.Info);
+ continue;
}
- if (!IsPointInPolygon(testPointResult.Value, outer.ProjectedPoints))
+ if (double.Abs(candidate.Info.SignedArea) <= areaTolerance * 4d
+ || IsPointNearPolygonEdge(candidate.SamplePoint, outer.Info.ProjectedPoints, containmentTolerance * 4d))
{
- return LoopRoleFailure<IReadOnlyList<LoopBuildData>>("Inner loop is not contained by outer loop.", "Importer.LoopRole.InnerNotContained");
+ continue;
}
+
+ var failure = BuildInnerContainmentFailure(candidate.Info, outer.Info, containmentTolerance, areaTolerance);
+ return LoopRoleFailure<IReadOnlyList<LoopBuildData>>(failure.Message, failure.Source);
}
- var innerLoops = infos.Where(i => i.Loop.LoopId != outer.Loop.LoopId).ToList();
+ var innerLoops = containedInners;
for (var i = 0; i < innerLoops.Count; i++)
{
for (var j = i + 1; j < innerLoops.Count; j++)
{
- if (LoopsOverlap(innerLoops[i], innerLoops[j]))
+ if (LoopsOverlap(innerLoops[i], innerLoops[j], containmentTolerance))
{
return LoopRoleFailure<IReadOnlyList<LoopBuildData>>("Inner loops overlap or are nested.", "Importer.LoopRole.InnerOverlap");
}
}
}
- var normalizedOuter = NormalizeLoopWinding(outer.Loop, outer.SignedArea, shouldBePositive: true);
+ var normalizedOuter = NormalizeLoopWinding(outer.Info.Loop, outer.Info.SignedArea, shouldBePositive: true);
var normalizedInners = innerLoops
- .OrderBy(i => i.Loop.LoopId.Value)
+ .OrderByDescending(i => double.Abs(i.SignedArea))
+ .ThenBy(i => i.Loop.LoopId.Value)
.Select(i => NormalizeLoopWinding(i.Loop, i.SignedArea, shouldBePositive: false))
.ToList();
@@ -1037,19 +1074,121 @@ public static class Step242Importer
return new LoopBuildData(loop.LoopId, flippedCoedges, loop.Samples);
}
- private static bool LoopsOverlap(PlanarLoopInfo a, PlanarLoopInfo b)
+ private static bool LoopsOverlap(PlanarLoopInfo a, PlanarLoopInfo b, double containmentTolerance)
{
- var aPoint = ChooseContainmentPoint(a.ProjectedPoints);
- var bPoint = ChooseContainmentPoint(b.ProjectedPoints);
+ var aPoint = ChooseContainmentPoint(a.ProjectedPoints, containmentTolerance);
+ var bPoint = ChooseContainmentPoint(b.ProjectedPoints, containmentTolerance);
if (!aPoint.IsSuccess || !bPoint.IsSuccess)
{
return true;
}
- return IsPointInPolygon(aPoint.Value, b.ProjectedPoints) || IsPointInPolygon(bPoint.Value, a.ProjectedPoints);
+ return IsPointInPolygon(aPoint.Value, b.ProjectedPoints, containmentTolerance) || IsPointInPolygon(bPoint.Value, a.ProjectedPoints, containmentTolerance);
+ }
+
+ private static ContainmentFailure BuildInnerContainmentFailure(
+ PlanarLoopInfo inner,
+ PlanarLoopInfo outer,
+ double containmentTolerance,
+ double areaTolerance)
+ {
+ var containment = EvaluateContainment(inner.ProjectedPoints, outer.ProjectedPoints, containmentTolerance);
+ var crossingOuter = PolygonsIntersect(inner.ProjectedPoints, outer.ProjectedPoints, containmentTolerance);
+
+ var areaRatio = double.Abs(outer.SignedArea) <= areaTolerance
+ ? 0d
+ : double.Abs(inner.SignedArea) / double.Abs(outer.SignedArea);
+
+ var reason = crossingOuter
+ ? "crosses_outer_boundary"
+ : (containment.OutsideCount == containment.VertexCount ? "disjoint" : "partially_outside");
+
+ var source = reason switch
+ {
+ "crosses_outer_boundary" => "Importer.LoopRole.InnerCrossesOuterAfterNormalization",
+ "disjoint" => "Importer.LoopRole.InnerDisjointAfterNormalization",
+ _ => "Importer.LoopRole.InnerPartiallyOutsideAfterNormalization"
+ };
+
+ var message = $"Inner loop could not be normalized: {reason}. innerLoopId={inner.Loop.LoopId.Value}, outerLoopId={outer.Loop.LoopId.Value}, outsideVertices={containment.OutsideCount}/{containment.VertexCount}, nearestOuterDistance={containment.MinDistanceToOuter:E6}, areaRatio={areaRatio:E6}.";
+ return new ContainmentFailure(message, source);
+ }
+
+ private static ContainmentEvaluation EvaluateContainment(
+ IReadOnlyList<UvPoint> inner,
+ IReadOnlyList<UvPoint> outer,
+ double containmentTolerance)
+ {
+ var outsideCount = 0;
+ var vertexCount = 0;
+ var minDistanceToOuter = double.MaxValue;
+
+ for (var i = 0; i < inner.Count - 1; i++)
+ {
+ var point = inner[i];
+ vertexCount++;
+ minDistanceToOuter = double.Min(minDistanceToOuter, DistancePointToPolygon(point, outer));
+ if (!IsPointInPolygon(point, outer, containmentTolerance))
+ {
+ outsideCount++;
+ }
+ }
+
+ if (double.IsPositiveInfinity(minDistanceToOuter) || minDistanceToOuter == double.MaxValue)
+ {
+ minDistanceToOuter = 0d;
+ }
+
+ return new ContainmentEvaluation(outsideCount, vertexCount, minDistanceToOuter);
+ }
+
+ private static double DistancePointToPolygon(UvPoint point, IReadOnlyList<UvPoint> polygon)
+ {
+ var minDistance = double.MaxValue;
+ for (var i = 0; i < polygon.Count - 1; i++)
+ {
+ minDistance = double.Min(minDistance, DistancePointToSegment(point, polygon[i], polygon[i + 1]));
+ }
+
+ return minDistance;
+ }
+
+ private static bool PolygonsIntersect(IReadOnlyList<UvPoint> a, IReadOnlyList<UvPoint> b, double tolerance)
+ {
+ for (var i = 0; i < a.Count - 1; i++)
+ {
+ for (var j = 0; j < b.Count - 1; j++)
+ {
+ if (SegmentsIntersect(a[i], a[i + 1], b[j], b[j + 1], tolerance))
+ {
+ return true;
+ }
+ }
+ }
+
+ return false;
+ }
+
+ private static bool SegmentsIntersect(UvPoint a0, UvPoint a1, UvPoint b0, UvPoint b1, double tolerance)
+ {
+ if (DistancePointToSegment(a0, b0, b1) <= tolerance || DistancePointToSegment(a1, b0, b1) <= tolerance
+ || DistancePointToSegment(b0, a0, a1) <= tolerance || DistancePointToSegment(b1, a0, a1) <= tolerance)
+ {
+ return true;
+ }
+
+ var o1 = Orientation(a0, a1, b0);
+ var o2 = Orientation(a0, a1, b1);
+ var o3 = Orientation(b0, b1, a0);
+ var o4 = Orientation(b0, b1, a1);
+
+ return (o1 * o2) < 0d && (o3 * o4) < 0d;
}
- private static KernelResult<UvPoint> ChooseContainmentPoint(IReadOnlyList<UvPoint> polygon)
+ private static double Orientation(UvPoint a, UvPoint b, UvPoint c)
+ => ((b.X - a.X) * (c.Y - a.Y)) - ((b.Y - a.Y) * (c.X - a.X));
+
+ private static KernelResult<UvPoint> ChooseContainmentPoint(IReadOnlyList<UvPoint> polygon, double containmentTolerance)
{
if (polygon.Count < 4)
{
@@ -1057,7 +1196,7 @@ public static class Step242Importer
}
var centroid = ComputePolygonCentroid(polygon);
- if (!IsPointNearPolygonEdge(centroid, polygon) && IsPointInPolygon(centroid, polygon))
+ if (!IsPointNearPolygonEdge(centroid, polygon, containmentTolerance) && IsPointInPolygon(centroid, polygon, containmentTolerance))
{
return KernelResult<UvPoint>.Success(centroid);
}
@@ -1069,7 +1208,7 @@ public static class Step242Importer
var midpoint = new UvPoint((start.X + end.X) * 0.5d, (start.Y + end.Y) * 0.5d);
var towardCentroid = centroid - midpoint;
var candidate = midpoint + (towardCentroid * 0.125d);
- if (!IsPointNearPolygonEdge(candidate, polygon) && IsPointInPolygon(candidate, polygon))
+ if (!IsPointNearPolygonEdge(candidate, polygon, containmentTolerance) && IsPointInPolygon(candidate, polygon, containmentTolerance))
{
return KernelResult<UvPoint>.Success(candidate);
}
@@ -1099,11 +1238,11 @@ public static class Step242Importer
return new UvPoint(sumX / count, sumY / count);
}
- private static bool IsPointNearPolygonEdge(UvPoint point, IReadOnlyList<UvPoint> polygon)
+ private static bool IsPointNearPolygonEdge(UvPoint point, IReadOnlyList<UvPoint> polygon, double containmentTolerance)
{
for (var i = 0; i < polygon.Count - 1; i++)
{
- if (DistancePointToSegment(point, polygon[i], polygon[i + 1]) <= ContainmentEps)
+ if (DistancePointToSegment(point, polygon[i], polygon[i + 1]) <= containmentTolerance)
{
return true;
}
@@ -1135,7 +1274,7 @@ public static class Step242Importer
return (p - closest).Length;
}
- private static bool IsPointInPolygon(UvPoint point, IReadOnlyList<UvPoint> polygon)
+ private static bool IsPointInPolygon(UvPoint point, IReadOnlyList<UvPoint> polygon, double containmentTolerance)
{
var inside = false;
for (var i = 0; i < polygon.Count - 1; i++)
@@ -1143,7 +1282,7 @@ public static class Step242Importer
var a = polygon[i];
var b = polygon[i + 1];
- if (DistancePointToSegment(point, a, b) <= ContainmentEps)
+ if (DistancePointToSegment(point, a, b) <= containmentTolerance)
{
return true;
}
@@ -1159,12 +1298,12 @@ public static class Step242Importer
return inside;
}
- private static int CountUniquePoints(IReadOnlyList<UvPoint> points)
+ private static int CountUniquePoints(IReadOnlyList<UvPoint> points, double tolerance)
{
var unique = new List<UvPoint>();
foreach (var point in points)
{
- if (unique.Any(u => (u - point).Length <= ContainmentEps))
+ if (unique.Any(u => (u - point).Length <= tolerance))
{
continue;
}
@@ -1205,6 +1344,38 @@ public static class Step242Importer
return 0.5d * area;
}
+ private static double ComputeContainmentTolerance(IEnumerable<UvPoint> points)
+ {
+ var array = points.ToArray();
+ if (array.Length == 0)
+ {
+ return ContainmentEps;
+ }
+
+ var minX = array.Min(p => p.X);
+ var maxX = array.Max(p => p.X);
+ var minY = array.Min(p => p.Y);
+ var maxY = array.Max(p => p.Y);
+ var diagonal = double.Sqrt(((maxX - minX) * (maxX - minX)) + ((maxY - minY) * (maxY - minY)));
+ return double.Max(ContainmentEps, diagonal * 1e-6d);
+ }
+
+ private static double ComputeAreaTolerance(IEnumerable<UvPoint> points)
+ {
+ var array = points.ToArray();
+ if (array.Length == 0)
+ {
+ return AreaEps;
+ }
+
+ var minX = array.Min(p => p.X);
+ var maxX = array.Max(p => p.X);
+ var minY = array.Min(p => p.Y);
+ var maxY = array.Max(p => p.Y);
+ var extentArea = (maxX - minX) * (maxY - minY);
+ return double.Max(AreaEps, extentArea * 1e-8d);
+ }
+
private static void AppendLoopSamples(ICollection<Point3D> loopSamples, IReadOnlyList<Point3D> edgeSamples)
{
foreach (var point in edgeSamples)
@@ -1292,6 +1463,14 @@ public static class Step242Importer
private sealed record PlanarLoopInfo(LoopBuildData Loop, IReadOnlyList<UvPoint> ProjectedPoints, double SignedArea);
+ private sealed record PlanarLoopInfoWithSample(PlanarLoopInfo Info, UvPoint SamplePoint);
+
+ private sealed record PlanarLoopOuterCandidate(PlanarLoopInfo Info, UvPoint SamplePoint, int ContainmentCount);
+
+ private sealed record ContainmentEvaluation(int OutsideCount, int VertexCount, double MinDistanceToOuter);
+
+ private sealed record ContainmentFailure(string Message, string Source);
+
private readonly record struct UvPoint(double X, double Y)
{
public static UvPoint operator +(UvPoint a, UvPoint b) => new(a.X + b.X, a.Y + b.Y);
diff --git a/testdata/step242/manifests/nist.v0.report.json b/testdata/step242/manifests/nist.v0.report.json
index 38246c1b..e9b7b283 100644
--- a/testdata/step242/manifests/nist.v0.report.json
+++ b/testdata/step242/manifests/nist.v0.report.json
@@ -79,8 +79,8 @@
"firstFailureLayer": "importer-topology",
"firstDiagnostic": {
"code": "ValidationFailed",
- "source": "Importer.LoopRole.InnerNotContained",
- "messagePrefix": "Inner loop is not contained by outer loop."
+ "source": "Importer.LoopRole.InnerCrossesOuterAfterNormalization",
+ "messagePrefix": "Inner loop could not be normalized"
},
"diagnosticCount": 1,
"exceptionEscaped": false,
@@ -103,8 +103,8 @@
"firstFailureLayer": "importer-topology",
"firstDiagnostic": {
"code": "ValidationFailed",
- "source": "Importer.LoopRole.DegenerateLoop",
- "messagePrefix": "Loop projection is degenerate."
+ "source": "Importer.LoopRole.CylinderMappingFailed",
+ "messagePrefix": "Cylinder multi-loop hole classification is not yet safely supported."
},
"diagnosticCount": 1,
"exceptionEscaped": false,
@@ -150,9 +150,9 @@
"status": "importFail",
"firstFailureLayer": "importer-topology",
"firstDiagnostic": {
- "code": "ValidationFailed",
- "source": "Importer.LoopRole.InnerNotContained",
- "messagePrefix": "Inner loop is not contained by outer loop."
+ "code": "NotImplemented",
+ "source": "Importer.EntityFamily",
+ "messagePrefix": "ADVANCED_FACE surface \u0027B_SPLINE_SURFACE_WITH_KNOTS\u0027 is unsupported."
},
"diagnosticCount": 1,
"exceptionEscaped": false,
@@ -247,8 +247,8 @@
"firstFailureLayer": "importer-topology",
"firstDiagnostic": {
"code": "ValidationFailed",
- "source": "Importer.LoopRole.InnerNotContained",
- "messagePrefix": "Inner loop is not contained by outer loop."
+ "source": "Importer.LoopRole.InnerCrossesOuterAfterNormalization",
+ "messagePrefix": "Inner loop could not be normalized"
},
"diagnosticCount": 1,
"exceptionEscaped": false,
@@ -294,9 +294,9 @@
"status": "importFail",
"firstFailureLayer": "importer-topology",
"firstDiagnostic": {
- "code": "ValidationFailed",
- "source": "Importer.LoopRole.DegenerateLoop",
- "messagePrefix": "Loop projection is degenerate."
+ "code": "NotImplemented",
+ "source": "Importer.EntityFamily",
+ "messagePrefix": "EDGE_CURVE geometry \u0027ELLIPSE\u0027 is unsupported."
},
"diagnosticCount": 1,
"exceptionEscaped": false,
@@ -367,10 +367,10 @@
"firstFailureLayer": "importer-topology",
"firstDiagnostic": {
"code": "ValidationFailed",
- "source": "Importer.LoopRole.DegenerateLoop",
- "messagePrefix": "Loop projection is degenerate."
+ "source": "",
+ "messagePrefix": "Loop 51 references missing child ID CoedgeId { Value = 219, IsValid = True }."
},
- "diagnosticCount": 1,
+ "diagnosticCount": 29,
"exceptionEscaped": false,
"topologyCounts": {
"vertices": 0,