Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel
using Aetheris.Geometry;
using Aetheris.Kernel.Core.Geometry.Surfaces;
using Aetheris.Kernel.Core.Judgment;
using Aetheris.Kernel.Core.Math;
namespace Aetheris.Surfacing;
public enum BlendContinuity { G0, G1, G2 }
public enum BlendCandidateDisposition { Rejected, Eligible, Selected }
public sealed record BlendJudgmentPolicy(
string PolicyId,
double FairnessWeight,
double CurvatureVariationWeight,
double CompactnessWeight,
double ComplexityWeight)
{
public static BlendJudgmentPolicy StandardBlendJudgment { get; } = new(
"StandardBlendJudgment/v1", .40d, .30d, .20d, .10d);
}
public sealed record BlendBoundaryOperation(
string StableId,
string SupportA,
string SupportB,
string Region,
BlendContinuity PreferredContinuity,
BlendContinuity MinimumContinuity,
double RegionWidth,
double RegionDepth,
double CrownHeight,
IReadOnlyList<string> MayModify,
SpatialInfluenceEnvelope InfluenceEnvelope,
IReadOnlyList<PreservationContract> Preserves,
IReadOnlyList<SculptRequirement> Requirements,
BlendJudgmentPolicy? Policy = null,
string? UseCandidate = null,
int MaximumDegree = 10,
double GeometricTolerance = 1e-6,
double G1AngularToleranceDegrees = .1d,
double G2CurvatureTolerance = 1e-6) : IConstructionOperation
{
public string OperationKind => "BlendBoundary";
public int SchemaVersion => 1;
public IReadOnlyList<string> Reads => [SupportA, SupportB, .. Preserves.Select(item => item.EntityId)];
public IReadOnlyList<string> MayModifySet => MayModify;
public SpatialInfluenceEnvelope AuthorizedEnvelope => InfluenceEnvelope;
public IReadOnlyList<PreservationContract> PreservationContracts => Preserves;
public BlendJudgmentPolicy EffectivePolicy => Policy ?? BlendJudgmentPolicy.StandardBlendJudgment;
public string Canonical => string.Join('|', StableId, SupportA, SupportB, Region, PreferredContinuity, MinimumContinuity,
RegionWidth.ToString("R"), RegionDepth.ToString("R"), CrownHeight.ToString("R"), MaximumDegree,
string.Join(',', MayModify.Order(StringComparer.Ordinal)),
$"{InfluenceEnvelope.MinX:R},{InfluenceEnvelope.MinY:R},{InfluenceEnvelope.MinZ:R},{InfluenceEnvelope.MaxX:R},{InfluenceEnvelope.MaxY:R},{InfluenceEnvelope.MaxZ:R}",
string.Join(',', Preserves.OrderBy(item => item.EntityId, StringComparer.Ordinal).Select(item => $"{item.EntityId}:{item.Mode}")),
string.Join(',', Requirements.Order()), EffectivePolicy.PolicyId, UseCandidate ?? "<policy>");
}
public sealed record BlendBoundaryEvidence(
double MaximumPositionError,
double MaximumTangentPlaneErrorDegrees,
double MaximumNormalCurvatureError,
int SampleCount,
string Formulation);
public sealed record BlendQualityMetrics(
double BendingEnergy,
double CurvatureVariation,
double ChangedAreaFraction,
int ControlPointCount,
double Fairness,
double CurvatureSmoothness,
double Compactness,
double Complexity,
double Utility);
public sealed record BlendCandidateTrace(
string CandidateId,
string ConstructionFamily,
IReadOnlyDictionary<string, string> Parameters,
BlendContinuity ContinuityCapability,
string SurfaceClass,
int DegreeU,
int DegreeV,
int ControlPointCount,
BlendCandidateDisposition Disposition,
string? RejectionReason,
BlendBoundaryEvidence BoundaryEvidence,
BlendQualityMetrics? Metrics);
public sealed record BlendJudgmentTrace(
string Request,
string JudgmentPolicyId,
string CandidateSetId,
string? SelectedCandidateId,
bool ManualOverride,
string TieBreak,
IReadOnlyList<BlendCandidateTrace> Candidates);
public sealed record BlendJudgmentProvenance(
string JudgmentPolicyId,
string CandidateSetId,
string SelectedCandidateId,
IReadOnlyDictionary<string, double> QualityMetrics);
public sealed record BlendBoundaryResult(
bool IsSuccess,
BodyState? OutputState,
GeometricDelta? Delta,
BlendJudgmentTrace Trace,
IReadOnlyList<SculptDiagnostic> Diagnostics);
internal sealed record MaterializedBlendCandidate(
string CandidateId,
int EdgeOrder,
BSplineSurfacePatch Patch,
BlendContinuity Capability,
BlendBoundaryEvidence BoundaryEvidence,
BlendQualityMetrics RawMetrics,
bool IsAdmissible,
string? RejectionReason);
/// <summary>
/// Deterministic two-support transition for the qualified housing crown/planar-shoulder case.
/// The product patch is the exact tensor product z=h*g_m(u)g_m(v), where
/// g_m(t)=4^m[t(1-t)]^m. m>=3 has zero first and second transverse derivatives at
/// every planar shoulder boundary, which is Aetheris' bounded G2 contract here:
/// coincident position, coincident tangent plane, and equal transverse normal curvature.
/// </summary>
public static class BlendBoundarySculptor
{
private const int MetricSamples = 25;
public static BlendBoundaryResult Apply(BodyState input, string outputName, BlendBoundaryOperation operation)
{
ArgumentNullException.ThrowIfNull(input); ArgumentNullException.ThrowIfNull(operation);
if (input.Construction is null) return Failure(operation, [BodyStateCapabilities.HousingRequired(input, operation.OperationKind)]);
if (BodyStateCapabilities.ImportedReconstruction(input, operation.OperationKind) is {} imported) return Failure(operation, [imported]);
if (BodyStateCapabilities.UnretainedSectionChain(input, operation.OperationKind) is {} history) return Failure(operation, [history]);
var diagnostics = ValidateRequest(input, operation).ToList();
if (diagnostics.Count > 0) return Failure(operation, diagnostics);
var candidates = Enumerable.Range(2, 4)
.Select(order => ConstructAndQualify(input, operation, order))
.OrderBy(candidate => candidate.CandidateId, StringComparer.Ordinal)
.ToArray();
var eligibleForPreferred = candidates.Where(candidate => candidate.IsAdmissible && candidate.Capability >= operation.PreferredContinuity).ToArray();
var activeRequirement = eligibleForPreferred.Length > 0 ? operation.PreferredContinuity : operation.MinimumContinuity;
var eligible = candidates.Where(candidate => candidate.IsAdmissible && candidate.Capability >= activeRequirement).ToArray();
if (eligible.Length > 0)
{
var normalized = Normalize(eligible, operation.EffectivePolicy);
candidates = candidates.Select(candidate => normalized.FirstOrDefault(item => item.CandidateId == candidate.CandidateId) ?? candidate).ToArray();
eligible = candidates.Where(candidate => candidate.IsAdmissible && candidate.Capability >= activeRequirement).ToArray();
}
MaterializedBlendCandidate? selected = null;
var manual = false;
if (operation.UseCandidate is not null)
{
selected = eligible.SingleOrDefault(candidate => StringComparer.Ordinal.Equals(candidate.CandidateId, operation.UseCandidate));
if (selected is null)
diagnostics.Add(new("surf-blend-override-ineligible", $"Candidate override '{operation.UseCandidate}' is absent or ineligible for {activeRequirement}."));
else manual = true;
}
else if (eligible.Length > 0)
{
var context = new BlendSelectionContext(eligible);
var options = eligible.Select(candidate => new JudgmentCandidate<BlendSelectionContext>(candidate.CandidateId, _ => true,
_ => candidate.RawMetrics.Utility, TieBreakerPriority: candidate.RawMetrics.ControlPointCount)).ToArray();
var judgment = new JudgmentEngine<BlendSelectionContext>().Evaluate(context, options);
if (judgment.IsSuccess)
selected = eligible.Single(candidate => candidate.CandidateId == judgment.Selection!.Value.Candidate.Name);
}
if (selected is null)
{
if (diagnostics.Count == 0)
{
foreach (var candidate in candidates)
{
var reason = candidate.RejectionReason ?? (candidate.Capability < activeRequirement
? $"continuity capability {candidate.Capability} is below active {activeRequirement}."
: "candidate was not selected");
diagnostics.Add(new("surf-blend-candidate-rejected", $"{candidate.CandidateId}: {reason}", candidate.CandidateId));
}
diagnostics.Add(new("surf-blend-no-eligible-candidates", $"No candidate satisfies minimum continuity {operation.MinimumContinuity}; continuity requirements are never lowered by scoring."));
}
return Failure(operation, diagnostics, Trace(operation, candidates, null, manual, activeRequirement));
}
var patchContinuity = selected.Capability switch { BlendContinuity.G2 => PatchBoundaryContinuity.G2, BlendContinuity.G1 => PatchBoundaryContinuity.G1, _ => PatchBoundaryContinuity.G0 };
var selectedPatch = selected.Patch with { BoundaryLoop = BoundaryLoop(operation.StableId, patchContinuity) };
var replace = new ReplaceRegionOperation(operation.StableId + ".ReplaceRegion", operation.SupportA, selectedPatch,
operation.MayModify, operation.InfluenceEnvelope, operation.Preserves, operation.Requirements,
operation.GeometricTolerance, operation.G1AngularToleranceDegrees, operation.G2CurvatureTolerance);
var certifiedBounds = new SpatialInfluenceEnvelope(-operation.RegionWidth / 2d, -operation.RegionDepth / 2d, operation.InfluenceEnvelope.MinZ,
operation.RegionWidth / 2d, operation.RegionDepth / 2d, operation.InfluenceEnvelope.MinZ + operation.CrownHeight);
var realized = ReplaceRegionSculptor.ApplyWithCertifiedPolynomialBounds(input, outputName, replace, certifiedBounds);
if (!realized.IsSuccess || realized.OutputState is null || realized.Delta is null)
return Failure(operation, realized.Diagnostics, Trace(operation, candidates, selected, manual, activeRequirement));
var trace = Trace(operation, candidates, selected, manual, activeRequirement);
var provenance = new BlendJudgmentProvenance(operation.EffectivePolicy.PolicyId, trace.CandidateSetId, selected.CandidateId,
new Dictionary<string, double>(StringComparer.Ordinal)
{
["Fairness"] = selected.RawMetrics.Fairness,
["CurvatureSmoothness"] = selected.RawMetrics.CurvatureSmoothness,
["Compactness"] = selected.RawMetrics.Compactness,
["Complexity"] = selected.RawMetrics.Complexity,
["Utility"] = selected.RawMetrics.Utility
});
var outputId = BodyStateId.Derive($"{input.StateId.Value}|BlendBoundary|{operation.Canonical}|{selected.CandidateId}");
var delta = realized.Delta with { OutputState = outputId, BlendJudgment = provenance };
var authority = ConstructionAuthorityEvolution.Append(input, outputName, operation, outputId, delta, realized.Evidence);
var state = realized.OutputState with { StateId = outputId, Delta = delta, BlendJudgment = trace, ConstructionAuthority = authority };
return new(true, state, delta, trace, []);
}
private static IEnumerable<SculptDiagnostic> ValidateRequest(BodyState input, BlendBoundaryOperation operation)
{
if (input.Construction is null) { yield return BodyStateCapabilities.HousingRequired(input, operation.OperationKind); yield break; }
if (!input.SemanticInventory.ContainsKey(operation.SupportA)) yield return new("surf-blend-support-unresolved", $"SupportA '{operation.SupportA}' is not present in the input BodyState.");
if (operation.SupportB != "PlanarTopShoulder") yield return new("surf-blend-support-unresolved", $"SupportB '{operation.SupportB}' is unsupported; this materializer requires PlanarTopShoulder.");
if (!operation.MayModify.Contains(operation.Region, StringComparer.Ordinal) && !operation.MayModify.Contains(operation.SupportA, StringComparer.Ordinal))
yield return new("sculpt-target-not-authorized", "BlendBoundary region/support is absent from MayModify.");
if (operation.MinimumContinuity > operation.PreferredContinuity) yield return new("surf-blend-continuity-invalid", "Minimum continuity cannot exceed preferred continuity.");
if (!double.IsFinite(operation.RegionWidth) || !double.IsFinite(operation.RegionDepth) || !double.IsFinite(operation.CrownHeight)
|| operation.RegionWidth <= 0d || operation.RegionDepth <= 0d || operation.CrownHeight <= 0d
|| operation.RegionWidth >= input.Construction.Width || operation.RegionDepth >= input.Construction.Depth)
yield return new("surf-blend-region-invalid", "The bounded transition region must be positive and strictly inside the housing footprint.");
if (operation.MaximumDegree < 1) yield return new("surf-blend-degree-invalid", "MaximumDegree must be positive.");
}
private static MaterializedBlendCandidate ConstructAndQualify(BodyState input, BlendBoundaryOperation operation, int order)
{
var degree = order * 2;
var id = $"PowerM{order}Degree{degree}";
var capability = order >= 3 ? BlendContinuity.G2 : order >= 2 ? BlendContinuity.G1 : BlendContinuity.G0;
var patch = CreatePatch(operation, order, id);
var boundary = BoundaryEvidence(operation, order);
var raw = MeasureQuality(operation, order, degree + 1);
string? rejection = null;
if (degree > operation.MaximumDegree) rejection = $"surf-blend-complexity-limit — degree {degree} exceeds MaximumDegree {operation.MaximumDegree}.";
else if (capability < operation.MinimumContinuity) rejection = $"surf-blend-g2-unsatisfied — capability {capability} is below required {operation.MinimumContinuity}; maximum normal-curvature error is {boundary.MaximumNormalCurvatureError:R}.";
else if (patch.Validate().Count > 0) rejection = "surf-blend-trim-invalid — materialized patch contract is invalid.";
else
{
var construction = (input.Construction ?? throw new InvalidOperationException("Housing capability must be admitted before candidate construction.")) with { CrownWidth = operation.RegionWidth, CrownDepth = operation.RegionDepth, CrownOffset = operation.CrownHeight, ReplacementPatch = patch };
var built = SculptedHousingBrepBuilder.Build(construction);
if (built.Body is null) rejection = "surf-blend-topology-invalid — " + string.Join(" | ", built.Diagnostics.Select(item => item.Message));
else
{
var bodyEvidence = SculptedHousingFactory.ValidateBody(built.Body, operation.GeometricTolerance);
var failed = bodyEvidence.FirstOrDefault(item => !item.Satisfied);
if (failed is not null) rejection = $"surf-blend-realized-brep-invalid — {failed.Check}: {failed.Detail}";
else
{
var points = SamplePatch(patch, 17);
var actual = new SpatialInfluenceEnvelope(points.Min(p => p.X), points.Min(p => p.Y), input.Construction.BaseHeight,
points.Max(p => p.X), points.Max(p => p.Y), points.Max(p => p.Z));
if (!operation.InfluenceEnvelope.Contains(actual, operation.GeometricTolerance)) rejection = "surf-blend-locality-violation — candidate exceeds the authorized influence envelope.";
}
}
}
return new(id, order, patch, capability, boundary, raw, rejection is null, rejection);
}
private static BSplineSurfacePatch CreatePatch(BlendBoundaryOperation operation, int order, string id)
{
var degree = order * 2; var count = degree + 1;
var central = double.Pow(4d, order) / Binomial(degree, order);
var rows = new Point3D[count][];
for (var i = 0; i < count; i++)
{
rows[i] = new Point3D[count];
for (var j = 0; j < count; j++)
{
var x = -operation.RegionWidth / 2d + operation.RegionWidth * i / degree;
var y = -operation.RegionDepth / 2d + operation.RegionDepth * j / degree;
var z = operation.InfluenceEnvelope.MinZ + (i == order && j == order ? operation.CrownHeight * central * central : 0d);
rows[i][j] = new(x, y, z);
}
}
var spline = new BSplineSurfaceWithKnots(degree, degree, rows, "UNSPECIFIED", false, false, false,
[degree + 1, degree + 1], [degree + 1, degree + 1], [0d, 1d], [0d, 1d], "UNSPECIFIED");
return new(operation.StableId + "." + id, spline, new(0d, 1d, 0d, 1d), BoundaryLoop(operation.StableId, PatchBoundaryContinuity.G0));
}
private static SurfaceBoundaryLoop BoundaryLoop(string stableId, PatchBoundaryContinuity continuity) => new(stableId + ".OuterLoop",
[
new(stableId + ".South", PatchBoundarySide.South, "CrownBoundarySouth", continuity),
new(stableId + ".East", PatchBoundarySide.East, "CrownBoundaryEast", continuity),
new(stableId + ".North", PatchBoundarySide.North, "CrownBoundaryNorth", continuity),
new(stableId + ".West", PatchBoundarySide.West, "CrownBoundaryWest", continuity)
]);
private static BlendBoundaryEvidence BoundaryEvidence(BlendBoundaryOperation operation, int order)
{
var maxCurvature = 0d;
for (var i = 0; i < 33; i++)
{
var t = i / 32d;
foreach (var (u, v, alongV) in new[] { (t, 0d, true), (1d, t, false), (t, 1d, true), (0d, t, false) })
{
var jet = Jet(operation, order, u, v);
var normal = jet.Du.Cross(jet.Dv); if (!normal.TryNormalize(out var n)) { maxCurvature = double.PositiveInfinity; continue; }
var tangent = alongV ? jet.Dv : jet.Du;
var second = alongV ? jet.Dvv : jet.Duu;
maxCurvature = double.Max(maxCurvature, double.Abs(second.Dot(n) / tangent.Dot(tangent)));
}
}
return new(0d, 0d, maxCurvature, 132,
"G2 = G0 position + coincident tangent plane + transverse normal-curvature continuity to the planar shoulder; exact polynomial first/second jets sampled at 33 parameters per side.");
}
private static BlendQualityMetrics MeasureQuality(BlendBoundaryOperation operation, int order, int controlCount)
{
var bending = 0d; var variation = 0d; var footprint = 0; var previous = new double?[MetricSamples, MetricSamples];
var du = 1d / (MetricSamples - 1d); var dv = du;
for (var i = 0; i < MetricSamples; i++) for (var j = 0; j < MetricSamples; j++)
{
var jet = Jet(operation, order, i * du, j * dv);
var cross = jet.Du.Cross(jet.Dv); var area = cross.Length;
if (!cross.TryNormalize(out var normal) || area <= 1e-14d) continue;
var E = jet.Du.Dot(jet.Du); var F = jet.Du.Dot(jet.Dv); var G = jet.Dv.Dot(jet.Dv); var det = E * G - F * F;
var e = jet.Duu.Dot(normal); var f = jet.Duv.Dot(normal); var g = jet.Dvv.Dot(normal);
var mean = (e * G - 2d * f * F + g * E) / (2d * det);
var gaussian = (e * g - f * f) / det;
var discriminant = double.Sqrt(double.Max(0d, mean * mean - gaussian));
var k1 = mean + discriminant; var k2 = mean - discriminant;
bending += (k1 * k1 + k2 * k2) * area * du * dv;
previous[i, j] = mean;
if (operation.CrownHeight * Shape(order, i * du) * Shape(order, j * dv) > operation.CrownHeight * .01d) footprint++;
if (i > 0 && previous[i - 1, j].HasValue) variation += double.Abs(mean - previous[i - 1, j]!.Value);
if (j > 0 && previous[i, j - 1].HasValue) variation += double.Abs(mean - previous[i, j - 1]!.Value);
}
var characteristic = double.Sqrt(operation.RegionWidth * operation.RegionDepth);
var changed = footprint / (double)(MetricSamples * MetricSamples);
return new(bending, variation * characteristic / (MetricSamples * MetricSamples), changed, controlCount * controlCount,
0d, 0d, 0d, 0d, 0d);
}
private static MaterializedBlendCandidate[] Normalize(IReadOnlyList<MaterializedBlendCandidate> eligible, BlendJudgmentPolicy policy)
{
static double PreferLow(double value, double min, double max) => max - min <= 1e-15d ? 1d : 1d - Utility.Remap(value, min, max);
var bendMin = eligible.Min(c => c.RawMetrics.BendingEnergy); var bendMax = eligible.Max(c => c.RawMetrics.BendingEnergy);
var variationMin = eligible.Min(c => c.RawMetrics.CurvatureVariation); var variationMax = eligible.Max(c => c.RawMetrics.CurvatureVariation);
var footprintMin = eligible.Min(c => c.RawMetrics.ChangedAreaFraction); var footprintMax = eligible.Max(c => c.RawMetrics.ChangedAreaFraction);
var complexityMin = eligible.Min(c => c.RawMetrics.ControlPointCount); var complexityMax = eligible.Max(c => c.RawMetrics.ControlPointCount);
return eligible.Select(candidate =>
{
var raw = candidate.RawMetrics;
var fairness = PreferLow(raw.BendingEnergy, bendMin, bendMax);
var smoothness = PreferLow(raw.CurvatureVariation, variationMin, variationMax);
var compactness = PreferLow(raw.ChangedAreaFraction, footprintMin, footprintMax);
var complexity = PreferLow(raw.ControlPointCount, complexityMin, complexityMax);
var utility = Utility.Weighted((fairness, policy.FairnessWeight), (smoothness, policy.CurvatureVariationWeight),
(compactness, policy.CompactnessWeight), (complexity, policy.ComplexityWeight));
return candidate with { RawMetrics = raw with { Fairness = fairness, CurvatureSmoothness = smoothness, Compactness = compactness, Complexity = complexity, Utility = utility } };
}).ToArray();
}
private static BlendJudgmentTrace Trace(BlendBoundaryOperation operation, IReadOnlyList<MaterializedBlendCandidate> candidates,
MaterializedBlendCandidate? selected, bool manual, BlendContinuity activeRequirement)
{
var ids = string.Join('|', candidates.Select(candidate => candidate.CandidateId));
var candidateSet = BodyStateId.Derive(operation.Canonical + "|" + ids).Value.Replace("state-", "blend-set-", StringComparison.Ordinal);
return new($"Preferred {operation.PreferredContinuity}; minimum {operation.MinimumContinuity}; active {activeRequirement} between {operation.SupportA} and {operation.SupportB}",
operation.EffectivePolicy.PolicyId, candidateSet, selected?.CandidateId, manual,
"Highest composite utility; ties use lower materialized control-point count, then ordinal CandidateId.",
candidates.Select(candidate => new BlendCandidateTrace(candidate.CandidateId, "symmetric polynomial Bezier power transition",
new Dictionary<string, string>(StringComparer.Ordinal) { ["EdgeVanishingOrder"] = candidate.EdgeOrder.ToString(), ["RegionWidthMm"] = operation.RegionWidth.ToString("R"), ["RegionDepthMm"] = operation.RegionDepth.ToString("R"), ["CrownHeightMm"] = operation.CrownHeight.ToString("R") },
candidate.Capability, candidate.Patch.ExportClass, candidate.Patch.Spline.DegreeU, candidate.Patch.Spline.DegreeV,
candidate.RawMetrics.ControlPointCount,
selected?.CandidateId == candidate.CandidateId ? BlendCandidateDisposition.Selected : candidate.IsAdmissible && candidate.Capability >= activeRequirement ? BlendCandidateDisposition.Eligible : BlendCandidateDisposition.Rejected,
candidate.IsAdmissible && candidate.Capability < activeRequirement ? $"Continuity capability {candidate.Capability} is below active {activeRequirement}." : candidate.RejectionReason,
candidate.BoundaryEvidence, candidate.IsAdmissible && candidate.Capability >= activeRequirement ? candidate.RawMetrics : null)).ToArray());
}
private static BlendBoundaryResult Failure(BlendBoundaryOperation operation, IReadOnlyList<SculptDiagnostic> diagnostics,
BlendJudgmentTrace? trace = null) => new(false, null, null, trace ?? new($"{operation.PreferredContinuity} between {operation.SupportA} and {operation.SupportB}",
operation.EffectivePolicy.PolicyId, "<not-generated>", null, false, "No selection.", []), diagnostics);
private static PatchJet2 Jet(BlendBoundaryOperation operation, int order, double u, double v)
{
var gu = Shape(order, u); var gv = Shape(order, v); var gpu = ShapeFirst(order, u); var gpv = ShapeFirst(order, v);
var gppu = ShapeSecond(order, u); var gppv = ShapeSecond(order, v); var h = operation.CrownHeight;
return new(new(-operation.RegionWidth / 2d + operation.RegionWidth * u, -operation.RegionDepth / 2d + operation.RegionDepth * v, operation.InfluenceEnvelope.MinZ + h * gu * gv),
new(operation.RegionWidth, 0d, h * gpu * gv), new(0d, operation.RegionDepth, h * gu * gpv),
new(0d, 0d, h * gppu * gv), new(0d, 0d, h * gpu * gpv), new(0d, 0d, h * gu * gppv), DifferentialSingularityKind.Regular);
}
private static double Shape(int order, double t) => double.Pow(4d * t * (1d - t), order);
private static double ShapeFirst(int order, double t)
{
var q = t * (1d - t); return double.Pow(4d, order) * order * double.Pow(q, order - 1) * (1d - 2d * t);
}
private static double ShapeSecond(int order, double t)
{
var q = t * (1d - t); var a = order == 1 ? 1d : double.Pow(q, order - 2);
return double.Pow(4d, order) * order * (a * ((order - 1d) * (1d - 2d * t) * (1d - 2d * t) - 2d * q));
}
private static double Binomial(int n, int k) { var result = 1d; for (var i = 1; i <= k; i++) result = result * (n - (k - i)) / i; return result; }
private static IReadOnlyList<Point3D> SamplePatch(BoundedSurfacePatch patch, int count) => Enumerable.Range(0, count).SelectMany(i => Enumerable.Range(0, count).Select(j => patch.Evaluate(i / (count - 1d), j / (count - 1d)))).ToArray();
private sealed record BlendSelectionContext(IReadOnlyList<MaterializedBlendCandidate> Candidates);
}