@ccpc/math 0.1.0

package/dist/curves/curve2.js

@@ -0,0 +1,238 @@
+/*
+ * Linea Math - Curves
+ * Curve2: 二维曲线抽象基类
+ */
+import { GeomBase } from '../core/geom_base';
+import { MathError } from '../utils/math_error';
+import { Precision } from '../utils/precision';
+import { DiscretizeEngine } from '../discretize/discretize_engine';
+import { Interval } from './interval';
+export class Curve2 extends GeomBase {
+    constructor() {
+        super(...arguments);
+        /**
+         * 参数域
+         * - 默认使用无界区间，具体曲线应在子类中覆盖
+         * - 子类可直接赋值 this._range，或调用 setRange()
+         */
+        this._range = Interval.infinite();
+    }
+    /**
+     * 获取参数域。
+     * @returns 参数域副本，调用方修改不会影响内部状态。
+     */
+    getRange() {
+        return this._range.clone();
+    }
+    /**
+     * 判断参数是否落在当前曲线参数域内。
+     * @param u 待判断参数。
+     * @param eps 区间边界比较容差。
+     * @returns 落在参数域内返回 `true`。
+     */
+    containsParam(u, eps = Precision.CURVE_PARAM_EPS) {
+        return this._range.contains(u, eps);
+    }
+    /**
+     * 是否为退化曲线。
+     * 默认规则：参数域过小或曲线长度过小。
+     */
+    isDegenerate() {
+        return this._range.length() <= Precision.CURVE_PARAM_EPS || this.length() <= Precision.CURVE_LENGTH_EPS;
+    }
+    /**
+     * 是否为闭合曲线。
+     * 默认返回 `false`，由闭合曲线子类覆盖。
+     */
+    isClosed() {
+        return false;
+    }
+    /** 是否为线段曲线。 */
+    isLine() {
+        return false;
+    }
+    /** 是否为整圆曲线。 */
+    isCircle() {
+        return false;
+    }
+    /** 是否为圆弧曲线。 */
+    isArc() {
+        return false;
+    }
+    /** 是否为整椭圆曲线。 */
+    isEllipse() {
+        return false;
+    }
+    /** 是否为椭圆弧曲线。 */
+    isEllipseArc() {
+        return false;
+    }
+    /** 是否为 B 样条曲线。 */
+    isBSpline() {
+        return false;
+    }
+    /**
+     * 获取第 `n` 阶导数（默认由 `derivatives` 派生）。
+     * @param u 曲线参数。
+     * @param n 导数阶数，要求为非负整数。
+     * @returns 第 `n` 阶导数向量。
+     */
+    derivativeAt(u, n) {
+        MathError.assert(Number.isInteger(n) && n >= 0, 'Curve2.derivativeAt: n must be a non-negative integer');
+        const ds = this.derivatives(u, n);
+        MathError.assert(ds.length > n, 'Curve2.derivativeAt: derivative order is not available');
+        return ds[n];
+    }
+    /**
+     * 最近参数（默认由 `closestPoint` 派生）。
+     * @param p 查询点。
+     * @param tol 计算容差。
+     * @returns 最近点对应参数。
+     */
+    closestParam(p, tol = Precision.LEN_EPS) {
+        return this.closestPoint(p, tol).param;
+    }
+    /**
+     * 点到曲线距离（默认由 `closestPoint` 派生）。
+     * @param p 查询点。
+     * @param tol 计算容差。
+     * @returns 点到曲线的最短距离。
+     */
+    distanceToPoint(p, tol = Precision.LEN_EPS) {
+        return this.closestPoint(p, tol).distance;
+    }
+    /**
+     * 曲线离散化便捷入口（薄封装）。
+     * @param options 离散参数。
+     * @returns 折线采样结果。
+     */
+    discretize(options) {
+        return DiscretizeEngine.discretize(this, options);
+    }
+    /**
+     * 设置参数域（供子类构造期使用）。
+     * @param range 参数区间。
+     * @returns 当前实例。
+     */
+    setRange(range) {
+        this._range = range.clone();
+        return this;
+    }
+    /**
+     * Newton + 二分混合求解参数（常用于弧长反参）。
+     * @param target 目标值（如目标弧长）。
+     * @param start 参数下界。
+     * @param end 参数上界。
+     * @param tol 收敛容差。
+     * @param evalValue 参数到目标量的映射函数（要求在 [start, end] 上单调）。
+     * @param evalSlope 参数处导数量（如速度），用于 Newton 步。
+     * @param failMessage 未收敛时抛错信息。
+     * @param initialGuess 可选初值；不传时取区间中点。
+     * @returns 收敛后的参数。
+     */
+    solveParamByHybridNewton(target, start, end, tol, evalValue, evalSlope, failMessage, initialGuess) {
+        MathError.assert(Number.isFinite(start) && Number.isFinite(end) && end > start, 'Curve2.solveParamByHybridNewton: invalid range');
+        MathError.assert(Number.isFinite(tol) && tol > 0, 'Curve2.solveParamByHybridNewton: tol must be > 0');
+        // lo/hi 始终包住当前根，Newton 出界时回退到二分保证收敛性。
+        let lo = start;
+        let hi = end;
+        let u = initialGuess ?? ((lo + hi) * 0.5);
+        if (!Number.isFinite(u) || u <= lo || u >= hi) {
+            u = (lo + hi) * 0.5;
+        }
+        for (let i = 0; i < Precision.CURVE_MAX_ITER; i++) {
+            const value = evalValue(u);
+            const f = value - target;
+            if (Math.abs(f) <= tol)
+                return u;
+            const slope = evalSlope(u);
+            let next = Number.NaN;
+            if (Math.abs(slope) > Precision.CURVE_NEWTON_EPS) {
+                next = u - f / slope;
+            }
+            // Newton 步越界或数值异常时，退回二分步，避免振荡/发散。
+            if (!Number.isFinite(next) || next <= lo || next >= hi) {
+                next = (lo + hi) * 0.5;
+            }
+            if (f > 0) {
+                hi = u;
+            }
+            else {
+                lo = u;
+            }
+            u = next;
+        }
+        MathError.throw(failMessage);
+    }
+    /**
+     * “采样粗定位 + Newton 细化”最近点求解通用流程。
+     * @param p 查询点。
+     * @param tol 收敛容差。
+     * @param sampleCount 初始采样数（含两端点）。
+     * @param evalPoint 参数求点函数。
+     * @param evalD1 一阶导函数。
+     * @param evalD2 二阶导函数。
+     * @param failMessage 未收敛时抛错信息。
+     * @param compareParam 参数平局比较器（返回 <0 表示 a 更优）。
+     * @returns 最近点结果。
+     */
+    solveClosestPointBySampleNewton(p, tol, sampleCount, evalPoint, evalD1, evalD2, failMessage, compareParam = (a, b) => a - b) {
+        MathError.assert(Number.isFinite(tol) && tol > 0, 'Curve2.solveClosestPointBySampleNewton: tol must be > 0');
+        MathError.assert(Number.isInteger(sampleCount) && sampleCount > 0, 'Curve2.solveClosestPointBySampleNewton: sampleCount must be a positive integer');
+        const start = this._range.start;
+        const span = this._range.length();
+        // 零跨度参数域直接退化为单点评估。
+        if (span <= Precision.CURVE_PARAM_EPS) {
+            const point = evalPoint(start);
+            return { point, param: start, distance: point.distanceTo(p) };
+        }
+        // 第 1 阶段：均匀采样找一个稳定的初始参数。
+        let bestU = start;
+        let bestDistSq = Number.POSITIVE_INFINITY;
+        for (let i = 0; i <= sampleCount; i++) {
+            const u = start + (span * i) / sampleCount;
+            const q = evalPoint(u);
+            const d2 = q.distanceToSq(p);
+            if (d2 < bestDistSq - tol * tol) {
+                bestDistSq = d2;
+                bestU = u;
+                continue;
+            }
+            if (Math.abs(d2 - bestDistSq) <= tol * tol && compareParam(u, bestU) < 0) {
+                bestU = u;
+            }
+        }
+        // 第 2 阶段：在采样命中的局部窗口做 Newton 迭代。
+        const step = span / sampleCount;
+        let lo = Math.max(start, bestU - step);
+        let hi = Math.min(start + span, bestU + step);
+        let u = bestU;
+        for (let i = 0; i < Precision.CURVE_MAX_ITER; i++) {
+            const c = evalPoint(u);
+            const d1 = evalD1(u);
+            const d2 = evalD2(u);
+            const cp = c.subtracted(p);
+            const f = cp.dot(d1);
+            if (Math.abs(f) <= tol) {
+                return { point: c, param: u, distance: c.distanceTo(p) };
+            }
+            const fp = d1.dot(d1) + cp.dot(d2);
+            let next = Number.NaN;
+            if (Math.abs(fp) > Precision.CURVE_NEWTON_EPS) {
+                next = u - f / fp;
+            }
+            // Newton 失效时回退二分，保持区间收缩。
+            if (!Number.isFinite(next) || next <= lo || next >= hi) {
+                next = (lo + hi) * 0.5;
+            }
+            if (f > 0) {
+                hi = u;
+            }
+            else {
+                lo = u;
+            }
+            u = next;
+        }
+        MathError.throw(failMessage);
+    }
+}

package/dist/curves/ellipse2.d.ts

@@ -0,0 +1,42 @@
+import { EN_GEO_TYPE } from '../constants/geom_type';
+import { Box2 } from '../core/box2';
+import { Mat3 } from '../core/mat3';
+import { Vec2 } from '../core/vec2';
+import type { IDBEllipse2 } from '../serialize/dump_types';
+import { EllipseArc2 } from './ellipse_arc2';
+import { EllipseCurve2 } from './ellipse_curve2';
+import { Interval } from './interval';
+export declare class Ellipse2 extends EllipseCurve2 {
+    static readonly type = EN_GEO_TYPE.Ellipse2;
+    /**
+     * 构造整椭圆。
+     * @param center 中心点。
+     * @param rx 长半轴。
+     * @param ry 短半轴。
+     * @param rotation 椭圆局部 x 轴相对全局 x 轴旋转角（弧度）。
+     */
+    constructor(center: Vec2, rx: number, ry: number, rotation?: number);
+    split(u: number): EllipseArc2[];
+    trim(range: Interval): EllipseArc2[];
+    reverse(): this;
+    transform(m: Mat3): this;
+    transformed(m: Mat3): this;
+    boundingBox(): Box2;
+    isValid(eps?: number): boolean;
+    isClosed(): boolean;
+    isEllipse(): this is Ellipse2;
+    /**
+     * 结构等价判断（字段级）。
+     * @param other 对比椭圆。
+     * @param eps 数值容差。
+     * @returns 中心、长短半轴和旋转角近似相等时返回 `true`。
+     */
+    equals(other: Ellipse2, eps?: number): boolean;
+    clone(): this;
+    dump(): IDBEllipse2;
+    static load(data: IDBEllipse2): Ellipse2;
+    protected paramToAngle(u: number): number;
+    protected angleToParam(theta: number): number;
+    protected angleDerivativeSign(): 1 | -1;
+}
+//# sourceMappingURL=ellipse2.d.ts.map

package/dist/curves/ellipse2.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ellipse2.d.ts","sourceRoot":"","sources":["../../src/curves/ellipse2.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAA;AAEpD,OAAO,EAAE,IAAI,EAAE,MAAM,cAAc,CAAA;AACnC,OAAO,EAAE,IAAI,EAAE,MAAM,cAAc,CAAA;AACnC,OAAO,EAAE,IAAI,EAAE,MAAM,cAAc,CAAA;AACnC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAA;AAI1D,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAA;AAC5C,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAA;AAChD,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAA;AAGrC,qBAKa,QAAS,SAAQ,aAAa;IACvC,gBAAuB,IAAI,wBAAuB;IAElD;;;;;;OAMG;gBACS,MAAM,EAAE,IAAI,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,QAAQ,SAAI;IAK9C,KAAK,CAAC,CAAC,EAAE,MAAM;IAYf,IAAI,CAAC,KAAK,EAAE,QAAQ;IAOpB,OAAO;IAKP,SAAS,CAAC,CAAC,EAAE,IAAI;IAWjB,WAAW,CAAC,CAAC,EAAE,IAAI,GAAG,IAAI;IAI1B,WAAW;IAaX,OAAO,CAAC,GAAG,SAA6B;IAIxC,QAAQ,IAAI,OAAO;IAInB,SAAS,IAAI,IAAI,IAAI,QAAQ;IAI7C;;;;;OAKG;IACI,MAAM,CAAC,KAAK,EAAE,QAAQ,EAAE,GAAG,SAAgB;IAOlC,KAAK,IAAI,IAAI;IAIb,IAAI,IAAI,WAAW;WAUrB,IAAI,CAAC,IAAI,EAAE,WAAW;cASjB,YAAY,CAAC,CAAC,EAAE,MAAM;cAKtB,YAAY,CAAC,KAAK,EAAE,MAAM;cAK1B,mBAAmB,IAAI,CAAC,GAAG,CAAC,CAAC;CAGnD"}

package/dist/curves/ellipse2.js

@@ -0,0 +1,125 @@
+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 Ellipse2_1;
+import { EN_GEO_TYPE } from '../constants/geom_type';
+import { MathConst } from '../constants/math_const';
+import { Box2 } from '../core/box2';
+import { Vec2 } from '../core/vec2';
+import { RegisterGeom } from '../serialize/geom_mgr';
+import { MathError } from '../utils/math_error';
+import { Precision } from '../utils/precision';
+import { EllipseArc2 } from './ellipse_arc2';
+import { EllipseCurve2 } from './ellipse_curve2';
+import { PeriodInterval } from './period_interval';
+let Ellipse2 = Ellipse2_1 = class Ellipse2 extends EllipseCurve2 {
+    /**
+     * 构造整椭圆。
+     * @param center 中心点。
+     * @param rx 长半轴。
+     * @param ry 短半轴。
+     * @param rotation 椭圆局部 x 轴相对全局 x 轴旋转角（弧度）。
+     */
+    constructor(center, rx, ry, rotation = 0) {
+        super(center, rx, ry, rotation);
+        this.setRange(new PeriodInterval(0, MathConst.PI2, MathConst.PI2));
+    }
+    split(u) {
+        const range = this._range;
+        const uu = range.normalizeInPeriod(u, range.start);
+        if (Math.abs(uu - range.start) <= Precision.CURVE_PARAM_EPS || Math.abs(uu - range.end) <= Precision.CURVE_PARAM_EPS) {
+            return [];
+        }
+        const left = new EllipseArc2(this._center, this._rx, this._ry, this._rotation, range.start, uu, false);
+        const right = new EllipseArc2(this._center, this._rx, this._ry, this._rotation, uu, range.start + range.period, false);
+        return [left, right].filter((arc) => arc.length() > Precision.CURVE_LENGTH_EPS);
+    }
+    trim(range) {
+        this._range.assertContainsRange(range, Precision.CURVE_PARAM_EPS);
+        if (range.length() <= Precision.CURVE_PARAM_EPS)
+            return [];
+        return [new EllipseArc2(this._center, this._rx, this._ry, this._rotation, range.start, range.end, false)];
+    }
+    reverse() {
+        // 整椭圆反转后几何与参数域等价，保持不变即可。
+        return this;
+    }
+    transform(m) {
+        const next = this.transformedEllipseParams(m);
+        MathError.assert(next.rx > Precision.CURVE_LENGTH_EPS && next.ry > Precision.CURVE_LENGTH_EPS, 'Ellipse2.transform: degenerate ellipse after transform');
+        this._center = next.center;
+        this._rx = next.rx;
+        this._ry = next.ry;
+        this._rotation = next.rotation;
+        return this;
+    }
+    transformed(m) {
+        return this.clone().transform(m);
+    }
+    boundingBox() {
+        const c = Math.cos(this._rotation);
+        const s = Math.sin(this._rotation);
+        const ex = Math.hypot(this._rx * c, this._ry * s);
+        const ey = Math.hypot(this._rx * s, this._ry * c);
+        return new Box2(this._center.x - ex, this._center.y - ey, this._center.x + ex, this._center.y + ey);
+    }
+    isValid(eps = Precision.CURVE_LENGTH_EPS) {
+        return this.isEllipseStructValid(eps);
+    }
+    isClosed() {
+        return true;
+    }
+    isEllipse() {
+        return true;
+    }
+    /**
+     * 结构等价判断（字段级）。
+     * @param other 对比椭圆。
+     * @param eps 数值容差。
+     * @returns 中心、长短半轴和旋转角近似相等时返回 `true`。
+     */
+    equals(other, eps = Precision.EPS) {
+        return this._center.equals(other._center, eps) &&
+            Precision.equal(this._rx, other._rx, eps) &&
+            Precision.equal(this._ry, other._ry, eps) &&
+            Precision.equal(this._rotation, other._rotation, eps);
+    }
+    clone() {
+        return new Ellipse2_1(this._center, this._rx, this._ry, this._rotation);
+    }
+    dump() {
+        return {
+            type: Ellipse2_1.type,
+            center: { x: this._center.x, y: this._center.y },
+            rx: this._rx,
+            ry: this._ry,
+            rotation: this._rotation,
+        };
+    }
+    static load(data) {
+        return new Ellipse2_1(new Vec2(data.center.x, data.center.y), data.rx, data.ry, data.rotation);
+    }
+    paramToAngle(u) {
+        const range = this._range;
+        return range.normalizeInPeriod(u, range.start);
+    }
+    angleToParam(theta) {
+        const range = this._range;
+        return range.normalizeInPeriod(theta, range.start);
+    }
+    angleDerivativeSign() {
+        return 1;
+    }
+};
+Ellipse2.type = EN_GEO_TYPE.Ellipse2;
+Ellipse2 = Ellipse2_1 = __decorate([
+    RegisterGeom
+    /**
+     * 二维整椭圆曲线。
+     * 参数域固定为 `PeriodInterval(0, 2π, 2π)`。
+     */
+], Ellipse2);
+export { Ellipse2 };

package/dist/curves/ellipse_arc2.d.ts

@@ -0,0 +1,49 @@
+import { EN_GEO_TYPE } from '../constants/geom_type';
+import { Mat3 } from '../core/mat3';
+import { Vec2 } from '../core/vec2';
+import type { IDBEllipseArc2 } from '../serialize/dump_types';
+import { EllipseCurve2 } from './ellipse_curve2';
+import { Interval } from './interval';
+export declare class EllipseArc2 extends EllipseCurve2 {
+    static readonly type = EN_GEO_TYPE.EllipseArc2;
+    private _clockwise;
+    /**
+     * 构造椭圆弧。
+     * @param center 中心点。
+     * @param rx 长半轴。
+     * @param ry 短半轴。
+     * @param rotation 椭圆局部 x 轴相对全局 x 轴旋转角（弧度）。
+     * @param startAngle 起始角（几何语义）。
+     * @param endAngle 终止角（几何语义）。
+     * @param clockwise 是否顺时针。
+     */
+    constructor(center: Vec2, rx: number, ry: number, rotation: number, startAngle: number, endAngle: number, clockwise?: boolean);
+    get clockwise(): boolean;
+    get startAngle(): number;
+    get endAngle(): number;
+    split(u: number): EllipseArc2[];
+    trim(range: Interval): EllipseArc2[];
+    reverse(): this;
+    transform(m: Mat3): this;
+    transformed(m: Mat3): this;
+    isValid(eps?: number): boolean;
+    isClosed(): boolean;
+    isEllipseArc(): this is EllipseArc2;
+    /**
+     * 结构等价判断（字段级）。
+     * @param other 对比椭圆弧。
+     * @param eps 数值容差。
+     * @returns 中心、轴长、旋转、方向与起终角参数近似相等时返回 `true`。
+     */
+    equals(other: EllipseArc2, eps?: number): boolean;
+    clone(): this;
+    dump(): IDBEllipseArc2;
+    static load(data: IDBEllipseArc2): EllipseArc2;
+    protected paramToAngle(u: number): number;
+    protected angleToParam(theta: number): number;
+    protected angleDerivativeSign(): 1 | -1;
+    private resetAngles;
+    private normalizeAngle;
+    private positiveMod;
+}
+//# sourceMappingURL=ellipse_arc2.d.ts.map

package/dist/curves/ellipse_arc2.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ellipse_arc2.d.ts","sourceRoot":"","sources":["../../src/curves/ellipse_arc2.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAA;AAEpD,OAAO,EAAE,IAAI,EAAE,MAAM,cAAc,CAAA;AACnC,OAAO,EAAE,IAAI,EAAE,MAAM,cAAc,CAAA;AACnC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAA;AAI7D,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAA;AAChD,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAA;AAGrC,qBAKa,WAAY,SAAQ,aAAa;IAC1C,gBAAuB,IAAI,2BAA0B;IAErD,OAAO,CAAC,UAAU,CAAS;IAE3B;;;;;;;;;OASG;gBACS,MAAM,EAAE,IAAI,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,SAAS,UAAQ;IAO3H,IAAW,SAAS,YAEnB;IAED,IAAW,UAAU,WAEpB;IAED,IAAW,QAAQ,WAMlB;IAEe,KAAK,CAAC,CAAC,EAAE,MAAM;IAUf,IAAI,CAAC,KAAK,EAAE,QAAQ;IAUpB,OAAO;IAOP,SAAS,CAAC,CAAC,EAAE,IAAI;IA4BjB,WAAW,CAAC,CAAC,EAAE,IAAI,GAAG,IAAI;IAI1B,OAAO,CAAC,GAAG,SAA6B;IAIxC,QAAQ,IAAI,OAAO;IAInB,YAAY,IAAI,IAAI,IAAI,WAAW;IAInD;;;;;OAKG;IACI,MAAM,CAAC,KAAK,EAAE,WAAW,EAAE,GAAG,SAAgB;IAUrC,KAAK,IAAI,IAAI;IAYb,IAAI,IAAI,cAAc;WAaxB,IAAI,CAAC,IAAI,EAAE,cAAc;cAYpB,YAAY,CAAC,CAAC,EAAE,MAAM;cAMtB,YAAY,CAAC,KAAK,EAAE,MAAM;cAS1B,mBAAmB,IAAI,CAAC,GAAG,CAAC,CAAC;IAIhD,OAAO,CAAC,WAAW;IAiBnB,OAAO,CAAC,cAAc;IAKtB,OAAO,CAAC,WAAW;CAItB"}

package/dist/curves/ellipse_arc2.js

@@ -0,0 +1,184 @@
+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 EllipseArc2_1;
+import { EN_GEO_TYPE } from '../constants/geom_type';
+import { MathConst } from '../constants/math_const';
+import { Vec2 } from '../core/vec2';
+import { RegisterGeom } from '../serialize/geom_mgr';
+import { MathError } from '../utils/math_error';
+import { Precision } from '../utils/precision';
+import { EllipseCurve2 } from './ellipse_curve2';
+import { PeriodInterval } from './period_interval';
+let EllipseArc2 = EllipseArc2_1 = class EllipseArc2 extends EllipseCurve2 {
+    /**
+     * 构造椭圆弧。
+     * @param center 中心点。
+     * @param rx 长半轴。
+     * @param ry 短半轴。
+     * @param rotation 椭圆局部 x 轴相对全局 x 轴旋转角（弧度）。
+     * @param startAngle 起始角（几何语义）。
+     * @param endAngle 终止角（几何语义）。
+     * @param clockwise 是否顺时针。
+     */
+    constructor(center, rx, ry, rotation, startAngle, endAngle, clockwise = false) {
+        super(center, rx, ry, rotation);
+        MathError.assert(Number.isFinite(startAngle) && Number.isFinite(endAngle), 'EllipseArc2: startAngle/endAngle must be finite');
+        this._clockwise = clockwise;
+        this.resetAngles(startAngle, endAngle, clockwise);
+    }
+    get clockwise() {
+        return this._clockwise;
+    }
+    get startAngle() {
+        return this.normalizeAngle(this._range.start);
+    }
+    get endAngle() {
+        const sweep = this._range.length();
+        const end = this._clockwise
+            ? this._range.start - sweep
+            : this._range.start + sweep;
+        return this.normalizeAngle(end);
+    }
+    split(u) {
+        const parts = this._range.split(u, Precision.CURVE_PARAM_EPS);
+        if (parts.length === 0)
+            return [];
+        const theta = this.paramToAngle(u);
+        const left = new EllipseArc2_1(this._center, this._rx, this._ry, this._rotation, this.startAngle, theta, this._clockwise);
+        const right = new EllipseArc2_1(this._center, this._rx, this._ry, this._rotation, theta, this.endAngle, this._clockwise);
+        return [left, right].filter((arc) => arc.length() > Precision.CURVE_LENGTH_EPS);
+    }
+    trim(range) {
+        this._range.assertContainsRange(range, Precision.CURVE_PARAM_EPS);
+        if (range.length() <= Precision.CURVE_PARAM_EPS)
+            return [];
+        const start = this.paramToAngle(range.start);
+        const end = this.paramToAngle(range.end);
+        const arc = new EllipseArc2_1(this._center, this._rx, this._ry, this._rotation, start, end, this._clockwise);
+        return arc.length() <= Precision.CURVE_LENGTH_EPS ? [] : [arc];
+    }
+    reverse() {
+        const s = this.startAngle;
+        const e = this.endAngle;
+        this.resetAngles(e, s, !this._clockwise);
+        return this;
+    }
+    transform(m) {
+        const oldSweep = this._range.length();
+        const startPoint = this.pointAt(this._range.start);
+        const endPoint = this.pointAt(this._range.end);
+        const next = this.transformedEllipseParams(m);
+        MathError.assert(next.rx > Precision.CURVE_LENGTH_EPS && next.ry > Precision.CURVE_LENGTH_EPS, 'EllipseArc2.transform: degenerate ellipse after transform');
+        const nextStartPoint = m.transformedPoint(startPoint);
+        const nextEndPoint = m.transformedPoint(endPoint);
+        const startAngle = this.angleFromPointOnEllipse(nextStartPoint, next.center, next.rx, next.ry, next.rotation);
+        let endAngle = this.angleFromPointOnEllipse(nextEndPoint, next.center, next.rx, next.ry, next.rotation);
+        const nextClockwise = next.mirrored ? !this._clockwise : this._clockwise;
+        if (Math.abs(oldSweep - MathConst.PI2) <= Precision.CURVE_PARAM_EPS) {
+            endAngle = startAngle + (nextClockwise ? -MathConst.PI2 : MathConst.PI2);
+        }
+        this._center = next.center;
+        this._rx = next.rx;
+        this._ry = next.ry;
+        this._rotation = next.rotation;
+        this.resetAngles(startAngle, endAngle, nextClockwise);
+        return this;
+    }
+    transformed(m) {
+        return this.clone().transform(m);
+    }
+    isValid(eps = Precision.CURVE_LENGTH_EPS) {
+        return this.isEllipseStructValid(eps) && this._range.length() >= 0 && this._range.length() <= MathConst.PI2 + Precision.CURVE_PARAM_EPS;
+    }
+    isClosed() {
+        return Precision.equal(this._range.length(), MathConst.PI2, Precision.CURVE_PARAM_EPS);
+    }
+    isEllipseArc() {
+        return true;
+    }
+    /**
+     * 结构等价判断（字段级）。
+     * @param other 对比椭圆弧。
+     * @param eps 数值容差。
+     * @returns 中心、轴长、旋转、方向与起终角参数近似相等时返回 `true`。
+     */
+    equals(other, eps = Precision.EPS) {
+        return this._clockwise === other._clockwise &&
+            this._center.equals(other._center, eps) &&
+            Precision.equal(this._rx, other._rx, eps) &&
+            Precision.equal(this._ry, other._ry, eps) &&
+            Precision.equal(this._rotation, other._rotation, eps) &&
+            Precision.equal(this.startAngle, other.startAngle, eps) &&
+            Precision.equal(this.endAngle, other.endAngle, eps);
+    }
+    clone() {
+        return new EllipseArc2_1(this._center, this._rx, this._ry, this._rotation, this.startAngle, this.endAngle, this._clockwise);
+    }
+    dump() {
+        return {
+            type: EllipseArc2_1.type,
+            center: { x: this._center.x, y: this._center.y },
+            rx: this._rx,
+            ry: this._ry,
+            rotation: this._rotation,
+            startAngle: this.startAngle,
+            endAngle: this.endAngle,
+            clockwise: this._clockwise,
+        };
+    }
+    static load(data) {
+        return new EllipseArc2_1(new Vec2(data.center.x, data.center.y), data.rx, data.ry, data.rotation, data.startAngle, data.endAngle, data.clockwise);
+    }
+    paramToAngle(u) {
+        const uu = this.normalizeParamForEval(u);
+        if (!this._clockwise)
+            return uu;
+        return this._range.start - (uu - this._range.start);
+    }
+    angleToParam(theta) {
+        const range = this._range;
+        if (!this._clockwise) {
+            return range.normalizeInPeriod(theta, range.start);
+        }
+        const reflected = 2 * range.start - theta;
+        return range.normalizeInPeriod(reflected, range.start);
+    }
+    angleDerivativeSign() {
+        return this._clockwise ? -1 : 1;
+    }
+    resetAngles(startAngle, endAngle, clockwise) {
+        const s = this.normalizeAngle(startAngle);
+        const startEqEnd = Precision.equal(startAngle, endAngle, Precision.CURVE_PARAM_EPS);
+        let sweep = 0;
+        if (!startEqEnd) {
+            const raw = clockwise ? (startAngle - endAngle) : (endAngle - startAngle);
+            sweep = this.positiveMod(raw);
+            if (Precision.equal(sweep, 0, Precision.CURVE_PARAM_EPS)) {
+                sweep = MathConst.PI2;
+            }
+        }
+        this._clockwise = clockwise;
+        this.setRange(new PeriodInterval(s, s + sweep, MathConst.PI2));
+    }
+    normalizeAngle(a) {
+        const r = a % MathConst.PI2;
+        return r < 0 ? r + MathConst.PI2 : r;
+    }
+    positiveMod(x) {
+        const r = x % MathConst.PI2;
+        return r < 0 ? r + MathConst.PI2 : r;
+    }
+};
+EllipseArc2.type = EN_GEO_TYPE.EllipseArc2;
+EllipseArc2 = EllipseArc2_1 = __decorate([
+    RegisterGeom
+    /**
+     * 二维椭圆弧曲线。
+     * 内部参数域统一为递增区间 `[s, s + sweep]`，方向由 `clockwise` 表示。
+     */
+], EllipseArc2);
+export { EllipseArc2 };