@ccpc/math 0.1.0

package/dist/curves/bspline2.js

@@ -0,0 +1,793 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var BSpline2_1;
+import { EN_GEO_TYPE } from '../constants/geom_type';
+import { Box2 } from '../core/box2';
+import { Vec2 } from '../core/vec2';
+import { RegisterGeom } from '../serialize/geom_mgr';
+import { Axis2D } from '../types/type_define';
+import { MathError } from '../utils/math_error';
+import { Precision } from '../utils/precision';
+import { Curve2 } from './curve2';
+import { Interval } from './interval';
+let BSpline2 = BSpline2_1 = class BSpline2 extends Curve2 {
+    /**
+     * 构造 B 样条曲线。
+     * @param controlPoints 控制点数组。
+     * @param degree 样条次数（`>=1`）。
+     * @param options 节点、权重与周期配置。
+     */
+    constructor(controlPoints, degree, options = {}) {
+        super();
+        MathError.assert(Number.isInteger(degree) && degree >= 1, 'BSpline2: degree must be an integer >= 1');
+        MathError.assert(controlPoints.length >= degree + 1, 'BSpline2: controlPoints.length must be >= degree + 1');
+        MathError.assert(options.isPeriodic !== true, 'BSpline2: periodic is not supported in v1');
+        this._degree = degree;
+        this._controlPoints = controlPoints.map((p) => p.clone());
+        this.assertFiniteControlPoints(this._controlPoints);
+        this._weights = this.resolveWeights(options.weights);
+        this._knots = this.resolveKnots(options);
+        this.validateExpandedKnots(this._knots, this._controlPoints.length, degree);
+        const domainStart = this._knots[this._degree];
+        const domainEnd = this._knots[this._knots.length - this._degree - 1];
+        MathError.assert(domainEnd > domainStart, 'BSpline2: invalid parameter domain');
+        this.setRange(new Interval(domainStart, domainEnd));
+    }
+    /** 控制点数组（返回深拷贝） */
+    get controlPoints() {
+        return this._controlPoints.map((p) => p.clone());
+    }
+    /** 样条次数 */
+    get degree() {
+        return this._degree;
+    }
+    /** 展开节点向量（返回副本） */
+    get expandedKnots() {
+        return [...this._knots];
+    }
+    /** 权重数组（返回副本） */
+    get weights() {
+        return [...this._weights];
+    }
+    /**
+     * 获取参数域内部的连续性断点参数。
+     * 当 knot 重数 >= degree 时，可视为连续性下降断点。
+     */
+    getContinuityBreakParams(eps = Precision.CURVE_PARAM_EPS) {
+        const breaks = [];
+        const range = this._range;
+        for (let i = 0; i < this._knots.length;) {
+            const knot = this._knots[i];
+            let multiplicity = 1;
+            i++;
+            while (i < this._knots.length && Math.abs(this._knots[i] - knot) <= eps) {
+                multiplicity++;
+                i++;
+            }
+            if (multiplicity >= this._degree && knot > range.start + eps && knot < range.end - eps) {
+                breaks.push(knot);
+            }
+        }
+        return breaks;
+    }
+    pointAt(u) {
+        return this.derivatives(u, 0)[0];
+    }
+    tangentAt(u) {
+        return this.derivativeAt(u, 1);
+    }
+    derivatives(u, n) {
+        MathError.assert(Number.isInteger(n) && n >= 0, 'BSpline2.derivatives: n must be a non-negative integer');
+        const uu = this.snapParam(u);
+        const p = this._degree;
+        const du = Math.min(n, p);
+        const span = BSpline2_1.findSpan(this._controlPoints.length - 1, p, uu, this._knots);
+        const ders = BSpline2_1.basisFunctionDerivatives(span, uu, p, du, this._knots);
+        const pw = this.homogeneousControlPoints();
+        const ckw = [];
+        for (let k = 0; k <= du; k++) {
+            let x = 0;
+            let y = 0;
+            let w = 0;
+            for (let j = 0; j <= p; j++) {
+                const idx = span - p + j;
+                const coeff = ders[k][j];
+                x += coeff * pw[idx].x;
+                y += coeff * pw[idx].y;
+                w += coeff * pw[idx].w;
+            }
+            ckw.push({ x, y, w });
+        }
+        MathError.assert(Math.abs(ckw[0].w) > Precision.CURVE_NEWTON_EPS, 'BSpline2.derivatives: rational weight is degenerate');
+        const ret = [];
+        for (let k = 0; k <= du; k++) {
+            let vx = ckw[k].x;
+            let vy = ckw[k].y;
+            for (let i = 1; i <= k; i++) {
+                const b = BSpline2_1.binomial(k, i) * ckw[i].w;
+                vx -= b * ret[k - i].x;
+                vy -= b * ret[k - i].y;
+            }
+            ret.push(new Vec2(vx / ckw[0].w, vy / ckw[0].w));
+        }
+        for (let k = du + 1; k <= n; k++) {
+            ret.push(Vec2.zero());
+        }
+        return ret;
+    }
+    curvatureAt(u) {
+        const d1 = this.derivativeAt(u, 1);
+        const d2 = this.derivativeAt(u, 2);
+        const denom = Math.pow(d1.lenSq(), 1.5);
+        MathError.assert(denom > Precision.CURVE_NEWTON_EPS, 'BSpline2.curvatureAt: tangent is degenerate');
+        return Math.abs(d1.cross(d2)) / denom;
+    }
+    length(range) {
+        if (!range) {
+            return this.integrateLength(this._range.start, this._range.end);
+        }
+        this._range.assertContainsRange(range, Precision.CURVE_PARAM_EPS);
+        return this.integrateLength(range.start, range.end);
+    }
+    lengthAtParam(u) {
+        const uu = this.snapParam(u);
+        return this.integrateLength(this._range.start, uu);
+    }
+    paramAtLength(s, tol = Precision.CURVE_LENGTH_EPS) {
+        MathError.assert(Number.isFinite(tol) && tol > 0, 'BSpline2.paramAtLength: tol must be > 0');
+        const total = this.length();
+        const start = this._range.start;
+        const end = this._range.end;
+        MathError.assert(s >= -tol && s <= total + tol, `BSpline2.paramAtLength: s out of range [0, ${total}]`);
+        if (s <= tol)
+            return start;
+        if (total - s <= tol)
+            return end;
+        const target = Math.min(total, Math.max(0, s));
+        // 使用基类统一的“Newton + 二分”模板，保证边界与收敛行为一致。
+        return this.solveParamByHybridNewton(target, start, end, tol, (u) => this.integrateLength(start, u), (u) => this.tangentAt(u).len(), 'BSpline2.paramAtLength: failed to converge', start + (target / total) * (end - start));
+    }
+    split(u) {
+        const splitParts = this._range.split(u, Precision.CURVE_PARAM_EPS);
+        if (splitParts.length === 0)
+            return [];
+        const uu = this.snapParam(u);
+        const p = this._degree;
+        const U = [...this._knots];
+        const n = this._controlPoints.length - 1;
+        const k = BSpline2_1.findSpan(n, p, uu, U);
+        const s = BSpline2_1.knotMultiplicity(uu, U);
+        let pw = this.homogeneousControlPoints();
+        let knots = U;
+        const r = p - s;
+        for (let i = 0; i < r; i++) {
+            const inserted = BSpline2_1.insertKnotOnce(pw, knots, p, uu);
+            pw = inserted.points;
+            knots = inserted.knots;
+        }
+        const leftEnd = k - s;
+        const leftPw = pw.slice(0, leftEnd + 1);
+        const rightPw = pw.slice(leftEnd);
+        const leftKnots = [...U.slice(0, k + 1), ...new Array(p - s + 1).fill(uu)];
+        const rightKnots = [...new Array(p + 1).fill(uu), ...U.slice(k + 1)];
+        const left = BSpline2_1.fromHomogeneous(leftPw, p, leftKnots);
+        const right = BSpline2_1.fromHomogeneous(rightPw, p, rightKnots);
+        const ret = [left, right].filter((c) => c.length() > Precision.CURVE_LENGTH_EPS);
+        return ret;
+    }
+    trim(range) {
+        this._range.assertContainsRange(range, Precision.CURVE_PARAM_EPS);
+        if (range.length() <= Precision.CURVE_PARAM_EPS)
+            return [];
+        const fullStart = this._range.start;
+        const fullEnd = this._range.end;
+        let cur = this.clone();
+        if (range.end < fullEnd - Precision.CURVE_PARAM_EPS) {
+            const s = cur.split(range.end);
+            MathError.assert(s.length > 0, 'BSpline2.trim: split at end failed');
+            cur = s[0];
+        }
+        if (range.start > fullStart + Precision.CURVE_PARAM_EPS) {
+            const s = cur.split(range.start);
+            MathError.assert(s.length > 0, 'BSpline2.trim: split at start failed');
+            cur = s[s.length - 1];
+        }
+        return cur.length() > Precision.CURVE_LENGTH_EPS ? [cur] : [];
+    }
+    reverse() {
+        const m = this._knots.length - 1;
+        const start = this._range.start;
+        const end = this._range.end;
+        this._controlPoints.reverse();
+        this._weights.reverse();
+        const nextKnots = new Array(this._knots.length);
+        for (let i = 0; i <= m; i++) {
+            nextKnots[i] = start + end - this._knots[m - i];
+        }
+        this._knots = nextKnots;
+        this.setRange(new Interval(this._knots[this._degree], this._knots[this._knots.length - this._degree - 1]));
+        return this;
+    }
+    transform(m) {
+        const next = this._controlPoints.map((p) => m.transformedPoint(p));
+        this.assertFiniteControlPoints(next);
+        this._controlPoints = next;
+        return this;
+    }
+    transformed(m) {
+        return this.clone().transform(m);
+    }
+    closestPoint(p, tol = Precision.CURVE_LENGTH_EPS) {
+        MathError.assert(Number.isFinite(tol) && tol > 0, 'BSpline2.closestPoint: tol must be > 0');
+        // 先采样粗定位，再用 Newton 在局部窗口细化，避免直接迭代落入错误极值点。
+        return this.solveClosestPointBySampleNewton(p, tol, 96, (u) => this.pointAt(u), (u) => this.derivativeAt(u, 1), (u) => this.derivativeAt(u, 2), 'BSpline2.closestPoint: failed to converge');
+    }
+    boundingBox(accurate = false) {
+        const controlBox = Box2.fromPoints(this._controlPoints);
+        if (!accurate)
+            return controlBox;
+        const range = this.getRange();
+        const spanBounds = this.buildBBoxSpanBounds();
+        const candidates = [
+            this.pointAt(range.start),
+            this.pointAt(range.end),
+        ];
+        for (const [u0, u1] of spanBounds) {
+            const xRoots = this.solveComponentExtremaInSpan(Axis2D.X, u0, u1);
+            const yRoots = this.solveComponentExtremaInSpan(Axis2D.Y, u0, u1);
+            for (const u of [...xRoots, ...yRoots]) {
+                if (!range.contains(u, Precision.CURVE_PARAM_EPS))
+                    continue;
+                candidates.push(this.pointAt(u));
+            }
+        }
+        if (candidates.length < 2)
+            return controlBox;
+        const tightBox = Box2.fromPoints(candidates);
+        return this.expandBoxBySpanSamples(tightBox, spanBounds);
+    }
+    isValid(eps = Precision.CURVE_LENGTH_EPS) {
+        if (!Number.isInteger(this._degree) || this._degree < 1)
+            return false;
+        if (this._controlPoints.length < this._degree + 1)
+            return false;
+        if (this._weights.length !== this._controlPoints.length)
+            return false;
+        if (this._weights.some((w) => !Number.isFinite(w) || w <= eps))
+            return false;
+        if (this._knots.length !== this._controlPoints.length + this._degree + 1)
+            return false;
+        for (let i = 1; i < this._knots.length; i++) {
+            if (this._knots[i] < this._knots[i - 1])
+                return false;
+        }
+        const domainStart = this._knots[this._degree];
+        const domainEnd = this._knots[this._knots.length - this._degree - 1];
+        return Number.isFinite(domainStart) && Number.isFinite(domainEnd) && domainEnd - domainStart > eps;
+    }
+    isBSpline() {
+        return true;
+    }
+    /**
+     * 结构等价判断（字段级）。
+     * @param other 对比样条。
+     * @param eps 数值容差。
+     * @returns 阶次、控制点、权重与节点向量逐项近似相等时返回 `true`。
+     */
+    equals(other, eps = Precision.EPS) {
+        if (this._degree !== other._degree)
+            return false;
+        if (this._controlPoints.length !== other._controlPoints.length)
+            return false;
+        if (this._weights.length !== other._weights.length)
+            return false;
+        if (this._knots.length !== other._knots.length)
+            return false;
+        for (let i = 0; i < this._controlPoints.length; i++) {
+            if (!this._controlPoints[i].equals(other._controlPoints[i], eps))
+                return false;
+            if (!Precision.equal(this._weights[i], other._weights[i], eps))
+                return false;
+        }
+        for (let i = 0; i < this._knots.length; i++) {
+            if (!Precision.equal(this._knots[i], other._knots[i], eps))
+                return false;
+        }
+        return true;
+    }
+    clone() {
+        return new BSpline2_1(this._controlPoints, this._degree, {
+            expandedKnots: this._knots,
+            weights: this._weights,
+            isPeriodic: false,
+        });
+    }
+    dump() {
+        return {
+            type: BSpline2_1.type,
+            controlPoints: this._controlPoints.map((p) => ({ x: p.x, y: p.y })),
+            degree: this._degree,
+            expandedKnots: [...this._knots],
+            weights: [...this._weights],
+            isPeriodic: false,
+        };
+    }
+    static load(data) {
+        return new BSpline2_1(data.controlPoints.map((p) => new Vec2(p.x, p.y)), data.degree, {
+            expandedKnots: data.expandedKnots,
+            weights: data.weights,
+            isPeriodic: data.isPeriodic,
+        });
+    }
+    /**
+     * 解析并校验权重。
+     * @param weights 输入权重；未传时返回全 1。
+     */
+    resolveWeights(weights) {
+        if (!weights) {
+            return new Array(this._controlPoints.length).fill(1);
+        }
+        MathError.assert(weights.length === this._controlPoints.length, 'BSpline2: weights.length must equal controlPoints.length');
+        const w = [...weights];
+        for (const wi of w) {
+            MathError.assert(Number.isFinite(wi) && wi > 0, 'BSpline2: weight must be > 0');
+        }
+        return w;
+    }
+    /**
+     * 解析并统一节点输入。
+     * @param options 构造选项。
+     * @returns 统一后的 expanded knots。
+     */
+    resolveKnots(options) {
+        const fromExpanded = options.expandedKnots ? [...options.expandedKnots] : undefined;
+        const fromCompact = options.knots && options.multiplicities
+            ? BSpline2_1.expandKnots(options.knots, options.multiplicities)
+            : undefined;
+        const resolved = fromExpanded ?? fromCompact;
+        if (!resolved) {
+            MathError.throw('BSpline2: expandedKnots or (knots+multiplicities) is required');
+        }
+        if (fromExpanded && fromCompact) {
+            MathError.assert(fromExpanded.length === fromCompact.length, 'BSpline2: expandedKnots mismatch with knots+multiplicities');
+            for (let i = 0; i < fromExpanded.length; i++) {
+                MathError.assert(Precision.equal(fromExpanded[i], fromCompact[i], Precision.CURVE_PARAM_EPS), 'BSpline2: expandedKnots mismatch with knots+multiplicities');
+            }
+        }
+        return resolved;
+    }
+    /**
+     * 校验 expanded knots 基本合法性。
+     * @param knots 展开节点向量。
+     * @param controlPointCount 控制点数量。
+     * @param degree 样条次数。
+     */
+    validateExpandedKnots(knots, controlPointCount, degree) {
+        MathError.assert(knots.length === controlPointCount + degree + 1, 'BSpline2: invalid expandedKnots length');
+        for (const k of knots) {
+            MathError.assert(Number.isFinite(k), 'BSpline2: knot must be finite');
+        }
+        for (let i = 1; i < knots.length; i++) {
+            MathError.assert(knots[i] >= knots[i - 1], 'BSpline2: knots must be non-decreasing');
+        }
+    }
+    /**
+     * 校验控制点坐标有限性。
+     * @param points 控制点数组。
+     */
+    assertFiniteControlPoints(points) {
+        for (const p of points) {
+            MathError.assert(Number.isFinite(p.x) && Number.isFinite(p.y), 'BSpline2: control point must be finite');
+        }
+    }
+    /**
+     * 转换为齐次控制点。
+     * @returns 齐次点数组 `{x,y,w}`。
+     */
+    homogeneousControlPoints() {
+        const ret = [];
+        for (let i = 0; i < this._controlPoints.length; i++) {
+            const w = this._weights[i];
+            const p = this._controlPoints[i];
+            ret.push({ x: p.x * w, y: p.y * w, w });
+        }
+        return ret;
+    }
+    /**
+     * 自适应积分计算弧长。
+     * @param u0 起始参数。
+     * @param u1 结束参数。
+     * @param depth 当前递归深度。
+     */
+    integrateLength(u0, u1, depth = 0) {
+        if (u1 < u0)
+            return 0;
+        const f = (u) => this.tangentAt(u).len();
+        const whole = this.gaussLegendre5(f, u0, u1);
+        if (depth >= Precision.CURVE_INTEGRAL_MAX_DEPTH) {
+            return whole;
+        }
+        const mid = (u0 + u1) * 0.5;
+        const left = this.gaussLegendre5(f, u0, mid);
+        const right = this.gaussLegendre5(f, mid, u1);
+        const err = Math.abs((left + right) - whole);
+        if (err <= Precision.CURVE_LENGTH_EPS) {
+            return left + right;
+        }
+        return this.integrateLength(u0, mid, depth + 1) + this.integrateLength(mid, u1, depth + 1);
+    }
+    gaussLegendre5(f, a, b) {
+        const nodes = [
+            0,
+            -0.5384693101056831,
+            0.5384693101056831,
+            -0.906179845938664,
+            0.906179845938664,
+        ];
+        const weights = [
+            0.5688888888888889,
+            0.47862867049936647,
+            0.47862867049936647,
+            0.23692688505618908,
+            0.23692688505618908,
+        ];
+        const c1 = (b - a) * 0.5;
+        const c2 = (b + a) * 0.5;
+        let sum = 0;
+        for (let i = 0; i < nodes.length; i++) {
+            sum += weights[i] * f(c1 * nodes[i] + c2);
+        }
+        return c1 * sum;
+    }
+    buildBBoxSpanBounds() {
+        const range = this.getRange();
+        const boundaries = [range.start, range.end, ...this.getUniqueKnotsInRange(range.start, range.end)];
+        const sorted = [...new Set(boundaries)]
+            .filter((u) => Number.isFinite(u) && range.contains(u, Precision.CURVE_PARAM_EPS))
+            .sort((a, b) => a - b);
+        const spans = [];
+        for (let i = 0; i < sorted.length - 1; i++) {
+            const u0 = sorted[i];
+            const u1 = sorted[i + 1];
+            if (u1 - u0 <= Precision.CURVE_PARAM_EPS)
+                continue;
+            spans.push([u0, u1]);
+        }
+        return spans;
+    }
+    getUniqueKnotsInRange(start, end) {
+        const unique = [];
+        for (const knot of this._knots) {
+            if (knot <= start + Precision.CURVE_PARAM_EPS || knot >= end - Precision.CURVE_PARAM_EPS)
+                continue;
+            if (unique.length > 0 && Math.abs(unique[unique.length - 1] - knot) <= Precision.CURVE_PARAM_EPS)
+                continue;
+            unique.push(knot);
+        }
+        return unique;
+    }
+    solveComponentExtremaInSpan(axis, u0, u1) {
+        const roots = [];
+        const brackets = this.findRootBrackets(axis, u0, u1);
+        for (const [b0, b1] of brackets) {
+            const root = this.refineRootBracketedNewton(axis, b0, b1);
+            if (root === undefined)
+                continue;
+            const clamped = this.clampParamForBBox(root);
+            if (clamped < u0 - Precision.CURVE_PARAM_EPS || clamped > u1 + Precision.CURVE_PARAM_EPS)
+                continue;
+            if (roots.some((u) => Math.abs(u - clamped) <= Precision.CURVE_PARAM_EPS * 4))
+                continue;
+            roots.push(clamped);
+        }
+        return roots;
+    }
+    findRootBrackets(axis, u0, u1) {
+        const brackets = [];
+        const steps = this.bboxRootSampleCount();
+        const du = (u1 - u0) / steps;
+        let prevU = u0;
+        let prevF = this.componentDerivative(axis, prevU, 1);
+        for (let i = 1; i <= steps; i++) {
+            const curU = i === steps ? u1 : (u0 + du * i);
+            const curF = this.componentDerivative(axis, curU, 1);
+            if (Math.abs(prevF) <= Precision.CURVE_NEWTON_EPS) {
+                brackets.push([
+                    Math.max(u0, prevU - du),
+                    Math.min(u1, prevU + du),
+                ]);
+            }
+            if (Math.abs(curF) <= Precision.CURVE_NEWTON_EPS || prevF * curF <= 0) {
+                brackets.push([prevU, curU]);
+            }
+            prevU = curU;
+            prevF = curF;
+        }
+        return this.mergeBrackets(brackets, u0, u1);
+    }
+    refineRootBracketedNewton(axis, uL, uR) {
+        let lo = this.clampParamForBBox(Math.min(uL, uR));
+        let hi = this.clampParamForBBox(Math.max(uL, uR));
+        if (hi - lo <= Precision.CURVE_PARAM_EPS)
+            return undefined;
+        let fLo = this.componentDerivative(axis, lo, 1);
+        let fHi = this.componentDerivative(axis, hi, 1);
+        let u = (lo + hi) * 0.5;
+        for (let iter = 0; iter < Precision.CURVE_MAX_ITER; iter++) {
+            const f = this.componentDerivative(axis, u, 1);
+            if (Math.abs(f) <= Precision.CURVE_NEWTON_EPS)
+                return u;
+            const d2 = this.componentDerivative(axis, u, 2);
+            let next = Number.NaN;
+            if (Number.isFinite(d2) && Math.abs(d2) > Precision.CURVE_NEWTON_EPS) {
+                next = u - f / d2;
+            }
+            if (!Number.isFinite(next) || next <= lo || next >= hi) {
+                next = (lo + hi) * 0.5;
+            }
+            if (fLo * f <= 0) {
+                hi = u;
+                fHi = f;
+            }
+            else if (f * fHi <= 0) {
+                lo = u;
+                fLo = f;
+            }
+            else {
+                if (next < u)
+                    hi = u;
+                else
+                    lo = u;
+                fLo = this.componentDerivative(axis, lo, 1);
+                fHi = this.componentDerivative(axis, hi, 1);
+            }
+            if (hi - lo <= Precision.CURVE_PARAM_EPS) {
+                const mid = (lo + hi) * 0.5;
+                if (Math.abs(this.componentDerivative(axis, mid, 1)) <= Precision.CURVE_NEWTON_EPS * 10) {
+                    return mid;
+                }
+                return undefined;
+            }
+            u = next;
+        }
+        return undefined;
+    }
+    mergeBrackets(brackets, u0, u1) {
+        if (brackets.length === 0)
+            return [];
+        const sorted = brackets
+            .map(([a, b]) => [this.clampParamForBBox(Math.min(a, b)), this.clampParamForBBox(Math.max(a, b))])
+            .filter(([a, b]) => b - a > Precision.CURVE_PARAM_EPS)
+            .sort((lhs, rhs) => lhs[0] - rhs[0] || lhs[1] - rhs[1]);
+        if (sorted.length === 0)
+            return [];
+        const merged = [sorted[0]];
+        for (let i = 1; i < sorted.length; i++) {
+            const cur = sorted[i];
+            const prev = merged[merged.length - 1];
+            if (cur[0] <= prev[1] + Precision.CURVE_PARAM_EPS) {
+                prev[1] = Math.max(prev[1], cur[1]);
+                continue;
+            }
+            merged.push(cur);
+        }
+        for (const item of merged) {
+            item[0] = Math.max(item[0], u0);
+            item[1] = Math.min(item[1], u1);
+        }
+        return merged.filter(([a, b]) => b - a > Precision.CURVE_PARAM_EPS);
+    }
+    bboxRootSampleCount() {
+        // Degree-scaled sampling keeps low-order curves fast while giving higher-order curves
+        // enough brackets for extrema detection without a single hard-coded global level.
+        return Math.max(8, Math.min(32, this._degree * 4));
+    }
+    expandBoxBySpanSamples(box, spans) {
+        let expanded = box;
+        const samplesPerSpan = Math.max(4, Math.floor(this.bboxRootSampleCount() / 2));
+        for (const [u0, u1] of spans) {
+            for (let i = 1; i < samplesPerSpan; i++) {
+                const t = i / samplesPerSpan;
+                const u = u0 + (u1 - u0) * t;
+                const p = this.pointAt(u);
+                if (!expanded.containsPoint(p)) {
+                    expanded = expanded.expandByPoint(p);
+                }
+            }
+        }
+        return expanded;
+    }
+    componentDerivative(axis, u, order) {
+        const d = this.derivativeAt(this.clampParamForBBox(u), order);
+        return axis === Axis2D.X ? d.x : d.y;
+    }
+    clampParamForBBox(u) {
+        const range = this._range;
+        if (u <= range.start)
+            return range.start;
+        if (u >= range.end)
+            return range.end;
+        return u;
+    }
+    /**
+     * 参数吸附到端点，避免边界浮点抖动。
+     * @param u 输入参数。
+     * @returns 吸附后的参数。
+     */
+    snapParam(u) {
+        this._range.assertContains(u, Precision.CURVE_PARAM_EPS);
+        const start = this._range.start;
+        const end = this._range.end;
+        if (Math.abs(u - start) <= Precision.CURVE_PARAM_EPS)
+            return start;
+        if (Math.abs(u - end) <= Precision.CURVE_PARAM_EPS)
+            return end;
+        return u;
+    }
+    static fromHomogeneous(points, degree, knots) {
+        const cps = [];
+        const ws = [];
+        for (const p of points) {
+            MathError.assert(Math.abs(p.w) > Precision.CURVE_NEWTON_EPS, 'BSpline2.fromHomogeneous: invalid homogeneous weight');
+            cps.push(new Vec2(p.x / p.w, p.y / p.w));
+            ws.push(p.w);
+        }
+        return new BSpline2_1(cps, degree, { expandedKnots: knots, weights: ws, isPeriodic: false });
+    }
+    static expandKnots(knots, multiplicities) {
+        MathError.assert(knots.length === multiplicities.length, 'BSpline2: knots and multiplicities length mismatch');
+        const expanded = [];
+        for (let i = 0; i < knots.length; i++) {
+            const m = multiplicities[i];
+            MathError.assert(Number.isInteger(m) && m > 0, 'BSpline2: multiplicity must be positive integer');
+            for (let j = 0; j < m; j++)
+                expanded.push(knots[i]);
+        }
+        return expanded;
+    }
+    static findSpan(n, p, u, U) {
+        if (u >= U[n + 1] - Precision.CURVE_PARAM_EPS)
+            return n;
+        if (u <= U[p] + Precision.CURVE_PARAM_EPS)
+            return p;
+        let low = p;
+        let high = n + 1;
+        let mid = Math.floor((low + high) * 0.5);
+        while (u < U[mid] || u >= U[mid + 1]) {
+            if (u < U[mid])
+                high = mid;
+            else
+                low = mid;
+            mid = Math.floor((low + high) * 0.5);
+        }
+        return mid;
+    }
+    static knotMultiplicity(u, U) {
+        let s = 0;
+        for (const k of U) {
+            if (Precision.equal(k, u, Precision.CURVE_PARAM_EPS))
+                s++;
+        }
+        return s;
+    }
+    static insertKnotOnce(points, knots, degree, u) {
+        const n = points.length - 1;
+        const k = BSpline2_1.findSpan(n, degree, u, knots);
+        const s = BSpline2_1.knotMultiplicity(u, knots);
+        const outPoints = new Array(points.length + 1);
+        const outKnots = new Array(knots.length + 1);
+        for (let i = 0; i <= k; i++)
+            outKnots[i] = knots[i];
+        outKnots[k + 1] = u;
+        for (let i = k + 1; i < knots.length; i++)
+            outKnots[i + 1] = knots[i];
+        for (let i = 0; i <= k - degree; i++)
+            outPoints[i] = points[i];
+        for (let i = k - s; i <= n; i++)
+            outPoints[i + 1] = points[i];
+        for (let i = k - degree + 1; i <= k - s; i++) {
+            const denom = knots[i + degree] - knots[i];
+            const alpha = Math.abs(denom) <= Precision.CURVE_NEWTON_EPS ? 0 : (u - knots[i]) / denom;
+            const p0 = points[i - 1];
+            const p1 = points[i];
+            outPoints[i] = {
+                x: (1 - alpha) * p0.x + alpha * p1.x,
+                y: (1 - alpha) * p0.y + alpha * p1.y,
+                w: (1 - alpha) * p0.w + alpha * p1.w,
+            };
+        }
+        return { points: outPoints, knots: outKnots };
+    }
+    static basisFunctionDerivatives(span, u, p, n, U) {
+        const ndu = Array.from({ length: p + 1 }, () => new Array(p + 1).fill(0));
+        const left = new Array(p + 1).fill(0);
+        const right = new Array(p + 1).fill(0);
+        ndu[0][0] = 1;
+        for (let j = 1; j <= p; j++) {
+            left[j] = u - U[span + 1 - j];
+            right[j] = U[span + j] - u;
+            let saved = 0;
+            for (let r = 0; r < j; r++) {
+                ndu[j][r] = right[r + 1] + left[j - r];
+                const denom = ndu[j][r];
+                const temp = Math.abs(denom) <= Precision.CURVE_NEWTON_EPS ? 0 : ndu[r][j - 1] / denom;
+                ndu[r][j] = saved + right[r + 1] * temp;
+                saved = left[j - r] * temp;
+            }
+            ndu[j][j] = saved;
+        }
+        const ders = Array.from({ length: n + 1 }, () => new Array(p + 1).fill(0));
+        for (let j = 0; j <= p; j++) {
+            ders[0][j] = ndu[j][p];
+        }
+        const a = [new Array(p + 1).fill(0), new Array(p + 1).fill(0)];
+        for (let r = 0; r <= p; r++) {
+            let s1 = 0;
+            let s2 = 1;
+            a[0][0] = 1;
+            for (let k = 1; k <= n; k++) {
+                let d = 0;
+                const rk = r - k;
+                const pk = p - k;
+                if (r >= k) {
+                    const denom = ndu[pk + 1][rk];
+                    a[s2][0] = Math.abs(denom) <= Precision.CURVE_NEWTON_EPS ? 0 : a[s1][0] / denom;
+                    d = a[s2][0] * ndu[rk][pk];
+                }
+                const j1 = rk >= -1 ? 1 : -rk;
+                const j2 = (r - 1 <= pk) ? (k - 1) : (p - r);
+                for (let j = j1; j <= j2; j++) {
+                    const denom = ndu[pk + 1][rk + j];
+                    a[s2][j] = Math.abs(denom) <= Precision.CURVE_NEWTON_EPS
+                        ? 0
+                        : (a[s1][j] - a[s1][j - 1]) / denom;
+                    d += a[s2][j] * ndu[rk + j][pk];
+                }
+                if (r <= pk) {
+                    const denom = ndu[pk + 1][r];
+                    a[s2][k] = Math.abs(denom) <= Precision.CURVE_NEWTON_EPS ? 0 : -a[s1][k - 1] / denom;
+                    d += a[s2][k] * ndu[r][pk];
+                }
+                ders[k][r] = d;
+                const tmp = s1;
+                s1 = s2;
+                s2 = tmp;
+            }
+        }
+        let scale = p;
+        for (let k = 1; k <= n; k++) {
+            for (let j = 0; j <= p; j++) {
+                ders[k][j] *= scale;
+            }
+            scale *= (p - k);
+        }
+        return ders;
+    }
+    static binomial(n, k) {
+        if (k < 0 || k > n)
+            return 0;
+        if (k === 0 || k === n)
+            return 1;
+        let kk = k;
+        if (kk > n - kk)
+            kk = n - kk;
+        let result = 1;
+        for (let i = 1; i <= kk; i++) {
+            result = (result * (n - kk + i)) / i;
+        }
+        return result;
+    }
+};
+BSpline2.type = EN_GEO_TYPE.BSpline2;
+BSpline2 = BSpline2_1 = __decorate([
+    RegisterGeom
+    /**
+     * 二维有理 B 样条（NURBS）曲线。
+     * 内部统一使用 expanded knot vector 存储与计算。
+     */
+], BSpline2);
+export { BSpline2 };