@ccpc/math 0.1.0

package/dist/core/vec2.js

@@ -0,0 +1,297 @@
+/*
+ * Linea Math - Core
+ * Vec2：二维向量，采用不可变设计，支持链式调用。
+ */
+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 Vec2_1;
+import { GeomBase } from './geom_base';
+import { EN_GEO_TYPE } from '../constants/geom_type';
+import { RegisterGeom } from '../serialize/geom_mgr';
+import { Precision } from '../utils/precision';
+let Vec2 = Vec2_1 = class Vec2 extends GeomBase {
+    constructor(xOrObj = 0, y = 0) {
+        super();
+        if (typeof xOrObj === 'number') {
+            this.x = xOrObj;
+            this.y = y;
+        }
+        else {
+            this.x = xOrObj.x;
+            this.y = xOrObj.y;
+        }
+    }
+    /** 零向量 */
+    static zero() {
+        return new Vec2_1(0, 0);
+    }
+    /** 单位向量 X */
+    static unitX() {
+        return new Vec2_1(1, 0);
+    }
+    /** 单位向量 Y */
+    static unitY() {
+        return new Vec2_1(0, 1);
+    }
+    /** 克隆当前向量 */
+    clone() {
+        return new Vec2_1(this.x, this.y);
+    }
+    /** 返回替换 X 分量的新向量 */
+    withX(x) {
+        return new Vec2_1(x, this.y);
+    }
+    /** 返回替换 Y 分量的新向量 */
+    withY(y) {
+        return new Vec2_1(this.x, y);
+    }
+    /** 设置 X 分量（就地修改） */
+    setX(x) {
+        this.x = x;
+        return this;
+    }
+    /** 设置 Y 分量（就地修改） */
+    setY(y) {
+        this.y = y;
+        return this;
+    }
+    /** 向量相加（就地修改） */
+    add(v) {
+        this.x += v.x;
+        this.y += v.y;
+        return this;
+    }
+    /** 向量相加（返回新对象） */
+    added(v) {
+        return this.clone().add(v);
+    }
+    /** 向量相减（就地修改） */
+    subtract(v) {
+        this.x -= v.x;
+        this.y -= v.y;
+        return this;
+    }
+    /** 向量相减（返回新对象） */
+    subtracted(v) {
+        return this.clone().subtract(v);
+    }
+    /**
+     * 向量线性叠加：this + v * s
+     * - 常用于积分、插值、偏移等计算
+     */
+    addScaled(v, s) {
+        this.x += v.x * s;
+        this.y += v.y * s;
+        return this;
+    }
+    /** 向量线性叠加（返回新对象） */
+    addScaleded(v, s) {
+        return this.clone().addScaled(v, s);
+    }
+    /** 反向量（取相反方向） */
+    negate() {
+        this.x = -this.x;
+        this.y = -this.y;
+        return this;
+    }
+    /** 反向量（返回新对象） */
+    negated() {
+        return this.clone().negate();
+    }
+    /**
+     * 绕原点旋转（弧度）
+     * - 逆时针为正方向
+     */
+    rotate(rad) {
+        const c = Math.cos(rad);
+        const s = Math.sin(rad);
+        const x = this.x * c - this.y * s;
+        const y = this.x * s + this.y * c;
+        this.x = x;
+        this.y = y;
+        return this;
+    }
+    /** 绕原点旋转（返回新对象） */
+    rotated(rad) {
+        return this.clone().rotate(rad);
+    }
+    /**
+     * 绕指定点旋转（弧度）
+     * - 先平移到原点旋转，再平移回去
+     */
+    rotateAround(center, rad) {
+        const x = this.x - center.x;
+        const y = this.y - center.y;
+        const c = Math.cos(rad);
+        const s = Math.sin(rad);
+        this.x = x * c - y * s + center.x;
+        this.y = x * s + y * c + center.y;
+        return this;
+    }
+    /**
+     * 垂直向量（默认逆时针 90°）
+     * - (x, y) -> (-y, x)
+     * - 若需顺时针方向，可对结果取反
+     */
+    perp() {
+        const x = -this.y;
+        const y = this.x;
+        this.x = x;
+        this.y = y;
+        return this;
+    }
+    /** 垂直向量（返回新对象） */
+    perped() {
+        return this.clone().perp();
+    }
+    /** 标量缩放 */
+    scale(s) {
+        this.x *= s;
+        this.y *= s;
+        return this;
+    }
+    /** 标量缩放（返回新对象） */
+    scaled(s) {
+        return this.clone().scale(s);
+    }
+    /** 点积 */
+    dot(v) {
+        return this.x * v.x + this.y * v.y;
+    }
+    /** 叉积（返回标量） */
+    cross(v) {
+        return this.x * v.y - this.y * v.x;
+    }
+    /** 长度平方 */
+    lenSq() {
+        return this.x * this.x + this.y * this.y;
+    }
+    /** 向量长度 */
+    len() {
+        return Math.hypot(this.x, this.y);
+    }
+    /**
+     * 设置向量长度（保持方向）
+     * - 零向量返回零向量
+     */
+    setLength(len, eps = Precision.LEN_EPS) {
+        const l = this.len();
+        if (l < eps) {
+            this.x = 0;
+            this.y = 0;
+            return this;
+        }
+        return this.scale(len / l);
+    }
+    /** 设置向量长度（返回新对象） */
+    setLengthed(len, eps = Precision.LEN_EPS) {
+        return this.clone().setLength(len, eps);
+    }
+    /** 归一化，极短向量返回零向量 */
+    normalize(eps = Precision.LEN_EPS) {
+        const l = this.len();
+        if (l < eps) {
+            this.x = 0;
+            this.y = 0;
+            return this;
+        }
+        return this.scale(1 / l);
+    }
+    /** 归一化（返回新对象） */
+    normalized(eps = Precision.LEN_EPS) {
+        return this.clone().normalize(eps);
+    }
+    /**
+     * 应用 Mat3 变换（就地修改）
+     */
+    applyMat3(m) {
+        return m.transformPoint(this);
+    }
+    /** 应用 Mat3 变换（返回新对象） */
+    appliedMat3(m) {
+        return this.clone().applyMat3(m);
+    }
+    /** 到目标向量的距离 */
+    distanceTo(v) {
+        return Math.hypot(this.x - v.x, this.y - v.y);
+    }
+    /** 到目标向量的距离平方（避免开方，更高效） */
+    distanceToSq(v) {
+        const dx = this.x - v.x;
+        const dy = this.y - v.y;
+        return dx * dx + dy * dy;
+    }
+    /**
+     * 向量投影（投影到目标向量上）
+     * - 若目标向量为零向量，则返回零向量
+     * - 结果与目标向量共线
+     */
+    project(on, eps = Precision.LEN_EPS) {
+        const denom = on.lenSq();
+        if (Precision.nearlyZeroSq(denom, eps)) {
+            this.x = 0;
+            this.y = 0;
+            return this;
+        }
+        const scale = this.dot(on) / denom;
+        this.x = on.x * scale;
+        this.y = on.y * scale;
+        return this;
+    }
+    /** 向量投影（返回新对象） */
+    projected(on, eps = Precision.LEN_EPS) {
+        return this.clone().project(on, eps);
+    }
+    /**
+     * 返回向量的方向角（弧度）
+     * - 相对于 +X 轴的角度
+     * - 结果范围为 [-PI, PI]
+     */
+    angle() {
+        return Math.atan2(this.y, this.x);
+    }
+    /** 线性插值 */
+    lerp(v, t) {
+        return new Vec2_1(this.x + (v.x - this.x) * t, this.y + (v.y - this.y) * t);
+    }
+    /**
+     * 计算当前向量到目标向量的夹角（弧度）
+     * - 结果范围为 [-PI, PI]
+     * - 使用 atan2(cross, dot)，保留方向（顺时针/逆时针）
+     */
+    angleTo(v) {
+        const dot = this.dot(v);
+        const det = this.cross(v);
+        return Math.atan2(det, dot);
+    }
+    /** 判断分量是否为有限数 */
+    isFinite() {
+        return Number.isFinite(this.x) && Number.isFinite(this.y);
+    }
+    /** 判断是否近似相等 */
+    equals(v, eps = Precision.EPS) {
+        return Precision.equal(this.x, v.x, eps) && Precision.equal(this.y, v.y, eps);
+    }
+    /** 转为元组 */
+    toArray() {
+        return [this.x, this.y];
+    }
+    /** 序列化为结构对象 */
+    dump() {
+        return { type: Vec2_1.type, x: this.x, y: this.y };
+    }
+    /** 从结构对象反序列化 */
+    static load(data) {
+        return new Vec2_1(data.x, data.y);
+    }
+};
+/** 序列化类型标识 */
+Vec2.type = EN_GEO_TYPE.Vec2;
+Vec2 = Vec2_1 = __decorate([
+    RegisterGeom
+], Vec2);
+export { Vec2 };

package/dist/curves/arc2.d.ts

@@ -0,0 +1,49 @@
+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 { IDBArc2 } from '../serialize/dump_types';
+import type { IClosestPointResult } from '../types/type_define';
+import { CircleCurve2 } from './circle_curve2';
+import { Interval } from './interval';
+export declare class Arc2 extends CircleCurve2 {
+    static readonly type = EN_GEO_TYPE.Arc2;
+    private _clockwise;
+    constructor(center: Vec2, radius: number, startAngle: number, endAngle: number, clockwise?: boolean);
+    get clockwise(): boolean;
+    get startAngle(): number;
+    get endAngle(): number;
+    pointAt(u: number): Vec2;
+    tangentAt(u: number): Vec2;
+    derivatives(u: number, n: number): Vec2[];
+    curvatureAt(u: number): number;
+    length(range?: Interval): number;
+    lengthAtParam(u: number): number;
+    paramAtLength(s: number, tol?: number): number;
+    split(u: number): Arc2[];
+    trim(range: Interval): Arc2[];
+    reverse(): this;
+    transform(m: Mat3): this;
+    transformed(m: Mat3): this;
+    closestPoint(p: Vec2): IClosestPointResult;
+    boundingBox(): Box2;
+    isValid(eps?: number): boolean;
+    isClosed(): boolean;
+    isArc(): this is Arc2;
+    /**
+     * 结构等价判断（字段级）。
+     * @param other 对比圆弧。
+     * @param eps 数值容差。
+     * @returns 圆心、半径、方向和起终角参数近似相等时返回 `true`。
+     */
+    equals(other: Arc2, eps?: number): boolean;
+    clone(): this;
+    dump(): IDBArc2;
+    static load(data: IDBArc2): Arc2;
+    private angleAtParam;
+    private paramFromAngle;
+    private resetAngles;
+    private normalizeAngle;
+    private positiveMod;
+}
+//# sourceMappingURL=arc2.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"arc2.d.ts","sourceRoot":"","sources":["../../src/curves/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,EAAE,IAAI,EAAE,MAAM,cAAc,CAAA;AACnC,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,yBAAyB,CAAA;AAEtD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAA;AAG/D,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAA;AAC9C,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAA;AAGrC,qBACa,IAAK,SAAQ,YAAY;IAClC,gBAAuB,IAAI,oBAAmB;IAE9C,OAAO,CAAC,UAAU,CAAS;gBAEf,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,SAAS,UAAQ;IAOjG,IAAW,SAAS,YAEnB;IAED,IAAW,UAAU,WAEpB;IAED,IAAW,QAAQ,WAMlB;IAEe,OAAO,CAAC,CAAC,EAAE,MAAM;IAIjB,SAAS,CAAC,CAAC,EAAE,MAAM;IAMnB,WAAW,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM;IAYhC,WAAW,CAAC,CAAC,EAAE,MAAM;IAKrB,MAAM,CAAC,KAAK,CAAC,EAAE,QAAQ;IAMvB,aAAa,CAAC,CAAC,EAAE,MAAM;IAKvB,aAAa,CAAC,CAAC,EAAE,MAAM,EAAE,GAAG,SAA6B;IAQzD,KAAK,CAAC,CAAC,EAAE,MAAM;IAUf,IAAI,CAAC,KAAK,EAAE,QAAQ;IAUpB,OAAO;IAOP,SAAS,CAAC,CAAC,EAAE,IAAI;IAiCjB,WAAW,CAAC,CAAC,EAAE,IAAI,GAAG,IAAI;IAI1B,YAAY,CAAC,CAAC,EAAE,IAAI,GAAG,mBAAmB;IAgD1C,WAAW;IAiBX,OAAO,CAAC,GAAG,SAA6B;IAIxC,QAAQ,IAAI,OAAO;IAInB,KAAK,IAAI,IAAI,IAAI,IAAI;IAIrC;;;;;OAKG;IACI,MAAM,CAAC,KAAK,EAAE,IAAI,EAAE,GAAG,SAAgB;IAQ9B,KAAK,IAAI,IAAI;IAIb,IAAI,IAAI,OAAO;WAWjB,IAAI,CAAC,IAAI,EAAE,OAAO;IAUhC,OAAO,CAAC,YAAY;IAOpB,OAAO,CAAC,cAAc;IAUtB,OAAO,CAAC,WAAW;IAiBnB,OAAO,CAAC,cAAc;IAKtB,OAAO,CAAC,WAAW;CAItB"}

package/dist/curves/arc2.js

@@ -0,0 +1,265 @@
+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 Arc2_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 { CircleCurve2 } from './circle_curve2';
+import { PeriodInterval } from './period_interval';
+let Arc2 = Arc2_1 = class Arc2 extends CircleCurve2 {
+    constructor(center, radius, startAngle, endAngle, clockwise = false) {
+        super(center, radius);
+        MathError.assert(Number.isFinite(startAngle) && Number.isFinite(endAngle), 'Arc2: 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);
+    }
+    pointAt(u) {
+        return this.pointAtAngle(this.angleAtParam(u));
+    }
+    tangentAt(u) {
+        const theta = this.angleAtParam(u);
+        const sign = this._clockwise ? -1 : 1;
+        return this.derivativeAtAngle(theta, 1, sign);
+    }
+    derivatives(u, n) {
+        MathError.assert(Number.isInteger(n) && n >= 0, 'Arc2.derivatives: n must be a non-negative integer');
+        const theta = this.angleAtParam(u);
+        const sign = this._clockwise ? -1 : 1;
+        const ret = [this.pointAtAngle(theta)];
+        for (let i = 1; i <= n; i++) {
+            ret.push(this.derivativeAtAngle(theta, i, sign));
+        }
+        return ret;
+    }
+    curvatureAt(u) {
+        this.angleAtParam(u);
+        return 1 / this._radius;
+    }
+    length(range) {
+        if (!range)
+            return this._range.length() * this._radius;
+        this._range.assertContainsRange(range, Precision.CURVE_PARAM_EPS);
+        return range.length() * this._radius;
+    }
+    lengthAtParam(u) {
+        const uu = this.normalizeParamForEval(u);
+        return (uu - this._range.start) * this._radius;
+    }
+    paramAtLength(s, tol = Precision.CURVE_LENGTH_EPS) {
+        const total = this.length();
+        MathError.assert(Number.isFinite(tol) && tol > 0, 'Arc2.paramAtLength: tol must be > 0');
+        MathError.assert(s >= -tol && s <= total + tol, `Arc2.paramAtLength: s out of range [0, ${total}]`);
+        const clamped = Math.min(total, Math.max(0, s));
+        return this._range.start + clamped / this._radius;
+    }
+    split(u) {
+        const pieces = this._range.split(u, Precision.CURVE_PARAM_EPS);
+        if (pieces.length === 0)
+            return [];
+        const theta = this.angleAtParam(u);
+        const left = new Arc2_1(this._center, this._radius, this.startAngle, theta, this._clockwise);
+        const right = new Arc2_1(this._center, this._radius, 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 s = this.angleAtParam(range.start);
+        const e = this.angleAtParam(range.end);
+        const arc = new Arc2_1(this._center, this._radius, s, e, 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) {
+        MathError.assert(m.isSimilarity2D(Precision.CURVE_PARAM_EPS), 'Arc2.transform: matrix must be a 2D similarity transform');
+        const oldSweep = this._range.length();
+        const oldClockwise = this._clockwise;
+        const startPoint = this.pointAt(this._range.start);
+        const endPoint = this.pointAt(this._range.end);
+        const nextCenter = m.transformedPoint(this._center);
+        const nextStartPoint = m.transformedPoint(startPoint);
+        const nextEndPoint = m.transformedPoint(endPoint);
+        const nextRadius = this._radius * m.getSimilarityScale2D(Precision.CURVE_PARAM_EPS);
+        MathError.assert(nextRadius > Precision.CURVE_LENGTH_EPS, 'Arc2.transform: degenerate radius after transform');
+        const det = m.determinant();
+        const mirrored = det < 0;
+        const nextClockwise = mirrored ? !oldClockwise : oldClockwise;
+        const startAngle = Math.atan2(nextStartPoint.y - nextCenter.y, nextStartPoint.x - nextCenter.x);
+        let endAngle = Math.atan2(nextEndPoint.y - nextCenter.y, nextEndPoint.x - nextCenter.x);
+        if (Math.abs(oldSweep - MathConst.PI2) <= Precision.CURVE_PARAM_EPS) {
+            endAngle = startAngle + (nextClockwise ? -MathConst.PI2 : MathConst.PI2);
+        }
+        this._center = nextCenter;
+        this._radius = nextRadius;
+        this.resetAngles(startAngle, endAngle, nextClockwise);
+        MathError.assert(this.length() > Precision.CURVE_LENGTH_EPS || Math.abs(oldSweep) <= Precision.CURVE_PARAM_EPS, 'Arc2.transform: invalid transformed arc');
+        return this;
+    }
+    transformed(m) {
+        return this.clone().transform(m);
+    }
+    closestPoint(p) {
+        const range = this._range;
+        const v = p.subtracted(this._center);
+        let candidateU = this._range.start;
+        if (v.len() > Precision.CURVE_NEWTON_EPS) {
+            const theta = Math.atan2(v.y, v.x);
+            candidateU = this.paramFromAngle(theta);
+        }
+        const candidates = [];
+        if (this.containsParam(candidateU)) {
+            candidates.push(candidateU);
+        }
+        candidates.push(this._range.start, this._range.end);
+        let bestU = candidates[0];
+        let bestP = this.pointAt(bestU);
+        let bestD = bestP.distanceTo(p);
+        for (let i = 1; i < candidates.length; i++) {
+            const u = candidates[i];
+            const q = this.pointAt(u);
+            const d = q.distanceTo(p);
+            if (d < bestD - Precision.CURVE_LENGTH_EPS) {
+                bestU = u;
+                bestP = q;
+                bestD = d;
+                continue;
+            }
+            if (Math.abs(d - bestD) <= Precision.CURVE_LENGTH_EPS) {
+                const uu = range.normalizeInPeriod(u, range.start);
+                const bb = range.normalizeInPeriod(bestU, range.start);
+                if (uu < bb) {
+                    bestU = u;
+                    bestP = q;
+                    bestD = d;
+                }
+            }
+        }
+        return {
+            point: bestP,
+            param: bestU,
+            distance: bestD,
+        };
+    }
+    boundingBox() {
+        const points = [
+            this.pointAt(this._range.start),
+            this.pointAt(this._range.end),
+        ];
+        const axes = [0, Math.PI * 0.5, Math.PI, Math.PI * 1.5];
+        for (const theta of axes) {
+            const u = this.paramFromAngle(theta);
+            if (this.containsParam(u)) {
+                points.push(this.pointAt(u));
+            }
+        }
+        return Box2.fromPoints(points);
+    }
+    isValid(eps = Precision.CURVE_LENGTH_EPS) {
+        return this.isCircleStructValid(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);
+    }
+    isArc() {
+        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._radius, other._radius, eps) &&
+            Precision.equal(this.startAngle, other.startAngle, eps) &&
+            Precision.equal(this.endAngle, other.endAngle, eps);
+    }
+    clone() {
+        return new Arc2_1(this._center, this._radius, this.startAngle, this.endAngle, this._clockwise);
+    }
+    dump() {
+        return {
+            type: Arc2_1.type,
+            center: { x: this._center.x, y: this._center.y },
+            radius: this._radius,
+            startAngle: this.startAngle,
+            endAngle: this.endAngle,
+            clockwise: this._clockwise,
+        };
+    }
+    static load(data) {
+        return new Arc2_1(new Vec2(data.center.x, data.center.y), data.radius, data.startAngle, data.endAngle, data.clockwise);
+    }
+    angleAtParam(u) {
+        const uu = this.normalizeParamForEval(u);
+        // 内部参数域总是递增；顺时针时通过镜像映射回几何角度。
+        if (!this._clockwise)
+            return uu;
+        return this._range.start - (uu - this._range.start);
+    }
+    paramFromAngle(theta) {
+        const range = this._range;
+        if (!this._clockwise) {
+            return range.normalizeInPeriod(theta, range.start);
+        }
+        // 反向参数化：关于 start 角做镜像。
+        const reflected = 2 * range.start - theta;
+        return range.normalizeInPeriod(reflected, range.start);
+    }
+    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;
+    }
+};
+Arc2.type = EN_GEO_TYPE.Arc2;
+Arc2 = Arc2_1 = __decorate([
+    RegisterGeom
+], Arc2);
+export { Arc2 };