Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel
Add analyze map components and probes
Yuechen Lide7f69615a56
diff --git a/Aetheris.CLI.Tests/CliBaselineTests.cs b/Aetheris.CLI.Tests/CliBaselineTests.csindex f09e5d4e..53c40c97 100644--- a/Aetheris.CLI.Tests/CliBaselineTests.cs+++ b/Aetheris.CLI.Tests/CliBaselineTests.cs@@ -561,7 +561,26 @@ public sealed class CliBaselineTestsAssert.Equal(8, compactGrid.GetProperty("width").GetInt32());Assert.Equal(8, compactGrid.GetProperty("height").GetInt32());Assert.Equal(8, compactGrid.GetProperty("rows").GetArrayLength());+ Assert.True(view.TryGetProperty("components", out var components));+ Assert.DoesNotContain(components.GetProperty("noHit").EnumerateArray(), c => c.GetProperty("classificationHint").GetString() == "interior-opening-candidate");+ Assert.NotEmpty(components.GetProperty("heightBands").EnumerateArray());+ Assert.NotEmpty(components.GetProperty("surfaceFamilies").EnumerateArray());+ Assert.NotEmpty(view.GetProperty("suggestedProbes").EnumerateArray());}++ Assert.NotEmpty(root.GetProperty("suggestedProbes").EnumerateArray());+ }++ [Fact]+ public void Analyze_Map_SixView_Llm_Cylinder_Reports_Surface_Component_Probe()+ {+ var stepPath = ExportPrimitiveToTempStep(BrepPrimitives.CreateCylinder(3d, 8d).Value, "cli-six-view-cylinder-component");+ using var doc = RunAnalyzeSixViewMap(stepPath, "17x17");+ var views = doc.RootElement.GetProperty("views").EnumerateArray().ToArray();+ var hasCylinder = views.Any(v => v.GetProperty("components").GetProperty("surfaceFamilies").EnumerateArray().Any(c => c.GetProperty("surfaceFamily").GetString() == "cylinder"));++ Assert.True(hasCylinder, doc.RootElement.GetRawText());+ Assert.Contains(doc.RootElement.GetProperty("suggestedProbes").EnumerateArray(), p => p.GetProperty("command").GetString()?.Contains("--point", StringComparison.Ordinal) == true);}[Fact]@@ -576,6 +595,8 @@ public sealed class CliBaselineTestsAssert.True(top.GetProperty("summary").GetProperty("backendCounts").GetProperty("analytic").GetInt32() > 0);Assert.Equal(0, top.GetProperty("summary").GetProperty("backendCounts").GetProperty("tessellated-fallback").GetInt32());Assert.DoesNotContain("~", string.Concat(top.GetProperty("compactGrid").GetProperty("rows").EnumerateArray().Select(r => r.GetString())));+ Assert.Contains(top.GetProperty("components").GetProperty("surfaceFamilies").EnumerateArray(), c => c.GetProperty("surfaceFamily").GetString() == "torus");+ Assert.Contains(top.GetProperty("suggestedProbes").EnumerateArray(), p => p.GetProperty("reason").GetString()?.Contains("torus", StringComparison.OrdinalIgnoreCase) == true);}[Fact]@@ -588,6 +609,7 @@ public sealed class CliBaselineTestsAssert.Contains("linear-extrusion", root.GetRawText(), StringComparison.Ordinal);Assert.Contains("tessellated-fallback", root.GetRawText(), StringComparison.Ordinal);Assert.Contains(root.GetProperty("diagnostics").EnumerateArray(), d => d.GetString()?.Contains("used tessellated fallback", StringComparison.Ordinal) == true);+ Assert.Contains(root.GetProperty("views").EnumerateArray(), v => v.GetProperty("components").GetProperty("noHit").GetArrayLength() > 0 || v.GetProperty("components").GetProperty("fallback").GetArrayLength() > 0);}diff --git a/Aetheris.CLI/StepAnalysisModels.cs b/Aetheris.CLI/StepAnalysisModels.csindex 8d4b65b8..c932184d 100644--- a/Aetheris.CLI/StepAnalysisModels.cs+++ b/Aetheris.CLI/StepAnalysisModels.cs@@ -124,11 +124,15 @@ public sealed record RayMapHit(double T, Point3D Position, int? FaceIndex, strinpublic sealed record RayMapSample(int I, int J, double U, double V, bool Hit, RayMapHit? FirstHit, RayMapHit? LastHit, int HitCount, IReadOnlyList<RayMapHit> Hits, IReadOnlyDictionary<string, int> IntersectionModes);public sealed record RayMapSummary(double HitCoverage, double[]? HeightRange, IReadOnlyDictionary<string, int> SurfaceFamiliesHit, int AnalyticHitCount, int CirHitCount, int TessellatedFallbackHitCount, int UnsupportedSampleCount);public sealed record RayMapResult(string Mode, string Plane, string Direction, int[]? Resolution, double[]? Point, RayMapBounds Bounds, IReadOnlyList<RayMapSample> Samples, int HitCount, IReadOnlyList<RayMapHit>? Hits, RayMapSummary Summary, string IntersectionMode, string BackendPolicy, IReadOnlyList<string> Diagnostics);-public sealed record SixViewMapResult(string Mode, string MapVersion, int[] Resolution, IReadOnlyList<SixViewMapView> Views, IReadOnlyList<string> Diagnostics);-public sealed record SixViewMapView(string Name, string Plane, string Direction, SixViewMapSummary Summary, CompactGrid? CompactGrid, IReadOnlyList<string> MeasuredSummary);+public sealed record SixViewMapResult(string Mode, string MapVersion, int[] Resolution, IReadOnlyList<SixViewMapView> Views, IReadOnlyList<SuggestedMapProbe> SuggestedProbes, IReadOnlyList<string> Diagnostics);+public sealed record SixViewMapView(string Name, string Plane, string Direction, SixViewMapSummary Summary, CompactGrid? CompactGrid, SixViewMapComponents Components, IReadOnlyList<SuggestedMapProbe> SuggestedProbes, IReadOnlyList<string> MeasuredSummary);public sealed record SixViewMapSummary(int SampleCount, int HitCount, double HitCoverage, double[]? HeightRange, IReadOnlyList<DominantBand> DominantBands, IReadOnlyDictionary<string, int> SurfaceFamiliesHit, IReadOnlyDictionary<string, int> BackendCounts, double FallbackRatio);public sealed record DominantBand(double? Value, int SampleCount, double Coverage, string? Meaning, bool MostlyFallback);public sealed record CompactGrid(string Encoding, int Width, int Height, IReadOnlyDictionary<string, string> Legend, IReadOnlyList<string> Rows);+public sealed record SixViewMapComponents(IReadOnlyList<MapComponent> NoHit, IReadOnlyList<MapComponent> HeightBands, IReadOnlyList<MapComponent> SurfaceFamilies, IReadOnlyList<MapComponent> Fallback, bool Truncated, int OmittedCount);+public sealed record MapComponent(string ComponentId, string Kind, string View, int CellCount, double Coverage, bool TouchesBorder, CellBoundingBox BboxCells, double[] CentroidCell, double[] CentroidUv, string? ClassificationHint, string Confidence, string? Band, double? RepresentativeValue, string? SurfaceFamily, string? BackendModeDominance);+public sealed record CellBoundingBox(int MinI, int MinJ, int MaxI, int MaxJ);+public sealed record SuggestedMapProbe(string ProbeId, string View, string Plane, string Direction, double[] Point, string Reason, string Command, string? SourceComponentId);public enum SectionPlaneFamily{diff --git a/Aetheris.CLI/StepAnalyzer.cs b/Aetheris.CLI/StepAnalyzer.csindex d8f1f32e..6557df25 100644--- a/Aetheris.CLI/StepAnalyzer.cs+++ b/Aetheris.CLI/StepAnalyzer.cs@@ -963,10 +963,10 @@ public sealed record VolumeAnalysisResult(diagnostics.Add($"{definition.Name}: {diagnostic}");}- views.Add(BuildSixViewSummary(definition.Name, map, cols, rows));+ views.Add(BuildSixViewSummary(definition.Name, map, cols, rows, stepPath));}- return new SixViewMapResult("six-view-summary", "analyze-map-v1", [cols, rows], views, diagnostics.ToArray());+ return new SixViewMapResult("six-view-summary", "analyze-map-v1", [cols, rows], views, views.SelectMany(v => v.SuggestedProbes).Take(30).ToArray(), diagnostics.ToArray());}public static RayMapResult AnalyzeImportedBodyRayMap(BrepBody body, string stepPath, string plane, string direction, int cols, int rows, (double U, double V)? point = null)@@ -1063,7 +1063,7 @@ public sealed record VolumeAnalysisResult(return new RayMapResult(mode, plane.ToLowerInvariant(), direction.ToLowerInvariant(), point.HasValue ? null : [cols, rows], pointArray, bounds, samples, samples.Sum(s => s.HitCount), point.HasValue ? samples.Single().Hits : null, summary, resultMode, "analytic-cir-tessellated-fallback", diagnostics);}- private static SixViewMapView BuildSixViewSummary(string name, RayMapResult map, int cols, int rows)+ private static SixViewMapView BuildSixViewSummary(string name, RayMapResult map, int cols, int rows, string stepPath){var sampleCount = map.Samples.Count;var hitCount = map.Samples.Count(s => s.Hit);@@ -1087,8 +1087,10 @@ public sealed record VolumeAnalysisResult(backendHitTotal == 0 ? 0d : map.Summary.TessellatedFallbackHitCount / (double)backendHitTotal);var compactGrid = cols <= 64 && rows <= 64 ? BuildCompactGrid(map.Samples, cols, rows, bands, map.Direction) : null;- var measured = BuildMeasuredSummary(name, map, summary);- return new SixViewMapView(name, map.Plane, map.Direction, summary, compactGrid, measured);+ var components = BuildSixViewComponents(name, map, cols, rows, bands);+ var probes = BuildSuggestedProbes(name, map.Plane, map.Direction, stepPath, components).Take(10).ToArray();+ var measured = BuildMeasuredSummary(name, map, summary, components);+ return new SixViewMapView(name, map.Plane, map.Direction, summary, compactGrid, components, probes, measured);}private static IReadOnlyList<DominantBand> BuildDominantBands(IReadOnlyList<RayMapSample> samples, int sampleCount, string direction)@@ -1181,7 +1183,126 @@ public sealed record VolumeAnalysisResult(}, gridRows);}- private static IReadOnlyList<string> BuildMeasuredSummary(string name, RayMapResult map, SixViewMapSummary summary)+ private static SixViewMapComponents BuildSixViewComponents(string view, RayMapResult map, int cols, int rows, IReadOnlyList<DominantBand> bands)+ {+ const int limit = 10;+ var noHit = FindComponents(view, "no-hit", cols, rows, map.Samples, s => !s.Hit || s.FirstHit is null, _ => "no-hit")+ .Select((c, index) => c with+ {+ ComponentId = $"{view}.nohit.{index}",+ ClassificationHint = c.TouchesBorder ? "silhouette-or-exterior-gap" : "interior-opening-candidate",+ Confidence = c.TouchesBorder ? (c.CellCount >= 8 ? "medium" : "low") : (c.CellCount >= 4 ? "medium" : "low")+ })+ .OrderByDescending(c => c.CellCount)+ .ThenBy(c => c.BboxCells.MinJ)+ .ThenBy(c => c.BboxCells.MinI)+ .ToArray();++ var bandValues = bands.Where(b => b.Value.HasValue).Select((b, i) => (Value: b.Value!.Value, Symbol: i.ToString(System.Globalization.CultureInfo.InvariantCulture))).ToDictionary(x => x.Value, x => x.Symbol);+ var heightBands = FindComponents(view, "height-band", cols, rows, map.Samples, s => s.Hit && s.FirstHit is not null && s.FirstHit.IntersectionMode != "tessellated-fallback", s =>+ Math.Round(GetRayAxisScalar(s.FirstHit!.Position, map.Direction), 4, MidpointRounding.AwayFromZero).ToString("0.####", System.Globalization.CultureInfo.InvariantCulture))+ .Select((c, index) =>+ {+ var value = double.TryParse(c.Band, System.Globalization.NumberStyles.Float, System.Globalization.CultureInfo.InvariantCulture, out var v) ? v : (double?)null;+ var symbol = value.HasValue && bandValues.TryGetValue(value.Value, out var b) ? b : c.Band;+ return c with { ComponentId = $"{view}.band.{index}", Band = symbol, RepresentativeValue = value, Confidence = c.CellCount >= 4 ? "medium" : "low" };+ })+ .OrderByDescending(c => c.CellCount)+ .Where(c => IsSignificantComponent(c, rows * cols)).Take(20)+ .ToArray();++ var surfaceFamilies = FindComponents(view, "surface-family", cols, rows, map.Samples, s => s.Hit && s.FirstHit is not null, s => s.FirstHit!.SurfaceFamily ?? "unknown")+ .Select((c, index) => c with { ComponentId = $"{view}.surface.{index}", SurfaceFamily = c.Band, Band = null, Confidence = c.CellCount >= 3 ? "medium" : "low" })+ .OrderByDescending(c => c.CellCount)+ .Where(c => IsSignificantComponent(c, rows * cols)).Take(20)+ .ToArray();++ var fallback = FindComponents(view, "fallback", cols, rows, map.Samples, s => s.FirstHit?.IntersectionMode == "tessellated-fallback", _ => "tessellated-fallback")+ .Select((c, index) => c with { ComponentId = $"{view}.fallback.{index}", BackendModeDominance = "tessellated-fallback", Confidence = c.CellCount >= 3 ? "medium" : "low" })+ .OrderByDescending(c => c.CellCount)+ .ToArray();++ var omitted = Math.Max(0, noHit.Length - limit) + Math.Max(0, heightBands.Length - limit) + Math.Max(0, surfaceFamilies.Length - limit) + Math.Max(0, fallback.Length - limit);+ return new SixViewMapComponents(noHit.Take(limit).ToArray(), heightBands.Take(limit).ToArray(), surfaceFamilies.Take(limit).ToArray(), fallback.Take(limit).ToArray(), omitted > 0, omitted);+ }++ private static bool IsSignificantComponent(MapComponent component, int totalCells) => component.CellCount > 1 || component.Coverage >= 0.02d;++ private static IReadOnlyList<MapComponent> FindComponents(string view, string kind, int cols, int rows, IReadOnlyList<RayMapSample> samples, Func<RayMapSample, bool> include, Func<RayMapSample, string> keySelector)+ {+ var byCell = samples.ToDictionary(s => (s.I, s.J));+ var visited = new HashSet<(int I, int J)>();+ var components = new List<MapComponent>();+ for (var j = 0; j < rows; j++)+ for (var i = 0; i < cols; i++)+ {+ if (visited.Contains((i, j)) || !byCell.TryGetValue((i, j), out var seed) || !include(seed)) continue;+ var key = keySelector(seed);+ var queue = new Queue<RayMapSample>();+ var cells = new List<RayMapSample>();+ queue.Enqueue(seed);+ visited.Add((i, j));+ while (queue.Count > 0)+ {+ var current = queue.Dequeue();+ cells.Add(current);+ foreach (var (ni, nj) in new[] { (current.I - 1, current.J), (current.I + 1, current.J), (current.I, current.J - 1), (current.I, current.J + 1) })+ {+ if (ni < 0 || nj < 0 || ni >= cols || nj >= rows || visited.Contains((ni, nj)) || !byCell.TryGetValue((ni, nj), out var next) || !include(next) || keySelector(next) != key) continue;+ visited.Add((ni, nj));+ queue.Enqueue(next);+ }+ }++ var bbox = new CellBoundingBox(cells.Min(c => c.I), cells.Min(c => c.J), cells.Max(c => c.I), cells.Max(c => c.J));+ var centroidCell = new[] { cells.Average(c => c.I), cells.Average(c => c.J) };+ var centroidUv = new[] { cells.Average(c => c.U), cells.Average(c => c.V) };+ var backend = cells.Select(c => c.FirstHit?.IntersectionMode ?? "unsupported").GroupBy(x => x, StringComparer.Ordinal).OrderByDescending(g => g.Count()).ThenBy(g => g.Key, StringComparer.Ordinal).First().Key;+ components.Add(new MapComponent("", kind, view, cells.Count, cells.Count / (double)(cols * rows), cells.Any(c => c.I == 0 || c.J == 0 || c.I == cols - 1 || c.J == rows - 1), bbox, centroidCell, centroidUv, null, "low", key, null, null, backend));+ }++ return components;+ }++ private static IReadOnlyList<SuggestedMapProbe> BuildSuggestedProbes(string view, string plane, string direction, string stepPath, SixViewMapComponents components)+ {+ var probes = new List<SuggestedMapProbe>();+ foreach (var component in components.NoHit.Take(3))+ {+ var reason = component.TouchesBorder ? "Border-touching silhouette gap; probe to confirm exterior or edge cutout region." : "Center of interior no-hit component; probe to distinguish through-opening, recess, or missing hit.";+ probes.Add(MakeProbe($"{component.ComponentId}.center", view, plane, direction, stepPath, component, reason));+ }++ foreach (var component in components.SurfaceFamilies.Where(c => c.SurfaceFamily is "cylinder" or "cone" or "sphere" or "torus").Take(3))+ {+ var family = component.SurfaceFamily == "cylinder" ? "cylindrical" : component.SurfaceFamily;+ probes.Add(MakeProbe($"{component.ComponentId}.center", view, plane, direction, stepPath, component, $"Center of {family} hit component; inspect possible round or curved feature."));+ }++ foreach (var component in components.HeightBands.Take(2))+ {+ var reason = component == components.HeightBands.FirstOrDefault()+ ? "Representative point on dominant height plateau."+ : "Representative point on isolated height band component.";+ probes.Add(MakeProbe($"{component.ComponentId}.center", view, plane, direction, stepPath, component, reason));+ }++ foreach (var component in components.Fallback.Take(2))+ {+ probes.Add(MakeProbe($"{component.ComponentId}.center", view, plane, direction, stepPath, component, "Center of tessellated fallback component; measurement is approximate and may need analytic support."));+ }++ return probes.Take(10).ToArray();+ }++ private static SuggestedMapProbe MakeProbe(string id, string view, string plane, string direction, string stepPath, MapComponent component, string reason)+ {+ var pointText = $"{component.CentroidUv[0]:0.####},{component.CentroidUv[1]:0.####}";+ var command = $"aetheris analyze map {stepPath} --plane {plane} --direction {direction} --point {pointText} --json";+ return new SuggestedMapProbe(id, view, plane, direction, component.CentroidUv, reason, command, component.ComponentId);+ }++ private static IReadOnlyList<string> BuildMeasuredSummary(string name, RayMapResult map, SixViewMapSummary summary, SixViewMapComponents? components = null){var lines = new List<string>{@@ -1199,6 +1320,16 @@ public sealed record VolumeAnalysisResult(lines.Add($"{noHit.Coverage:P1} of samples are no-hit, indicating measured empty rays in this view.");}+ if (components is not null)+ {+ var interiorNoHit = components.NoHit.Count(c => c.ClassificationHint == "interior-opening-candidate");+ var borderNoHit = components.NoHit.Count(c => c.ClassificationHint == "silhouette-or-exterior-gap");+ if (interiorNoHit > 0) lines.Add($"{name} view: found {interiorNoHit} interior no-hit component(s); largest covers {components.NoHit.Where(c => c.ClassificationHint == "interior-opening-candidate").Max(c => c.Coverage):P1} of the sampled view.");+ if (borderNoHit > 0) lines.Add($"{name} view: found {borderNoHit} border-touching no-hit component(s), likely silhouette or exterior gap regions.");+ var curved = components.SurfaceFamilies.FirstOrDefault(c => c.SurfaceFamily is "cylinder" or "cone" or "sphere" or "torus");+ if (curved is not null) lines.Add($"{name} view: largest {curved.SurfaceFamily} hit component is centered near ({curved.CentroidUv[0]:0.####}, {curved.CentroidUv[1]:0.####}); inspect with suggested probe.");+ }+lines.Add(summary.FallbackRatio > 0d? $"{name} view includes tessellated fallback hits; fallback ratio is {summary.FallbackRatio:P1} of hit intersections.": $"{name} view hit intersections are reported without tessellated fallback.");diff --git a/docs/implementation/analyze-map-a4-six-view-llm-summary.md b/docs/implementation/analyze-map-a4-six-view-llm-summary.mdindex 819448e6..06fa2202 100644--- a/docs/implementation/analyze-map-a4-six-view-llm-summary.md+++ b/docs/implementation/analyze-map-a4-six-view-llm-summary.md@@ -118,3 +118,6 @@ For `testdata/step242/generated/ruled-a2/ellipse-linear-extrusion-production.ste- The route summarizes first-hit measurements; it does not replace detailed single-view sample JSON.- The route does not perform feature reconstruction, connected-component naming, rendering, or machine vision.- `analyze volume` policy is unchanged.+++Forward link: ANALYZE-MAP-A5 adds connected components and suggested probes; see `docs/implementation/analyze-map-a5-components-and-probes.md`.diff --git a/docs/implementation/analyze-map-a5-components-and-probes.md b/docs/implementation/analyze-map-a5-components-and-probes.mdnew file mode 100644index 00000000..f1a8f485--- /dev/null+++ b/docs/implementation/analyze-map-a5-components-and-probes.md@@ -0,0 +1,134 @@+# ANALYZE-MAP-A5: connected components and suggested probes++ANALYZE-MAP-A5 extends `aetheris analyze map --views six --llm --json` with conservative connected-component summaries and ready-to-copy follow-up point probes. The goal is to make the six-view map more directly useful to an LLM without asking it to infer topology manually from ASCII grids.++## Purpose++The A4 six-view summary already reports envelope, hit coverage, dominant height/depth bands, surface-family counts, analytic-vs-fallback provenance, and compact grids. Dogfooding on FTC-09 showed that the next useful observation layer is not higher default resolution, but measured regions:++- connected no-hit islands;+- connected same-height/depth bands;+- connected first-hit surface-family clusters;+- connected tessellated fallback/approximate regions;+- concrete point probes derived from those regions.++These are measurement-derived hints. They are not semantic feature reconstruction, and A5 does not claim that a region is a hole, slot, boss, or cutout as fact.++## Connectivity rule++A5 uses **4-connected** grid components. Cells connect only through horizontal or vertical neighbors, not diagonals. This is intentionally conservative for topology: diagonal contact is not treated as a single opening or plateau unless future adaptive refinement proves continuity.++## Output shape++Each six-view entry may include bounded component arrays and per-view suggested probes:++```json+{+ "name": "top",+ "plane": "xy",+ "direction": "-z",+ "components": {+ "noHit": [+ {+ "componentId": "top.nohit.0",+ "kind": "no-hit",+ "view": "top",+ "cellCount": 4,+ "coverage": 0.015625,+ "touchesBorder": false,+ "bboxCells": { "minI": 7, "minJ": 7, "maxI": 8, "maxJ": 8 },+ "centroidCell": [7.5, 7.5],+ "centroidUv": [0.0, 0.0],+ "classificationHint": "interior-opening-candidate",+ "confidence": "medium"+ }+ ],+ "heightBands": [],+ "surfaceFamilies": [],+ "fallback": [],+ "truncated": false,+ "omittedCount": 0+ },+ "suggestedProbes": [+ {+ "probeId": "top.nohit.0.center",+ "view": "top",+ "plane": "xy",+ "direction": "-z",+ "point": [0.0, 0.0],+ "reason": "Center of interior no-hit component; probe to distinguish through-opening, recess, or missing hit.",+ "command": "aetheris analyze map part.step --plane xy --direction -z --point 0,0 --json",+ "sourceComponentId": "top.nohit.0"+ }+ ]+}+```++The top-level `suggestedProbes` array contains the first bounded probes across all views for convenient global consumption.++## Component types++### No-hit components++No-hit cells are grouped where a ray produced no first hit. Each component reports cell count, coverage, border contact, cell bbox, centroid cell, centroid UV coordinate, and a conservative classification hint:++- `interior-opening-candidate` when the component does not touch the sampled view border;+- `silhouette-or-exterior-gap` when it touches the border.++This distinction is the main A5 value: interior no-hit islands are places to inspect, while border-touching no-hit regions are usually silhouette/exterior gaps or edge cutouts.++### Height/depth band components++Hit cells are grouped by the same rounded first-hit scalar used by the compact grid. These components identify dominant planar plateaus and isolated raised/lowered bands. Tiny one-cell noise is filtered unless it covers enough of the view to remain significant.++### Surface-family components++Hit cells are grouped by first-hit surface family, including `plane`, `cylinder`, `cone`, `sphere`, `torus`, `linear-extrusion`, `surface-of-revolution`, `b-spline`, and `unknown` where present. Curved-family components are especially useful when holes or rounds are visible as cylindrical/conical/torus hit clusters rather than no-hit islands.++### Fallback components++Cells whose first hit used tessellated fallback are grouped separately. These regions tell downstream agents where measurements are approximate and where future analytic support or targeted probes may be warranted.++## Suggested probe strategy++A5 generates bounded point probes from component centroids:++- no-hit components: center probe, distinguishing interior candidates from border-touching silhouette gaps;+- curved surface-family components (`cylinder`, `cone`, `sphere`, `torus`): center probe to inspect possible round or curved features;+- height-band components: dominant plateau and isolated plateau/recess representative probes;+- fallback components: center probe with an explicit approximate-measurement reason.++Commands use the native CLI form consistently:++```bash+aetheris analyze map <file.step> --plane xy --direction -z --point <u>,<v> --json+```++## Limits and truncation++Output is bounded to keep LLM summaries readable:++- at most 10 components per category per view;+- at most 10 suggested probes per view;+- at most 30 global suggested probes;+- if component category limits omit entries, `components.truncated` is true and `components.omittedCount` reports the omitted count.++## FTC-09 motivation++FTC-09 dogfooding showed that broad six-view facts were useful but not actionable enough: an LLM still had to parse no-hit islands, bands, and curved regions from compact ASCII. A5 moves that work into the measurement tool, allowing the next LLM step to choose specific point probes instead of visually decoding topology.++## Limitations++- A5 is still grid-sampling, not feature reconstruction.+- Classification hints are conservative and may depend on resolution.+- 4-connected components can split diagonally touching regions.+- Centroid probes are representative, not guaranteed feature centers.+- Fallback regions remain approximate; A5 surfaces them rather than hiding them.+- Detailed ray sample output for non-six-view map analysis is unchanged.++## Next milestone ideas++- Adaptive refinement around hit/no-hit and high-gradient boundaries.+- Face-id grids and connected face-region summaries.+- View-pair correlation to relate a top-view island to front/side evidence.+- Conservative hole/slot candidate hints that remain measured and explicitly non-semantic.diff --git a/docs/reports/analyze-map-dogfood-ftc09-a0.md b/docs/reports/analyze-map-dogfood-ftc09-a0.mdindex eb0dfbfa..317779e6 100644--- a/docs/reports/analyze-map-dogfood-ftc09-a0.md+++ b/docs/reports/analyze-map-dogfood-ftc09-a0.md@@ -103,3 +103,8 @@ Recommended schema improvements:**Recommended next milestone:** `ANALYZE-MAP-A5 — connected components and interesting point suggestions`.FTC-09 shows that the current map already measures the model successfully, but it leaves too much topology interpretation to the LLM. Connected components and suggested point probes are the shortest path from “ASCII measurement grid” to “actionable CAD reasoning loop”: they would identify candidate holes/slots/cutouts conservatively, distinguish border-touching silhouette gaps from interior no-hit islands, and give Codex exact next commands to inspect ambiguous regions without requiring image vision or major feature reconstruction.+++## A5 follow-up++ANALYZE-MAP-A5 was proposed from this dogfood report to turn compact-grid topology into measured connected components and suggested point probes. See `docs/implementation/analyze-map-a5-components-and-probes.md`.