Skip to content

Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel

Add second-jet differential geometry support

Yuechen Li4daa1c6cac44
diff --git a/Aetheris.CLI/CliRunner.cs b/Aetheris.CLI/CliRunner.cs
index 7145a495..ffbb914b 100644
--- a/Aetheris.CLI/CliRunner.cs
+++ b/Aetheris.CLI/CliRunner.cs
@@ -21,6 +21,7 @@ using Aetheris.Semantics;
using Aetheris.Modules.BuiltIn;
using Aetheris.Piping;
using Aetheris.Surfacing;
+using Aetheris.Geometry;
namespace Aetheris.CLI;
@@ -497,7 +498,8 @@ public static class CliRunner
{
var brep=SurfacePatchBrepMaterializer.Materialize(entry.Support,entry.Evaluate);if(brep.Body is null){stderr.WriteLine(string.Join("; ",brep.Diagnostics.Select(d=>d.Message)));return 1;}var step=Step242Exporter.ExportBody(brep.Body);if(!step.IsSuccess){stderr.WriteLine(string.Join("; ",step.Diagnostics.Select(d=>d.Message)));return 1;}
var fileName=entry.StableId+".step";File.WriteAllText(Path.Combine(output,fileName),step.Value);var reimport=Step242Importer.ImportBody(step.Value);
- galleryReports.Add(new{entry.StableId,panelId=entry.Panel.StableId,constructionFamily=entry.ConstructionKind.ToString(),supportType=entry.Support.Kind.ToString(),materialization=entry.MaterializationKind.ToString(),parameterDomain=new{u=new[]{entry.Panel.ParameterDomain.U.Minimum,entry.Panel.ParameterDomain.U.Maximum},v=new[]{entry.Panel.ParameterDomain.V.Minimum,entry.Panel.ParameterDomain.V.Maximum}},orientation=entry.Panel.Orientation,edges=entry.Panel.BoundaryEdges.Select(edge=>new{edge.Name,edge.StableId,curveFamily=edge.Curve.Kind.ToString(),lengthMm=edge.Length(),direction=edge.SourceDirection.ToString(),edge.SourceCurveStableId}),corners=entry.Panel.Corners.Values.Select(corner=>new{corner.Name,corner.StableId,corner.Point}),entry.SourceDeclarations,entry.AuthoringSummary,developability=entry.Developability,approximation=entry.Approximation,step=fileName,stepSha256=Hash(step.Value),brepFaces=brep.Body.Topology.Faces.Count(),stepReimport=reimport.IsSuccess,surfaceMeshIr=entry.Support.Kind==Aetheris.Kernel.Core.Geometry.SurfaceGeometryKind.BSplineSurfaceWithKnots?"typed-unsupported-non-rational-bspline-support":"supported-when-analytic-family-admitted"});
+ var authored=entry.Panel.AuthoredPatch;var centerU=(authored.Domain.U.Minimum+authored.Domain.U.Maximum)/2d;var centerV=(authored.Domain.V.Minimum+authored.Domain.V.Maximum)/2d;var curvature=CurvatureQuery.Patch(authored,centerU,centerV);
+ galleryReports.Add(new{entry.StableId,panelId=entry.Panel.StableId,constructionFamily=entry.ConstructionKind.ToString(),supportType=entry.Support.Kind.ToString(),materialization=entry.MaterializationKind.ToString(),parameterDomain=new{u=new[]{entry.Panel.ParameterDomain.U.Minimum,entry.Panel.ParameterDomain.U.Maximum},v=new[]{entry.Panel.ParameterDomain.V.Minimum,entry.Panel.ParameterDomain.V.Maximum}},orientation=entry.Panel.Orientation,secondJetCapability=authored.SupportsSecondJet,centerDifferential=new{status=curvature.Status.ToString(),regular=curvature.Singularity==DifferentialSingularityKind.Regular,curvature.GaussianCurvature,curvature.MeanCurvature,curvature.K1,curvature.K2,evidence=curvature.Evidence.ToString(),curvature.Diagnostic},edges=entry.Panel.BoundaryEdges.Select(edge=>new{edge.Name,edge.StableId,curveFamily=edge.Curve.Kind.ToString(),lengthMm=edge.Length(),direction=edge.SourceDirection.ToString(),edge.SourceCurveStableId}),corners=entry.Panel.Corners.Values.Select(corner=>new{corner.Name,corner.StableId,corner.Point}),entry.SourceDeclarations,entry.AuthoringSummary,developability=entry.Developability,approximation=entry.Approximation,step=fileName,stepSha256=Hash(step.Value),brepFaces=brep.Body.Topology.Faces.Count(),stepReimport=reimport.IsSuccess,surfaceMeshIr=entry.Support.Kind==Aetheris.Kernel.Core.Geometry.SurfaceGeometryKind.BSplineSurfaceWithKnots?"typed-unsupported-non-rational-bspline-support":"supported-when-analytic-family-admitted"});
}
var galleryMs=Stopwatch.GetElapsedTime(galleryStarted).TotalMilliseconds;
var canonicalPanelSource="""
diff --git a/Aetheris.Geometry.Tests/DifferentialGeometryTests.cs b/Aetheris.Geometry.Tests/DifferentialGeometryTests.cs
new file mode 100644
index 00000000..7a536a48
--- /dev/null
+++ b/Aetheris.Geometry.Tests/DifferentialGeometryTests.cs
@@ -0,0 +1,100 @@
+using Aetheris.Geometry;
+using Aetheris.Kernel.Core.Geometry;
+using Aetheris.Kernel.Core.Geometry.Curves;
+using Aetheris.Kernel.Core.Math;
+using Aetheris.Surfacing;
+using Xunit;
+
+namespace Aetheris.Geometry.Tests;
+
+public sealed class DifferentialGeometryTests
+{
+ private static readonly Direction3D X=Direction3D.Create(new(1,0,0));
+ private static readonly Direction3D Z=Direction3D.Create(new(0,0,1));
+
+ [Fact]
+ public void AnalyticFamiliesAndExpressionsExposeKnownSecondJets()
+ {
+ var line=Adapt("line",CurveGeometry.FromLine(new(Point3D.Origin,X)),0,2);AssertVector(line.EvaluateJet2(1).SecondDerivative,0,0,0);
+ var circle=Adapt("circle",CurveGeometry.FromCircle(new(Point3D.Origin,Z,2,X)),0,2*double.Pi);AssertVector(circle.EvaluateJet2(0).SecondDerivative,-2,0,0);
+ var ellipse=Adapt("ellipse",CurveGeometry.FromEllipse(new(Point3D.Origin,Z,3,2,X)),0,double.Pi);AssertVector(ellipse.EvaluateJet2(0).SecondDerivative,-3,0,0);
+ var hyperbola=Adapt("hyperbola",CurveGeometry.FromHyperbola(new(Point3D.Origin,Z,X,2,3,HyperbolaBranch.PositiveAxisU)),-1,1);AssertVector(hyperbola.EvaluateJet2(0).SecondDerivative,2,0,0);
+ var splineSupport=new BSpline3Curve(2,[new(0,0,0),new(.5,0,0),new(1,1,0)],[3,3],[0,1],"PARABOLIC_ARC",false,false,"UNSPECIFIED");
+ var spline=Adapt("spline",CurveGeometry.FromBSpline(splineSupport),0,1);AssertVector(spline.EvaluateJet2(.4).SecondDerivative,0,2,0);
+
+ var t=CurveExpression.T;var one=CurveExpression.Length(1);
+ var parabola=Expression("parabola",new(CurveExpression.Multiply(one,t),CurveExpression.Multiply(one,CurveExpression.Power(t,2)),CurveExpression.Length(0)),-2,2);AssertVector(parabola.EvaluateJet2(1.5).SecondDerivative,0,2,0);
+ var sinusoid=Expression("sin",new(CurveExpression.Multiply(one,t),CurveExpression.Multiply(one,CurveExpression.Sin(t)),CurveExpression.Length(0)),-double.Pi,double.Pi);AssertVector(sinusoid.EvaluateJet2(double.Pi/2).SecondDerivative,0,-1,0);
+ var helix=Expression("helix",new(CurveExpression.Multiply(one,CurveExpression.Cos(t)),CurveExpression.Multiply(one,CurveExpression.Sin(t)),CurveExpression.Multiply(one,t)),0,2*double.Pi);AssertVector(helix.EvaluateJet2(0).SecondDerivative,-1,0,0);
+ }
+
+ [Fact]
+ public void CurveCurvatureIsEvidenceAwareAndParameterizationInvariant()
+ {
+ var line=Adapt("line-k",CurveGeometry.FromLine(new(Point3D.Origin,X)),0,2);var lineK=CurvatureQuery.Curve(line,1);Assert.Equal(0,lineK.Curvature!.Value,12);Assert.True(double.IsPositiveInfinity(lineK.RadiusOfCurvature!.Value));
+ var circle=Adapt("circle-k",CurveGeometry.FromCircle(new(Point3D.Origin,Z,4,X)),0,2*double.Pi);var circleK=CurvatureQuery.Curve(circle,.7);Assert.Equal(.25,circleK.Curvature!.Value,12);Assert.Equal(PredicateEvidenceKind.ToleranceBounded,circleK.Evidence);Assert.NotEqual(PredicateEvidenceKind.Certified,circleK.Evidence);
+ var t=CurveExpression.T;var one=CurveExpression.Length(1);var scaled=Expression("scaled-circle",new(CurveExpression.Multiply(one,CurveExpression.Cos(CurveExpression.Multiply(CurveExpression.Number(2),t))),CurveExpression.Multiply(one,CurveExpression.Sin(CurveExpression.Multiply(CurveExpression.Number(2),t))),CurveExpression.Length(0)),0,double.Pi);
+ Assert.Equal(1,CurvatureQuery.Curve(scaled,.3).Curvature!.Value,11);
+ var singular=BoundedParametricCurve3.Procedural("singular-k",new(0,1),x=>(new(x,0,0),Vector3D.Zero),x=>new(new(x,0,0),Vector3D.Zero,Vector3D.Zero,DifferentialSingularityKind.Singular),"fixture");
+ Assert.Equal(DifferentialQueryStatus.Unknown,CurvatureQuery.Curve(singular,.5).Status);
+ }
+
+ [Fact]
+ public void ExpressionPatchesExposeSecondJetsAndClassicalCurvatures()
+ {
+ var saddle=MathematicalSurfaces.HyperbolicParaboloid("saddle",2,3,4).Patch;var sj=saddle.EvaluateJet2(0,0);AssertVector(sj.Duv,0,0,4);Assert.Equal(0,sj.Duu.Length,12);Assert.True(CurvatureQuery.Patch(saddle,0,0).GaussianCurvature<0);
+ var cylinder=MathematicalSurfaces.ParabolicCylinder("parabolic-cylinder",2,3,4).Patch;AssertVector(cylinder.EvaluateJet2(0,0).Duu,0,0,8);
+ var bowl=MathematicalSurfaces.EllipticParaboloid("bowl",2,3,4).Patch;var bowlK=CurvatureQuery.Patch(bowl,0,0);Assert.True(bowlK.GaussianCurvature>0);Assert.NotNull(bowlK.K1);Assert.NotNull(bowlK.K2);
+ var helicoid=MathematicalSurfaces.Helicoid("helicoid",2,1).Patch;Assert.True(helicoid.EvaluateJet2(.5,.25).Duv.Length>0);
+
+ var plane=Patch("plane",SurfaceExpression.Multiply(SurfaceExpression.Length(2),SurfaceExpression.U),SurfaceExpression.Multiply(SurfaceExpression.Length(3),SurfaceExpression.V),SurfaceExpression.Length(0));var pk=CurvatureQuery.Patch(plane,0,0);Assert.Equal(0,pk.K1!.Value,12);Assert.Equal(0,pk.K2!.Value,12);Assert.Null(pk.Direction1);
+ var sphere=Sphere("sphere",5);var sk=CurvatureQuery.Patch(sphere,0,0);Assert.Equal(.2,double.Abs(sk.K1!.Value),8);Assert.Equal(.2,double.Abs(sk.K2!.Value),8);
+ var circularCylinder=Cylinder("cylinder",4);var ck=CurvatureQuery.Patch(circularCylinder,.4,.2);Assert.Equal(.25,double.Max(double.Abs(ck.K1!.Value),double.Abs(ck.K2!.Value)),10);Assert.Equal(0,double.Min(double.Abs(ck.K1.Value),double.Abs(ck.K2.Value)),10);
+ }
+
+ [Fact]
+ public void SurfaceCurvatureAndNormalCurvatureIgnoreParameterScalingAndReversal()
+ {
+ var a=ParabolicPatch("a",1,false);var b=ParabolicPatch("b",3,true);var ka=CurvatureQuery.Patch(a,0,0);var kb=CurvatureQuery.Patch(b,0,0);
+ Assert.Equal(ka.GaussianCurvature!.Value,kb.GaussianCurvature!.Value,10);Assert.Equal(double.Abs(ka.MeanCurvature!.Value),double.Abs(kb.MeanCurvature!.Value),10);
+ var na=CurvatureQuery.NormalCurvature(a,0,0,new(1,0,0));var nb=CurvatureQuery.NormalCurvature(b,0,0,new(1,0,0));Assert.Equal(double.Abs(na.Curvature!.Value),double.Abs(nb.Curvature!.Value),10);
+ }
+
+ [Fact]
+ public void ExistingPanelMatesDistinguishG0G1G2AndUnknownWithSampledEvidence()
+ {
+ var crease=PanelPair("crease",x=>SurfaceExpression.Length(0),x=>SurfaceExpression.Multiply(SurfaceExpression.Length(1),x));
+ var g0=Validate(crease,PanelContinuity.PositionG0);Assert.Equal("valid",g0.Status);
+ var g1Fail=Validate(crease,PanelContinuity.TangentG1);Assert.Equal("invalid",g1Fail.Status);Assert.True(g1Fail.MaximumAngularResidualRadians>0);
+
+ var curvatureBreak=PanelPair("curvature-break",x=>SurfaceExpression.Length(0),x=>SurfaceExpression.Multiply(SurfaceExpression.Length(1),SurfaceExpression.Power(x,2)));
+ Assert.Equal("valid",Validate(curvatureBreak,PanelContinuity.TangentG1).Status);var g2Fail=Validate(curvatureBreak,PanelContinuity.CurvatureG2);Assert.Equal("invalid",g2Fail.Status);Assert.True(g2Fail.MaximumNormalCurvatureResidual>0);
+
+ var smooth=PanelPair("smooth",x=>SurfaceExpression.Multiply(SurfaceExpression.Length(1),SurfaceExpression.Power(x,2)),x=>SurfaceExpression.Multiply(SurfaceExpression.Length(1),SurfaceExpression.Power(x,2)));
+ var g2=Validate(smooth,PanelContinuity.CurvatureG2);Assert.Equal("valid",g2.Status);Assert.Equal(PredicateEvidenceKind.Sampled,g2.Evidence);Assert.Equal(0,g2.MaximumNormalCurvatureResidual!.Value,9);
+ var flipped=smooth.Right with{Orientation=new(PanelNormalOrientation.ReversedSupportNormal,PanelMaterialSide.Back)};Assert.Equal("valid",Validate((smooth.Left,flipped),PanelContinuity.CurvatureG2).Status);
+
+ var original=smooth.Right.AuthoredPatch;var firstOnly=BoundedParametricPatch3.Procedural("first-only",original.Domain,(u,v)=>original.EvaluateJet1(u,v),"fixture");var unavailable=smooth.Right with{SurfaceConstruction=smooth.Right.SurfaceConstruction with{AuthoredPatch=firstOnly}};var unknown=Validate((smooth.Left,unavailable),PanelContinuity.CurvatureG2);Assert.Equal("unknown",unknown.Status);Assert.Equal(PredicateEvidenceKind.Sampled,unknown.Evidence);
+ }
+
+ [Fact]
+ public void LocalMinimumFixtureExposesDifferentialIngredientsWithoutContactOrderClaim()
+ {
+ var t=CurveExpression.T;var one=CurveExpression.Length(1);var value=CurveExpression.Multiply(one,CurveExpression.Power(t,2));var scalar=value.Evaluate(0,0);Assert.Equal(0,scalar.Value,12);Assert.Equal(0,scalar.Du,12);Assert.Equal(2,scalar.Duu,12);
+ var parabola=Expression("local-minimum",new(CurveExpression.Multiply(one,t),value,CurveExpression.Length(0)),-1,1);var jet=parabola.EvaluateJet2(0);AssertVector(jet.FirstDerivative,1,0,0);AssertVector(jet.SecondDerivative,0,2,0);Assert.Equal(DifferentialQueryStatus.Available,CurvatureQuery.Curve(parabola,0).Status);
+ }
+
+ private static PanelMateEvidence Validate((PanelIr Left,PanelIr Right) pair,PanelContinuity continuity)=>PanelNetworkValidator.Validate([pair.Left,pair.Right],[new("seam",pair.Left["East"],pair.Right["West"],continuity)]).Mates.Single();
+ private static (PanelIr Left,PanelIr Right) PanelPair(string id,Func<SurfaceScalarExpression,SurfaceScalarExpression> leftZ,Func<SurfaceScalarExpression,SurfaceScalarExpression> rightZ)
+ {
+ ParametricSurfaceIr Side(string suffix,double min,double max,Func<SurfaceScalarExpression,SurfaceScalarExpression> z){var u=SurfaceExpression.U;return new(id+suffix,SurfaceConstructionKind.ParametricSurface,new(new(min,max),new(-1,1)),new(SurfaceExpression.Multiply(SurfaceExpression.Length(1),u),SurfaceExpression.Multiply(SurfaceExpression.Length(1),SurfaceExpression.V),z(u)),"fixture");}
+ return(PanelFactory.FromParametric(Side("-left",-1,0,leftZ),controlCountU:9,controlCountV:3,tolerance:.01).Panel!,PanelFactory.FromParametric(Side("-right",0,1,rightZ),controlCountU:9,controlCountV:3,tolerance:.01).Panel!);
+ }
+ private static BoundedParametricPatch3 Patch(string id,SurfaceScalarExpression x,SurfaceScalarExpression y,SurfaceScalarExpression z)=>new(id,new(new(-1,1),new(-1,1)),new(x,y,z),"fixture");
+ private static BoundedParametricPatch3 ParabolicPatch(string id,double scale,bool reverse){var u=SurfaceExpression.Multiply(SurfaceExpression.Number(reverse?-scale:scale),SurfaceExpression.U);return Patch(id,SurfaceExpression.Multiply(SurfaceExpression.Length(1),u),SurfaceExpression.Multiply(SurfaceExpression.Length(1),SurfaceExpression.V),SurfaceExpression.Multiply(SurfaceExpression.Length(1),SurfaceExpression.Power(u,2)));}
+ private static BoundedParametricPatch3 Sphere(string id,double r){var u=SurfaceExpression.U;var v=SurfaceExpression.V;var cv=SurfaceExpression.Cos(v);return new(id,new(new(-.5,.5),new(-.5,.5)),new(SurfaceExpression.Multiply(SurfaceExpression.Length(r),SurfaceExpression.Multiply(cv,SurfaceExpression.Cos(u))),SurfaceExpression.Multiply(SurfaceExpression.Length(r),SurfaceExpression.Multiply(cv,SurfaceExpression.Sin(u))),SurfaceExpression.Multiply(SurfaceExpression.Length(r),SurfaceExpression.Sin(v))),"fixture");}
+ private static BoundedParametricPatch3 Cylinder(string id,double r){var u=SurfaceExpression.U;return new(id,new(new(-1,1),new(-1,1)),new(SurfaceExpression.Multiply(SurfaceExpression.Length(r),SurfaceExpression.Cos(u)),SurfaceExpression.Multiply(SurfaceExpression.Length(r),SurfaceExpression.Sin(u)),SurfaceExpression.Multiply(SurfaceExpression.Length(1),SurfaceExpression.V)),"fixture");}
+ private static BoundedParametricCurve3 Adapt(string id,CurveGeometry curve,double start,double end)=>BoundedParametricCurve3.FromCurveGeometry(id,curve,start,end,"fixture");
+ private static BoundedParametricCurve3 Expression(string id,CurvePointExpression expression,double start,double end)=>new(id,new(start,end),expression,"fixture");
+ private static void AssertVector(Vector3D actual,double x,double y,double z){Assert.Equal(x,actual.X,9);Assert.Equal(y,actual.Y,9);Assert.Equal(z,actual.Z,9);}
+}
diff --git a/Aetheris.Geometry/CurvatureQuery.cs b/Aetheris.Geometry/CurvatureQuery.cs
new file mode 100644
index 00000000..6757ed14
--- /dev/null
+++ b/Aetheris.Geometry/CurvatureQuery.cs
@@ -0,0 +1,98 @@
+using Aetheris.Kernel.Core.Math;
+
+namespace Aetheris.Geometry;
+
+public sealed record DifferentialPolicy(
+ double MinimumFirstDerivativeMagnitude=1e-10,
+ double MinimumNormalMagnitude=1e-12,
+ double MinimumMetricDeterminant=1e-18,
+ double MaximumMetricCondition=1e12,
+ double CurvatureTolerance=1e-9)
+{
+ public static DifferentialPolicy Default { get; }=new();
+}
+
+public enum DifferentialQueryStatus { Available, Unknown }
+
+public sealed record CurveCurvatureResult(double? Curvature,double? RadiusOfCurvature,PredicateEvidenceKind Evidence,
+ DifferentialQueryStatus Status,DifferentialSingularityKind Singularity,string? Diagnostic);
+
+public sealed record FundamentalForm(double E,double F,double G);
+public sealed record SecondFundamentalForm(double E2,double F2,double G2);
+
+/// <summary>Principal curvatures are ordered K1 &gt;= K2. Directions are absent at umbilics or unstable metrics.</summary>
+public sealed record PatchCurvatureResult(
+ double? GaussianCurvature,double? MeanCurvature,double? K1,double? K2,
+ Direction3D? Direction1,Direction3D? Direction2,Direction3D? OrientedNormal,
+ FundamentalForm? FirstFundamentalForm,SecondFundamentalForm? SecondFundamentalForm,
+ PredicateEvidenceKind Evidence,DifferentialQueryStatus Status,DifferentialSingularityKind Singularity,string? Diagnostic);
+
+public sealed record NormalCurvatureResult(double? Curvature,PredicateEvidenceKind Evidence,DifferentialQueryStatus Status,
+ DifferentialSingularityKind Singularity,string? Diagnostic);
+
+public static class CurvatureQuery
+{
+ public static CurveCurvatureResult Curve(BoundedParametricCurve3 curve,double parameter,DifferentialPolicy? policy=null)
+ {
+ ArgumentNullException.ThrowIfNull(curve);policy??=DifferentialPolicy.Default;
+ if(!curve.SupportsSecondJet)return UnknownCurve(DifferentialSingularityKind.Undefined,"Second-jet capability is unavailable.");
+ CurveJet2 jet;
+ try{jet=curve.EvaluateJet2(parameter);}catch(ArithmeticException ex){return UnknownCurve(DifferentialSingularityKind.Undefined,ex.Message);}
+ var speed=jet.FirstDerivative.Length;
+ if(jet.Singularity!=DifferentialSingularityKind.Regular||!double.IsFinite(speed)||speed<policy.MinimumFirstDerivativeMagnitude)
+ return UnknownCurve(jet.Singularity==DifferentialSingularityKind.Regular?DifferentialSingularityKind.Singular:jet.Singularity,"First derivative is too small or non-finite for stable curvature.");
+ var denominator=speed*speed*speed;var curvature=jet.FirstDerivative.Cross(jet.SecondDerivative).Length/denominator;
+ if(!double.IsFinite(curvature))return UnknownCurve(DifferentialSingularityKind.NonFinite,"Curvature denominator is ill-conditioned.");
+ return new(curvature,curvature<=policy.CurvatureTolerance?double.PositiveInfinity:1d/curvature,PredicateEvidenceKind.ToleranceBounded,DifferentialQueryStatus.Available,DifferentialSingularityKind.Regular,null);
+ }
+
+ public static PatchCurvatureResult Patch(BoundedParametricPatch3 patch,double u,double v,DifferentialPolicy? policy=null)
+ {
+ ArgumentNullException.ThrowIfNull(patch);policy??=DifferentialPolicy.Default;
+ if(!patch.SupportsSecondJet)return UnknownPatch(DifferentialSingularityKind.Undefined,"Second-jet capability is unavailable.");
+ PatchJet2 jet;try{jet=patch.EvaluateJet2(u,v);}catch(ArithmeticException ex){return UnknownPatch(DifferentialSingularityKind.Undefined,ex.Message);}
+ if(jet.Singularity!=DifferentialSingularityKind.Regular)return UnknownPatch(jet.Singularity,"Patch second jet is singular or non-finite.");
+ var cross=jet.Du.Cross(jet.Dv);var area=cross.Length;
+ if(!double.IsFinite(area)||area<policy.MinimumNormalMagnitude)return UnknownPatch(DifferentialSingularityKind.Singular,"Surface normal magnitude is too small for stable curvature.");
+ var normalVector=cross*(1d/area);var normal=Direction3D.Create(normalVector);
+ var E=jet.Du.Dot(jet.Du);var F=jet.Du.Dot(jet.Dv);var G=jet.Dv.Dot(jet.Dv);var determinant=E*G-F*F;
+ var trace=E+G;var discriminant=double.Sqrt(double.Max(0d,trace*trace-4d*determinant));var minEigen=(trace-discriminant)/2d;var maxEigen=(trace+discriminant)/2d;
+ if(!double.IsFinite(determinant)||determinant<policy.MinimumMetricDeterminant||minEigen<=0||maxEigen/minEigen>policy.MaximumMetricCondition)
+ return UnknownPatch(DifferentialSingularityKind.Singular,"First fundamental form is singular or ill-conditioned.");
+ var e=normalVector.Dot(jet.Duu);var f=normalVector.Dot(jet.Duv);var g=normalVector.Dot(jet.Dvv);
+ var gaussian=(e*g-f*f)/determinant;var mean=(E*g-2d*F*f+G*e)/(2d*determinant);
+ var root=double.Sqrt(double.Max(0d,mean*mean-gaussian));var k1=mean+root;var k2=mean-root;
+ if(!new[]{gaussian,mean,k1,k2}.All(double.IsFinite))return UnknownPatch(DifferentialSingularityKind.NonFinite,"Curvature evaluation produced a non-finite value.");
+ Direction3D? d1=null,d2=null;
+ if(double.Abs(k1-k2)>policy.CurvatureTolerance)
+ {
+ d1=PrincipalDirection(jet,E,F,G,e,f,g,k1);d2=PrincipalDirection(jet,E,F,G,e,f,g,k2);
+ if(d1 is not null&&d2 is null)d2=Direction3D.TryCreate(normalVector.Cross(d1.Value.ToVector()),out var perpendicular)?perpendicular:null;
+ if(d2 is not null&&d1 is null)d1=Direction3D.TryCreate(d2.Value.ToVector().Cross(normalVector),out var perpendicular)?perpendicular:null;
+ }
+ return new(gaussian,mean,k1,k2,d1,d2,normal,new(E,F,G),new(e,f,g),PredicateEvidenceKind.ToleranceBounded,DifferentialQueryStatus.Available,DifferentialSingularityKind.Regular,d1 is null?"Principal directions are indeterminate at an umbilic or repeated-curvature point.":null);
+ }
+
+ public static NormalCurvatureResult NormalCurvature(BoundedParametricPatch3 patch,double u,double v,Vector3D tangentDirection,DifferentialPolicy? policy=null)
+ {
+ policy??=DifferentialPolicy.Default;var curvature=Patch(patch,u,v,policy);
+ if(curvature.Status!=DifferentialQueryStatus.Available||curvature.FirstFundamentalForm is null||curvature.SecondFundamentalForm is null)
+ return new(null,PredicateEvidenceKind.Unknown,DifferentialQueryStatus.Unknown,curvature.Singularity,curvature.Diagnostic);
+ var jet=patch.EvaluateJet2(u,v);var form=curvature.FirstFundamentalForm;var second=curvature.SecondFundamentalForm;
+ var rhsU=tangentDirection.Dot(jet.Du);var rhsV=tangentDirection.Dot(jet.Dv);var determinant=form.E*form.G-form.F*form.F;
+ var a=(rhsU*form.G-rhsV*form.F)/determinant;var b=(rhsV*form.E-rhsU*form.F)/determinant;
+ var denominator=form.E*a*a+2d*form.F*a*b+form.G*b*b;
+ if(!double.IsFinite(denominator)||denominator<policy.MinimumFirstDerivativeMagnitude*policy.MinimumFirstDerivativeMagnitude)
+ return new(null,PredicateEvidenceKind.Unknown,DifferentialQueryStatus.Unknown,DifferentialSingularityKind.Singular,"Tangent direction has insufficient magnitude in the patch tangent plane.");
+ var value=(second.E2*a*a+2d*second.F2*a*b+second.G2*b*b)/denominator;
+ return double.IsFinite(value)?new(value,PredicateEvidenceKind.ToleranceBounded,DifferentialQueryStatus.Available,DifferentialSingularityKind.Regular,null):new(null,PredicateEvidenceKind.Unknown,DifferentialQueryStatus.Unknown,DifferentialSingularityKind.NonFinite,"Normal curvature is non-finite.");
+ }
+
+ private static Direction3D? PrincipalDirection(PatchJet2 jet,double E,double F,double G,double e,double f,double g,double k)
+ {
+ var a=e-k*E;var b=f-k*F;var c=g-k*G;var x=double.Abs(a)+double.Abs(b)>=double.Abs(b)+double.Abs(c)?-b:-c;var y=double.Abs(a)+double.Abs(b)>=double.Abs(b)+double.Abs(c)?a:b;
+ return Direction3D.TryCreate(jet.Du*x+jet.Dv*y,out var direction)?direction:null;
+ }
+ private static CurveCurvatureResult UnknownCurve(DifferentialSingularityKind singularity,string diagnostic)=>new(null,null,PredicateEvidenceKind.Unknown,DifferentialQueryStatus.Unknown,singularity,diagnostic);
+ private static PatchCurvatureResult UnknownPatch(DifferentialSingularityKind singularity,string diagnostic)=>new(null,null,null,null,null,null,null,null,null,PredicateEvidenceKind.Unknown,DifferentialQueryStatus.Unknown,singularity,diagnostic);
+}
diff --git a/Aetheris.Geometry/ParametricCurves.cs b/Aetheris.Geometry/ParametricCurves.cs
index c86e4b1e..e1bfe31b 100644
--- a/Aetheris.Geometry/ParametricCurves.cs
+++ b/Aetheris.Geometry/ParametricCurves.cs
@@ -33,6 +33,12 @@ public sealed record CurveJet1(
public bool IsRegular => Singularity == DifferentialSingularityKind.Regular;
}
+public sealed record CurveJet2(Point3D Point, Vector3D FirstDerivative, Vector3D SecondDerivative,
+ DifferentialSingularityKind Singularity) : ISecondJet3
+{
+ public bool IsRegular => Singularity == DifferentialSingularityKind.Regular;
+}
+
public sealed record CurvePointExpression(
SurfaceScalarExpression X,
SurfaceScalarExpression Y,
@@ -67,6 +73,7 @@ public static class CurveExpression
public sealed class BoundedParametricCurve3
{
private readonly Func<double, (Point3D Point, Vector3D Derivative)> _evaluator;
+ private readonly Func<double,CurveJet2>? _secondJetEvaluator;
public BoundedParametricCurve3(
string stableId,
@@ -86,15 +93,22 @@ public sealed class BoundedParametricCurve3
var z = pointExpression.Z.Evaluate(t, 0d);
return (new(x.Value, y.Value, z.Value), new(x.Du, y.Du, z.Du));
};
+ _secondJetEvaluator=t=>
+ {
+ var x=pointExpression.X.Evaluate(t,0d);var y=pointExpression.Y.Evaluate(t,0d);var z=pointExpression.Z.Evaluate(t,0d);
+ var first=new Vector3D(x.Du,y.Du,z.Du);var second=new Vector3D(x.Duu,y.Duu,z.Duu);
+ return new(new(x.Value,y.Value,z.Value),first,second,Classify(first,second,new(x.Value,y.Value,z.Value)));
+ };
Initialize(stableId, domain, provenance, semanticOwner, isGenerated, GeometryRepresentationKind.AnalyticExpression);
}
private BoundedParametricCurve3(string stableId, ParameterDomain1 domain,
- Func<double, (Point3D Point, Vector3D Derivative)> evaluator, string provenance,
+ Func<double, (Point3D Point, Vector3D Derivative)> evaluator, Func<double,CurveJet2>? secondJetEvaluator, string provenance,
string? semanticOwner, bool isGenerated, GeometryRepresentationKind representation,
bool isPeriodic, string? nativeFamily, int? degree = null)
{
_evaluator = evaluator ?? throw new ArgumentNullException(nameof(evaluator));
+ _secondJetEvaluator=secondJetEvaluator;
IsPeriodic = isPeriodic;
NativeFamily = nativeFamily;
Degree = degree;
@@ -111,6 +125,7 @@ public sealed class BoundedParametricCurve3
public bool IsPeriodic { get; }
public string? NativeFamily { get; }
public int? Degree { get; }
+ public bool SupportsSecondJet => _secondJetEvaluator is not null;
public Point3D Evaluate(double parameter) => EvaluateJet1(parameter).Point;
@@ -129,11 +144,23 @@ public sealed class BoundedParametricCurve3
return new(point, derivative, Direction3D.Create(normalized), DifferentialSingularityKind.Regular);
}
+ public CurveJet2 EvaluateJet2(double parameter)
+ {
+ if(!Domain.Contains(parameter))throw new ArgumentOutOfRangeException(nameof(parameter),"Parameter must be finite and lie inside the authored curve domain.");
+ if(_secondJetEvaluator is null)throw new NotSupportedException($"Curve '{StableId}' does not expose second-jet capability.");
+ var jet=_secondJetEvaluator(parameter);
+ return jet with{Singularity=Classify(jet.FirstDerivative,jet.SecondDerivative,jet.Point)};
+ }
+
public static BoundedParametricCurve3 Procedural(string stableId, ParameterDomain1 domain,
Func<double, (Point3D Point, Vector3D Derivative)> evaluator, string provenance,
string? semanticOwner = null, bool isGenerated = false,
GeometryRepresentationKind representation = GeometryRepresentationKind.ProceduralParametric) =>
- new(stableId, domain, evaluator, provenance, semanticOwner, isGenerated, representation, false, null);
+ new(stableId, domain, evaluator, null, provenance, semanticOwner, isGenerated, representation, false, null);
+
+ public static BoundedParametricCurve3 Procedural(string stableId,ParameterDomain1 domain,Func<double,(Point3D Point,Vector3D Derivative)> evaluator,
+ Func<double,CurveJet2> secondJetEvaluator,string provenance,string? semanticOwner=null,bool isGenerated=false,GeometryRepresentationKind representation=GeometryRepresentationKind.ProceduralParametric)=>
+ new(stableId,domain,evaluator,secondJetEvaluator,provenance,semanticOwner,isGenerated,representation,false,null);
public static BoundedParametricCurve3 FromCurveGeometry(string stableId, CurveGeometry curve,
double parameterStart, double parameterEnd, string provenance, string? semanticOwner = null,
@@ -151,25 +178,25 @@ public sealed class BoundedParametricCurve3
return curve.Kind switch
{
CurveGeometryKind.Line3 => NativeCurve("Line3", false, t =>
- (curve.Line3!.Value.Evaluate(Native(t)), curve.Line3.Value.Direction.ToVector() * sign)),
+ (curve.Line3!.Value.Evaluate(Native(t)), curve.Line3.Value.Direction.ToVector() * sign),t=>new(curve.Line3!.Value.Evaluate(Native(t)),curve.Line3.Value.Direction.ToVector()*sign,new(0,0,0),DifferentialSingularityKind.Regular)),
CurveGeometryKind.Circle3 => NativeCurve("Circle3", IsFullPeriod(minimum, maximum), t =>
- (curve.Circle3!.Value.Evaluate(Native(t)), curve.Circle3.Value.Tangent(Native(t)) * sign)),
+ (curve.Circle3!.Value.Evaluate(Native(t)), curve.Circle3.Value.Tangent(Native(t)) * sign),t=>{var c=curve.Circle3!.Value;var n=Native(t);return new(c.Evaluate(n),c.Tangent(n)*sign,c.XAxis.ToVector()*(-c.Radius*double.Cos(n))+c.YAxis.ToVector()*(-c.Radius*double.Sin(n)),DifferentialSingularityKind.Regular);}),
CurveGeometryKind.Ellipse3 => NativeCurve("Ellipse3", IsFullPeriod(minimum, maximum), t =>
{
var e = curve.Ellipse3!.Value; var n = Native(t);
var derivative = e.XAxis.ToVector() * (-e.MajorRadius * double.Sin(n)) + e.YAxis.ToVector() * (e.MinorRadius * double.Cos(n));
return (e.Evaluate(n), derivative * sign);
- }),
+ },t=>{var e=curve.Ellipse3!.Value;var n=Native(t);var first=(e.XAxis.ToVector()*(-e.MajorRadius*double.Sin(n))+e.YAxis.ToVector()*(e.MinorRadius*double.Cos(n)))*sign;var second=e.XAxis.ToVector()*(-e.MajorRadius*double.Cos(n))+e.YAxis.ToVector()*(-e.MinorRadius*double.Sin(n));return new(e.Evaluate(n),first,second,DifferentialSingularityKind.Regular);}),
CurveGeometryKind.Hyperbola3 => NativeCurve("Hyperbola3", false, t =>
- (curve.Hyperbola3!.Value.Evaluate(Native(t)), curve.Hyperbola3.Value.FirstDerivative(Native(t)) * sign)),
+ (curve.Hyperbola3!.Value.Evaluate(Native(t)), curve.Hyperbola3.Value.FirstDerivative(Native(t)) * sign),t=>{var h=curve.Hyperbola3!.Value;var n=Native(t);return new(h.Evaluate(n),h.FirstDerivative(n)*sign,h.SecondDerivative(n),DifferentialSingularityKind.Regular);}),
CurveGeometryKind.BSpline3 => NativeCurve("BSpline3", curve.BSpline3!.Value.ClosedCurve, t =>
- (curve.BSpline3.Value.Evaluate(Native(t)), curve.BSpline3.Value.EvaluateTangent(Native(t)) * sign)),
+ (curve.BSpline3.Value.Evaluate(Native(t)), curve.BSpline3.Value.EvaluateTangent(Native(t)) * sign),t=>{var s=curve.BSpline3!.Value;var n=Native(t);return new(s.Evaluate(n),s.EvaluateTangent(n)*sign,s.EvaluateSecondDerivative(n),DifferentialSingularityKind.Regular);}),
_ => throw new NotSupportedException($"Curve family '{curve.Kind}' has no bounded public adapter.")
};
BoundedParametricCurve3 NativeCurve(string family, bool periodic,
- Func<double, (Point3D Point, Vector3D Derivative)> evaluator) =>
- new(stableId, domain, evaluator, provenance, semanticOwner, isGenerated,
+ Func<double, (Point3D Point, Vector3D Derivative)> evaluator,Func<double,CurveJet2> secondJetEvaluator) =>
+ new(stableId, domain, evaluator, secondJetEvaluator,provenance, semanticOwner, isGenerated,
representation, periodic, family, family == "BSpline3" ? curve.BSpline3!.Value.Degree : null);
}
@@ -192,4 +219,5 @@ public sealed class BoundedParametricCurve3
private static bool IsFullPeriod(double minimum, double maximum) => double.Abs((maximum - minimum) - 2d * double.Pi) <= 1e-12;
private static bool Finite(Point3D p) => double.IsFinite(p.X) && double.IsFinite(p.Y) && double.IsFinite(p.Z);
private static bool Finite(Vector3D v) => double.IsFinite(v.X) && double.IsFinite(v.Y) && double.IsFinite(v.Z);
+ private static DifferentialSingularityKind Classify(Vector3D first,Vector3D second,Point3D point)=>!Finite(point)||!Finite(first)||!Finite(second)?DifferentialSingularityKind.NonFinite:!first.TryNormalize(out _)?DifferentialSingularityKind.Singular:DifferentialSingularityKind.Regular;
}
diff --git a/Aetheris.Geometry/ParametricGeometry.cs b/Aetheris.Geometry/ParametricGeometry.cs
index 6782abfa..9fd310be 100644
--- a/Aetheris.Geometry/ParametricGeometry.cs
+++ b/Aetheris.Geometry/ParametricGeometry.cs
@@ -58,6 +58,8 @@ public interface IFirstJet3
DifferentialSingularityKind Singularity { get; }
}
+public interface ISecondJet3 : IFirstJet3 { }
+
public enum GeometryRepresentationKind
{
AnalyticExpression,
@@ -76,7 +78,7 @@ public readonly record struct UnitDimension(int LengthPower)
public static UnitDimension operator /(UnitDimension a, UnitDimension b) => new(a.LengthPower - b.LengthPower);
}
-public readonly record struct ScalarJet(double Value, double Du, double Dv);
+public readonly record struct ScalarJet(double Value, double Du, double Dv, double Duu, double Duv, double Dvv);
/// <summary>A deliberately small, unit-aware expression tree with forward automatic differentiation.</summary>
public abstract record SurfaceScalarExpression(UnitDimension Unit)
@@ -84,23 +86,27 @@ public abstract record SurfaceScalarExpression(UnitDimension Unit)
public abstract ScalarJet Evaluate(double u, double v);
public sealed record Constant(double ConstantValue, UnitDimension ConstantUnit) : SurfaceScalarExpression(ConstantUnit)
- { public override ScalarJet Evaluate(double u, double v) => new(ConstantValue, 0d, 0d); }
+ { public override ScalarJet Evaluate(double u, double v) => new(ConstantValue, 0d, 0d, 0d, 0d, 0d); }
public sealed record Parameter(bool IsU) : SurfaceScalarExpression(UnitDimension.Dimensionless)
- { public override ScalarJet Evaluate(double u, double v) => IsU ? new(u, 1d, 0d) : new(v, 0d, 1d); }
+ { public override ScalarJet Evaluate(double u, double v) => IsU ? new(u, 1d, 0d, 0d, 0d, 0d) : new(v, 0d, 1d, 0d, 0d, 0d); }
public sealed record Sum(SurfaceScalarExpression Left, SurfaceScalarExpression Right) : SurfaceScalarExpression(RequireSame(Left, Right))
- { public override ScalarJet Evaluate(double u, double v) { var a = Left.Evaluate(u, v); var b = Right.Evaluate(u, v); return new(a.Value + b.Value, a.Du + b.Du, a.Dv + b.Dv); } }
+ { public override ScalarJet Evaluate(double u, double v) { var a = Left.Evaluate(u, v); var b = Right.Evaluate(u, v); return new(a.Value + b.Value, a.Du + b.Du, a.Dv + b.Dv, a.Duu + b.Duu, a.Duv + b.Duv, a.Dvv + b.Dvv); } }
public sealed record Difference(SurfaceScalarExpression Left, SurfaceScalarExpression Right) : SurfaceScalarExpression(RequireSame(Left, Right))
- { public override ScalarJet Evaluate(double u, double v) { var a = Left.Evaluate(u, v); var b = Right.Evaluate(u, v); return new(a.Value - b.Value, a.Du - b.Du, a.Dv - b.Dv); } }
+ { public override ScalarJet Evaluate(double u, double v) { var a = Left.Evaluate(u, v); var b = Right.Evaluate(u, v); return new(a.Value - b.Value, a.Du - b.Du, a.Dv - b.Dv, a.Duu - b.Duu, a.Duv - b.Duv, a.Dvv - b.Dvv); } }
public sealed record Product(SurfaceScalarExpression Left, SurfaceScalarExpression Right) : SurfaceScalarExpression(Left.Unit * Right.Unit)
- { public override ScalarJet Evaluate(double u, double v) { var a = Left.Evaluate(u, v); var b = Right.Evaluate(u, v); return new(a.Value * b.Value, a.Du * b.Value + a.Value * b.Du, a.Dv * b.Value + a.Value * b.Dv); } }
+ { public override ScalarJet Evaluate(double u, double v) { var a = Left.Evaluate(u, v); var b = Right.Evaluate(u, v); return new(a.Value*b.Value, a.Du*b.Value+a.Value*b.Du, a.Dv*b.Value+a.Value*b.Dv, a.Duu*b.Value+2*a.Du*b.Du+a.Value*b.Duu, a.Duv*b.Value+a.Du*b.Dv+a.Dv*b.Du+a.Value*b.Duv, a.Dvv*b.Value+2*a.Dv*b.Dv+a.Value*b.Dvv); } }
public sealed record Quotient(SurfaceScalarExpression Left, SurfaceScalarExpression Right) : SurfaceScalarExpression(Left.Unit / Right.Unit)
- { public override ScalarJet Evaluate(double u, double v) { var a = Left.Evaluate(u, v); var b = Right.Evaluate(u, v); if (double.Abs(b.Value) <= 1e-15) throw new DivideByZeroException("Parametric expression divisor is zero."); var q = b.Value * b.Value; return new(a.Value / b.Value, (a.Du * b.Value - a.Value * b.Du) / q, (a.Dv * b.Value - a.Value * b.Dv) / q); } }
+ { public override ScalarJet Evaluate(double u, double v) { var a=Left.Evaluate(u,v);var b=Right.Evaluate(u,v);if(double.Abs(b.Value)<=1e-15)throw new DivideByZeroException("Parametric expression divisor is zero.");var inverse=Reciprocal(b);return Multiply(a,inverse); } }
public sealed record IntegerPower(SurfaceScalarExpression Operand, int Exponent) : SurfaceScalarExpression(new UnitDimension(Operand.Unit.LengthPower * Exponent))
- { public override ScalarJet Evaluate(double u, double v) { var a = Operand.Evaluate(u, v); var value = double.Pow(a.Value, Exponent); var scale = Exponent == 0 ? 0d : Exponent * double.Pow(a.Value, Exponent - 1); return new(value, scale * a.Du, scale * a.Dv); } }
+ { public override ScalarJet Evaluate(double u, double v) { var a=Operand.Evaluate(u,v);if(Exponent<0&&double.Abs(a.Value)<=1e-15)throw new DivideByZeroException("Negative power is singular at zero.");var value=double.Pow(a.Value,Exponent);var first=Exponent==0?0d:Exponent*double.Pow(a.Value,Exponent-1);var second=Exponent is 0 or 1?0d:Exponent*(Exponent-1)*double.Pow(a.Value,Exponent-2);return Compose(a,value,first,second); } }
public sealed record Sine(SurfaceScalarExpression Operand) : SurfaceScalarExpression(RequireDimensionless(Operand))
- { public override ScalarJet Evaluate(double u, double v) { var a = Operand.Evaluate(u, v); var c = double.Cos(a.Value); return new(double.Sin(a.Value), c * a.Du, c * a.Dv); } }
+ { public override ScalarJet Evaluate(double u, double v) { var a=Operand.Evaluate(u,v);return Compose(a,double.Sin(a.Value),double.Cos(a.Value),-double.Sin(a.Value)); } }
public sealed record Cosine(SurfaceScalarExpression Operand) : SurfaceScalarExpression(RequireDimensionless(Operand))
- { public override ScalarJet Evaluate(double u, double v) { var a = Operand.Evaluate(u, v); var s = -double.Sin(a.Value); return new(double.Cos(a.Value), s * a.Du, s * a.Dv); } }
+ { public override ScalarJet Evaluate(double u, double v) { var a=Operand.Evaluate(u,v);return Compose(a,double.Cos(a.Value),-double.Sin(a.Value),-double.Cos(a.Value)); } }
+
+ private static ScalarJet Compose(ScalarJet a,double value,double first,double second)=>new(value,first*a.Du,first*a.Dv,second*a.Du*a.Du+first*a.Duu,second*a.Du*a.Dv+first*a.Duv,second*a.Dv*a.Dv+first*a.Dvv);
+ private static ScalarJet Reciprocal(ScalarJet b){var v=b.Value;return Compose(b,1d/v,-1d/(v*v),2d/(v*v*v));}
+ private static ScalarJet Multiply(ScalarJet a,ScalarJet b)=>new(a.Value*b.Value,a.Du*b.Value+a.Value*b.Du,a.Dv*b.Value+a.Value*b.Dv,a.Duu*b.Value+2*a.Du*b.Du+a.Value*b.Duu,a.Duv*b.Value+a.Du*b.Dv+a.Dv*b.Du+a.Value*b.Duv,a.Dvv*b.Value+2*a.Dv*b.Dv+a.Value*b.Dvv);
private static UnitDimension RequireSame(SurfaceScalarExpression a, SurfaceScalarExpression b) =>
a.Unit == b.Unit ? a.Unit : throw new ArgumentException($"Cannot add/subtract dimensions L^{a.Unit.LengthPower} and L^{b.Unit.LengthPower}.");
@@ -137,10 +143,17 @@ public sealed record SurfaceDifferential(Point3D Point, Vector3D Du, Vector3D Dv
public DifferentialSingularityKind Singularity => IsSingular ? DifferentialSingularityKind.Singular : DifferentialSingularityKind.Regular;
}
+public sealed record PatchJet2(Point3D Point, Vector3D Du, Vector3D Dv, Vector3D Duu, Vector3D Duv, Vector3D Dvv,
+ DifferentialSingularityKind Singularity) : ISecondJet3
+{
+ public bool IsRegular => Singularity == DifferentialSingularityKind.Regular;
+}
+
/// <summary>Authored rectangular parametric geometry, independent of CAD realization and topology.</summary>
public sealed class BoundedParametricPatch3
{
private readonly Func<double, double, SurfaceDifferential>? _proceduralEvaluator;
+ private readonly Func<double, double, PatchJet2>? _secondJetEvaluator;
public BoundedParametricPatch3(string stableId, ParametricDomain domain, SurfacePointExpression pointExpression,
string provenance, GeometryRepresentationKind representation = GeometryRepresentationKind.AnalyticExpression)
@@ -154,12 +167,12 @@ public sealed class BoundedParametricPatch3
Identity = new(stableId); GeometryProvenance = new(provenance);
}
- private BoundedParametricPatch3(string stableId, ParametricDomain domain, Func<double, double, SurfaceDifferential> evaluator,
+ private BoundedParametricPatch3(string stableId, ParametricDomain domain, Func<double, double, SurfaceDifferential> evaluator, Func<double,double,PatchJet2>? secondJetEvaluator,
string provenance, GeometryRepresentationKind representation)
{
ArgumentException.ThrowIfNullOrWhiteSpace(stableId);
ArgumentException.ThrowIfNullOrWhiteSpace(provenance);
- StableId = stableId; Domain = domain; Provenance = provenance; Representation = representation; _proceduralEvaluator = evaluator;
+ StableId = stableId; Domain = domain; Provenance = provenance; Representation = representation; _proceduralEvaluator = evaluator; _secondJetEvaluator=secondJetEvaluator;
Identity = new(stableId); GeometryProvenance = new(provenance);
}
@@ -171,10 +184,15 @@ public sealed class BoundedParametricPatch3
public GeometryProvenance GeometryProvenance { get; }
public GeometryRepresentationKind Representation { get; }
public bool HasExpressionTree => PointExpression is not null;
+ public bool SupportsSecondJet => PointExpression is not null || _secondJetEvaluator is not null;
public static BoundedParametricPatch3 Procedural(string stableId, ParametricDomain domain,
Func<double, double, SurfaceDifferential> evaluator, string provenance) =>
- new(stableId, domain, evaluator ?? throw new ArgumentNullException(nameof(evaluator)), provenance, GeometryRepresentationKind.ProceduralParametric);
+ new(stableId, domain, evaluator ?? throw new ArgumentNullException(nameof(evaluator)), null, provenance, GeometryRepresentationKind.ProceduralParametric);
+
+ public static BoundedParametricPatch3 Procedural(string stableId, ParametricDomain domain,
+ Func<double,double,SurfaceDifferential> evaluator, Func<double,double,PatchJet2> secondJetEvaluator, string provenance) =>
+ new(stableId,domain,evaluator ?? throw new ArgumentNullException(nameof(evaluator)),secondJetEvaluator ?? throw new ArgumentNullException(nameof(secondJetEvaluator)),provenance,GeometryRepresentationKind.ProceduralParametric);
public SurfaceDifferential Evaluate(double u, double v)
{
@@ -193,4 +211,19 @@ public sealed class BoundedParametricPatch3
public Point3D EvaluatePoint(double u, double v) => Evaluate(u, v).Point;
public SurfaceDifferential EvaluateJet1(double u, double v) => Evaluate(u, v);
+
+ public PatchJet2 EvaluateJet2(double u,double v)
+ {
+ ValidateParameters(u,v);
+ if(_secondJetEvaluator is not null)return Validate(_secondJetEvaluator(u,v));
+ if(PointExpression is null)throw new NotSupportedException($"Patch '{StableId}' does not expose second-jet capability.");
+ var x=PointExpression.X.Evaluate(u,v);var y=PointExpression.Y.Evaluate(u,v);var z=PointExpression.Z.Evaluate(u,v);
+ var values=new[]{x.Value,x.Du,x.Dv,x.Duu,x.Duv,x.Dvv,y.Value,y.Du,y.Dv,y.Duu,y.Duv,y.Dvv,z.Value,z.Du,z.Dv,z.Duu,z.Duv,z.Dvv};
+ if(!values.All(double.IsFinite))return new(new(x.Value,y.Value,z.Value),new(x.Du,y.Du,z.Du),new(x.Dv,y.Dv,z.Dv),new(x.Duu,y.Duu,z.Duu),new(x.Duv,y.Duv,z.Duv),new(x.Dvv,y.Dvv,z.Dvv),DifferentialSingularityKind.NonFinite);
+ var du=new Vector3D(x.Du,y.Du,z.Du);var dv=new Vector3D(x.Dv,y.Dv,z.Dv);
+ return new(new(x.Value,y.Value,z.Value),du,dv,new(x.Duu,y.Duu,z.Duu),new(x.Duv,y.Duv,z.Duv),new(x.Dvv,y.Dvv,z.Dvv),du.Cross(dv).TryNormalize(out _)?DifferentialSingularityKind.Regular:DifferentialSingularityKind.Singular);
+ }
+
+ private void ValidateParameters(double u,double v){if(!double.IsFinite(u)||!double.IsFinite(v)||u<Domain.U.Minimum||u>Domain.U.Maximum||v<Domain.V.Minimum||v>Domain.V.Maximum)throw new ArgumentOutOfRangeException(nameof(u),"Parameters must be finite and lie inside the authored rectangular domain.");}
+ private static PatchJet2 Validate(PatchJet2 jet)=>new[]{jet.Point.X,jet.Point.Y,jet.Point.Z,jet.Du.X,jet.Du.Y,jet.Du.Z,jet.Dv.X,jet.Dv.Y,jet.Dv.Z,jet.Duu.X,jet.Duu.Y,jet.Duu.Z,jet.Duv.X,jet.Duv.Y,jet.Duv.Z,jet.Dvv.X,jet.Dvv.Y,jet.Dvv.Z}.All(double.IsFinite)?jet:jet with{Singularity=DifferentialSingularityKind.NonFinite};
}
diff --git a/Aetheris.Kernel.Core/Geometry/Curves/BSpline3Curve.cs b/Aetheris.Kernel.Core/Geometry/Curves/BSpline3Curve.cs
index 164ca428..0a1285e9 100644
--- a/Aetheris.Kernel.Core/Geometry/Curves/BSpline3Curve.cs
+++ b/Aetheris.Kernel.Core/Geometry/Curves/BSpline3Curve.cs
@@ -160,6 +160,36 @@ public readonly record struct BSpline3Curve
return d[derivativeDegree];
}
+ /// <summary>Evaluates the exact polynomial second derivative of this non-rational B-spline.</summary>
+ public Vector3D EvaluateSecondDerivative(double parameter)
+ {
+ if (!double.IsFinite(parameter)) throw new ArgumentOutOfRangeException(nameof(parameter), "Parameter must be finite.");
+ if (Degree < 2) return new Vector3D(0d,0d,0d);
+ var first=new Vector3D[ControlPoints.Count-1];
+ for(var i=0;i<first.Length;i++)
+ {
+ var denominator=FullKnots[i+Degree+1]-FullKnots[i+1];
+ first[i]=double.Abs(denominator)<=1e-15?new(0,0,0):(ControlPoints[i+1]-ControlPoints[i])*(Degree/denominator);
+ }
+ var second=new Vector3D[first.Length-1];
+ for(var i=0;i<second.Length;i++)
+ {
+ var denominator=FullKnots[i+Degree+1]-FullKnots[i+2];
+ second[i]=double.Abs(denominator)<=1e-15?new(0,0,0):(first[i+1]-first[i])*((Degree-1)/denominator);
+ }
+ return EvaluateVectorSpline(second,Degree-2,FullKnots.Skip(2).SkipLast(2).ToArray(),ClampToDomain(parameter));
+ }
+
+ private Vector3D EvaluateVectorSpline(IReadOnlyList<Vector3D> controls,int degree,IReadOnlyList<double> knots,double u)
+ {
+ if(degree==0)return controls[FindSpan(controls.Count,degree,knots,u)];
+ if(double.Abs(u-DomainEnd)<=1e-12)return controls[^1];
+ var span=FindSpan(controls.Count,degree,knots,u);var d=new Vector3D[degree+1];
+ for(var j=0;j<=degree;j++)d[j]=controls[span-degree+j];
+ for(var r=1;r<=degree;r++)for(var j=degree;j>=r;j--){var left=knots[span-degree+j];var right=knots[span+1+j-r];var denominator=right-left;var alpha=double.Abs(denominator)<=1e-15?0d:(u-left)/denominator;d[j]=d[j-1]+(d[j]-d[j-1])*alpha;}
+ return d[degree];
+ }
+
public IReadOnlyList<ParameterInterval> GetNonZeroKnotSpans(ParameterInterval interval)
{
var start = double.Max(DomainStart, double.Min(interval.Start, interval.End));
diff --git a/Aetheris.Modules.Tests/PanelM0Tests.cs b/Aetheris.Modules.Tests/PanelM0Tests.cs
index 615ab6df..36ef433c 100644
--- a/Aetheris.Modules.Tests/PanelM0Tests.cs
+++ b/Aetheris.Modules.Tests/PanelM0Tests.cs
@@ -71,7 +71,7 @@ public sealed class PanelM0Tests
var duplicate=PanelNetworkValidator.Validate(showcase.Panels,[showcase.Mates[0],showcase.Mates[0] with{StableId="duplicate"}]);
Assert.Contains(duplicate.Diagnostics,item=>item.Code=="panel-mate-edge-already-mated");
var g1=PanelNetworkValidator.Validate(showcase.Panels,[showcase.Mates[0] with{Continuity=PanelContinuity.TangentG1}]);
- Assert.Contains(g1.Diagnostics,item=>item.Code=="panel-mate-g1-unsupported");
+ Assert.Contains(g1.Diagnostics,item=>item.Code=="panel-mate-g1-failure");
}
[Fact]
diff --git a/Aetheris.Surfacing/Panels.cs b/Aetheris.Surfacing/Panels.cs
index 58d6a718..ce877707 100644
--- a/Aetheris.Surfacing/Panels.cs
+++ b/Aetheris.Surfacing/Panels.cs
@@ -11,7 +11,7 @@ namespace Aetheris.Surfacing;
public enum PanelNormalOrientation { SupportNormal, ReversedSupportNormal }
public enum PanelMaterialSide { Front, Back }
public enum PanelEdgeDirection { AlongSource, OppositeSource }
-public enum PanelContinuity { PositionG0, TangentG1 }
+public enum PanelContinuity { PositionG0, TangentG1, CurvatureG2 }
public enum PanelEdgeCorrespondence { OppositeDirections, SameDirection }
public sealed record PanelOrientation(
@@ -160,7 +160,7 @@ public static class PanelFactory
var construction = new PanelConstruction(source.StableId,
source.Kind == RuledConstructionKind.RuledTransition ? SurfaceConstructionKind.RuledTransition : SurfaceConstructionKind.RuledSurface,
patch.Domain, patch.ExactSurface, patch.Evaluate,
- ProceduralPatch(source.StableId, patch.Domain, patch.Evaluate, string.Join(";", patch.BoundaryProvenance.Select(item => item.BoundaryStableId))),
+ RuledPatch(source,patch.Domain,patch.Evaluate,string.Join(";",patch.BoundaryProvenance.Select(item=>item.BoundaryStableId))),
patch.MaterializationKind, patch.ApproximationCertificate,
patch.Developability, patch.BoundaryProvenance);
var curves = new[]
@@ -220,12 +220,29 @@ public static class PanelFactory
var u0 = double.Max(domain.U.Minimum, u - hu); var u1 = double.Min(domain.U.Maximum, u + hu);
var v0 = double.Max(domain.V.Minimum, v - hv); var v1 = double.Min(domain.V.Maximum, v + hv);
var point = evaluate(u, v);
- var du = (evaluate(u1, v) - evaluate(u0, v)) / (u1 - u0);
- var dv = (evaluate(u, v1) - evaluate(u, v0)) / (v1 - v0);
+ var du = (evaluate(u1, v) - evaluate(u0, v)) * (1d / (u1 - u0));
+ var dv = (evaluate(u, v1) - evaluate(u, v0)) * (1d / (v1 - v0));
var singular = !du.Cross(dv).TryNormalize(out var normal);
return new(point, du, dv, singular ? null : Direction3D.Create(normal), singular);
}, provenance);
+ private static BoundedParametricPatch3 RuledPatch(RuledSurfaceIr source,ParametricDomain domain,Func<double,double,Point3D> evaluate,string provenance)
+ {
+ var a=BoundaryCurve(source.BoundaryA);var b=BoundaryCurve(source.BoundaryB);
+ CurveJet2 Jet(BoundedParametricCurve3 curve,double u){var jet=curve.EvaluateJet2(curve.Domain.Map(u));var scale=curve.Domain.Length;return jet with{FirstDerivative=jet.FirstDerivative*scale,SecondDerivative=jet.SecondDerivative*(scale*scale)};}
+ PatchJet2 Second(double u,double v){var ja=Jet(a,u);var jb=Jet(b,u);var du=ja.FirstDerivative*(1-v)+jb.FirstDerivative*v;var dv=jb.Point-ja.Point;return new(evaluate(u,v),du,dv,ja.SecondDerivative*(1-v)+jb.SecondDerivative*v,jb.FirstDerivative-ja.FirstDerivative,Vector3D.Zero,du.Cross(dv).TryNormalize(out _)?DifferentialSingularityKind.Regular:DifferentialSingularityKind.Singular);}
+ return BoundedParametricPatch3.Procedural(source.StableId,domain,(u,v)=>{var jet=Second(u,v);var singular=jet.Singularity!=DifferentialSingularityKind.Regular;return new(jet.Point,jet.Du,jet.Dv,singular?null:Direction3D.Create(jet.Du.Cross(jet.Dv)),singular);},Second,provenance);
+ }
+
+ private static BoundedParametricCurve3 BoundaryCurve(RuledBoundary boundary)=>boundary switch
+ {
+ RuledBoundary.Line line=>BoundedParametricCurve3.LineSegment(line.Id,line.Start,line.End,"ruled-boundary"),
+ RuledBoundary.Arc arc=>BoundedParametricCurve3.FromCurveGeometry(arc.Id,CurveGeometry.FromCircle(new(arc.Center,arc.Normal,arc.Radius,arc.ReferenceAxis)),arc.StartAngleRadians,arc.StartAngleRadians+arc.SweepAngleRadians,"ruled-boundary"),
+ RuledBoundary.Circle circle=>BoundedParametricCurve3.FromCurveGeometry(circle.Id,CurveGeometry.FromCircle(new(circle.Center,circle.Normal,circle.Radius,circle.ReferenceAxis)),0,2*Math.PI,"ruled-boundary"),
+ RuledBoundary.BSpline spline=>BoundedParametricCurve3.FromCurveGeometry(spline.Id,CurveGeometry.FromBSpline(spline.Curve),spline.Curve.DomainStart,spline.Curve.DomainEnd,"ruled-boundary"),
+ _=>throw new NotSupportedException($"Ruled boundary '{boundary.GetType().Name}' has no second-jet adapter.")
+ };
+
private static PanelResult Create(
PanelConstruction construction,
PanelOrientation? orientation,
@@ -363,9 +380,14 @@ public static class PanelFactory
public sealed record PanelMateRequest(string StableId, PanelEdgeIr A, PanelEdgeIr B,
PanelContinuity Continuity = PanelContinuity.PositionG0,
PanelEdgeCorrespondence Correspondence = PanelEdgeCorrespondence.OppositeDirections,
- double Tolerance = 1e-6);
+ double Tolerance = 1e-6,
+ double AngularToleranceRadians = 1e-6,
+ double CurvatureTolerance = 1e-6,
+ int SampleCount = 17);
public sealed record PanelMateEvidence(string StableId, string EdgeA, string EdgeB, PanelContinuity Continuity,
- PanelEdgeCorrespondence Correspondence, double EndpointResidual, double G0Residual, string Status);
+ PanelEdgeCorrespondence Correspondence, double EndpointResidual, double G0Residual, string Status,
+ PredicateEvidenceKind Evidence=PredicateEvidenceKind.Sampled,double? MaximumAngularResidualRadians=null,
+ double? MaximumNormalCurvatureResidual=null,int SampleCount=17,string? Diagnostic=null);
public sealed record PanelNetworkReport(IReadOnlyList<PanelMateEvidence> Mates, IReadOnlyList<string> FreeEdges,
IReadOnlyList<SurfacingDiagnostic> Diagnostics)
{
@@ -379,6 +401,7 @@ public static class PanelNetworkValidator
{
var diagnostics = new List<SurfacingDiagnostic>(); var evidence = new List<PanelMateEvidence>();
var allEdges = panels.SelectMany(panel => panel.BoundaryEdges).ToDictionary(edge => edge.StableId, StringComparer.Ordinal);
+ var owners=panels.SelectMany(panel=>panel.BoundaryEdges.Select(edge=>(edge.StableId,Panel:panel))).ToDictionary(item=>item.StableId,item=>item.Panel,StringComparer.Ordinal);
var used = new HashSet<string>(StringComparer.Ordinal);
foreach (var mate in mates.OrderBy(item => item.StableId, StringComparer.Ordinal))
{
@@ -386,25 +409,55 @@ public static class PanelNetworkValidator
{ diagnostics.Add(new("panel-mate-edge-not-in-network", $"Mate '{mate.StableId}' references an edge outside the network.")); continue; }
foreach (var edge in new[] { mate.A, mate.B })
if (!used.Add(edge.StableId)) diagnostics.Add(new("panel-mate-edge-already-mated", $"Edge '{edge.StableId}' is used by more than one one-to-one Mate."));
- if (!double.IsFinite(mate.Tolerance) || mate.Tolerance <= 0)
+ if (!double.IsFinite(mate.Tolerance) || mate.Tolerance <= 0||!double.IsFinite(mate.AngularToleranceRadians)||mate.AngularToleranceRadians<=0||!double.IsFinite(mate.CurvatureTolerance)||mate.CurvatureTolerance<=0||mate.SampleCount<2)
{ diagnostics.Add(new("panel-mate-tolerance-invalid", $"Mate '{mate.StableId}' tolerance must be finite and positive.")); continue; }
var b0 = mate.Correspondence == PanelEdgeCorrespondence.OppositeDirections ? mate.B.End : mate.B.Start;
var b1 = mate.Correspondence == PanelEdgeCorrespondence.OppositeDirections ? mate.B.Start : mate.B.End;
var endpoint = Math.Max((mate.A.Start - b0).Length, (mate.A.End - b1).Length);
var residual = 0d;
- for (var i = 0; i <= 16; i++)
+ var maxAngle=0d;var maxCurvature=0d;string? unknown=null;
+ var panelA=owners[mate.A.StableId];var panelB=owners[mate.B.StableId];
+ for (var i = 0; i < mate.SampleCount; i++)
{
- var t = i / 16d; var paired = mate.Correspondence == PanelEdgeCorrespondence.OppositeDirections ? 1 - t : t;
+ var t = i / (double)(mate.SampleCount-1); var paired = mate.Correspondence == PanelEdgeCorrespondence.OppositeDirections ? 1 - t : t;
residual = Math.Max(residual, (mate.A.Evaluate(t) - mate.B.Evaluate(paired)).Length);
+ if(mate.Continuity==PanelContinuity.PositionG0)continue;
+ var uvA=BoundaryParameter(panelA,mate.A,t);var uvB=BoundaryParameter(panelB,mate.B,paired);
+ var firstA=panelA.AuthoredPatch.EvaluateJet1(uvA.U,uvA.V);var firstB=panelB.AuthoredPatch.EvaluateJet1(uvB.U,uvB.V);
+ if(firstA.IsSingular||firstB.IsSingular||firstA.Normal is null||firstB.Normal is null){unknown="A seam tangent plane is singular.";continue;}
+ var na=OrientedNormal(panelA,firstA.Normal.Value.ToVector());var nb=OrientedNormal(panelB,firstB.Normal.Value.ToVector());
+ var dot=double.Clamp(na.Dot(nb),-1d,1d);maxAngle=Math.Max(maxAngle,double.Acos(double.Abs(dot)));
+ if(mate.Continuity!=PanelContinuity.CurvatureG2)continue;
+ if(!panelA.AuthoredPatch.SupportsSecondJet||!panelB.AuthoredPatch.SupportsSecondJet){unknown="Second-jet capability is unavailable on one or both Panel supports.";continue;}
+ var tangent=mate.A.AuthoredCurve.EvaluateJet1(mate.A.AuthoredCurve.Domain.Map(t)).Derivative;
+ if(!tangent.TryNormalize(out tangent)){unknown="The seam tangent is singular.";continue;}
+ var transverseA=na.Cross(tangent);var transverseB=nb.Cross(tangent);
+ var ka=CurvatureQuery.NormalCurvature(panelA.AuthoredPatch,uvA.U,uvA.V,transverseA);
+ var kb=CurvatureQuery.NormalCurvature(panelB.AuthoredPatch,uvB.U,uvB.V,transverseB);
+ if(ka.Status!=DifferentialQueryStatus.Available||kb.Status!=DifferentialQueryStatus.Available){unknown=ka.Diagnostic??kb.Diagnostic??"Normal curvature is unavailable.";continue;}
+ var orientedKa=ka.Curvature!.Value*(panelA.Orientation.SameSense?1d:-1d);
+ var orientedKb=kb.Curvature!.Value*(panelB.Orientation.SameSense?1d:-1d)*(dot>=0?1d:-1d);
+ maxCurvature=Math.Max(maxCurvature,double.Abs(orientedKa-orientedKb));
}
if (endpoint > mate.Tolerance) diagnostics.Add(new("panel-mate-endpoint-mismatch", $"Mate '{mate.StableId}' endpoint residual {endpoint:G6} mm exceeds {mate.Tolerance:G6} mm."));
if (residual > mate.Tolerance) diagnostics.Add(new("panel-mate-g0-failure", $"Mate '{mate.StableId}' G0 residual {residual:G6} mm exceeds {mate.Tolerance:G6} mm."));
- if (mate.Continuity == PanelContinuity.TangentG1)
- diagnostics.Add(new("panel-mate-g1-unsupported", $"Mate '{mate.StableId}' requests G1, but Panel M0 only verifies exact G0 position continuity."));
- evidence.Add(new(mate.StableId, mate.A.StableId, mate.B.StableId, mate.Continuity, mate.Correspondence, endpoint, residual,
- endpoint <= mate.Tolerance && residual <= mate.Tolerance && mate.Continuity == PanelContinuity.PositionG0 ? "valid" : "invalid"));
+ var g0=endpoint<=mate.Tolerance&&residual<=mate.Tolerance;var g1=maxAngle<=mate.AngularToleranceRadians;
+ if(mate.Continuity!=PanelContinuity.PositionG0&&unknown is null&&g0&&!g1)diagnostics.Add(new("panel-mate-g1-failure",$"Mate '{mate.StableId}' tangent-plane angular residual {maxAngle:G6} rad exceeds {mate.AngularToleranceRadians:G6} rad."));
+ if(mate.Continuity==PanelContinuity.CurvatureG2&&unknown is null&&g0&&g1&&maxCurvature>mate.CurvatureTolerance)diagnostics.Add(new("panel-mate-g2-failure",$"Mate '{mate.StableId}' transverse normal-curvature residual {maxCurvature:G6} exceeds {mate.CurvatureTolerance:G6}."));
+ if(unknown is not null&&mate.Continuity!=PanelContinuity.PositionG0)diagnostics.Add(new(mate.Continuity==PanelContinuity.CurvatureG2?"panel-mate-g2-unknown":"panel-mate-g1-unknown",$"Mate '{mate.StableId}' continuity is Unknown: {unknown}"));
+ var pass=g0&&(mate.Continuity==PanelContinuity.PositionG0||(unknown is null&&g1&&(mate.Continuity==PanelContinuity.TangentG1||maxCurvature<=mate.CurvatureTolerance)));
+ evidence.Add(new(mate.StableId,mate.A.StableId,mate.B.StableId,mate.Continuity,mate.Correspondence,endpoint,residual,unknown is null?(pass?"valid":"invalid"):"unknown",PredicateEvidenceKind.Sampled,mate.Continuity==PanelContinuity.PositionG0?null:maxAngle,mate.Continuity==PanelContinuity.CurvatureG2?maxCurvature:null,mate.SampleCount,unknown));
}
var free = allEdges.Keys.Where(id => !used.Contains(id)).Order(StringComparer.Ordinal).ToArray();
return new(evidence, free, diagnostics);
}
+
+ private static Vector3D OrientedNormal(PanelIr panel,Vector3D normal)=>panel.Orientation.SameSense?normal:-normal;
+ private static (double U,double V) BoundaryParameter(PanelIr panel,PanelEdgeIr edge,double normalized)
+ {
+ var domain=panel.AuthoredPatch.Domain;
+ (double U,double V) Map(double t)=>edge.Name switch{"South"=>(domain.U.Map(t),domain.V.Minimum),"East"=>(domain.U.Maximum,domain.V.Map(t)),"North"=>(domain.U.Map(t),domain.V.Maximum),"West"=>(domain.U.Minimum,domain.V.Map(t)),_=>(domain.U.Map(t),domain.V.Minimum)};
+ var direct=Map(normalized);var reverse=Map(1d-normalized);var point=edge.Evaluate(normalized);
+ return (panel.AuthoredPatch.EvaluatePoint(direct.U,direct.V)-point).Length<=(panel.AuthoredPatch.EvaluatePoint(reverse.U,reverse.V)-point).Length?direct:reverse;
+ }
}
diff --git a/Aetheris.Surfacing/ParametricSurfaces.cs b/Aetheris.Surfacing/ParametricSurfaces.cs
index 8b0bd888..775392a5 100644
--- a/Aetheris.Surfacing/ParametricSurfaces.cs
+++ b/Aetheris.Surfacing/ParametricSurfaces.cs
@@ -26,6 +26,7 @@ public sealed record ParametricSurfaceIr
public BoundedParametricPatch3 Patch { get; }
public SurfaceDifferential Evaluate(double u, double v) => Patch.Evaluate(u,v);
+ public PatchJet2 EvaluateJet2(double u,double v)=>Patch.EvaluateJet2(u,v);
}
public sealed record ParametricMaterialization(BSplineSurfaceWithKnots Surface, ApproximationCertificate Certificate,
diff --git a/Aetheris.Surfacing/SurfacingModule.cs b/Aetheris.Surfacing/SurfacingModule.cs
index afc6e61d..6f58a850 100644
--- a/Aetheris.Surfacing/SurfacingModule.cs
+++ b/Aetheris.Surfacing/SurfacingModule.cs
@@ -23,6 +23,6 @@ public static class SurfacingModule
new(PanelCapability,Id,Version,"Bounded oriented engineering surface with ordered semantic boundary edges and developability evidence.")],
["Surfacing.PanelConcept", "Surfacing.SurfacePatchConcept"], ["Surfacing.RuledCanopyPanel","Surfacing.HyperbolicParaboloid","Surfacing.ParabolicCylinder","Surfacing.EllipticParaboloid","Surfacing.Helicoid"],
["Surface construction -> PanelIR -> semantic edges", "Panel edge Interface/Mate -> deterministic G0 evidence", "PanelIR -> bounded BRep-backed STEP export envelope"],
- ["panel-incomplete-boundary", "panel-boundary-orientation-inconsistent","panel-mate-endpoint-mismatch","panel-mate-g0-failure","panel-mate-g1-unsupported","surfacing-panel-thickness-invalid"],
+ ["panel-incomplete-boundary", "panel-boundary-orientation-inconsistent","panel-mate-endpoint-mismatch","panel-mate-g0-failure","panel-mate-g1-failure","panel-mate-g1-unknown","panel-mate-g2-failure","panel-mate-g2-unknown","surfacing-panel-thickness-invalid"],
[new(CoreModule.Id, new(1, 0, 0))], new("docs/modules/surfacing.md"));
}
diff --git a/Aetheris.slnx b/Aetheris.slnx
index 9f683f60..16f4a9e1 100644
--- a/Aetheris.slnx
+++ b/Aetheris.slnx
@@ -27,6 +27,7 @@
<Project Path="tools/Aetheris.Forge.M1Evidence/Aetheris.Forge.M1Evidence.csproj" />
<Project Path="tools/Aetheris.Geometry.M0Evidence/Aetheris.Geometry.M0Evidence.csproj" />
<Project Path="tools/Aetheris.Geometry.M1Evidence/Aetheris.Geometry.M1Evidence.csproj" />
+ <Project Path="tools/Aetheris.Geometry.M2Evidence/Aetheris.Geometry.M2Evidence.csproj" />
<Project Path="tools/Aetheris.Continuum.AttentionE0/Aetheris.Continuum.AttentionE0.csproj" />
<Project Path="tools/Aetheris.Continuum.AttentionE1/Aetheris.Continuum.AttentionE1.csproj" />
<Project Path="Aetheris.Forge/Aetheris.Forge.csproj" />
diff --git a/docs/geometry/artifacts/reasoning-m2/api-architecture.md b/docs/geometry/artifacts/reasoning-m2/api-architecture.md
new file mode 100644
index 00000000..0d05ef21
--- /dev/null
+++ b/docs/geometry/artifacts/reasoning-m2/api-architecture.md
@@ -0,0 +1,9 @@
+# M2 API architecture
+
+Public ownership remains in `Aetheris.Geometry`: `CurveJet2`, `PatchJet2`, `DifferentialPolicy`, `CurveCurvatureResult`, `PatchCurvatureResult`, `NormalCurvatureResult`, and `CurvatureQuery`. The bounded curve/patch objects expose `SupportsSecondJet` and `EvaluateJet2`; unavailable procedural capability is explicit.
+
+`PredicateEvidenceKind` is reused. Successful local floating-point curvature is `ToleranceBounded`; deterministic whole-seam sampling is `Sampled`; singular or unavailable states are `Unknown`. Representation kind never upgrades evidence.
+
+Surfacing owns only correspondence: it maps semantic Panel edges to patch boundaries, aligns tangent planes/orientations, selects geometric transverse directions, and consumes public normal curvature. It does not implement fundamental-form math or compare raw parameter-grid derivatives.
+
+No topology is authored, no generic intersection/contact-order service is introduced, and no theorem-specific semantics enter the dependency graph.
diff --git a/docs/geometry/artifacts/reasoning-m2/canonical-second-jets-and-curvature.json b/docs/geometry/artifacts/reasoning-m2/canonical-second-jets-and-curvature.json
new file mode 100644
index 00000000..e41d44f3
--- /dev/null
+++ b/docs/geometry/artifacts/reasoning-m2/canonical-second-jets-and-curvature.json
@@ -0,0 +1,195 @@
+{
+ "line": {
+ "StableId": "line",
+ "SupportsSecondJet": true,
+ "jet": {
+ "Point": {
+ "X": 1,
+ "Y": 0,
+ "Z": 0
+ },
+ "FirstDerivative": {
+ "X": 1,
+ "Y": 0,
+ "Z": 0,
+ "LengthSquared": 1,
+ "Length": 1
+ },
+ "SecondDerivative": {
+ "X": 0,
+ "Y": 0,
+ "Z": 0,
+ "LengthSquared": 0,
+ "Length": 0
+ },
+ "Singularity": "Regular",
+ "IsRegular": true
+ },
+ "curvature": {
+ "Curvature": 0,
+ "RadiusOfCurvature": "Infinity",
+ "Evidence": "ToleranceBounded",
+ "Status": "Available",
+ "Singularity": "Regular",
+ "Diagnostic": null
+ }
+ },
+ "circle": {
+ "StableId": "circle",
+ "SupportsSecondJet": true,
+ "jet": {
+ "Point": {
+ "X": 3.6842439760115404,
+ "Y": 1.557673369234602,
+ "Z": 0
+ },
+ "FirstDerivative": {
+ "X": -1.557673369234602,
+ "Y": 3.6842439760115404,
+ "Z": 0,
+ "LengthSquared": 16,
+ "Length": 4
+ },
+ "SecondDerivative": {
+ "X": -3.6842439760115404,
+ "Y": -1.557673369234602,
+ "Z": -0,
+ "LengthSquared": 16,
+ "Length": 4
+ },
+ "Singularity": "Regular",
+ "IsRegular": true
+ },
+ "curvature": {
+ "Curvature": 0.25,
+ "RadiusOfCurvature": 4,
+ "Evidence": "ToleranceBounded",
+ "Status": "Available",
+ "Singularity": "Regular",
+ "Diagnostic": null
+ }
+ },
+ "parabola": {
+ "StableId": "parabola",
+ "SupportsSecondJet": true,
+ "jet": {
+ "Point": {
+ "X": 0,
+ "Y": 0,
+ "Z": 0
+ },
+ "FirstDerivative": {
+ "X": 1,
+ "Y": 0,
+ "Z": 0,
+ "LengthSquared": 1,
+ "Length": 1
+ },
+ "SecondDerivative": {
+ "X": 0,
+ "Y": 2,
+ "Z": 0,
+ "LengthSquared": 4,
+ "Length": 2
+ },
+ "Singularity": "Regular",
+ "IsRegular": true
+ },
+ "curvature": {
+ "Curvature": 2,
+ "RadiusOfCurvature": 0.5,
+ "Evidence": "ToleranceBounded",
+ "Status": "Available",
+ "Singularity": "Regular",
+ "Diagnostic": null
+ }
+ },
+ "patch": {
+ "jet": {
+ "Point": {
+ "X": 0,
+ "Y": 0,
+ "Z": 0
+ },
+ "Du": {
+ "X": 2,
+ "Y": 0,
+ "Z": 0,
+ "LengthSquared": 4,
+ "Length": 2
+ },
+ "Dv": {
+ "X": 0,
+ "Y": 3,
+ "Z": 0,
+ "LengthSquared": 9,
+ "Length": 3
+ },
+ "Duu": {
+ "X": 0,
+ "Y": 0,
+ "Z": 2,
+ "LengthSquared": 4,
+ "Length": 2
+ },
+ "Duv": {
+ "X": 0,
+ "Y": 0,
+ "Z": 0,
+ "LengthSquared": 0,
+ "Length": 0
+ },
+ "Dvv": {
+ "X": 0,
+ "Y": 0,
+ "Z": 2,
+ "LengthSquared": 4,
+ "Length": 2
+ },
+ "Singularity": "Regular",
+ "IsRegular": true
+ },
+ "curvature": {
+ "GaussianCurvature": 0.1111111111111111,
+ "MeanCurvature": 0.3611111111111111,
+ "K1": 0.5,
+ "K2": 0.2222222222222222,
+ "Direction1": {
+ "X": 1,
+ "Y": 0,
+ "Z": 0
+ },
+ "Direction2": {
+ "X": 0,
+ "Y": 1,
+ "Z": 0
+ },
+ "OrientedNormal": {
+ "X": 0,
+ "Y": 0,
+ "Z": 1
+ },
+ "FirstFundamentalForm": {
+ "E": 4,
+ "F": 0,
+ "G": 9
+ },
+ "SecondFundamentalForm": {
+ "E2": 2,
+ "F2": 0,
+ "G2": 2
+ },
+ "Evidence": "ToleranceBounded",
+ "Status": "Available",
+ "Singularity": "Regular",
+ "Diagnostic": null
+ }
+ },
+ "localMinimum": {
+ "parameter": 0,
+ "value": 0,
+ "firstDerivative": 0,
+ "secondDerivative": 2,
+ "observation": "The scalar value has zero first derivative and positive second derivative; no general contact-order classification is made."
+ }
+}
diff --git a/docs/geometry/artifacts/reasoning-m2/deterministic-hashes.json b/docs/geometry/artifacts/reasoning-m2/deterministic-hashes.json
new file mode 100644
index 00000000..355e1dc8
--- /dev/null
+++ b/docs/geometry/artifacts/reasoning-m2/deterministic-hashes.json
@@ -0,0 +1,17 @@
+{
+ "algorithm": "SHA-256",
+ "files": [
+ {
+ "file": "canonical-second-jets-and-curvature.json",
+ "sha256": "925db5209e63ce6559b8d17a88455c25e782f0672c0e253712cfdf8dd48e9d7a"
+ },
+ {
+ "file": "panel-continuity.json",
+ "sha256": "6dd2506bddfb7bfeca32cd6feb773a7b94a17ea075d3ba90bfa62402be113ef7"
+ },
+ {
+ "file": "parameterization-invariance.json",
+ "sha256": "0bc2a7739fcaf569534ad40a8dc43c16158d6ae299e3f5a91e9008daa6ebd604"
+ }
+ ]
+}
diff --git a/docs/geometry/artifacts/reasoning-m2/panel-continuity.json b/docs/geometry/artifacts/reasoning-m2/panel-continuity.json
new file mode 100644
index 00000000..527af086
--- /dev/null
+++ b/docs/geometry/artifacts/reasoning-m2/panel-continuity.json
@@ -0,0 +1,62 @@
+{
+ "g0PassG1Fail": {
+ "StableId": "seam",
+ "EdgeA": "panel:crease-left:edge:east",
+ "EdgeB": "panel:crease-right:edge:west",
+ "Continuity": "TangentG1",
+ "Correspondence": "OppositeDirections",
+ "EndpointResidual": 0,
+ "G0Residual": 0,
+ "Status": "invalid",
+ "Evidence": "Sampled",
+ "MaximumAngularResidualRadians": 0.7853981633974483,
+ "MaximumNormalCurvatureResidual": null,
+ "SampleCount": 17,
+ "Diagnostic": null
+ },
+ "g1PassG2Fail": {
+ "StableId": "seam",
+ "EdgeA": "panel:curvature-break-left:edge:east",
+ "EdgeB": "panel:curvature-break-right:edge:west",
+ "Continuity": "CurvatureG2",
+ "Correspondence": "OppositeDirections",
+ "EndpointResidual": 0,
+ "G0Residual": 0,
+ "Status": "invalid",
+ "Evidence": "Sampled",
+ "MaximumAngularResidualRadians": 0,
+ "MaximumNormalCurvatureResidual": 2,
+ "SampleCount": 17,
+ "Diagnostic": null
+ },
+ "g2Pass": {
+ "StableId": "seam",
+ "EdgeA": "panel:smooth-left:edge:east",
+ "EdgeB": "panel:smooth-right:edge:west",
+ "Continuity": "CurvatureG2",
+ "Correspondence": "OppositeDirections",
+ "EndpointResidual": 0,
+ "G0Residual": 0,
+ "Status": "valid",
+ "Evidence": "Sampled",
+ "MaximumAngularResidualRadians": 0,
+ "MaximumNormalCurvatureResidual": 0,
+ "SampleCount": 17,
+ "Diagnostic": null
+ },
+ "unknown": {
+ "StableId": "seam",
+ "EdgeA": "panel:smooth-left:edge:east",
+ "EdgeB": "panel:smooth-right:edge:west",
+ "Continuity": "CurvatureG2",
+ "Correspondence": "OppositeDirections",
+ "EndpointResidual": 0,
+ "G0Residual": 0,
+ "Status": "unknown",
+ "Evidence": "Sampled",
+ "MaximumAngularResidualRadians": 0,
+ "MaximumNormalCurvatureResidual": 0,
+ "SampleCount": 17,
+ "Diagnostic": "Second-jet capability is unavailable on one or both Panel supports."
+ }
+}
diff --git a/docs/geometry/artifacts/reasoning-m2/parameterization-invariance.json b/docs/geometry/artifacts/reasoning-m2/parameterization-invariance.json
new file mode 100644
index 00000000..0f9ccff0
--- /dev/null
+++ b/docs/geometry/artifacts/reasoning-m2/parameterization-invariance.json
@@ -0,0 +1,73 @@
+{
+ "scaled": {
+ "GaussianCurvature": 0,
+ "MeanCurvature": 1,
+ "K1": 2,
+ "K2": 0,
+ "Direction1": {
+ "X": 1,
+ "Y": 0,
+ "Z": 0
+ },
+ "Direction2": {
+ "X": 0,
+ "Y": 1,
+ "Z": 0
+ },
+ "OrientedNormal": {
+ "X": 0,
+ "Y": 0,
+ "Z": 1
+ },
+ "FirstFundamentalForm": {
+ "E": 9,
+ "F": 0,
+ "G": 1
+ },
+ "SecondFundamentalForm": {
+ "E2": 18,
+ "F2": 0,
+ "G2": 0
+ },
+ "Evidence": "ToleranceBounded",
+ "Status": "Available",
+ "Singularity": "Regular",
+ "Diagnostic": null
+ },
+ "reversed": {
+ "GaussianCurvature": -0,
+ "MeanCurvature": -1,
+ "K1": 0,
+ "K2": -2,
+ "Direction1": {
+ "X": 0,
+ "Y": -1,
+ "Z": -0
+ },
+ "Direction2": {
+ "X": 1,
+ "Y": 0,
+ "Z": 0
+ },
+ "OrientedNormal": {
+ "X": 0,
+ "Y": 0,
+ "Z": -1
+ },
+ "FirstFundamentalForm": {
+ "E": 9,
+ "F": 0,
+ "G": 1
+ },
+ "SecondFundamentalForm": {
+ "E2": -18,
+ "F2": 0,
+ "G2": 0
+ },
+ "Evidence": "ToleranceBounded",
+ "Status": "Available",
+ "Singularity": "Regular",
+ "Diagnostic": null
+ },
+ "invariant": "Gaussian curvature and principal-curvature magnitudes agree; signed mean/normal curvature follows orientation."
+}
diff --git a/docs/geometry/artifacts/reasoning-m2/performance.json b/docs/geometry/artifacts/reasoning-m2/performance.json
new file mode 100644
index 00000000..3375b060
--- /dev/null
+++ b/docs/geometry/artifacts/reasoning-m2/performance.json
@@ -0,0 +1,38 @@
+[
+ {
+ "Name": "curve-second-jet",
+ "Iterations": 100000,
+ "ElapsedMilliseconds": 46.8765,
+ "NanosecondsPerOperation": 468.765
+ },
+ {
+ "Name": "patch-second-jet",
+ "Iterations": 100000,
+ "ElapsedMilliseconds": 93.2749,
+ "NanosecondsPerOperation": 932.749
+ },
+ {
+ "Name": "curve-curvature",
+ "Iterations": 100000,
+ "ElapsedMilliseconds": 53.7946,
+ "NanosecondsPerOperation": 537.946
+ },
+ {
+ "Name": "principal-curvature",
+ "Iterations": 100000,
+ "ElapsedMilliseconds": 163.2521,
+ "NanosecondsPerOperation": 1632.521
+ },
+ {
+ "Name": "panel-g1",
+ "Iterations": 5000,
+ "ElapsedMilliseconds": 711.4234,
+ "NanosecondsPerOperation": 142284.68
+ },
+ {
+ "Name": "panel-g2",
+ "Iterations": 5000,
+ "ElapsedMilliseconds": 1148.7136,
+ "NanosecondsPerOperation": 229742.72
+ }
+]
diff --git a/docs/geometry/artifacts/reasoning-m2/second-derivative-audit.md b/docs/geometry/artifacts/reasoning-m2/second-derivative-audit.md
new file mode 100644
index 00000000..208069f8
--- /dev/null
+++ b/docs/geometry/artifacts/reasoning-m2/second-derivative-audit.md
@@ -0,0 +1,14 @@
+# Second-derivative audit
+
+| Area | Finding | Classification / M2 action |
+|---|---|---|
+| Kernel.Core hyperbola | `Hyperbola3Curve.SecondDerivative` already implements the native cosh/sinh form | Reused through the public adapter |
+| Kernel.Core non-rational B-spline curve | Exact polynomial first derivative existed; second derivative was missing | Extended the derivative-control-polygon evaluator; no finite differences |
+| Circle, ellipse, line | First derivatives existed in family adapters | Added local exact-form second derivatives |
+| Shared unit-aware expression tree | Forward first AD for curves and patches | Extended once to `Duu/Duv/Dvv`; reused by both dimensions |
+| Surfacing ruled patches | Boundary evaluators exposed point/tangent; Panel wrapper finite-differenced first jets | Added ruled second jets from boundary jets: linear interpolation, mixed derivative, zero `Dvv` |
+| Section/Boundary patches | Procedural point evaluators/materializers | Second capability remains unavailable rather than invented |
+| SurfaceMeshIR/Drawing/FEA | No authoritative reusable fundamental-form or curvature service found | No duplicated curvature math added there |
+| Legacy blend/fillet search | No general production curvature layer found | Curvature implemented once in `Aetheris.Geometry` |
+
+Duplicated numerical derivative pressure remains in display/materialization code, but it serves approximation/tessellation rather than an authored public second jet. M2 does not broaden that refactor.
diff --git a/docs/geometry/artifacts/reasoning-m2/validation-report.md b/docs/geometry/artifacts/reasoning-m2/validation-report.md
new file mode 100644
index 00000000..7eb4b485
--- /dev/null
+++ b/docs/geometry/artifacts/reasoning-m2/validation-report.md
@@ -0,0 +1,17 @@
+# M2 validation report
+
+Generated machine-readable evidence:
+
+- `canonical-second-jets-and-curvature.json`: line/circle/parabola jets, curve curvature, elliptic-paraboloid principal curvature, and local-minimum observations.
+- `parameterization-invariance.json`: scaled/reversed patch results and orientation convention.
+- `panel-continuity.json`: G0-pass/G1-fail, G1-pass/G2-fail, G2-pass, and unavailable-second-jet `Unknown` cases.
+- `performance.json`: second-jet, curvature, and seam timings.
+- `deterministic-hashes.json`: SHA-256 manifest for repeatability.
+
+Validation completed on net10.0: restore succeeded; the full solution build succeeded with 0 warnings and 0 errors; 2,722 tests passed across 12 discovered test assemblies with 0 failed and 0 skipped. `Aetheris.FrictionLab.Tests` currently contains no discoverable tests. The focused counts are 25 Geometry tests and 37 Modules/Panel tests. Sampling remains `Sampled`; analytic curvature remains `ToleranceBounded`. SignedSide tangent-candidate enrichment was not implemented because it was optional and would couple a whole-domain predicate result to local observations without improving its classification.
+
+The final Debug smoke run measured approximately 469 ns curve second jet, 933 ns patch second jet, 538 ns curve curvature, 1,633 ns principal curvature, 142 microseconds per 17-sample G1 seam, and 230 microseconds per 17-sample G2 seam. These are bounded observations, not optimization claims. Two complete evidence generations produced identical deterministic-manifest SHA-256 `56DF1F00992BA351314A3E6020A9730BDD8F7144DD1F1D1AF1B0B73B239D82D7`.
+
+The real `aetheris modules showcase` path succeeded: its six Surfacing gallery entries reported second-jet capability and center differential inspection, with four curvature-available expression-backed entries and two honest unavailable procedural entries.
+
+BoundaryPatch/SectionSurface and materialized non-rational B-spline surface supports retain first-jet-only public capability; non-rational B-spline curves expose exact second derivatives. Their unavailable quality inspection returns `Unknown`, which is useful pressure for a later interpolation/fairing milestone. The demonstrated G1/G2 distinction supports a future bounded blend capability, but M2 does not introduce a BlendSurface framework.
diff --git a/docs/geometry/differential-geometry.md b/docs/geometry/differential-geometry.md
new file mode 100644
index 00000000..dbb91dfb
--- /dev/null
+++ b/docs/geometry/differential-geometry.md
@@ -0,0 +1,33 @@
+# Differential geometry
+
+M2 adds a public, bounded second-order layer in `Aetheris.Geometry`. It is geometry infrastructure, not Surfacing or topology code.
+
+## Jets and capability
+
+`CurveJet1` contains point and raw first derivative. `CurveJet2` contains point, raw first derivative, raw second derivative, and singularity. `SurfaceDifferential` is the patch first jet; `PatchJet2` adds `Duu`, `Duv`, and `Dvv`. Raw derivatives are retained because normalization would discard parameter-speed information needed by later queries.
+
+`BoundedParametricCurve3.SupportsSecondJet` and `BoundedParametricPatch3.SupportsSecondJet` distinguish capability from representation. Expression geometry differentiates `+`, `-`, `*`, `/`, integer powers, sine, and cosine through second order. The patch AD value carries one mixed partial, so users do not author both `Puv` and `Pvu`. Lines, circles/arcs, ellipses, hyperbolas, non-rational B-splines, and ruled patches with supported boundary curves expose analytic/double-evaluated second jets. A first-jet-only procedural evaluator remains first-jet-only.
+
+Division by zero, a singular negative power, and non-finite evaluation are not accepted as useful derivatives. Direct evaluation throws a typed arithmetic failure; evidence-producing curvature queries translate these cases to `Unknown`.
+
+## Curve curvature
+
+For regular curves, `CurvatureQuery.Curve` evaluates:
+
+```text
+k = |P' × P''| / |P'|³
+```
+
+It returns curvature, radius, evidence, status, singularity, and diagnostic. A straight line has zero curvature and infinite radius. A tiny or non-finite first derivative returns `Unknown` rather than a large quotient.
+
+## Patch curvature
+
+For a regular patch, the oriented normal is `normalize(Du × Dv)`. The first form is `(E,F,G) = (Du·Du, Du·Dv, Dv·Dv)` and the second is `(e,f,g) = (N·Duu, N·Duv, N·Dvv)`. `CurvatureQuery.Patch` reports Gaussian curvature, mean curvature, principal curvatures ordered `K1 >= K2`, and principal directions when the eigen-directions are stable. At an umbilic the curvature values can remain available while directions are indeterminate.
+
+`NormalCurvature` accepts a geometric tangent vector, resolves its coordinates through the metric, and evaluates the second-form quotient. It does not compare raw parameter derivatives.
+
+## Evidence and conditioning
+
+`DifferentialPolicy` centralizes minimum tangent/normal magnitudes, metric determinant and condition limits, and curvature tolerance. A successful finite floating-point differential calculation is `ToleranceBounded`; it is not `Certified`. Panel seam sampling is always `Sampled`. `Unknown` is expected for unavailable jets, singular parameterizations, ill-conditioned metrics, or insufficient seam correspondence.
+
+Differential evidence changes no topology and proves no general contact order. The local parabola fixture exposes a stationary scalar component and positive second derivative as observations only.
diff --git a/docs/geometry/reasoning.md b/docs/geometry/reasoning.md
index 5ed41cea..927874a9 100644
--- a/docs/geometry/reasoning.md
+++ b/docs/geometry/reasoning.md
@@ -1,19 +1,19 @@
# Authored geometry reasoning
-Status: AETHERIS-GEOMETRY-REASONING-M1
+Status: AETHERIS-GEOMETRY-REASONING-M2
## Architecture and authority
Aetheris separates four layers:
-1. authored bounded geometry, including parameter domain, evaluation, first jet, identity, and provenance;
+1. authored bounded geometry, including parameter domain, first/second jets, identity, and provenance;
2. predicates that inspect that geometry and return explicit evidence;
3. optional realization into a supported surface representation;
4. BRep topology and STEP serialization.
-`Aetheris.Geometry.BoundedParametricCurve3` and `BoundedParametricPatch3` are sibling public objects at layer 1. Neither owns B-rep topology or CAD intent. Curves and patches share `GeometryIdentity`, `GeometryProvenance`, `GeometryRepresentationKind`, `IFirstJet3`, and `DifferentialSingularityKind`, while retaining dimension-appropriate `CurveJet1` and `SurfaceDifferential` results. `Aetheris.Surfacing.PanelIr` remains the manufacturing/CAD wrapper and exposes its source through `AuthoredPatch`; each semantic edge exposes its directed source through `AuthoredCurve`.
+`Aetheris.Geometry.BoundedParametricCurve3` and `BoundedParametricPatch3` are sibling public objects at layer 1. Neither owns B-rep topology or CAD intent. Curves and patches share identity, provenance, representation, first/second-jet interfaces, and explicit singularity states while retaining dimension-appropriate `CurveJet1`, `CurveJet2`, `SurfaceDifferential`, and `PatchJet2` results. `SupportsSecondJet` is a capability statement: expression geometry and supported analytic/non-rational spline adapters return raw second derivatives; first-jet-only procedural geometry does not silently finite-difference them.
-Patch domains are rectangular and curve domains are one dimensional. All bounds are finite and strictly increasing. A reversed native curve support is mapped into an increasing public domain whose increasing parameter follows the authored edge direction. Arbitrary trim-domain topology and second jets are deferred.
+Patch domains are rectangular and curve domains are one dimensional. All bounds are finite and strictly increasing. A reversed native curve support is mapped into an increasing public domain whose increasing parameter follows the authored edge direction. Curvature is computed from geometric differential forms, so parameter scaling and reversal do not change unsigned curve curvature, Gaussian curvature, or principal-curvature magnitudes; signed surface curvature follows orientation.
## Representation is not evidence
@@ -87,15 +87,21 @@ var result = SignedSideQuery.Query(patch, plane, SignedSidePolicy.Certified());
Normal Aetheris code references `Aetheris.Geometry` directly. Forge extension authors may do the same or call `Aetheris.Forge.KernelSDK.KernelSdk.QuerySignedSide`; KernelSDK is an exposure surface, not the owner.
+## Differential queries
+
+`CurvatureQuery` consumes public second jets. Curve curvature uses `|P' × P''| / |P'|³`. Patch curvature forms the first and second fundamental forms, then reports oriented normal, Gaussian and mean curvature, ordered principal curvatures (`K1 >= K2`), stable principal directions where distinct, and normal curvature in an arbitrary tangent direction. `DifferentialPolicy` owns magnitude, metric-conditioning, and curvature tolerances.
+
+Finite analytic evaluation returns `ToleranceBounded`, never `Certified` merely because the source is an expression. Singular tangents, tiny normals, ill-conditioned metrics, unavailable second jets, and indeterminate principal directions remain explicit. See [differential-geometry.md](differential-geometry.md).
+
## Limitations
-M0 has no second jets, curvature, contact order, generic tangency certificate, arbitrary trimmed parameter domains, generic curve/surface intersection, CAS, or theorem-specific vocabulary. Procedural patches have public first-jet evaluation but require a future certified evaluator before the interval policy can certify them. No generic predicate materializes intersection curves or mutates topology.
+M2 does not add contact order, a generic tangency certificate, arbitrary trimmed parameter domains, generic curve/surface intersection, CAS, rational splines/NURBS, or theorem-specific vocabulary. Section and boundary procedural patches remain first-jet-only unless an honest second evaluator is supplied. No differential query materializes intersection curves or mutates topology.
## Differential-geometry ladder
- M0 established bounded patches and evidence-aware signed-side reasoning.
- M1 adds bounded curves and a shared first-jet vocabulary.
-- M2 is the intended home for curve `P''`, patch `Puu/Puv/Pvv`, curvature, and Panel G2 evidence.
-- Closest point, distance, certified intersection, contact classification, and contact order remain later independent query milestones.
+- M2 adds curve `P''`, patch `Puu/Puv/Pvv`, curvature, and sampled Panel G1/G2 evidence.
+- M3 pressure is closest point/distance. Certified intersection and generic contact classification/order remain later independent query milestones; chronology may change with product pressure.
M1 adds no generic curve intersection service. The constructive transverse-cone/world-Z hyperbola remains an admitted construction-specific analytic result; adapting its bounded trim does not grant it topology-authoring authority.
diff --git a/docs/modules/panels.md b/docs/modules/panels.md
index 283347fb..be04e667 100644
--- a/docs/modules/panels.md
+++ b/docs/modules/panels.md
@@ -14,7 +14,7 @@ ParametricSurface / RuledSurface / SectionSurface / BoundaryPatch
A Panel is neither a naked support nor necessarily a closed solid Part. M0 is BRep-backed, rectangular-domain/four-sided, and retains the source construction so a later Panel implementation may use BRep, SubD, or SDF backing without changing the high-level edge and Mate contract. Arbitrary trim networks and SubD/SDF construction are not implemented.
-## M0 model
+## Panel model
`PanelIr` owns a stable ID, `PanelConstruction`, rectangular parameter domain, four explicitly ordered `PanelEdgeIr` members, four corners, normal/material-side orientation, optional positive thickness metadata, optional material text, developability evidence, approximation certificate, and construction provenance. Thickness is engineering metadata; it does not turn the Panel into a solid.
@@ -26,7 +26,13 @@ Corners are stable semantic points named `SW`, `SE`, `NE`, and `NW`. Panel and m
Each boundary edge is a `SemanticValue` with `CurveCapable`, `BoundaryEdgeCapable`, `ExactGeometryCapable`, and `Selectable`, backed by `ExactCurveBinding`. The binding contains a directed source curve and parameter interval. Raw BRep `EdgeId` is not part of the authoring contract.
-The existing Assembly `InterfaceDefinition`/`MateIr` path handles Panel seams. A two-role Interface requiring `BoundaryEdgeCapable` validates its exact curve bindings. `Correspondence: OppositeDirections` is the default physical seam mapping; `SameDirection` is explicit. M0 measures both paired endpoints and 17 deterministic curve samples. It reports endpoint and G0 residuals, duplicate one-to-one edge use, free edges, and missing exact bindings. `Continuity: G1` binds cleanly but produces `assembly-panel-mate-g1-unsupported`; M0 never claims tangent continuity it cannot verify.
+The existing `PanelMateRequest`/`PanelNetworkValidator` relation handles Panel seams; M2 extends it rather than creating another continuity system. `Correspondence: OppositeDirections` is the default physical seam mapping and `SameDirection` is explicit. A deterministic sample policy reports `Sampled` evidence:
+
+- G0 compares paired endpoints and boundary positions.
+- G1 first requires G0, then compares surface tangent planes through oriented normals. Boundary-curve tangent equality alone is insufficient.
+- G2 first requires G0/G1, constructs corresponding geometric transverse directions from the seam tangent and tangent planes, and compares normal curvature.
+
+The patch boundary parameter is recovered per semantic edge, including reversed edge traversal. G1/G2 therefore do not require identical `(u,v)` coordinates or scaling. Normal signs are aligned geometrically so a deliberate Panel orientation flip does not manufacture a curvature failure. Singular tangent planes, missing second jets, and unstable normal curvature return `Unknown`. The older Firmament Assembly serialization bridge still reports its historical G0 binding evidence; it does not fabricate G1/G2 from exact curve bindings alone.
Mating relates separate Panels. It neither Boolean-unions them nor implies a closed shell.
diff --git a/tools/Aetheris.Geometry.M2Evidence/Aetheris.Geometry.M2Evidence.csproj b/tools/Aetheris.Geometry.M2Evidence/Aetheris.Geometry.M2Evidence.csproj
new file mode 100644
index 00000000..d3e71ae3
--- /dev/null
+++ b/tools/Aetheris.Geometry.M2Evidence/Aetheris.Geometry.M2Evidence.csproj
@@ -0,0 +1,7 @@
+<Project Sdk="Microsoft.NET.Sdk">
+ <PropertyGroup><OutputType>Exe</OutputType><TargetFramework>net10.0</TargetFramework><ImplicitUsings>enable</ImplicitUsings><Nullable>enable</Nullable></PropertyGroup>
+ <ItemGroup>
+ <ProjectReference Include="..\..\Aetheris.Geometry\Aetheris.Geometry.csproj" />
+ <ProjectReference Include="..\..\Aetheris.Surfacing\Aetheris.Surfacing.csproj" />
+ </ItemGroup>
+</Project>
diff --git a/tools/Aetheris.Geometry.M2Evidence/Program.cs b/tools/Aetheris.Geometry.M2Evidence/Program.cs
new file mode 100644
index 00000000..fedd89d6
--- /dev/null
+++ b/tools/Aetheris.Geometry.M2Evidence/Program.cs
@@ -0,0 +1,38 @@
+using System.Diagnostics;
+using System.Security.Cryptography;
+using System.Text;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using Aetheris.Geometry;
+using Aetheris.Kernel.Core.Geometry;
+using Aetheris.Kernel.Core.Geometry.Curves;
+using Aetheris.Kernel.Core.Math;
+using Aetheris.Surfacing;
+
+var output=Path.GetFullPath(Path.Combine(AppContext.BaseDirectory,"..","..","..","..","..","docs","geometry","artifacts","reasoning-m2"));Directory.CreateDirectory(output);
+var options=new JsonSerializerOptions{WriteIndented=true,NumberHandling=JsonNumberHandling.AllowNamedFloatingPointLiterals};options.Converters.Add(new JsonStringEnumConverter());var t=CurveExpression.T;var mm=CurveExpression.Length(1);var x=Direction3D.Create(new(1,0,0));var z=Direction3D.Create(new(0,0,1));
+var line=BoundedParametricCurve3.LineSegment("line",Point3D.Origin,new(5,0,0),"evidence");
+var circle=BoundedParametricCurve3.FromCurveGeometry("circle",CurveGeometry.FromCircle(new(Point3D.Origin,z,4,x)),0,2*double.Pi,"evidence");
+var parabola=new BoundedParametricCurve3("parabola",new(-1,1),new(CurveExpression.Multiply(mm,t),CurveExpression.Multiply(mm,CurveExpression.Power(t,2)),CurveExpression.Length(0)),"evidence");
+var surface=MathematicalSurfaces.EllipticParaboloid("bowl",2,3,1).Patch;
+var minimumValue=CurveExpression.Multiply(mm,CurveExpression.Power(t,2)).Evaluate(0,0);var jetSnapshot=new{line=Curve(line,1),circle=Curve(circle,.4),parabola=Curve(parabola,0),patch=new{jet=surface.EvaluateJet2(0,0),curvature=CurvatureQuery.Patch(surface,0,0)},localMinimum=new{parameter=0,value=minimumValue.Value,firstDerivative=minimumValue.Du,secondDerivative=minimumValue.Duu,observation="The scalar value has zero first derivative and positive second derivative; no general contact-order classification is made."}};
+Write("canonical-second-jets-and-curvature.json",jetSnapshot);
+
+var scaled=Patch("scaled",SurfaceExpression.Multiply(SurfaceExpression.Length(3),SurfaceExpression.U),SurfaceExpression.Multiply(SurfaceExpression.Length(1),SurfaceExpression.V),SurfaceExpression.Multiply(SurfaceExpression.Length(1),SurfaceExpression.Power(SurfaceExpression.Multiply(SurfaceExpression.Number(3),SurfaceExpression.U),2)));
+var reversed=Patch("reversed",SurfaceExpression.Multiply(SurfaceExpression.Length(-3),SurfaceExpression.U),SurfaceExpression.Multiply(SurfaceExpression.Length(1),SurfaceExpression.V),SurfaceExpression.Multiply(SurfaceExpression.Length(1),SurfaceExpression.Power(SurfaceExpression.Multiply(SurfaceExpression.Number(-3),SurfaceExpression.U),2)));
+Write("parameterization-invariance.json",new{scaled=CurvatureQuery.Patch(scaled,0,0),reversed=CurvatureQuery.Patch(reversed,0,0),invariant="Gaussian curvature and principal-curvature magnitudes agree; signed mean/normal curvature follows orientation."});
+
+var crease=Pair("crease",u=>SurfaceExpression.Length(0),u=>SurfaceExpression.Multiply(SurfaceExpression.Length(1),u));var curvatureBreak=Pair("curvature-break",u=>SurfaceExpression.Length(0),u=>SurfaceExpression.Multiply(SurfaceExpression.Length(1),SurfaceExpression.Power(u,2)));var smooth=Pair("smooth",u=>SurfaceExpression.Multiply(SurfaceExpression.Length(1),SurfaceExpression.Power(u,2)),u=>SurfaceExpression.Multiply(SurfaceExpression.Length(1),SurfaceExpression.Power(u,2)));
+var unavailablePatch=BoundedParametricPatch3.Procedural("first-only",smooth.Right.AuthoredPatch.Domain,(u,v)=>smooth.Right.AuthoredPatch.EvaluateJet1(u,v),"evidence");var unavailable=smooth.Right with{SurfaceConstruction=smooth.Right.SurfaceConstruction with{AuthoredPatch=unavailablePatch}};
+var seams=new{g0PassG1Fail=Seam(crease,PanelContinuity.TangentG1),g1PassG2Fail=Seam(curvatureBreak,PanelContinuity.CurvatureG2),g2Pass=Seam(smooth,PanelContinuity.CurvatureG2),unknown=Seam((smooth.Left,unavailable),PanelContinuity.CurvatureG2)};Write("panel-continuity.json",seams);
+
+const int iterations=100_000;var measures=new[]{Measure("curve-second-jet",iterations,_=>circle.EvaluateJet2(.4)),Measure("patch-second-jet",iterations,_=>surface.EvaluateJet2(0,0)),Measure("curve-curvature",iterations,_=>CurvatureQuery.Curve(circle,.4)),Measure("principal-curvature",iterations,_=>CurvatureQuery.Patch(surface,0,0)),Measure("panel-g1",5_000,_=>Seam(smooth,PanelContinuity.TangentG1)),Measure("panel-g2",5_000,_=>Seam(smooth,PanelContinuity.CurvatureG2))};Write("performance.json",measures);
+var files=Directory.GetFiles(output,"*.json").Where(path=>Path.GetFileName(path) is not "deterministic-hashes.json" and not "performance.json").Order(StringComparer.Ordinal).Select(path=>new{file=Path.GetFileName(path),sha256=Convert.ToHexString(SHA256.HashData(File.ReadAllBytes(path))).ToLowerInvariant()}).ToArray();Write("deterministic-hashes.json",new{algorithm="SHA-256",files});Console.WriteLine(JsonSerializer.Serialize(new{output,measures,files},options));
+
+object Curve(BoundedParametricCurve3 curve,double parameter)=>new{curve.StableId,curve.SupportsSecondJet,jet=curve.EvaluateJet2(parameter),curvature=CurvatureQuery.Curve(curve,parameter)};
+BoundedParametricPatch3 Patch(string id,SurfaceScalarExpression px,SurfaceScalarExpression py,SurfaceScalarExpression pz)=>new(id,new(new(-1,1),new(-1,1)),new(px,py,pz),"evidence");
+(PanelIr Left,PanelIr Right) Pair(string id,Func<SurfaceScalarExpression,SurfaceScalarExpression> leftZ,Func<SurfaceScalarExpression,SurfaceScalarExpression> rightZ){ParametricSurfaceIr Side(string suffix,double min,double max,Func<SurfaceScalarExpression,SurfaceScalarExpression> fn){var u=SurfaceExpression.U;return new(id+suffix,SurfaceConstructionKind.ParametricSurface,new(new(min,max),new(-1,1)),new(SurfaceExpression.Multiply(SurfaceExpression.Length(1),u),SurfaceExpression.Multiply(SurfaceExpression.Length(1),SurfaceExpression.V),fn(u)),"evidence");}return(PanelFactory.FromParametric(Side("-left",-1,0,leftZ),controlCountU:9,controlCountV:3,tolerance:.01).Panel!,PanelFactory.FromParametric(Side("-right",0,1,rightZ),controlCountU:9,controlCountV:3,tolerance:.01).Panel!);}
+PanelMateEvidence Seam((PanelIr Left,PanelIr Right) pair,PanelContinuity continuity)=>PanelNetworkValidator.Validate([pair.Left,pair.Right],[new("seam",pair.Left["East"],pair.Right["West"],continuity)]).Mates.Single();
+void Write(string name,object value)=>File.WriteAllText(Path.Combine(output,name),JsonSerializer.Serialize(value,options)+Environment.NewLine,new UTF8Encoding(false));
+Measurement Measure(string name,int count,Action<int> operation){for(var i=0;i<100;i++)operation(i);var watch=Stopwatch.StartNew();for(var i=0;i<count;i++)operation(i);watch.Stop();return new(name,count,watch.Elapsed.TotalMilliseconds,watch.Elapsed.TotalNanoseconds/count);}
+record Measurement(string Name,int Iterations,double ElapsedMilliseconds,double NanosecondsPerOperation);