@ccpc/math 0.1.0 → 0.1.7

package/dist/discretize/discretize_engine.d.ts

@@ -1,33 +0,0 @@
-import type { Vec2 } from '../core/vec2';
-import type { Curve2 } from '../curves/curve2';
-import { DiscretizeOptions } from './discretize_options';
-export declare class DiscretizeEngine {
-    private constructor();
-    private static readonly CHORD_CHECK_FRACTIONS;
-    private static readonly HARD_MAX_SEGMENTS;
-    private static readonly HARD_MAX_REFINEMENT_STEPS;
-    static discretize(curve: Curve2, options?: DiscretizeOptions): Vec2[];
-    private static dispatch;
-    private static postprocessResult;
-    private static discretizeLineCurve;
-    private static discretizeCircleLikeCurve;
-    private static discretizeEllipseLikeCurve;
-    private static discretizeBSplineCurve;
-    private static dThetaByChord;
-    private static buildCircleLikeSamples;
-    private static buildInitialEllipseSegments;
-    private static buildInitialBSplineSegments;
-    private static refineAdaptiveSegments;
-    private static registerSegment;
-    private static popValidHeapItem;
-    private static pushMaxHeap;
-    private static popMaxHeap;
-    private static evaluateAdaptiveSegment;
-    private static isTurnCriterionRelevant;
-    private static segmentsToSamples;
-    private static maxChordDeviationAtFractions;
-    private static distancePointToSegment;
-    private static tangentTurnAbs;
-    private static deduplicateAdjacent;
-}
-//# sourceMappingURL=discretize_engine.d.ts.map

package/dist/discretize/discretize_engine.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"discretize_engine.d.ts","sourceRoot":"","sources":["../../src/discretize/discretize_engine.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,cAAc,CAAA;AAIxC,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAA;AAI9C,OAAO,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAA;AAyBxD,qBAAa,gBAAgB;IACzB,OAAO;IAEP,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,qBAAqB,CAA6B;IAC1E,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,iBAAiB,CAAY;IACrD,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,yBAAyB,CAAY;WAE/C,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,iBAAiB,GAAG,IAAI,EAAE;IAQ5E,OAAO,CAAC,MAAM,CAAC,QAAQ;IAkBvB,OAAO,CAAC,MAAM,CAAC,iBAAiB;IAoChC,OAAO,CAAC,MAAM,CAAC,mBAAmB;IASlC,OAAO,CAAC,MAAM,CAAC,yBAAyB;IA2BxC,OAAO,CAAC,MAAM,CAAC,0BAA0B;IAazC,OAAO,CAAC,MAAM,CAAC,sBAAsB;IAarC,OAAO,CAAC,MAAM,CAAC,aAAa;IAO5B,OAAO,CAAC,MAAM,CAAC,sBAAsB;IAerC,OAAO,CAAC,MAAM,CAAC,2BAA2B;IAmB1C,OAAO,CAAC,MAAM,CAAC,2BAA2B;IAwB1C,OAAO,CAAC,MAAM,CAAC,sBAAsB;IAoDrC,OAAO,CAAC,MAAM,CAAC,eAAe;IAiB9B,OAAO,CAAC,MAAM,CAAC,gBAAgB;IAS/B,OAAO,CAAC,MAAM,CAAC,WAAW;IAa1B,OAAO,CAAC,MAAM,CAAC,UAAU;IAuBzB,OAAO,CAAC,MAAM,CAAC,uBAAuB;IAgCtC,OAAO,CAAC,MAAM,CAAC,uBAAuB;IAKtC,OAAO,CAAC,MAAM,CAAC,iBAAiB;IAQhC,OAAO,CAAC,MAAM,CAAC,4BAA4B;IAoB3C,OAAO,CAAC,MAAM,CAAC,sBAAsB;IAarC,OAAO,CAAC,MAAM,CAAC,cAAc;IAS7B,OAAO,CAAC,MAAM,CAAC,mBAAmB;CAYrC"}

package/dist/discretize/discretize_engine.js

@@ -1,347 +0,0 @@
-import { MathError } from '../utils/math_error';
-import { MathUtils } from '../utils/math_utils';
-import { Precision } from '../utils/precision';
-import { DiscretizeOptions } from './discretize_options';
-export class DiscretizeEngine {
-    constructor() { }
-    static discretize(curve, options) {
-        const resolved = options ?? DiscretizeOptions.medium;
-        MathError.assert(curve.isValid(), '离散参数错误: 曲线无效');
-        const raw = this.dispatch(curve, resolved);
-        const samples = this.postprocessResult(curve, raw, resolved);
-        return samples.map((sample) => sample.p.clone());
-    }
-    static dispatch(curve, options) {
-        if (curve.isLine())
-            return this.discretizeLineCurve(curve);
-        if (curve.isCircle() || curve.isArc()) {
-            return this.discretizeCircleLikeCurve(curve, options);
-        }
-        if (curve.isEllipse() || curve.isEllipseArc()) {
-            return this.discretizeEllipseLikeCurve(curve, options);
-        }
-        if (curve.isBSpline()) {
-            return this.discretizeBSplineCurve(curve, options);
-        }
-        MathError.assert(false, `离散不支持: ${curve.getType()}`);
-    }
-    static postprocessResult(curve, raw, options) {
-        const range = curve.getRange();
-        const startParam = range.start;
-        const endParam = range.end;
-        const startPoint = curve.pointAt(startParam);
-        const endPoint = curve.pointAt(endParam);
-        let samples = raw.map((sample) => ({ u: sample.u, p: sample.p }));
-        if (samples.length === 0) {
-            samples = [{ u: startParam, p: startPoint }];
-        }
-        samples = this.deduplicateAdjacent(samples, options.chordTol);
-        samples[0] = { u: startParam, p: startPoint };
-        if (curve.isClosed()) {
-            while (samples.length > 1) {
-                const first = samples[0];
-                const last = samples[samples.length - 1];
-                if (first.p.distanceTo(last.p) <= options.chordTol) {
-                    samples.pop();
-                    continue;
-                }
-                break;
-            }
-        }
-        else {
-            const endSample = {
-                u: endParam,
-                p: endPoint,
-            };
-            samples[samples.length - 1] = endSample;
-        }
-        return samples;
-    }
-    static discretizeLineCurve(curve) {
-        const range = curve.getRange();
-        if (curve.isDegenerate())
-            return [{ u: range.start, p: curve.pointAt(range.start) }];
-        return [
-            { u: range.start, p: curve.pointAt(range.start) },
-            { u: range.end, p: curve.pointAt(range.end) },
-        ];
-    }
-    static discretizeCircleLikeCurve(curve, options) {
-        const range = curve.getRange();
-        const sweep = range.length();
-        if (curve.isDegenerate())
-            return [{ u: range.start, p: curve.pointAt(range.start) }];
-        const totalLen = curve.length();
-        const radius = curve.radius;
-        MathError.assert(Number.isFinite(radius) && radius > 0, `离散不支持: ${curve.getType()} 半径无效`);
-        const maxByInternal = Math.max(1, Math.floor(totalLen / Precision.CURVE_LENGTH_EPS));
-        const maxByMinLength = Math.max(1, Math.ceil(totalLen / options.minSegmentLength));
-        const dThetaChord = this.dThetaByChord(radius, options.chordTol);
-        const dTheta = Math.max(Precision.CURVE_PARAM_EPS, Math.min(dThetaChord, options.angleTolRad));
-        const byTolerance = Math.max(1, Math.ceil(sweep / dTheta));
-        const requiredSegments = Math.min(byTolerance, maxByInternal, maxByMinLength, this.HARD_MAX_SEGMENTS);
-        const closed = curve.isClosed();
-        return this.buildCircleLikeSamples(curve, requiredSegments, closed);
-    }
-    static discretizeEllipseLikeCurve(curve, options) {
-        const range = curve.getRange();
-        if (curve.isDegenerate())
-            return [{ u: range.start, p: curve.pointAt(range.start) }];
-        const initialSegmentCount = 1;
-        const segments = this.refineAdaptiveSegments(curve, this.buildInitialEllipseSegments(curve, initialSegmentCount), options);
-        return this.segmentsToSamples(segments);
-    }
-    static discretizeBSplineCurve(curve, options) {
-        const range = curve.getRange();
-        if (curve.isDegenerate())
-            return [{ u: range.start, p: curve.pointAt(range.start) }];
-        const initialSegments = this.buildInitialBSplineSegments(curve);
-        if (initialSegments.length === 0) {
-            return [{ u: range.start, p: curve.pointAt(range.start) }];
-        }
-        const refined = this.refineAdaptiveSegments(curve, initialSegments, options);
-        return this.segmentsToSamples(refined);
-    }
-    static dThetaByChord(radius, chordTol) {
-        const ratio = 1 - chordTol / radius;
-        if (ratio <= -1)
-            return Math.PI * 2;
-        const clamped = Math.min(1, Math.max(-1, ratio));
-        return 2 * Math.acos(clamped);
-    }
-    static buildCircleLikeSamples(curve, segmentCount, closed) {
-        const range = curve.getRange();
-        const start = range.start;
-        const span = range.length();
-        const steps = closed ? segmentCount : segmentCount + 1;
-        const samples = [];
-        for (let i = 0; i < steps; i++) {
-            const t = i / segmentCount;
-            const u = start + span * t;
-            samples.push({ u, p: curve.pointAt(u) });
-        }
-        return samples;
-    }
-    static buildInitialEllipseSegments(curve, segmentCount) {
-        const range = curve.getRange();
-        const start = range.start;
-        const span = range.length();
-        const segments = [];
-        for (let i = 0; i < segmentCount; i++) {
-            const u0 = start + (span * i) / segmentCount;
-            const u1 = start + (span * (i + 1)) / segmentCount;
-            segments.push({
-                u0,
-                u1,
-                p0: curve.pointAt(u0),
-                p1: curve.pointAt(u1),
-            });
-        }
-        return segments;
-    }
-    static buildInitialBSplineSegments(curve) {
-        const range = curve.getRange();
-        const boundaries = new Set([
-            range.start,
-            range.end,
-            ...curve.getContinuityBreakParams(Precision.CURVE_PARAM_EPS),
-        ]);
-        const sorted = [...boundaries].sort((a, b) => a - b);
-        const segments = [];
-        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;
-            segments.push({
-                u0,
-                u1,
-                p0: curve.pointAt(u0),
-                p1: curve.pointAt(u1),
-            });
-        }
-        return segments;
-    }
-    static refineAdaptiveSegments(curve, initialSegments, options) {
-        const states = new Map();
-        const heap = [];
-        let nextId = 1;
-        for (const segment of initialSegments) {
-            nextId = this.registerSegment(states, heap, nextId, curve, segment, options);
-        }
-        for (;;) {
-            if (states.size >= this.HARD_MAX_SEGMENTS || nextId >= this.HARD_MAX_REFINEMENT_STEPS) {
-                break;
-            }
-            const picked = this.popValidHeapItem(heap, states);
-            if (!picked)
-                break;
-            const segment = states.get(picked.id);
-            if (!segment)
-                continue;
-            const decision = this.evaluateAdaptiveSegment(curve, segment, options);
-            if (!decision.split)
-                continue;
-            MathError.assert(!decision.blocked, '离散溢出: 无法继续细分');
-            const mid = (segment.u0 + segment.u1) * 0.5;
-            MathError.assert(Math.abs(mid - segment.u0) > Precision.CURVE_PARAM_EPS
-                && Math.abs(segment.u1 - mid) > Precision.CURVE_PARAM_EPS, '离散不收敛');
-            const pm = curve.pointAt(mid);
-            const left = {
-                u0: segment.u0,
-                u1: mid,
-                p0: segment.p0,
-                p1: pm,
-            };
-            const right = {
-                u0: mid,
-                u1: segment.u1,
-                p0: pm,
-                p1: segment.p1,
-            };
-            states.delete(picked.id);
-            nextId = this.registerSegment(states, heap, nextId, curve, left, options);
-            nextId = this.registerSegment(states, heap, nextId, curve, right, options);
-        }
-        return [...states.values()]
-            .sort((a, b) => a.u0 - b.u0 || a.u1 - b.u1);
-    }
-    static registerSegment(states, heap, nextId, curve, segment, options) {
-        const id = nextId;
-        states.set(id, segment);
-        const decision = this.evaluateAdaptiveSegment(curve, segment, options);
-        if (decision.split) {
-            this.pushMaxHeap(heap, { id, score: decision.score });
-        }
-        return nextId + 1;
-    }
-    static popValidHeapItem(heap, states) {
-        for (;;) {
-            const candidate = this.popMaxHeap(heap);
-            if (!candidate)
-                return undefined;
-            if (!states.has(candidate.id))
-                continue;
-            return candidate;
-        }
-    }
-    static pushMaxHeap(heap, item) {
-        heap.push(item);
-        let i = heap.length - 1;
-        while (i > 0) {
-            const p = (i - 1) >> 1;
-            if (heap[p].score >= heap[i].score)
-                break;
-            const tmp = heap[p];
-            heap[p] = heap[i];
-            heap[i] = tmp;
-            i = p;
-        }
-    }
-    static popMaxHeap(heap) {
-        if (heap.length === 0)
-            return undefined;
-        const top = heap[0];
-        const tail = heap.pop();
-        if (tail && heap.length > 0) {
-            heap[0] = tail;
-            let i = 0;
-            for (;;) {
-                const l = i * 2 + 1;
-                const r = l + 1;
-                let m = i;
-                if (l < heap.length && heap[l].score > heap[m].score)
-                    m = l;
-                if (r < heap.length && heap[r].score > heap[m].score)
-                    m = r;
-                if (m === i)
-                    break;
-                const tmp = heap[m];
-                heap[m] = heap[i];
-                heap[i] = tmp;
-                i = m;
-            }
-        }
-        return top;
-    }
-    static evaluateAdaptiveSegment(curve, segment, options) {
-        const chordLenSq = segment.p0.distanceToSq(segment.p1);
-        const midParam = MathUtils.lerp(segment.u0, segment.u1, 0.5);
-        const midPoint = curve.pointAt(midParam);
-        const approxLength = segment.p0.distanceTo(midPoint) + midPoint.distanceTo(segment.p1);
-        if (approxLength <= options.minSegmentLength) {
-            return { split: false, blocked: false, score: 0 };
-        }
-        const useTurn = this.isTurnCriterionRelevant(chordLenSq, options);
-        const deviation = this.maxChordDeviationAtFractions(curve, segment.u0, segment.u1, segment.p0, segment.p1);
-        const turn = useTurn ? this.tangentTurnAbs(curve, segment.u0, segment.u1) : 0;
-        const splitByDeviation = deviation > options.chordTol;
-        const splitByTurn = useTurn && turn > options.angleTolRad;
-        const split = splitByDeviation || splitByTurn;
-        const blocked = split && Math.abs(segment.u1 - segment.u0) <= Precision.CURVE_PARAM_EPS;
-        const chordTolSafe = Math.max(options.chordTol, Precision.CURVE_LENGTH_EPS);
-        const angleTolSafe = Math.max(options.angleTolRad, Precision.ANG_EPS);
-        const scoreDeviation = deviation / chordTolSafe;
-        const scoreTurn = useTurn ? (turn / angleTolSafe) : 0;
-        const score = Math.max(scoreDeviation, scoreTurn);
-        return { split, blocked, score };
-    }
-    static isTurnCriterionRelevant(chordLenSq, options) {
-        const minChordForTurn = Math.max(options.chordTol * 2, Precision.CURVE_LENGTH_EPS * 10);
-        return chordLenSq > minChordForTurn * minChordForTurn;
-    }
-    static segmentsToSamples(segments) {
-        const samples = [{ u: segments[0].u0, p: segments[0].p0 }];
-        for (const segment of segments) {
-            samples.push({ u: segment.u1, p: segment.p1 });
-        }
-        return samples;
-    }
-    static maxChordDeviationAtFractions(curve, u0, u1, p0, p1, fractions = this.CHORD_CHECK_FRACTIONS) {
-        let maxDeviation = 0;
-        for (const fraction of fractions) {
-            const um = MathUtils.lerp(u0, u1, fraction);
-            const pm = curve.pointAt(um);
-            const deviation = this.distancePointToSegment(pm, p0, p1);
-            if (deviation > maxDeviation) {
-                maxDeviation = deviation;
-            }
-        }
-        return maxDeviation;
-    }
-    static distancePointToSegment(point, segStart, segEnd) {
-        const edge = segEnd.subtracted(segStart);
-        const lenSq = edge.lenSq();
-        if (lenSq <= Precision.CURVE_LENGTH_EPS_SQ) {
-            return point.distanceTo(segStart);
-        }
-        const rel = point.subtracted(segStart);
-        const t = Math.max(0, Math.min(1, rel.dot(edge) / lenSq));
-        const proj = segStart.added(edge.scaled(t));
-        return point.distanceTo(proj);
-    }
-    static tangentTurnAbs(curve, u0, u1) {
-        const t0 = curve.tangentAt(u0);
-        const t1 = curve.tangentAt(u1);
-        if (Math.min(t0.lenSq(), t1.lenSq()) <= Precision.CURVE_NEWTON_EPS) {
-            return 0;
-        }
-        return Math.abs(t0.angleTo(t1));
-    }
-    static deduplicateAdjacent(samples, tol) {
-        if (samples.length <= 1)
-            return samples;
-        const deduped = [samples[0]];
-        for (let i = 1; i < samples.length; i++) {
-            const prev = deduped[deduped.length - 1];
-            const cur = samples[i];
-            if (prev.p.distanceTo(cur.p) <= tol)
-                continue;
-            deduped.push(cur);
-        }
-        return deduped;
-    }
-}
-DiscretizeEngine.CHORD_CHECK_FRACTIONS = [0.25, 0.5, 0.75];
-DiscretizeEngine.HARD_MAX_SEGMENTS = 1000000;
-DiscretizeEngine.HARD_MAX_REFINEMENT_STEPS = 2000000;

package/dist/discretize/discretize_errors.d.ts

@@ -1,15 +0,0 @@
-export declare const DISCRETIZE_ERROR_PREFIX: Readonly<{
-    options: "DiscretizeOptionsError";
-    notSupported: "DiscretizeNotSupported";
-    overflow: "DiscretizeOverflowError";
-    convergence: "DiscretizeConvergenceError";
-}>;
-type DiscretizeErrorPrefix = typeof DISCRETIZE_ERROR_PREFIX[keyof typeof DISCRETIZE_ERROR_PREFIX];
-export declare function throwDiscretizeError(prefix: DiscretizeErrorPrefix, message: string): never;
-export declare function assertDiscretize(condition: unknown, prefix: DiscretizeErrorPrefix, message: string): asserts condition;
-export declare function throwDiscretizeOptionsError(message: string): never;
-export declare function throwDiscretizeNotSupportedError(message: string): never;
-export declare function throwDiscretizeOverflowError(message: string): never;
-export declare function throwDiscretizeConvergenceError(message: string): never;
-export {};
-//# sourceMappingURL=discretize_errors.d.ts.map

package/dist/discretize/discretize_errors.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"discretize_errors.d.ts","sourceRoot":"","sources":["../../src/discretize/discretize_errors.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,uBAAuB;;;;;EAKlC,CAAA;AAEF,KAAK,qBAAqB,GAAG,OAAO,uBAAuB,CAAC,MAAM,OAAO,uBAAuB,CAAC,CAAA;AAMjG,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,qBAAqB,EAAE,OAAO,EAAE,MAAM,GAAG,KAAK,CAE1F;AAED,wBAAgB,gBAAgB,CAC5B,SAAS,EAAE,OAAO,EAClB,MAAM,EAAE,qBAAqB,EAC7B,OAAO,EAAE,MAAM,GAChB,OAAO,CAAC,SAAS,CAInB;AAED,wBAAgB,2BAA2B,CAAC,OAAO,EAAE,MAAM,GAAG,KAAK,CAElE;AAED,wBAAgB,gCAAgC,CAAC,OAAO,EAAE,MAAM,GAAG,KAAK,CAEvE;AAED,wBAAgB,4BAA4B,CAAC,OAAO,EAAE,MAAM,GAAG,KAAK,CAEnE;AAED,wBAAgB,+BAA+B,CAAC,OAAO,EAAE,MAAM,GAAG,KAAK,CAEtE"}

package/dist/discretize/discretize_errors.js

@@ -1,30 +0,0 @@
-import { MathError } from '../utils/math_error';
-export const DISCRETIZE_ERROR_PREFIX = Object.freeze({
-    options: 'DiscretizeOptionsError',
-    notSupported: 'DiscretizeNotSupported',
-    overflow: 'DiscretizeOverflowError',
-    convergence: 'DiscretizeConvergenceError',
-});
-function makeMessage(prefix, message) {
-    return `${prefix}: ${message}`;
-}
-export function throwDiscretizeError(prefix, message) {
-    MathError.throw(makeMessage(prefix, message));
-}
-export function assertDiscretize(condition, prefix, message) {
-    if (!condition) {
-        throwDiscretizeError(prefix, message);
-    }
-}
-export function throwDiscretizeOptionsError(message) {
-    return throwDiscretizeError(DISCRETIZE_ERROR_PREFIX.options, message);
-}
-export function throwDiscretizeNotSupportedError(message) {
-    return throwDiscretizeError(DISCRETIZE_ERROR_PREFIX.notSupported, message);
-}
-export function throwDiscretizeOverflowError(message) {
-    return throwDiscretizeError(DISCRETIZE_ERROR_PREFIX.overflow, message);
-}
-export function throwDiscretizeConvergenceError(message) {
-    return throwDiscretizeError(DISCRETIZE_ERROR_PREFIX.convergence, message);
-}

package/dist/discretize/discretize_options.d.ts

@@ -1,18 +0,0 @@
-/**
- * 曲线离散参数类。
- */
-export declare class DiscretizeOptions {
-    static readonly low: DiscretizeOptions;
-    static readonly medium: DiscretizeOptions;
-    static readonly high: DiscretizeOptions;
-    static readonly ultra: DiscretizeOptions;
-    /** 弦高容差（世界坐标长度单位）。 */
-    chordTol: number;
-    /** 相邻采样切向转角容差（弧度）。 */
-    angleTolRad: number;
-    /** 允许继续细分的最小线段长度。 */
-    minSegmentLength: number;
-    constructor(chordTol?: number, angleTolRad?: number, minSegmentLength?: number);
-    clone(): DiscretizeOptions;
-}
-//# sourceMappingURL=discretize_options.d.ts.map

package/dist/discretize/discretize_options.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"discretize_options.d.ts","sourceRoot":"","sources":["../../src/discretize/discretize_options.ts"],"names":[],"mappings":"AAEA;;GAEG;AACH,qBAAa,iBAAiB;IAC1B,gBAAuB,GAAG,oBAAkD;IAE5E,gBAAuB,MAAM,oBAAkD;IAE/E,gBAAuB,IAAI,oBAAmD;IAE9E,gBAAuB,KAAK,oBAAmD;IAE/E,sBAAsB;IACf,QAAQ,EAAE,MAAM,CAAA;IAEvB,sBAAsB;IACf,WAAW,EAAE,MAAM,CAAA;IAE1B,qBAAqB;IACd,gBAAgB,EAAE,MAAM,CAAA;gBAG3B,QAAQ,SAAO,EACf,WAAW,SAAgB,EAC3B,gBAAgB,SAAO;IAWpB,KAAK,IAAI,iBAAiB;CAIpC"}

package/dist/discretize/discretize_options.js

@@ -1,19 +0,0 @@
-import { MathError } from '../utils/math_error';
-/**
- * 曲线离散参数类。
- */
-export class DiscretizeOptions {
-    constructor(chordTol = 1e-3, angleTolRad = Math.PI / 180, minSegmentLength = 1e-6) {
-        MathError.assert(Number.isFinite(minSegmentLength) && minSegmentLength > 0, 'DiscretizeOptionsError: minSegmentLength 必须是大于 0 的有限数');
-        this.chordTol = chordTol;
-        this.angleTolRad = angleTolRad;
-        this.minSegmentLength = minSegmentLength;
-    }
-    clone() {
-        return new DiscretizeOptions(this.chordTol, this.angleTolRad, this.minSegmentLength);
-    }
-}
-DiscretizeOptions.low = new DiscretizeOptions(5e-2, Math.PI / 18, 5e-3);
-DiscretizeOptions.medium = new DiscretizeOptions(5e-3, Math.PI / 90, 5e-4);
-DiscretizeOptions.high = new DiscretizeOptions(1e-4, Math.PI / 360, 1e-5);
-DiscretizeOptions.ultra = new DiscretizeOptions(1e-5, Math.PI / 720, 1e-6);

package/dist/discretize/discretize_types.d.ts

@@ -1,36 +0,0 @@
-import type { Vec2 } from '../core/vec2';
-export interface DiscretizeOptions {
-    mode?: 'world' | 'view';
-    chordTol?: number;
-    angleTolRad?: number;
-    maxSegmentLength?: number;
-    minSegments?: number;
-    maxSegments?: number;
-    includeEnd?: boolean;
-    pointMergeTol?: number;
-    pixelTol?: number;
-    worldPerPixel?: number;
-}
-export interface ResolvedDiscretizeOptions {
-    mode: 'world';
-    chordTol: number;
-    angleTolRad: number;
-    maxSegmentLength: number;
-    minSegments: number;
-    maxSegments: number;
-    minSegmentsExplicit: boolean;
-    includeEnd: boolean;
-    pointMergeTol: number;
-    effectiveChordTol: number;
-    effectivePointMergeTol: number;
-    minSegmentLengthInternal: number;
-}
-export interface PolylineSample {
-    u: number;
-    p: Vec2;
-}
-export interface DiscretizeResult {
-    samples: PolylineSample[];
-    closed: boolean;
-}
-//# sourceMappingURL=discretize_types.d.ts.map

package/dist/discretize/discretize_types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"discretize_types.d.ts","sourceRoot":"","sources":["../../src/discretize/discretize_types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,cAAc,CAAA;AAExC,MAAM,WAAW,iBAAiB;IAC9B,IAAI,CAAC,EAAE,OAAO,GAAG,MAAM,CAAA;IAEvB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,gBAAgB,CAAC,EAAE,MAAM,CAAA;IAEzB,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,WAAW,CAAC,EAAE,MAAM,CAAA;IAEpB,UAAU,CAAC,EAAE,OAAO,CAAA;IACpB,aAAa,CAAC,EAAE,MAAM,CAAA;IAEtB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,aAAa,CAAC,EAAE,MAAM,CAAA;CACzB;AAED,MAAM,WAAW,yBAAyB;IACtC,IAAI,EAAE,OAAO,CAAA;IAEb,QAAQ,EAAE,MAAM,CAAA;IAChB,WAAW,EAAE,MAAM,CAAA;IACnB,gBAAgB,EAAE,MAAM,CAAA;IAExB,WAAW,EAAE,MAAM,CAAA;IACnB,WAAW,EAAE,MAAM,CAAA;IACnB,mBAAmB,EAAE,OAAO,CAAA;IAE5B,UAAU,EAAE,OAAO,CAAA;IACnB,aAAa,EAAE,MAAM,CAAA;IAErB,iBAAiB,EAAE,MAAM,CAAA;IACzB,sBAAsB,EAAE,MAAM,CAAA;IAC9B,wBAAwB,EAAE,MAAM,CAAA;CACnC;AAED,MAAM,WAAW,cAAc;IAC3B,CAAC,EAAE,MAAM,CAAA;IACT,CAAC,EAAE,IAAI,CAAA;CACV;AAED,MAAM,WAAW,gBAAgB;IAC7B,OAAO,EAAE,cAAc,EAAE,CAAA;IACzB,MAAM,EAAE,OAAO,CAAA;CAClB"}

package/dist/discretize/discretize_types.js

@@ -1 +0,0 @@
-export {};

package/dist/discretize/internal/curve_guards.d.ts

@@ -1,35 +0,0 @@
-import { Vec2 } from '../../core/vec2';
-import type { Curve2 } from '../../curves/curve2';
-export type LineCurveLike = Curve2 & {
-    start: Vec2;
-    end: Vec2;
-};
-export type CircleCurveLike = Curve2 & {
-    center: Vec2;
-    radius: number;
-};
-export type ArcCurveLike = CircleCurveLike & {
-    clockwise: boolean;
-};
-export type EllipseCurveLike = Curve2 & {
-    center: Vec2;
-    rx: number;
-    ry: number;
-    rotation: number;
-};
-export type EllipseArcCurveLike = EllipseCurveLike & {
-    clockwise: boolean;
-};
-export type BSplineCurveLike = Curve2 & {
-    degree: number;
-    expandedKnots: number[];
-    controlPoints: Vec2[];
-};
-export declare function isLineCurveLike(curve: Curve2): curve is LineCurveLike;
-export declare function isCircleCurveLike(curve: Curve2): curve is CircleCurveLike;
-export declare function isArcCurveLike(curve: Curve2): curve is ArcCurveLike;
-export declare function isEllipseCurveLike(curve: Curve2): curve is EllipseCurveLike;
-export declare function isEllipseArcCurveLike(curve: Curve2): curve is EllipseArcCurveLike;
-export declare function isBSplineCurveLike(curve: Curve2): curve is BSplineCurveLike;
-export declare function isCurveSemanticallyClosed(curve: Curve2): boolean;
-//# sourceMappingURL=curve_guards.d.ts.map

package/dist/discretize/internal/curve_guards.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"curve_guards.d.ts","sourceRoot":"","sources":["../../../src/discretize/internal/curve_guards.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAA;AAEtC,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAA;AAEjD,MAAM,MAAM,aAAa,GAAG,MAAM,GAAG;IAAE,KAAK,EAAE,IAAI,CAAC;IAAC,GAAG,EAAE,IAAI,CAAA;CAAE,CAAA;AAC/D,MAAM,MAAM,eAAe,GAAG,MAAM,GAAG;IAAE,MAAM,EAAE,IAAI,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAA;AACvE,MAAM,MAAM,YAAY,GAAG,eAAe,GAAG;IAAE,SAAS,EAAE,OAAO,CAAA;CAAE,CAAA;AACnE,MAAM,MAAM,gBAAgB,GAAG,MAAM,GAAG;IAAE,MAAM,EAAE,IAAI,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAA;AAClG,MAAM,MAAM,mBAAmB,GAAG,gBAAgB,GAAG;IAAE,SAAS,EAAE,OAAO,CAAA;CAAE,CAAA;AAC3E,MAAM,MAAM,gBAAgB,GAAG,MAAM,GAAG;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,aAAa,EAAE,MAAM,EAAE,CAAC;IAAC,aAAa,EAAE,IAAI,EAAE,CAAA;CAAE,CAAA;AAc1G,wBAAgB,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK,IAAI,aAAa,CAGrE;AAED,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK,IAAI,eAAe,CAKzE;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK,IAAI,YAAY,CAGnE;AAED,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK,IAAI,gBAAgB,CAM3E;AAED,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK,IAAI,mBAAmB,CAOjF;AAED,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK,IAAI,gBAAgB,CAM3E;AAED,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,MAAM,WAOtD"}

package/dist/discretize/internal/curve_guards.js

@@ -1,62 +0,0 @@
-import { Vec2 } from '../../core/vec2';
-import { Precision } from '../../utils/precision';
-function isVec2(value) {
-    return value instanceof Vec2;
-}
-function isFiniteNumber(value) {
-    return typeof value === 'number' && Number.isFinite(value);
-}
-function hasBoolean(value) {
-    return typeof value === 'boolean';
-}
-export function isLineCurveLike(curve) {
-    const c = curve;
-    return isVec2(c.start) && isVec2(c.end);
-}
-export function isCircleCurveLike(curve) {
-    const c = curve;
-    if (!isVec2(c.center) || !isFiniteNumber(c.radius))
-        return false;
-    const maybeArc = curve;
-    return !hasBoolean(maybeArc.clockwise);
-}
-export function isArcCurveLike(curve) {
-    const c = curve;
-    return isVec2(c.center) && isFiniteNumber(c.radius) && hasBoolean(c.clockwise);
-}
-export function isEllipseCurveLike(curve) {
-    const c = curve;
-    if (!isVec2(c.center))
-        return false;
-    if (!isFiniteNumber(c.rx) || !isFiniteNumber(c.ry) || !isFiniteNumber(c.rotation))
-        return false;
-    const maybeArc = curve;
-    return !hasBoolean(maybeArc.clockwise);
-}
-export function isEllipseArcCurveLike(curve) {
-    const c = curve;
-    return isVec2(c.center) &&
-        isFiniteNumber(c.rx) &&
-        isFiniteNumber(c.ry) &&
-        isFiniteNumber(c.rotation) &&
-        hasBoolean(c.clockwise);
-}
-export function isBSplineCurveLike(curve) {
-    const c = curve;
-    if (!isFiniteNumber(c.degree))
-        return false;
-    if (!Array.isArray(c.expandedKnots) || !c.expandedKnots.every((k) => Number.isFinite(k)))
-        return false;
-    if (!Array.isArray(c.controlPoints) || !c.controlPoints.every((p) => p instanceof Vec2))
-        return false;
-    return true;
-}
-export function isCurveSemanticallyClosed(curve) {
-    if (isCircleCurveLike(curve) || isEllipseCurveLike(curve))
-        return true;
-    if (isArcCurveLike(curve) || isEllipseArcCurveLike(curve)) {
-        const sweep = curve.getRange().length();
-        return Math.abs(sweep - Math.PI * 2) <= Precision.CURVE_PARAM_EPS;
-    }
-    return false;
-}

package/dist/discretize/internal/postprocess.d.ts

@@ -1,5 +0,0 @@
-import type { Curve2 } from '../../curves/curve2';
-import type { DiscretizeResult, ResolvedDiscretizeOptions } from '../discretize_types';
-export declare function postprocessDiscretizeResult(curve: Curve2, raw: DiscretizeResult, options: ResolvedDiscretizeOptions): DiscretizeResult;
-export declare function assertDiscretizeResult(curve: Curve2, result: DiscretizeResult, options: ResolvedDiscretizeOptions): void;
-//# sourceMappingURL=postprocess.d.ts.map

package/dist/discretize/internal/postprocess.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"postprocess.d.ts","sourceRoot":"","sources":["../../../src/discretize/internal/postprocess.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAA;AAGjD,OAAO,KAAK,EAAE,gBAAgB,EAAkB,yBAAyB,EAAE,MAAM,qBAAqB,CAAA;AAkEtG,wBAAgB,2BAA2B,CACvC,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,gBAAgB,EACrB,OAAO,EAAE,yBAAyB,oBA+BrC;AAED,wBAAgB,sBAAsB,CAClC,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,gBAAgB,EACxB,OAAO,EAAE,yBAAyB,QA+BrC"}