Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel
Add convex prismatic CIR mirror
Yuechen Li47c75112f35c
diff --git a/Aetheris.Kernel.Core.Tests/Cir/CirPrismaticConvexPolyhedronMirrorTests.cs b/Aetheris.Kernel.Core.Tests/Cir/CirPrismaticConvexPolyhedronMirrorTests.csnew file mode 100644index 00000000..b98c6bf5--- /dev/null+++ b/Aetheris.Kernel.Core.Tests/Cir/CirPrismaticConvexPolyhedronMirrorTests.cs@@ -0,0 +1,154 @@+using Aetheris.Kernel.Core.Brep.Prismatic;+using Aetheris.Kernel.Core.Cir.Mirrors;+using Aetheris.Kernel.Core.Math;++namespace Aetheris.Kernel.Core.Tests.Cir;++public sealed class CirPrismaticConvexPolyhedronMirrorTests+{+ [Fact]+ public void CirPrismaticX2_RectangleInsetMirror_AdmitsClassifiesAndSummarizesDeterministically()+ {+ var first = CirPrismaticMirrorBuilder.BuildFromSections("rectangle-inset", RectangleInsetSections());+ var second = CirPrismaticMirrorBuilder.BuildFromSections("rectangle-inset", RectangleInsetSections());++ Assert.True(first.Succeeded, string.Join(Environment.NewLine, first.Diagnostics));+ Assert.Equal(CirMirrorStatus.MirrorAdmittedExact, first.Admission.Status);+ Assert.True(first.Admission.Supports(CirMirrorCapability.PointContainment));+ Assert.True(first.Admission.Supports(CirMirrorCapability.MapOccupancy));+ AssertKnownLosses(first.Admission);++ var mirror = first.Mirror!;+ Assert.Equal(6, mirror.HalfSpaces.Count);+ AssertInside(mirror, new Point3D(0d, 0d, 2d));+ AssertOutside(mirror, new Point3D(8d, 0d, 2d));+ AssertOutside(mirror, new Point3D(0d, 8d, 2d));+ AssertInside(mirror, new Point3D(4.5d, 0d, 0.25d));+ AssertOutside(mirror, new Point3D(4.5d, 0d, 3.75d));++ var summary = mirror.CreateTopViewSummary();+ var repeatedSummary = second.Mirror!.CreateTopViewSummary();+ AssertStableSummary(summary, repeatedSummary);+ Assert.Equal(16, summary.Rows);+ Assert.Equal(16, summary.Cols);+ Assert.Equal(256, summary.OccupiedCount);+ Assert.Equal(0, summary.EmptyCount);+ Assert.InRange(summary.ThicknessMin!.Value, 0.7d, 0.8d);+ Assert.Equal(4d, summary.ThicknessMax!.Value, 6);+ Assert.InRange(summary.ThicknessAverage!.Value, 3.0d, 3.1d);+ Assert.Contains("cir-prismatic-x2-map-summary-created:rectangle-inset", summary.Diagnostics);+ Assert.Contains("cir-prismatic-x2-no-production-analyzer-behavior-changed", first.Diagnostics);+ Assert.Contains("cir-prismatic-x2-no-cir-to-brep-extraction", first.Diagnostics);+ }++ [Fact]+ public void CirPrismaticX2_TopEdgeChamferMirror_AdmitsClassifiesAndSummarizesDeterministically()+ {+ var request = new PrismaticTopEdgeChamferRequest(10d, 6d, 4d, 1d);+ var first = CirPrismaticMirrorBuilder.BuildFromSections("top-edge-chamfer", PrismaticTopEdgeChamferPrototype.CreateSectionStack(request));+ var second = CirPrismaticMirrorBuilder.BuildFromSections("top-edge-chamfer", PrismaticTopEdgeChamferPrototype.CreateSectionStack(request));++ Assert.True(first.Succeeded, string.Join(Environment.NewLine, first.Diagnostics));+ Assert.Equal(CirMirrorStatus.MirrorAdmittedExact, first.Admission.Status);+ Assert.True(first.Admission.Supports(CirMirrorCapability.PointContainment));+ Assert.True(first.Admission.Supports(CirMirrorCapability.MapOccupancy));+ AssertKnownLosses(first.Admission);++ var mirror = first.Mirror!;+ Assert.Equal(10, mirror.HalfSpaces.Count);+ AssertInside(mirror, new Point3D(4.5d, 0d, 2.5d));+ AssertOutside(mirror, new Point3D(4.5d, 0d, 3.75d));+ AssertInside(mirror, new Point3D(4.25d, 0d, 3.25d));+ AssertOutside(mirror, new Point3D(4.75d, 0d, 3.75d));+ AssertInside(mirror, new Point3D(0d, 0d, 2d));++ var summary = mirror.CreateTopViewSummary();+ var repeatedSummary = second.Mirror!.CreateTopViewSummary();+ AssertStableSummary(summary, repeatedSummary);+ Assert.Equal(256, summary.OccupiedCount);+ Assert.Equal(0, summary.EmptyCount);+ Assert.InRange(summary.ThicknessMin!.Value, 3.3d, 3.4d);+ Assert.Equal(4d, summary.ThicknessMax!.Value, 6);+ Assert.InRange(summary.ThicknessAverage!.Value, 3.9d, 4.0d);+ Assert.Contains("cir-prismatic-x2-map-summary-created:top-edge-chamfer", summary.Diagnostics);+ Assert.Contains("cir-prismatic-x2-halfspace-count:10", first.Diagnostics);+ }++ [Fact]+ public void CirPrismaticX2_LossyTopologyRequestsRejectWithoutMapSummaryClaim()+ {+ var result = CirPrismaticMirrorBuilder.BuildFromSections("rectangle-inset", RectangleInsetSections());+ var mirror = result.Mirror!;++ var faceIdentity = mirror.RejectLossyRequest(CirPrismaticMirrorRequestKind.FaceIdentity);+ var topologyParity = mirror.RejectLossyRequest(CirPrismaticMirrorRequestKind.TopologyParity);++ Assert.Equal(CirMirrorStatus.MirrorRejectedLossyForRequest, faceIdentity.Status);+ Assert.False(faceIdentity.Supports(CirMirrorCapability.MapOccupancy));+ Assert.Contains("cir-prismatic-x2-mirror-rejected-lossy-for-request:face-identity", faceIdentity.Diagnostics);+ Assert.Contains("cir-prismatic-x2-loss-face-identity", faceIdentity.Diagnostics);++ Assert.Equal(CirMirrorStatus.MirrorRejectedLossyForRequest, topologyParity.Status);+ Assert.False(topologyParity.Supports(CirMirrorCapability.MapOccupancy));+ Assert.Contains("cir-prismatic-x2-mirror-rejected-lossy-for-request:topology-parity", topologyParity.Diagnostics);+ Assert.Contains("cir-prismatic-x2-loss-topology-parity", topologyParity.Diagnostics);+ }++ [Fact]+ public void CirPrismaticX2_NonConvexSectionRejectsDeterministically()+ {+ var sections = new[]+ {+ new PrismaticSection(0d, [(0d, 0d), (3d, 0d), (1d, 1d), (3d, 3d), (0d, 3d)]),+ new PrismaticSection(2d, [(0d, 0d), (3d, 0d), (1d, 1d), (3d, 3d), (0d, 3d)]),+ };++ var result = CirPrismaticMirrorBuilder.BuildFromSections("non-convex", sections);++ Assert.False(result.Succeeded);+ Assert.Equal(CirMirrorStatus.MirrorRejectedUnsupportedAtom, result.Status);+ Assert.Contains("cir-prismatic-x2-mirror-rejected-unsupported:non-convex-or-clockwise-section", result.Diagnostics);+ }++ private static IReadOnlyList<PrismaticSection> RectangleInsetSections() =>+ [+ new PrismaticSection(0d, [(-5d, -3d), (5d, -3d), (5d, 3d), (-5d, 3d)]),+ new PrismaticSection(4d, [(-4d, -2d), (4d, -2d), (4d, 2d), (-4d, 2d)]),+ ];++ private static void AssertStableSummary(CirPrismaticMirrorSummary expected, CirPrismaticMirrorSummary actual)+ {+ Assert.Equal(expected.Rows, actual.Rows);+ Assert.Equal(expected.Cols, actual.Cols);+ Assert.Equal(expected.View, actual.View);+ Assert.Equal(expected.OccupiedCount, actual.OccupiedCount);+ Assert.Equal(expected.EmptyCount, actual.EmptyCount);+ Assert.Equal(expected.ThicknessMin, actual.ThicknessMin);+ Assert.Equal(expected.ThicknessMax, actual.ThicknessMax);+ Assert.Equal(expected.ThicknessAverage, actual.ThicknessAverage);+ Assert.Equal(expected.Bounds, actual.Bounds);+ Assert.Equal(expected.Diagnostics, actual.Diagnostics);+ }++ private static void AssertKnownLosses(CirMirrorAdmissionResult admission)+ {+ Assert.True(admission.HasLoss(CirMirrorLossFlags.FaceIdentityLost));+ Assert.True(admission.HasLoss(CirMirrorLossFlags.LoopIdentityLost));+ Assert.True(admission.HasLoss(CirMirrorLossFlags.SplitFaceLineageLost));+ Assert.True(admission.HasLoss(CirMirrorLossFlags.FeatureRoleLabelsLost));+ Assert.True(admission.HasLoss(CirMirrorLossFlags.ExactTopologyUnavailable));+ }++ private static void AssertInside(CirConvexPolyhedronMirror mirror, Point3D point)+ {+ var classification = mirror.Classify(point);+ Assert.True(+ classification is CirConvexPointClassification.Inside or CirConvexPointClassification.Boundary,+ $"Expected inside but found {classification} with violation {mirror.Evaluate(point)} at {point}.");+ }++ private static void AssertOutside(CirConvexPolyhedronMirror mirror, Point3D point)+ {+ Assert.Equal(CirConvexPointClassification.Outside, mirror.Classify(point));+ }+}diff --git a/Aetheris.Kernel.Core/Cir/CirMirrorMetadata.cs b/Aetheris.Kernel.Core/Cir/CirMirrorMetadata.csindex d2b626fd..73978d53 100644--- a/Aetheris.Kernel.Core/Cir/CirMirrorMetadata.cs+++ b/Aetheris.Kernel.Core/Cir/CirMirrorMetadata.cs@@ -122,6 +122,18 @@ internal static class CirMirrorRegistryCirMirrorLossFlags.BoundaryPrecisionLimited |CirMirrorLossFlags.ExactTopologyUnavailable;+ public const CirMirrorCapability PrismaticConvexMirrorCapabilities =+ CirMirrorCapability.PointContainment |+ CirMirrorCapability.MapOccupancy |+ CirMirrorCapability.SectionSampling;++ public const CirMirrorLossFlags PrismaticConvexMirrorLosses =+ CirMirrorLossFlags.FaceIdentityLost |+ CirMirrorLossFlags.LoopIdentityLost |+ CirMirrorLossFlags.SplitFaceLineageLost |+ CirMirrorLossFlags.FeatureRoleLabelsLost |+ CirMirrorLossFlags.ExactTopologyUnavailable;+public static bool IsAdmittedPrimitive(CirMirrorAtomKind atomKind) =>atomKind is CirMirrorAtomKind.BoxPrimitive or CirMirrorAtomKind.CylinderPrimitive or CirMirrorAtomKind.SpherePrimitive;}diff --git a/Aetheris.Kernel.Core/Cir/Mirrors/CirConvexPolyhedronMirror.cs b/Aetheris.Kernel.Core/Cir/Mirrors/CirConvexPolyhedronMirror.csnew file mode 100644index 00000000..c904a840--- /dev/null+++ b/Aetheris.Kernel.Core/Cir/Mirrors/CirConvexPolyhedronMirror.cs@@ -0,0 +1,408 @@+using Aetheris.Kernel.Core.Brep.Prismatic;+using Aetheris.Kernel.Core.Math;++namespace Aetheris.Kernel.Core.Cir.Mirrors;++internal enum CirConvexPointClassification+{+ Inside,+ Boundary,+ Outside,+}++internal enum CirPrismaticMirrorRequestKind+{+ PointContainment,+ MapOccupancy,+ FaceIdentity,+ TopologyParity,+}++internal readonly record struct CirHalfSpacePlane(Vector3D Normal, double Offset, string Label)+{+ public double Evaluate(Point3D point) =>+ (Normal.X * point.X) + (Normal.Y * point.Y) + (Normal.Z * point.Z) + Offset;+}++internal sealed record CirPrismaticMirrorSummary(+ int Rows,+ int Cols,+ string View,+ int OccupiedCount,+ int EmptyCount,+ double? ThicknessMin,+ double? ThicknessMax,+ double? ThicknessAverage,+ CirBounds Bounds,+ IReadOnlyList<string> Diagnostics);++internal sealed record CirPrismaticMirrorResult(+ CirMirrorStatus Status,+ CirConvexPolyhedronMirror? Mirror,+ CirMirrorAdmissionResult Admission,+ IReadOnlyList<string> Diagnostics,+ string Recommendation)+{+ public bool Succeeded => Status == CirMirrorStatus.MirrorAdmittedExact && Mirror is not null;+}++internal sealed class CirConvexPolyhedronMirror+{+ private const double DefaultTolerance = 1e-8d;++ public CirConvexPolyhedronMirror(+ string caseLabel,+ IReadOnlyList<CirHalfSpacePlane> HalfSpaces,+ CirBounds bounds,+ CirMirrorAdmissionResult admission,+ IReadOnlyList<string> diagnostics)+ {+ CaseLabel = caseLabel;+ this.HalfSpaces = HalfSpaces;+ Bounds = bounds;+ Admission = admission;+ Diagnostics = diagnostics;+ }++ public string CaseLabel { get; }++ public IReadOnlyList<CirHalfSpacePlane> HalfSpaces { get; }++ public CirBounds Bounds { get; }++ public CirMirrorAdmissionResult Admission { get; }++ public IReadOnlyList<string> Diagnostics { get; }++ public double Evaluate(Point3D point) => HalfSpaces.Max(plane => plane.Evaluate(point));++ public CirConvexPointClassification Classify(Point3D point, double tolerance = DefaultTolerance)+ {+ var violation = Evaluate(point);+ if (violation > tolerance)+ {+ return CirConvexPointClassification.Outside;+ }++ return violation >= -tolerance ? CirConvexPointClassification.Boundary : CirConvexPointClassification.Inside;+ }++ public CirPrismaticMirrorSummary CreateTopViewSummary(int rows = 16, int cols = 16, double tolerance = DefaultTolerance)+ {+ if (!Admission.Supports(CirMirrorCapability.MapOccupancy))+ {+ return new CirPrismaticMirrorSummary(rows, cols, "top", 0, rows * cols, null, null, null, Bounds,+ Diagnostics.Concat(["cir-prismatic-x2-mirror-rejected-lossy-for-request:map-occupancy"]).ToArray());+ }++ var occupied = 0;+ var thicknesses = new List<double>();+ var diagnostics = Diagnostics.Concat([$"cir-prismatic-x2-map-summary-created:{CaseLabel}"]).ToArray();++ for (var row = 0; row < rows; row++)+ {+ var y = Bounds.Min.Y + ((row + 0.5d) / rows * Bounds.SizeY);+ for (var col = 0; col < cols; col++)+ {+ var x = Bounds.Min.X + ((col + 0.5d) / cols * Bounds.SizeX);+ if (TryIntersectVerticalRay(x, y, tolerance, out var zMin, out var zMax))+ {+ var thickness = double.Max(0d, zMax - zMin);+ if (thickness > tolerance)+ {+ occupied++;+ thicknesses.Add(thickness);+ }+ }+ }+ }++ var total = rows * cols;+ return new CirPrismaticMirrorSummary(+ rows,+ cols,+ "top",+ occupied,+ total - occupied,+ thicknesses.Count == 0 ? null : thicknesses.Min(),+ thicknesses.Count == 0 ? null : thicknesses.Max(),+ thicknesses.Count == 0 ? null : thicknesses.Average(),+ Bounds,+ diagnostics);+ }++ public CirMirrorAdmissionResult RejectLossyRequest(CirPrismaticMirrorRequestKind requestKind)+ {+ var request = requestKind switch+ {+ CirPrismaticMirrorRequestKind.FaceIdentity => CirMirrorCapability.FaceIdentity,+ CirPrismaticMirrorRequestKind.TopologyParity => CirMirrorCapability.TopologyParity,+ CirPrismaticMirrorRequestKind.PointContainment => CirMirrorCapability.PointContainment,+ CirPrismaticMirrorRequestKind.MapOccupancy => CirMirrorCapability.MapOccupancy,+ _ => CirMirrorCapability.None,+ };++ if ((request & (CirMirrorCapability.FaceIdentity | CirMirrorCapability.TopologyParity)) == 0)+ {+ return Admission;+ }++ var token = requestKind == CirPrismaticMirrorRequestKind.FaceIdentity ? "face-identity" : "topology-parity";+ var diagnostics = new List<string>+ {+ $"cir-prismatic-x2-mirror-rejected-lossy-for-request:{token}",+ "cir-prismatic-x2-loss-face-identity",+ "cir-prismatic-x2-loss-loop-identity",+ "cir-prismatic-x2-loss-split-face-lineage",+ "cir-prismatic-x2-loss-topology-parity",+ "cir-prismatic-x2-no-production-analyzer-behavior-changed",+ "cir-prismatic-x2-no-cir-to-brep-extraction",+ };++ return CreateAdmission(CaseLabel, CirMirrorStatus.MirrorRejectedLossyForRequest, CirMirrorCapability.None, diagnostics);+ }++ private bool TryIntersectVerticalRay(double x, double y, double tolerance, out double zMin, out double zMax)+ {+ zMin = Bounds.Min.Z;+ zMax = Bounds.Max.Z;++ foreach (var plane in HalfSpaces)+ {+ var constant = (plane.Normal.X * x) + (plane.Normal.Y * y) + plane.Offset;+ if (double.Abs(plane.Normal.Z) <= tolerance)+ {+ if (constant > tolerance)+ {+ return false;+ }++ continue;+ }++ var zLimit = (tolerance - constant) / plane.Normal.Z;+ if (plane.Normal.Z > 0d)+ {+ zMax = double.Min(zMax, zLimit);+ }+ else+ {+ zMin = double.Max(zMin, zLimit);+ }++ if (zMin > zMax + tolerance)+ {+ return false;+ }+ }++ return zMax >= zMin - tolerance;+ }++ internal static CirMirrorAdmissionResult CreateAdmission(string caseLabel, CirMirrorStatus status, CirMirrorCapability capabilities, IReadOnlyList<string> diagnostics)+ {+ var provenance = new CirMirrorProvenance(+ CirMirrorSourceRepresentationKind.Air,+ "cir-prismatic-x2-convex-polyhedron",+ caseLabel,+ "cir-prismatic-x2-halfspace-v1",+ "convex-all-planar-prismatic-halfspace-set",+ "default-1e-8",+ diagnostics);+ var losses = CirMirrorRegistry.PrismaticConvexMirrorLosses;+ var descriptor = new CirMirrorDescriptor(+ $"cir-prismatic-x2:{caseLabel}",+ CirMirrorAtomKind.PrismaticSectionTransition,+ status,+ capabilities,+ losses,+ provenance,+ diagnostics);+ return new CirMirrorAdmissionResult(status, capabilities, losses, provenance, diagnostics, descriptor);+ }+}++internal static class CirPrismaticMirrorBuilder+{+ private const double Tol = 1e-9d;++ public static CirPrismaticMirrorResult BuildFromSections(+ string caseLabel,+ IReadOnlyList<PrismaticSection> sections,+ PrismaticCorrespondenceMap? correspondence = null,+ double tolerance = Tol)+ {+ var token = Normalize(caseLabel);+ var diagnostics = new List<string>+ {+ "cir-prismatic-x2-mirror-builder-started",+ };++ var validation = Validate(sections, correspondence, tolerance, diagnostics);+ if (!validation.Valid)+ {+ diagnostics.Add($"cir-prismatic-x2-mirror-rejected-unsupported:{validation.Reason}");+ diagnostics.Add("cir-prismatic-x2-no-production-analyzer-behavior-changed");+ diagnostics.Add("cir-prismatic-x2-no-cir-to-brep-extraction");+ var rejectedAdmission = CirConvexPolyhedronMirror.CreateAdmission(token, CirMirrorStatus.MirrorRejectedUnsupportedAtom, CirMirrorCapability.None, diagnostics);+ return new CirPrismaticMirrorResult(CirMirrorStatus.MirrorRejectedUnsupportedAtom, null, rejectedAdmission, diagnostics, validation.Reason);+ }++ var vertexMap = correspondence?.VertexMap ?? Enumerable.Range(0, sections[0].OuterLoop.Count).ToArray();+ var vertices = sections.SelectMany(section => section.OuterLoop.Select(vertex => new Point3D(vertex.X, vertex.Y, section.Z))).ToArray();+ var centroid = new Point3D(vertices.Average(point => point.X), vertices.Average(point => point.Y), vertices.Average(point => point.Z));+ var bounds = Bounds(vertices);+ var planes = new List<CirHalfSpacePlane>+ {+ new(new Vector3D(0d, 0d, -1d), sections[0].Z, "cap-lower"),+ new(new Vector3D(0d, 0d, 1d), -sections[^1].Z, "cap-upper"),+ };++ for (var interval = 0; interval < sections.Count - 1; interval++)+ {+ var lower = sections[interval];+ var upper = sections[interval + 1];+ for (var edge = 0; edge < lower.OuterLoop.Count; edge++)+ {+ var next = (edge + 1) % lower.OuterLoop.Count;+ var p0 = ToPoint(lower, edge);+ var p1 = ToPoint(lower, next);+ var q1 = ToPoint(upper, vertexMap[next]);++ var edgeVector = p1 - p0;+ var riseVector = q1 - p0;+ var normal = edgeVector.Cross(riseVector);+ if (!normal.TryNormalize(out var normalized))+ {+ diagnostics.Add("cir-prismatic-x2-mirror-rejected-unsupported:degenerate-side-plane");+ var rejectedAdmission = CirConvexPolyhedronMirror.CreateAdmission(token, CirMirrorStatus.MirrorRejectedUnsupportedAtom, CirMirrorCapability.None, diagnostics);+ return new CirPrismaticMirrorResult(CirMirrorStatus.MirrorRejectedUnsupportedAtom, null, rejectedAdmission, diagnostics, "degenerate-side-plane");+ }++ var offset = -normalized.Dot(p0 - Point3D.Origin);+ if (((normalized.X * centroid.X) + (normalized.Y * centroid.Y) + (normalized.Z * centroid.Z) + offset) > 0d)+ {+ normalized = -normalized;+ offset = -normalized.Dot(p0 - Point3D.Origin);+ }++ planes.Add(new CirHalfSpacePlane(normalized, offset, $"side-{interval}-{edge}"));+ }+ }++ var worstViolation = vertices.Max(vertex => planes.Max(plane => plane.Evaluate(vertex)));+ if (worstViolation > tolerance * 10d)+ {+ diagnostics.Add("cir-prismatic-x2-mirror-rejected-unsupported:non-convex-or-inconsistent-halfspaces");+ var rejectedAdmission = CirConvexPolyhedronMirror.CreateAdmission(token, CirMirrorStatus.MirrorRejectedUnsupportedAtom, CirMirrorCapability.None, diagnostics);+ return new CirPrismaticMirrorResult(CirMirrorStatus.MirrorRejectedUnsupportedAtom, null, rejectedAdmission, diagnostics, "non-convex-or-inconsistent-halfspaces");+ }++ diagnostics.Add($"cir-prismatic-x2-halfspace-mirror-created:{token}");+ diagnostics.Add($"cir-prismatic-x2-halfspace-count:{planes.Count}");+ diagnostics.Add($"cir-prismatic-x2-mirror-admitted-exact:{token}");+ diagnostics.Add("cir-prismatic-x2-loss-face-identity");+ diagnostics.Add("cir-prismatic-x2-loss-loop-identity");+ diagnostics.Add("cir-prismatic-x2-loss-split-face-lineage");+ diagnostics.Add("cir-prismatic-x2-loss-topology-parity");+ diagnostics.Add("cir-prismatic-x2-no-production-analyzer-behavior-changed");+ diagnostics.Add("cir-prismatic-x2-no-cir-to-brep-extraction");++ var admission = CirConvexPolyhedronMirror.CreateAdmission(+ token,+ CirMirrorStatus.MirrorAdmittedExact,+ CirMirrorRegistry.PrismaticConvexMirrorCapabilities,+ diagnostics);+ var mirror = new CirConvexPolyhedronMirror(token, planes, bounds, admission, diagnostics);+ return new CirPrismaticMirrorResult(CirMirrorStatus.MirrorAdmittedExact, mirror, admission, diagnostics, "cir-prismatic-x2-convex-polyhedron-mirror-ready-for-lab-use");+ }++ private static (bool Valid, string Reason) Validate(IReadOnlyList<PrismaticSection> sections, PrismaticCorrespondenceMap? correspondence, double tolerance, List<string> diagnostics)+ {+ if (sections.Count < 2)+ {+ return (false, "fewer-than-two-sections");+ }++ var vertexCount = sections[0].OuterLoop.Count;+ if (vertexCount < 3)+ {+ return (false, "fewer-than-three-vertices");+ }++ if (correspondence is not null && (correspondence.VertexMap.Count != vertexCount || correspondence.VertexMap.Distinct().Count() != vertexCount || correspondence.VertexMap.Any(index => index < 0 || index >= vertexCount)))+ {+ return (false, "invalid-correspondence");+ }++ for (var sectionIndex = 0; sectionIndex < sections.Count; sectionIndex++)+ {+ var section = sections[sectionIndex];+ if (!double.IsFinite(section.Z) || section.HasArcs || section.HasHoles || section.OuterLoopCount != 1)+ {+ return (false, "unsupported-section-atom");+ }++ if (section.OuterLoop.Count != vertexCount)+ {+ return (false, "mismatched-vertex-count");+ }++ if (sectionIndex > 0 && section.Z <= sections[sectionIndex - 1].Z + tolerance)+ {+ return (false, "non-increasing-z");+ }++ if (!IsConvexCounterClockwise(section, tolerance))+ {+ return (false, "non-convex-or-clockwise-section");+ }++ diagnostics.Add("cir-prismatic-x2-section-validated");+ }++ return (true, "ok");+ }++ private static bool IsConvexCounterClockwise(PrismaticSection section, double tolerance)+ {+ var vertices = section.OuterLoop;+ var area = 0d;+ for (var i = 0; i < vertices.Count; i++)+ {+ var a = vertices[i];+ var b = vertices[(i + 1) % vertices.Count];+ area += (a.X * b.Y) - (b.X * a.Y);+ }++ if (area <= tolerance)+ {+ return false;+ }++ for (var i = 0; i < vertices.Count; i++)+ {+ var a = vertices[i];+ var b = vertices[(i + 1) % vertices.Count];+ var c = vertices[(i + 2) % vertices.Count];+ var cross = ((b.X - a.X) * (c.Y - b.Y)) - ((b.Y - a.Y) * (c.X - b.X));+ if (cross < -tolerance)+ {+ return false;+ }+ }++ return true;+ }++ private static Point3D ToPoint(PrismaticSection section, int index) =>+ new(section.OuterLoop[index].X, section.OuterLoop[index].Y, section.Z);++ private static CirBounds Bounds(IReadOnlyList<Point3D> vertices) =>+ new(+ new Point3D(vertices.Min(point => point.X), vertices.Min(point => point.Y), vertices.Min(point => point.Z)),+ new Point3D(vertices.Max(point => point.X), vertices.Max(point => point.Y), vertices.Max(point => point.Z)));++ private static string Normalize(string value) =>+ string.IsNullOrWhiteSpace(value) ? "unknown" : value.Trim().ToLowerInvariant().Replace(' ', '-');+}diff --git a/docs/air-cir-x1-mirror-metadata-prototype.md b/docs/air-cir-x1-mirror-metadata-prototype.mdindex 1d0da64c..58570dbe 100644--- a/docs/air-cir-x1-mirror-metadata-prototype.md+++ b/docs/air-cir-x1-mirror-metadata-prototype.md@@ -133,3 +133,7 @@ CIR-MAP-X2 is the first lab/test-only consumer of `CirMirrorAdmissionService` foCIR-PRISMATIC-X1 evaluates a bounded prismatic mirror in the friction-lab layer only. For `rectangle-inset` and `top-edge-chamfer`, the lab can produce `mirror-admitted-exact` metadata for point containment and map occupancy using AIR-authored section data, while still rejecting face identity and topology parity as lossy.The AIR-CIR-X1 production admission service remains intentionally conservative: prismatic mirrors are unavailable to production dispatch unless a later X2-style milestone promotes a bounded half-space/convex-polyhedron or section-stack evaluator into an explicitly admitted mirror path.++## CIR-PRISMATIC-X2 bounded prismatic availability note++CIR-PRISMATIC-X2 adds a bounded internal prismatic mirror availability path outside the AIR-CIR-X1 primitive admission service. For supported convex all-planar prismatic section stacks, `CirPrismaticMirrorBuilder` can return `mirror-admitted-exact` for point containment and map occupancy while carrying the established loss flags for face identity, loop identity, split-face lineage, feature role labels, and topology parity. This does not change production analyzer behavior or the X1 primitive dispatch contract.diff --git a/docs/cir-map-x2-mirror-aware-primitive-map-dispatch.md b/docs/cir-map-x2-mirror-aware-primitive-map-dispatch.mdindex a5d3e015..1c5fd998 100644--- a/docs/cir-map-x2-mirror-aware-primitive-map-dispatch.md+++ b/docs/cir-map-x2-mirror-aware-primitive-map-dispatch.md@@ -174,3 +174,7 @@ Do not claim prismatic map support until an actual admitted mirror exists and ca## CIR-PRISMATIC-X1 follow-up noteCIR-PRISMATIC-X1 proves prismatic mirror feasibility in a lab/test-only path for `rectangle-inset` and `top-edge-chamfer`, and recommends the convex half-space/polyhedron strategy as the next implementation direction. CIR-MAP-X2 dispatch remains primitive-only in production-facing terms: prismatic map dispatch is still unavailable until a later milestone promotes an explicitly admitted prismatic mirror into the dispatch contract.++## CIR-PRISMATIC-X2 prismatic mirror note++CIR-PRISMATIC-X2 implements the first reusable internal convex-polyhedron mirror for bounded prismatic section stacks, but CIR-MAP-X2 dispatch remains primitive-only. Prismatic map dispatch is still not integrated and remains pending an explicit follow-on milestone such as EDGE-PRISMATIC-X8; no production `analyze map` support claim is added by X2.diff --git a/docs/cir-prismatic-x1-prismatic-mirror-feasibility.md b/docs/cir-prismatic-x1-prismatic-mirror-feasibility.mdindex 9671aba6..a6866288 100644--- a/docs/cir-prismatic-x1-prismatic-mirror-feasibility.md+++ b/docs/cir-prismatic-x1-prismatic-mirror-feasibility.md@@ -154,3 +154,7 @@ The next milestone should be one of:- **EDGE-PRISMATIC-X8 hybrid map dispatch with admitted mirror**: only after X2 provides an admitted prismatic mirror handle, route production map dispatch through the hybrid policy without losing BRep topology responsibilities.Do not route production `analyze map` through this X1 lab prototype directly.++## CIR-PRISMATIC-X2 follow-up++CIR-PRISMATIC-X2 promotes the X1-recommended half-space / convex-polyhedron strategy into a reusable internal Core mirror component (`CirConvexPolyhedronMirror` built by `CirPrismaticMirrorBuilder`). The promoted seam remains test/lab-visible only: rectangle-inset and top-edge-chamfer section stacks can be admitted exact for point containment and occupancy-style summaries, while face identity and topology parity remain rejected as lossy requests. Production `analyze map` dispatch is still unchanged.diff --git a/docs/cir-prismatic-x2-convex-polyhedron-mirror.md b/docs/cir-prismatic-x2-convex-polyhedron-mirror.mdnew file mode 100644index 00000000..13fb53fa--- /dev/null+++ b/docs/cir-prismatic-x2-convex-polyhedron-mirror.md@@ -0,0 +1,172 @@+# CIR-PRISMATIC-X2 — Convex Polyhedron CIR Mirror++## 1. Purpose and scope++CIR-PRISMATIC-X2 promotes the CIR-PRISMATIC-X1 half-space feasibility proof into a reusable, internal/test-visible Core component. The new seam models admitted convex, all-planar prismatic section transitions as a convex polyhedron whose field value is the maximum signed half-space violation.++The milestone is intentionally bounded:++- the mirror is internal/test-visible only;+- no production `analyze map` dispatch changes;+- no default CLI behavior changes;+- no public API changes;+- no STEP importer/exporter, Boolean, BRep topology, AIR emitter, or production prismatic route changes;+- no CIR-to-BRep extraction;+- no production support claim for prismatic BRep maps.++## 2. References++This work follows the authority split and mirror vocabulary established by:++- `docs/air-cir-a0-authority-and-mirror-contract.md`;+- `docs/air-cir-x1-mirror-metadata-prototype.md`;+- `docs/cir-map-x1-primitive-map-prototype.md`;+- `docs/cir-map-x2-mirror-aware-primitive-map-dispatch.md`;+- `docs/cir-prismatic-x1-prismatic-mirror-feasibility.md`.++CIR-PRISMATIC-X1 compared two bounded prismatic strategies: a convex polyhedron/half-space mirror and a section-stack implicit evaluator. X2 implements the half-space strategy first because it naturally covers convex all-planar prismatic bodies and is not tied to one emitter-specific section-stack evaluator.++## 3. Component/API shape++The reusable internal component lives in `Aetheris.Kernel.Core.Cir.Mirrors`:++- `CirHalfSpacePlane` stores a normalized oriented plane/half-space;+- `CirConvexPolyhedronMirror` stores the half-space set, bounds, metadata admission result, and deterministic diagnostics;+- `CirPrismaticMirrorBuilder` builds the mirror from `PrismaticSection` source data and optional `PrismaticCorrespondenceMap`;+- `CirPrismaticMirrorResult` reports success/rejection status, metadata, diagnostics, and recommendation;+- `CirPrismaticMirrorSummary` reports deterministic top-view occupancy/thickness summaries;+- `CirConvexPointClassification` reports `Inside`, `Boundary`, or `Outside`;+- `CirPrismaticMirrorRequestKind` models accepted analysis requests and lossy topology requests.++The component is internal and currently exercised by `Aetheris.Kernel.Core.Tests`; it is not wired into production analyzer dispatch.++## 4. Half-space sign convention++Each half-space uses this convention:++```text+plane-value(point) = normal.X*x + normal.Y*y + normal.Z*z + offset+inside if max(plane-value(point)) <= tolerance+outside if max(plane-value(point)) > tolerance+boundary if max violation is within +/- tolerance+```++`CirConvexPolyhedronMirror.Evaluate(point)` returns the maximum plane violation. This makes containment deterministic and makes rejection of unsupported/non-convex inputs explicit.++## 5. Builder input contract++`CirPrismaticMirrorBuilder.BuildFromSections` accepts AIR/prismatic source data, not STEP or recovered BRep topology. The supported input contract is:++- at least two `PrismaticSection` instances;+- each section has one outer loop;+- line-only loops (`HasArcs == false`);+- no holes;+- equal vertex counts across sections;+- strictly increasing `Z` values;+- finite coordinates;+- convex counter-clockwise section loops;+- optional correspondence must be a deterministic bijection over the vertex range.++The builder creates two cap half-spaces and one side half-space per profile edge per section interval. Plane orientation is deterministic: side planes are derived from corresponding section edges, then flipped if needed so the section-stack centroid is inside.++Unsupported or ambiguous inputs reject deterministically with `mirror-rejected-unsupported-atom` and a `cir-prismatic-x2-mirror-rejected-unsupported:<reason>` diagnostic.++## 6. Supported cases++Required cases are implemented and covered by focused tests:++| Case | Status | Half-spaces | Notes |+| --- | --- | ---: | --- |+| `rectangle-inset` | `mirror-admitted-exact` | 6 | two Z caps plus four sloped side planes |+| `top-edge-chamfer` | `mirror-admitted-exact` | 10 | two Z caps plus eight interval side planes, including the chamfer transition plane |++The optional polygon-scaled cases are not claimed by X2 tests, but the builder is intentionally general for convex, line-only, equal-vertex section stacks.++## 7. Point classification findings++`rectangle-inset` classifications match the X1 motivating cases:++- center point: inside;+- far +X point: outside;+- far +Y point: outside;+- lower-Z point admitted by the lower full rectangle: inside;+- upper-Z point excluded by the inset top rectangle: outside.++`top-edge-chamfer` classifications match the X1 motivating cases:++- lower body below the transition: inside;+- near +X top transition where the inset excludes it: outside;+- below the chamfer plane: inside;+- beyond the chamfer plane: outside;+- center: inside.++## 8. Map-like summary findings++The X2 mirror provides a deterministic 16x16 top-view summary helper. It intersects each vertical sample ray with the half-space set and reports occupied/empty counts plus min/max/average thickness.++Stable X2 summaries from the focused tests:++| Case | Grid | Occupied | Empty | Thickness min | Thickness max | Thickness avg |+| --- | --- | ---: | ---: | ---: | ---: | ---: |+| `rectangle-inset` | 16x16 top | 256 | 0 | approximately 0.75 | 4.0 | approximately 3.05 |+| `top-edge-chamfer` | 16x16 top | 256 | 0 | approximately 3.3125 | 4.0 | approximately 3.9531 |++These are occupancy-style summaries for the admitted mirror, not production `analyze map` results.++## 9. Known losses and rejected requests++The admitted mirror is exact for bounded containment and map occupancy, but intentionally lossy for topology authority. Known losses are surfaced in metadata and diagnostics:++- face identity lost;+- loop identity lost;+- split-face lineage lost;+- feature role labels lost;+- exact topology parity unavailable.++Requests for face identity or topology parity return `mirror-rejected-lossy-for-request`; no map summary is returned as a substitute for those lossy requests.++## 10. Relationship to section-stack evaluator++The X1 section-stack evaluator remains useful as an AIR-intent comparison oracle and as a possible future specialized evaluator. X2 does not make it the primary mirror. The reusable Core seam is the convex half-space mirror; section-stack comparison remains X1 evidence unless a future milestone adds a clean oracle adapter.++## 11. Relationship to `analyze map`++CIR-PRISMATIC-X2 is not integrated with production `analyze map` or with CIR-MAP-X2 dispatch. Future hybrid dispatch must be an explicit follow-on milestone, such as EDGE-PRISMATIC-X8, after admission, drift/parity policy, and CLI behavior are separately reviewed.++## 12. Non-goals++X2 explicitly does not implement:++- production analyzer behavior changes;+- default CLI behavior changes;+- new production map support for prismatic BReps;+- topology/face identity parity;+- split-face lineage preservation as topology;+- non-convex prismatic bodies;+- holes, arcs, or multiple loops;+- inferred correspondence;+- imported STEP-to-CIR mirror recovery;+- CIR-to-BRep extraction;+- STEP importer/exporter changes;+- Boolean core changes;+- BRep topology changes;+- AIR emitter behavior changes;+- production prismatic route changes.++## 13. Tests run++Focused validation run during X2 development:++```text+dotnet test Aetheris.Kernel.Core.Tests/Aetheris.Kernel.Core.Tests.csproj -f net10.0 --filter "CirPrismaticX2"+```++Broader regression commands are recorded in the PR/test summary for the implementation change.++## 14. Next milestone++Likely next milestones are:++1. **EDGE-PRISMATIC-X8** — hybrid map dispatch using admitted prismatic mirrors, still without topology claims;+2. **CIR-PRISMATIC-X3** — add tape payload/lowering for admitted prismatic mirrors;+3. **AIR-CIR-A1** — drift/parity policy for mirror freshness and authority boundaries.diff --git a/docs/edge-prismatic-x7-analyze-map-cir-frep-audit.md b/docs/edge-prismatic-x7-analyze-map-cir-frep-audit.mdindex cb601549..065ed65a 100644--- a/docs/edge-prismatic-x7-analyze-map-cir-frep-audit.md+++ b/docs/edge-prismatic-x7-analyze-map-cir-frep-audit.md@@ -397,3 +397,7 @@ CIR-MAP-X2 adds a lab/test-only mirror-aware primitive map dispatcher, but it deCIR-PRISMATIC-X1 adds a lab-only prismatic mirror feasibility prototype for the required `rectangle-inset` and `top-edge-chamfer` prismatic corpus cases. It compares a convex half-space/polyhedron evaluator against a section-stack implicit evaluator, admits both as exact for bounded point containment and map-like occupancy in the lab, and recommends the half-space/convex-polyhedron path for the next first-class implementation step.This does **not** change the X7 production audit conclusion: production `analyze map` remains unsupported for prismatic STEP/BRep artifacts until a later milestone introduces an admitted prismatic mirror into production dispatch. X1 also makes no STEP, BRep topology, Boolean, AIR emitter, CLI, or CIR-to-BRep extraction changes.++## CIR-PRISMATIC-X2 follow-up++CIR-PRISMATIC-X2 implements the first reusable convex prismatic CIR mirror (`CirConvexPolyhedronMirror`/`CirPrismaticMirrorBuilder`) for admitted convex all-planar section stacks. The mirror supports test-visible point containment and top-view occupancy/thickness summaries for rectangle-inset and top-edge-chamfer, but X7 conclusions remain intact: production `analyze map` is not integrated with prismatic CIR mirrors yet, and topology/face identity parity remains out of scope.