@mlightcad/geometry-engine 1.0.7 → 2.0.1

package/lib/geometry/AcGeNurbsCurve.js

@@ -0,0 +1,166 @@
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+import { calculateCurveLength, evaluateNurbsPoint, generateChordKnots, generateSqrtChordKnots, generateUniformKnots } from '../util';
+import { AcGeCatmullRomCurve3d } from './AcGeCatmullRomCurve3d';
+/**
+ * A NURBS curve implementation that can be used by other curve classes
+ */
+var AcGeNurbsCurve = /** @class */ (function () {
+    function AcGeNurbsCurve(degree, knots, controlPoints, weights) {
+        this._degree = degree;
+        this._knots = __spreadArray([], __read(knots), false);
+        this._controlPoints = controlPoints.map(function (p) { return ({ x: p.x, y: p.y, z: p.z }); });
+        this._weights = weights
+            ? __spreadArray([], __read(weights), false) : new Array(controlPoints.length).fill(1.0);
+    }
+    /**
+     * Get the degree of the NURBS curve
+     */
+    AcGeNurbsCurve.prototype.degree = function () {
+        return this._degree;
+    };
+    /**
+     * Get the knot vector
+     */
+    AcGeNurbsCurve.prototype.knots = function () {
+        return __spreadArray([], __read(this._knots), false);
+    };
+    /**
+     * Get the control points
+     */
+    AcGeNurbsCurve.prototype.controlPoints = function () {
+        return this._controlPoints.map(function (p) { return ({ x: p.x, y: p.y, z: p.z }); });
+    };
+    /**
+     * Get the weights
+     */
+    AcGeNurbsCurve.prototype.weights = function () {
+        return __spreadArray([], __read(this._weights), false);
+    };
+    /**
+     * Calculate a point on the curve at parameter u
+     */
+    AcGeNurbsCurve.prototype.point = function (u) {
+        // Convert AcGePoint3dLike[] to number[][] for utility functions
+        var controlPointsArray = this._controlPoints.map(function (p) { return [p.x, p.y, p.z]; });
+        return evaluateNurbsPoint(u, this._degree, this._knots, controlPointsArray, this._weights);
+    };
+    /**
+     * Calculate curve length using numerical integration
+     */
+    AcGeNurbsCurve.prototype.length = function () {
+        // Convert AcGePoint3dLike[] to number[][] for utility functions
+        var controlPointsArray = this._controlPoints.map(function (p) { return [p.x, p.y, p.z]; });
+        return calculateCurveLength(this._degree, this._knots, controlPointsArray, this._weights);
+    };
+    /**
+     * Create a NURBS curve from control points and knots
+     */
+    AcGeNurbsCurve.byKnotsControlPointsWeights = function (degree, knots, controlPoints, weights) {
+        return new AcGeNurbsCurve(degree, knots, controlPoints, weights);
+    };
+    /**
+     * Create a NURBS curve from fit points using interpolation
+     */
+    AcGeNurbsCurve.byPoints = function (points, degree, parameterization) {
+        if (parameterization === void 0) { parameterization = 'Uniform'; }
+        // Generate knots based on parameterization type
+        var knots;
+        switch (parameterization) {
+            case 'Chord':
+                knots = generateChordKnots(degree, points);
+                break;
+            case 'SqrtChord':
+                knots = generateSqrtChordKnots(degree, points);
+                break;
+            case 'Uniform':
+            default:
+                knots = generateUniformKnots(degree, points.length);
+                break;
+        }
+        // Convert number[][] to AcGePoint3dLike[] for control points
+        var controlPoints = points.map(function (p) { return ({ x: p[0], y: p[1], z: p[2] }); });
+        var weights = new Array(controlPoints.length).fill(1.0);
+        return new AcGeNurbsCurve(degree, knots, controlPoints, weights);
+    };
+    /**
+     * Get the valid parameter range for this curve
+     */
+    AcGeNurbsCurve.prototype.getParameterRange = function () {
+        var startParam = this._knots[this._degree];
+        var endParam = this._knots[this._knots.length - this._degree - 1];
+        return { start: startParam, end: endParam };
+    };
+    /**
+     * Get points along the curve
+     * @param divisions - Number of divisions to create
+     * @returns Array of points along the curve
+     */
+    AcGeNurbsCurve.prototype.getPoints = function (divisions) {
+        var points = [];
+        var _a = this.getParameterRange(), start = _a.start, end = _a.end;
+        for (var i = 0; i <= divisions; i++) {
+            var t = start + (end - start) * (i / divisions);
+            points.push(this.point(t));
+        }
+        return points;
+    };
+    /**
+     * Check if the curve is closed by comparing start and end points
+     */
+    AcGeNurbsCurve.prototype.isClosed = function (tolerance) {
+        if (tolerance === void 0) { tolerance = 1e-6; }
+        var _a = this.getParameterRange(), start = _a.start, end = _a.end;
+        var startPoint = this.point(start);
+        var endPoint = this.point(end);
+        var dx = startPoint[0] - endPoint[0];
+        var dy = startPoint[1] - endPoint[1];
+        var dz = startPoint[2] - endPoint[2];
+        return Math.sqrt(dx * dx + dy * dy + dz * dz) < tolerance;
+    };
+    /**
+     * Create a closed NURBS curve using Catmull-Rom interpolation for smooth closure
+     */
+    AcGeNurbsCurve.createClosedCurve = function (points, degree, parameterization) {
+        if (parameterization === void 0) { parameterization = 'Chord'; }
+        if (points.length < 4) {
+            throw new Error('At least 4 points are required for a closed NURBS curve');
+        }
+        // Create a closed Catmull-Rom curve
+        var catmullRomCurve = new AcGeCatmullRomCurve3d(points, true, 'centripetal');
+        // Get points along the curve for NURBS interpolation
+        // Use more divisions for smoother curve
+        var divisions = Math.max(50, points.length * 2);
+        var curvePoints = catmullRomCurve.getPoints(divisions);
+        // Convert AcGePoint3d[] back to number[][]
+        var nurbsPoints = curvePoints.map(function (point) { return [point.x, point.y, point.z]; });
+        // Create NURBS curve from the interpolated points
+        return AcGeNurbsCurve.byPoints(nurbsPoints, degree, parameterization);
+    };
+    return AcGeNurbsCurve;
+}());
+export { AcGeNurbsCurve };
+//# sourceMappingURL=AcGeNurbsCurve.js.map

package/lib/geometry/AcGeNurbsCurve.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AcGeNurbsCurve.js","sourceRoot":"","sources":["../../src/geometry/AcGeNurbsCurve.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AACA,OAAO,EACL,oBAAoB,EACpB,kBAAkB,EAClB,kBAAkB,EAClB,sBAAsB,EACtB,oBAAoB,EACrB,MAAM,SAAS,CAAA;AAChB,OAAO,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAA;AAO/D;;GAEG;AACH;IAME,wBACE,MAAc,EACd,KAAe,EACf,aAAgC,EAChC,OAAkB;QAElB,IAAI,CAAC,OAAO,GAAG,MAAM,CAAA;QACrB,IAAI,CAAC,MAAM,4BAAO,KAAK,SAAC,CAAA;QACxB,IAAI,CAAC,cAAc,GAAG,aAAa,CAAC,GAAG,CAAC,UAAA,CAAC,IAAI,OAAA,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,EAA5B,CAA4B,CAAC,CAAA;QAC1E,IAAI,CAAC,QAAQ,GAAG,OAAO;YACrB,CAAC,0BAAK,OAAO,UACb,CAAC,CAAC,IAAI,KAAK,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAA;IAC/C,CAAC;IAED;;OAEG;IACH,+BAAM,GAAN;QACE,OAAO,IAAI,CAAC,OAAO,CAAA;IACrB,CAAC;IAED;;OAEG;IACH,8BAAK,GAAL;QACE,gCAAW,IAAI,CAAC,MAAM,UAAC;IACzB,CAAC;IAED;;OAEG;IACH,sCAAa,GAAb;QACE,OAAO,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,UAAA,CAAC,IAAI,OAAA,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,EAA5B,CAA4B,CAAC,CAAA;IACnE,CAAC;IAED;;OAEG;IACH,gCAAO,GAAP;QACE,gCAAW,IAAI,CAAC,QAAQ,UAAC;IAC3B,CAAC;IAED;;OAEG;IACH,8BAAK,GAAL,UAAM,CAAS;QACb,gEAAgE;QAChE,IAAM,kBAAkB,GAAG,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,UAAA,CAAC,IAAI,OAAA,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,EAAf,CAAe,CAAC,CAAA;QACxE,OAAO,kBAAkB,CACvB,CAAC,EACD,IAAI,CAAC,OAAO,EACZ,IAAI,CAAC,MAAM,EACX,kBAAkB,EAClB,IAAI,CAAC,QAAQ,CACd,CAAA;IACH,CAAC;IAED;;OAEG;IACH,+BAAM,GAAN;QACE,gEAAgE;QAChE,IAAM,kBAAkB,GAAG,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,UAAA,CAAC,IAAI,OAAA,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,EAAf,CAAe,CAAC,CAAA;QACxE,OAAO,oBAAoB,CACzB,IAAI,CAAC,OAAO,EACZ,IAAI,CAAC,MAAM,EACX,kBAAkB,EAClB,IAAI,CAAC,QAAQ,CACd,CAAA;IACH,CAAC;IAED;;OAEG;IACI,0CAA2B,GAAlC,UACE,MAAc,EACd,KAAe,EACf,aAAgC,EAChC,OAAkB;QAElB,OAAO,IAAI,cAAc,CAAC,MAAM,EAAE,KAAK,EAAE,aAAa,EAAE,OAAO,CAAC,CAAA;IAClE,CAAC;IAED;;OAEG;IACI,uBAAQ,GAAf,UACE,MAAkB,EAClB,MAAc,EACd,gBAA0D;QAA1D,iCAAA,EAAA,4BAA0D;QAE1D,gDAAgD;QAChD,IAAI,KAAe,CAAA;QACnB,QAAQ,gBAAgB,EAAE,CAAC;YACzB,KAAK,OAAO;gBACV,KAAK,GAAG,kBAAkB,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;gBAC1C,MAAK;YACP,KAAK,WAAW;gBACd,KAAK,GAAG,sBAAsB,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;gBAC9C,MAAK;YACP,KAAK,SAAS,CAAC;YACf;gBACE,KAAK,GAAG,oBAAoB,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,CAAA;gBACnD,MAAK;QACT,CAAC;QAED,6DAA6D;QAC7D,IAAM,aAAa,GAAG,MAAM,CAAC,GAAG,CAAC,UAAA,CAAC,IAAI,OAAA,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,EAA/B,CAA+B,CAAC,CAAA;QACtE,IAAM,OAAO,GAAG,IAAI,KAAK,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAA;QAEzD,OAAO,IAAI,cAAc,CAAC,MAAM,EAAE,KAAK,EAAE,aAAa,EAAE,OAAO,CAAC,CAAA;IAClE,CAAC;IAED;;OAEG;IACH,0CAAiB,GAAjB;QACE,IAAM,UAAU,GAAG,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAA;QAC5C,IAAM,QAAQ,GAAG,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,GAAG,IAAI,CAAC,OAAO,GAAG,CAAC,CAAC,CAAA;QACnE,OAAO,EAAE,KAAK,EAAE,UAAU,EAAE,GAAG,EAAE,QAAQ,EAAE,CAAA;IAC7C,CAAC;IAED;;;;OAIG;IACH,kCAAS,GAAT,UAAU,SAAiB;QACzB,IAAM,MAAM,GAAe,EAAE,CAAA;QACvB,IAAA,KAAiB,IAAI,CAAC,iBAAiB,EAAE,EAAvC,KAAK,WAAA,EAAE,GAAG,SAA6B,CAAA;QAE/C,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,SAAS,EAAE,CAAC,EAAE,EAAE,CAAC;YACpC,IAAM,CAAC,GAAG,KAAK,GAAG,CAAC,GAAG,GAAG,KAAK,CAAC,GAAG,CAAC,CAAC,GAAG,SAAS,CAAC,CAAA;YACjD,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAA;QAC5B,CAAC;QAED,OAAO,MAAM,CAAA;IACf,CAAC;IAED;;OAEG;IACH,iCAAQ,GAAR,UAAS,SAAwB;QAAxB,0BAAA,EAAA,gBAAwB;QACzB,IAAA,KAAiB,IAAI,CAAC,iBAAiB,EAAE,EAAvC,KAAK,WAAA,EAAE,GAAG,SAA6B,CAAA;QAC/C,IAAM,UAAU,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAA;QACpC,IAAM,QAAQ,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAA;QAEhC,IAAM,EAAE,GAAG,UAAU,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAA;QACtC,IAAM,EAAE,GAAG,UAAU,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAA;QACtC,IAAM,EAAE,GAAG,UAAU,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAA;QAEtC,OAAO,IAAI,CAAC,IAAI,CAAC,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,CAAC,GAAG,SAAS,CAAA;IAC3D,CAAC;IAED;;OAEG;IACI,gCAAiB,GAAxB,UACE,MAAyB,EACzB,MAAc,EACd,gBAAwD;QAAxD,iCAAA,EAAA,0BAAwD;QAExD,IAAI,MAAM,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YACtB,MAAM,IAAI,KAAK,CAAC,yDAAyD,CAAC,CAAA;QAC5E,CAAC;QAED,oCAAoC;QACpC,IAAM,eAAe,GAAG,IAAI,qBAAqB,CAC/C,MAAM,EACN,IAAI,EACJ,aAAa,CACd,CAAA;QAED,qDAAqD;QACrD,wCAAwC;QACxC,IAAM,SAAS,GAAG,IAAI,CAAC,GAAG,CAAC,EAAE,EAAE,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC,CAAA;QACjD,IAAM,WAAW,GAAG,eAAe,CAAC,SAAS,CAAC,SAAS,CAAC,CAAA;QAExD,2CAA2C;QAC3C,IAAM,WAAW,GAAG,WAAW,CAAC,GAAG,CAAC,UAAA,KAAK,IAAI,OAAA,CAAC,KAAK,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC,EAA3B,CAA2B,CAAC,CAAA;QAEzE,kDAAkD;QAClD,OAAO,cAAc,CAAC,QAAQ,CAAC,WAAW,EAAE,MAAM,EAAE,gBAAgB,CAAC,CAAA;IACvE,CAAC;IACH,qBAAC;AAAD,CAAC,AA9LD,IA8LC"}

package/lib/geometry/AcGeSpline3d.d.ts

@@ -1,63 +1,22 @@
 import { AcGeBox3d, AcGeMatrix3d, AcGePoint3d, AcGePoint3dLike, AcGePointLike } from '../math';
 import { AcGeCurve3d } from './AcGeCurve3d';
-export type AcGeKnotParameterizationType = 'Uniform' | 'Chord' | 'SqrtChord';
-/**
- * Lightweight NURBS curve implementation
- */
-declare class NurbsCurve {
-    private _degree;
-    private _knots;
-    private _controlPoints;
-    private _weights;
-    constructor(degree: number, knots: number[], controlPoints: number[][], weights?: number[]);
-    degree(): number;
-    knots(): number[];
-    controlPoints(): number[][];
-    weights(): number[];
-    /**
-     * Calculate a point on the curve at parameter u
-     */
-    point(u: number): number[];
-    /**
-     * Calculate curve length using numerical integration
-     */
-    length(): number;
-    /**
-     * Create a NURBS curve from control points and knots
-     */
-    static byKnotsControlPointsWeights(degree: number, knots: number[], controlPoints: number[][], weights?: number[]): NurbsCurve;
-    /**
-     * Create a NURBS curve from fit points using interpolation
-     */
-    static byPoints(points: number[][], degree: number, parameterization?: AcGeKnotParameterizationType): NurbsCurve;
-}
+import { AcGeKnotParameterizationType, AcGeNurbsCurve } from './AcGeNurbsCurve';
 export declare class AcGeSpline3d extends AcGeCurve3d {
     private _nurbsCurve;
     private _fitPoints?;
     private _knotParameterization?;
     private _controlPoints;
     private _closed;
-    private _originalControlPoints?;
-    private _originalKnots?;
-    private _originalWeights?;
-    constructor(controlPoints: AcGePointLike[], knots: number[], weights?: number[]);
-    constructor(fitPoints: AcGePointLike[], knotParam: AcGeKnotParameterizationType);
+    constructor(controlPoints: AcGePoint3dLike[], knots: number[], weights?: number[], closed?: boolean);
+    constructor(fitPoints: AcGePointLike[], knotParam: AcGeKnotParameterizationType, closed?: boolean);
     /**
-     * Set the closed property and rebuild the curve if necessary
-     */
-    private setClosed;
-    /**
-     * Make the spline closed by adding control points and adjusting knots
-     */
-    private makeClosed;
-    /**
-     * Make the spline open by restoring the original curve
+     * Build the NURBS curve using stored data
      */
-    private makeOpen;
+    private buildCurve;
     /**
-     * Create periodic knot vector for closed curve
+     * Set the closed property and rebuild the curve if necessary
      */
-    private createClosedKnotVector;
+    private setClosed;
     /**
      * Degree of the spline to be created.
      */
@@ -90,15 +49,15 @@ export declare class AcGeSpline3d extends AcGeCurve3d {
      * @param index Input index (0 based) of point to get
      * @returns
      */
-    getControlPointAt(index: number): import("../math").AcGeVectorLike;
+    getControlPointAt(index: number): import("../math").AcGeVector3dLike;
     /**
-     * Divide this spline into the specified number of points
+     * Divide this spline into the specified nubmer of points
      * those points as an array of points.
-     * @param numPoints Input the number of points returned
+     * @param numPoints Input the nubmer of points returned
      * @returns Return an array of point
      */
     getPoints(numPoints?: number): AcGePoint3d[];
-    getCurvePoints(curve: NurbsCurve, count: number): number[][];
+    getCurvePoints(curve: AcGeNurbsCurve, count: number): number[][];
     /**
      * @inheritdoc
      */
@@ -116,11 +75,11 @@ export declare class AcGeSpline3d extends AcGeCurve3d {
      */
     private toNurbsPoints;
     /**
-     * Convert input points to points in geometry engine format
-     * @param points Input points to convert
-     * @returns Return converted points
+     * Create a closed spline from fit points using AcGeNurbsCurve.createClosedCurve
+     * @param fitPoints - Array of fit points defining the curve
+     * @param parameterization - Knot parameterization type for NURBS
+     * @returns A closed spline
      */
-    private toGePoints;
+    static createClosedSpline(fitPoints: AcGePoint3dLike[], parameterization?: AcGeKnotParameterizationType): AcGeSpline3d;
 }
-export {};
 //# sourceMappingURL=AcGeSpline3d.d.ts.map

package/lib/geometry/AcGeSpline3d.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AcGeSpline3d.d.ts","sourceRoot":"","sources":["../../src/geometry/AcGeSpline3d.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"AcGeSpline3d.d.ts","sourceRoot":"","sources":["../../src/geometry/AcGeSpline3d.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,SAAS,EACT,YAAY,EACZ,WAAW,EACX,eAAe,EACf,aAAa,EACd,MAAM,SAAS,CAAA;AAChB,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAA;AAC3C,OAAO,EAAE,4BAA4B,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAA;AAE/E,qBAAa,YAAa,SAAQ,WAAW;IAC3C,OAAO,CAAC,WAAW,CAAgB;IACnC,OAAO,CAAC,UAAU,CAAC,CAAmB;IACtC,OAAO,CAAC,qBAAqB,CAAC,CAA8B;IAC5D,OAAO,CAAC,cAAc,CAAmB;IACzC,OAAO,CAAC,OAAO,CAAS;gBAGtB,aAAa,EAAE,eAAe,EAAE,EAChC,KAAK,EAAE,MAAM,EAAE,EACf,OAAO,CAAC,EAAE,MAAM,EAAE,EAClB,MAAM,CAAC,EAAE,OAAO;gBAGhB,SAAS,EAAE,aAAa,EAAE,EAC1B,SAAS,EAAE,4BAA4B,EACvC,MAAM,CAAC,EAAE,OAAO;IAoElB;;OAEG;IACH,OAAO,CAAC,UAAU;IAgDlB;;OAEG;IACH,OAAO,CAAC,SAAS;IAUjB;;OAEG;IACH,IAAI,MAAM,WAET;IAED,IAAI,oBAAoB,6CAEvB;IAED;;OAEG;IACH,IAAI,UAAU,IAAI,WAAW,CAM5B;IAED;;OAEG;IACH,IAAI,QAAQ,IAAI,WAAW,CAM1B;IAED;;OAEG;IACH,IAAI,MAAM,WAET;IAED;;;;;;OAMG;IACH,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,eAAe;IAU7C;;;;;;OAMG;IACH,iBAAiB,CAAC,KAAK,EAAE,MAAM;IAM/B;;;;;OAKG;IACH,SAAS,CAAC,SAAS,GAAE,MAAY,GAAG,WAAW,EAAE;IAsBjD,cAAc,CAAC,KAAK,EAAE,cAAc,EAAE,KAAK,EAAE,MAAM;IAkBnD;;OAEG;IACH,oBAAoB;IAKpB,IAAI,MAAM,IAGQ,OAAO,CADxB;IACD,IAAI,MAAM,CAAC,KAAK,EAAE,OAAO,EAExB;IAED;;OAEG;IACH,SAAS,CAAC,OAAO,EAAE,YAAY;IAM/B;;;;OAIG;IACH,OAAO,CAAC,aAAa;IAQrB;;;;;OAKG;IACH,MAAM,CAAC,kBAAkB,CACvB,SAAS,EAAE,eAAe,EAAE,EAC5B,gBAAgB,GAAE,4BAAwC,GACzD,YAAY;CAQhB"}

package/lib/geometry/AcGeSpline3d.js

@@ -13,144 +13,94 @@ var __extends = (this && this.__extends) || (function () {
         d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
     };
 })();
-var __read = (this && this.__read) || function (o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
-    try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-    }
-    catch (error) { e = { error: error }; }
-    finally {
-        try {
-            if (r && !r.done && (m = i["return"])) m.call(i);
-        }
-        finally { if (e) throw e.error; }
-    }
-    return ar;
-};
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
 import { AcCmErrors } from '@mlightcad/common';
 import { AcGeBox3d, AcGePoint3d } from '../math';
-import { calculateCurveLength, evaluateNurbsPoint, generateChordKnots, generateSqrtChordKnots, generateUniformKnots, interpolateControlPoints } from '../util';
 import { AcGeCurve3d } from './AcGeCurve3d';
-/**
- * Lightweight NURBS curve implementation
- */
-var NurbsCurve = /** @class */ (function () {
-    function NurbsCurve(degree, knots, controlPoints, weights) {
-        this._degree = degree;
-        this._knots = __spreadArray([], __read(knots), false);
-        this._controlPoints = controlPoints.map(function (p) { return __spreadArray([], __read(p), false); });
-        this._weights = weights
-            ? __spreadArray([], __read(weights), false) : new Array(controlPoints.length).fill(1.0);
-    }
-    NurbsCurve.prototype.degree = function () {
-        return this._degree;
-    };
-    NurbsCurve.prototype.knots = function () {
-        return __spreadArray([], __read(this._knots), false);
-    };
-    NurbsCurve.prototype.controlPoints = function () {
-        return this._controlPoints.map(function (p) { return __spreadArray([], __read(p), false); });
-    };
-    NurbsCurve.prototype.weights = function () {
-        return __spreadArray([], __read(this._weights), false);
-    };
-    /**
-     * Calculate a point on the curve at parameter u
-     */
-    NurbsCurve.prototype.point = function (u) {
-        return evaluateNurbsPoint(u, this._degree, this._knots, this._controlPoints, this._weights);
-    };
-    /**
-     * Calculate curve length using numerical integration
-     */
-    NurbsCurve.prototype.length = function () {
-        return calculateCurveLength(this._degree, this._knots, this._controlPoints, this._weights);
-    };
-    /**
-     * Create a NURBS curve from control points and knots
-     */
-    NurbsCurve.byKnotsControlPointsWeights = function (degree, knots, controlPoints, weights) {
-        return new NurbsCurve(degree, knots, controlPoints, weights);
-    };
-    /**
-     * Create a NURBS curve from fit points using interpolation
-     */
-    NurbsCurve.byPoints = function (points, degree, parameterization) {
-        if (parameterization === void 0) { parameterization = 'Uniform'; }
-        // Generate knots based on parameterization type
-        var knots;
-        switch (parameterization) {
-            case 'Chord':
-                knots = generateChordKnots(degree, points);
-                break;
-            case 'SqrtChord':
-                knots = generateSqrtChordKnots(degree, points);
-                break;
-            case 'Uniform':
-            default:
-                knots = generateUniformKnots(degree, points.length);
-                break;
-        }
-        // Generate control points from fit points
-        var controlPoints = interpolateControlPoints(points);
-        var weights = new Array(controlPoints.length).fill(1.0);
-        return new NurbsCurve(degree, knots, controlPoints, weights);
-    };
-    return NurbsCurve;
-}());
+import { AcGeNurbsCurve } from './AcGeNurbsCurve';
 var AcGeSpline3d = /** @class */ (function (_super) {
     __extends(AcGeSpline3d, _super);
-    function AcGeSpline3d(a, b, c) {
+    function AcGeSpline3d(a, b, c, d) {
         var _this = _super.call(this) || this;
-        var argsLength = +(a !== undefined) + +(b !== undefined) + +(c !== undefined);
-        if (argsLength != 2 && argsLength != 3) {
+        var argsLength = +(a !== undefined) +
+            +(b !== undefined) +
+            +(c !== undefined) +
+            +(d !== undefined);
+        if (argsLength < 2 || argsLength > 4) {
             throw AcCmErrors.ILLEGAL_PARAMETERS;
         }
         // For now, we support 3 degree only
         var degree = 3;
-        _this._closed = false;
-        if (argsLength == 2 && !Array.isArray(b)) {
+        _this._closed = d || false;
+        if (!Array.isArray(b)) {
+            // Constructor with fit points
             _this._fitPoints = a;
             _this._knotParameterization = b;
+            // Handle closed parameter for fit points constructor
+            if (argsLength >= 3) {
+                _this._closed = c;
+            }
             // Validate minimum number of fit points for degree 3
             if (_this._fitPoints.length < 4) {
                 throw AcCmErrors.ILLEGAL_PARAMETERS;
             }
             var points = _this.toNurbsPoints(_this._fitPoints);
-            _this._nurbsCurve = NurbsCurve.byPoints(points, degree, _this._knotParameterization);
-            _this._controlPoints = _this.toGePoints(_this._nurbsCurve.controlPoints());
-            // Store original data for potential reopening
-            _this._originalControlPoints = __spreadArray([], __read(_this._controlPoints), false);
-            _this._originalKnots = __spreadArray([], __read(_this._nurbsCurve.knots()), false);
-            _this._originalWeights = __spreadArray([], __read(_this._nurbsCurve.weights()), false);
+            _this._nurbsCurve = AcGeNurbsCurve.byPoints(points, degree, _this._knotParameterization);
+            _this._controlPoints = _this._nurbsCurve.controlPoints();
         }
         else {
+            // Constructor with control points
             _this._controlPoints = a;
+            // Handle closed parameter for control points constructor
+            if (argsLength >= 4) {
+                _this._closed = d;
+            }
             // Validate minimum number of control points for degree 3
             if (_this._controlPoints.length < 4) {
                 throw AcCmErrors.ILLEGAL_PARAMETERS;
             }
-            var points = _this.toNurbsPoints(_this._controlPoints);
-            _this._nurbsCurve = NurbsCurve.byKnotsControlPointsWeights(degree, b, points, c);
-            // Store original data for potential reopening
-            _this._originalControlPoints = __spreadArray([], __read(_this._controlPoints), false);
-            _this._originalKnots = __spreadArray([], __read(_this._nurbsCurve.knots()), false);
-            _this._originalWeights = c
-                ? __spreadArray([], __read(c), false) : new Array(_this._controlPoints.length).fill(1.0);
+            _this._nurbsCurve = AcGeNurbsCurve.byKnotsControlPointsWeights(degree, b, _this._controlPoints, c);
+        }
+        // Apply closed state if specified
+        if (_this._closed) {
+            _this.buildCurve();
         }
         return _this;
     }
+    /**
+     * Build the NURBS curve using stored data
+     */
+    AcGeSpline3d.prototype.buildCurve = function () {
+        var degree = 3;
+        if (this._fitPoints && this._knotParameterization) {
+            // Build from fit points
+            if (this._closed) {
+                // Create closed curve from fit points
+                this._nurbsCurve = AcGeNurbsCurve.createClosedCurve(this._fitPoints, degree, this._knotParameterization);
+            }
+            else {
+                // Create open curve from fit points
+                var points = this.toNurbsPoints(this._fitPoints);
+                this._nurbsCurve = AcGeNurbsCurve.byPoints(points, degree, this._knotParameterization);
+            }
+            this._controlPoints = this._nurbsCurve.controlPoints();
+        }
+        else if (this._controlPoints) {
+            // Build from control points
+            if (this._closed) {
+                // Create closed curve from control points
+                var parameterization = this._knotParameterization || 'Chord';
+                this._nurbsCurve = AcGeNurbsCurve.createClosedCurve(this._controlPoints, degree, parameterization);
+                this._controlPoints = this._nurbsCurve.controlPoints();
+            }
+            else {
+                // Create open curve from control points
+                // Get knots and weights from the current NURBS curve
+                var knots = this._nurbsCurve.knots();
+                var weights = this._nurbsCurve.weights();
+                this._nurbsCurve = AcGeNurbsCurve.byKnotsControlPointsWeights(degree, knots, this._controlPoints, weights);
+            }
+        }
+    };
     /**
      * Set the closed property and rebuild the curve if necessary
      */
@@ -160,57 +110,7 @@ var AcGeSpline3d = /** @class */ (function (_super) {
         }
         this._closed = closed;
         this._boundingBoxNeedsUpdate = true;
-        if (closed) {
-            this.makeClosed();
-        }
-        else {
-            this.makeOpen();
-        }
-    };
-    /**
-     * Make the spline closed by adding control points and adjusting knots
-     */
-    AcGeSpline3d.prototype.makeClosed = function () {
-        var degree = this._nurbsCurve.degree();
-        var originalControlPoints = this._nurbsCurve.controlPoints();
-        var originalWeights = this._nurbsCurve.weights();
-        var n = originalControlPoints.length;
-        // Append the first 'degree' control points to the end for periodicity
-        var closedControlPoints = __spreadArray(__spreadArray([], __read(originalControlPoints), false), __read(originalControlPoints.slice(0, degree)), false);
-        var closedWeights = __spreadArray(__spreadArray([], __read(originalWeights), false), __read(originalWeights.slice(0, degree)), false);
-        // Create a periodic (non-clamped) uniform knot vector
-        var closedKnots = this.createClosedKnotVector(n, degree);
-        // Create new NURBS curve
-        this._nurbsCurve = NurbsCurve.byKnotsControlPointsWeights(degree, closedKnots, closedControlPoints, closedWeights);
-        this._controlPoints = this.toGePoints(closedControlPoints);
-    };
-    /**
-     * Make the spline open by restoring the original curve
-     */
-    AcGeSpline3d.prototype.makeOpen = function () {
-        if (!this._originalControlPoints ||
-            !this._originalKnots ||
-            !this._originalWeights) {
-            throw new Error('Original curve data not available');
-        }
-        var degree = this._nurbsCurve.degree();
-        var originalPoints = this.toNurbsPoints(this._originalControlPoints);
-        // Create new NURBS curve with original data
-        this._nurbsCurve = NurbsCurve.byKnotsControlPointsWeights(degree, this._originalKnots, originalPoints, this._originalWeights);
-        this._controlPoints = __spreadArray([], __read(this._originalControlPoints), false);
-    };
-    /**
-     * Create periodic knot vector for closed curve
-     */
-    AcGeSpline3d.prototype.createClosedKnotVector = function (n, degree) {
-        // For periodic B-spline: knots go from 0 to n (not n+degree+1), no repeated knots at ends
-        // Number of knots = n + 2*degree + 1
-        var m = n + 2 * degree + 1;
-        var knots = [];
-        for (var i = 0; i < m; i++) {
-            knots.push(i);
-        }
-        return knots;
+        this.buildCurve();
     };
     Object.defineProperty(AcGeSpline3d.prototype, "degree", {
         /**
@@ -248,10 +148,6 @@ var AcGeSpline3d = /** @class */ (function (_super) {
          * The end point of this spline
          */
         get: function () {
-            if (this._closed) {
-                // For closed splines, the end point should be the same as the start point
-                return this.startPoint;
-            }
             var knots = this._nurbsCurve.knots();
             var degree = this._nurbsCurve.degree();
             var endParam = knots[knots.length - degree - 1];
@@ -300,38 +196,28 @@ var AcGeSpline3d = /** @class */ (function (_super) {
         return this._controlPoints[newIndex];
     };
     /**
-     * Divide this spline into the specified number of points
+     * Divide this spline into the specified nubmer of points
      * those points as an array of points.
-     * @param numPoints Input the number of points returned
+     * @param numPoints Input the nubmer of points returned
      * @returns Return an array of point
      */
     AcGeSpline3d.prototype.getPoints = function (numPoints) {
         if (numPoints === void 0) { numPoints = 100; }
         var curve = this._nurbsCurve;
         var points = [];
+        // Get the knot vector from the curve
         var knots = curve.knots();
-        var degree = curve.degree();
+        // The valid parameter range is between knots[degree] and knots[knots.length - degree - 1]
+        var degree = this._nurbsCurve.degree();
         var startParam = knots[degree];
         var endParam = knots[knots.length - degree - 1];
-        if (this._closed) {
-            // Sample numPoints-1 points, then append the first point to close the loop
-            var period = endParam - startParam;
-            var step = period / (numPoints - 1);
-            for (var i = 0; i < numPoints - 1; i++) {
-                var t = startParam + i * step;
-                var pt = curve.point(t);
-                points.push(new AcGePoint3d(pt[0], pt[1], pt[2]));
-            }
-            // Append the first point to close the loop
-            points.push(points[0]);
-        }
-        else {
-            var step = (endParam - startParam) / (numPoints - 1);
-            for (var i = 0; i < numPoints; i++) {
-                var t = i === numPoints - 1 ? endParam : startParam + i * step;
-                var pt = curve.point(t);
-                points.push(new AcGePoint3d(pt[0], pt[1], pt[2]));
-            }
+        // Adjust step size for correct range
+        var step = (endParam - startParam) / (numPoints - 1);
+        for (var i = 0; i < numPoints; i++) {
+            // For the last point, use endParam exactly to avoid floating-point issues
+            var t = i === numPoints - 1 ? endParam : startParam + i * step;
+            var point = curve.point(t);
+            points.push(new AcGePoint3d(point[0], point[1], point[2]));
         }
         return points;
     };
@@ -386,16 +272,18 @@ var AcGeSpline3d = /** @class */ (function (_super) {
         return nurbsPoints;
     };
     /**
-     * Convert input points to points in geometry engine format
-     * @param points Input points to convert
-     * @returns Return converted points
+     * Create a closed spline from fit points using AcGeNurbsCurve.createClosedCurve
+     * @param fitPoints - Array of fit points defining the curve
+     * @param parameterization - Knot parameterization type for NURBS
+     * @returns A closed spline
      */
-    AcGeSpline3d.prototype.toGePoints = function (points) {
-        var gePoints = new Array(points.length);
-        points.forEach(function (point, index) {
-            gePoints[index] = { x: point[0], y: point[1], z: point[2] };
-        });
-        return gePoints;
+    AcGeSpline3d.createClosedSpline = function (fitPoints, parameterization) {
+        if (parameterization === void 0) { parameterization = 'Uniform'; }
+        if (fitPoints.length < 4) {
+            throw new Error('At least 4 points are required for a closed spline');
+        }
+        // Create spline using the constructor with fit points and closed=true
+        return new AcGeSpline3d(fitPoints, parameterization, true);
     };
     return AcGeSpline3d;
 }(AcGeCurve3d));