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.csindex 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.csnew file mode 100644index 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.csindex 8a8a134f..295a5b08 100644--- a/Aetheris.Kernel.Core/Step242/Step242Importer.cs+++ b/Aetheris.Kernel.Core/Step242/Step242Importer.cs@@ -966,55 +966,92 @@ public static class Step242Importerforeach (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 Step242Importerreturn 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 Step242Importervar 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 Step242Importerreturn 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 Step242Importerreturn (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 Step242Importervar 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 Step242Importerreturn 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 Step242Importerreturn 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 Step242Importerprivate 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.jsonindex 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,