Skip to content

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.cs
new file mode 100644
index 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.cs
index d2b626fd..73978d53 100644
--- a/Aetheris.Kernel.Core/Cir/CirMirrorMetadata.cs
+++ b/Aetheris.Kernel.Core/Cir/CirMirrorMetadata.cs
@@ -122,6 +122,18 @@ internal static class CirMirrorRegistry
CirMirrorLossFlags.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.cs
new file mode 100644
index 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.md
index 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` fo
CIR-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.md
index 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 note
CIR-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.md
index 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.md
new file mode 100644
index 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.md
index 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 de
CIR-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.