@itwin/core-geometry 5.0.0-dev.9 → 5.0.0-dev.90

package/lib/cjs/bspline/KnotVector.d.ts

@@ -9,114 +9,131 @@
 export declare enum BSplineWrapMode {
     /** No conversion performed. */
     None = 0,
-    /** The B-spline was opened up by adding degree wrap-around control points to the legacy periodic data.
-     * * This is typical of B-splines constructed with maximum (degree - 1) continuity.
+    /**
+     * The legacy periodic B-spline data was opened up by adding `degree` wrap-around poles.
+     * * This is typical of B-spline curves and surfaces constructed with maximum `degree - 1` continuity.
      * * Knots are unaffected by this conversion.
      */
     OpenByAddingControlPoints = 1,
-    /** The B-spline was opened up by removing degree extreme knots from the legacy periodic data.
+    /**
+     * The legacy periodic B-spline data was opened up by removing `degree` exterior knots.
      * * This is typical of rational B-spline curves representing full circles and ellipses.
      * * Poles are unaffected by this conversion.
      */
     OpenByRemovingKnots = 2
 }
 /**
- * Array of non-decreasing numbers acting as a knot array for B-splines.
+ * Array of non-decreasing numbers acting as a knot vector for B-spline curves and surfaces.
  *
  * * Essential identity: numKnots = numPoles + order - 2 = numPoles + degree - 1
- * * Various B-spline libraries have confusion over how many "end knots" are needed. Many libraries (including MicroStation and Parasolid)
- * demand order knots at each end for clamping. But only order-1 are really needed. This class uses the order-1 convention.
+ * * Various B-spline libraries have confusion over how many "end knots" are needed. Many libraries (including MicroStation
+ * and Parasolid) demand order knots at each end for clamping. However, only order-1 are really needed. This class uses the
+ * order-1 convention.
  * * A span is a single interval of the knots.
- * * The left knot of span {k} is knot {k+degree-1}.
+ * * The left knot of the span with index `k>=0` is the knot with index `k+degree-1`.
+ * * A knot vector is clamped when the first `degree` knots are equal and the last `degree` knots are equal.
+ * * The "active knot interval" is the subset of the knot vector sans its first and last `degree-1` knots, and serves as
+ * the parametric domain of the associated B-spline object.
  * * This class provides queries to convert among spanIndex, knotIndex, spanFraction, fraction of knot range, and knot.
- * * Core computations (evaluateBasisFunctions) have leftKnotIndex and global knot value as inputs.  Callers need to
- * know their primary values (global knot, spanFraction).
+ * * Callers need to distinguish core computational inputs such as left knot index, knot value, span index, and span fraction.
  * @public
  */
 export declare class KnotVector {
     /** The simple array of knot values. */
     knots: Float64Array;
-    /** Return the degree of basis functions defined in these knots. */
+    /** The degree of basis functions defined in these knots. */
     degree: number;
+    /** The leftmost knot value (of the active interval, ignoring unclamped leading knots). */
     private _knot0;
+    /** The rightmost knot value (of the active interval, ignoring unclamped leading knots). */
     private _knot1;
     private _wrapMode?;
-    /** tolerance for considering two knots to be the same. */
+    /** Tolerance for considering two knots to be the same. */
     static readonly knotTolerance = 1e-9;
-    /** Return the leftmost knot value (of the active interval, ignoring unclamped leading knots)*/
+    /** Return the leftmost knot value (of the active interval, ignoring unclamped leading knots). */
     get leftKnot(): number;
-    /** Return the rightmost knot value (of the active interval, ignoring unclamped leading knots)*/
+    /** Return the rightmost knot value (of the active interval, ignoring unclamped leading knots). */
     get rightKnot(): number;
-    /** Return the index of the leftmost knot of the active interval */
+    /** Return the index of the leftmost knot of the active interval. */
     get leftKnotIndex(): number;
-    /** Return the index of the rightmost knot of the active interval */
+    /** Return the index of the rightmost knot of the active interval. */
     get rightKnotIndex(): number;
-    /** Whether this KnotVector was created by converting legacy periodic data during deserialization. The conversion used is specified by BSplineWrapMode, and is reversed at serialization time. */
+    /**
+     * Whether this KnotVector was created by converting legacy periodic data during deserialization. The conversion used
+     * is specified by BSplineWrapMode, and is reversed at serialization time.
+     */
     get wrappable(): BSplineWrapMode;
     set wrappable(value: BSplineWrapMode);
-    /** Return the number of bezier spans.  Note that this includes zero-length spans if there are repeated knots. */
+    /** Return the number of Bezier spans. Note that this includes zero-length spans if there are repeated knots. */
     get numSpans(): number;
     /**
-     *
-     * * If knots is a number array or Float64Array, the those values become the local knot array.
-     * * If knots is a simple number, the local knot array is allocated to that size but left as zeros.
-     * @param knots
-     * @param degree
+     * Private constructor.
+     * * If `knots` is a number array or Float64Array, then its values are copied to the instance array.
+     * * If `knots` is a number, the instance array is allocated to this size but left as zeros.
      */
     private constructor();
-    /** copy degree and knots to a new KnotVector. */
+    /** Copy degree and knots to a new KnotVector. */
     clone(): KnotVector;
     private setupFixedValues;
-    /** Return the total knot distance from beginning to end. */
+    /**
+     * Return the length of the active knot interval.
+     * * This is the size of (one dimension of) the parametric domain for the associated B-spline object.
+     */
     get knotLength01(): number;
     /**
-     * Returns true if all numeric values have wraparound conditions that allow the knots to be closed with specified wrap mode.
-     * @param mode optional test mode.  If undefined, use this.wrappable.
+     * Returns true if all numeric values have wraparound conditions that allow the knots to be closed with specified
+     * wrap mode.
+     * @param mode optional test mode. If undefined, use this.wrappable.
      */
     testClosable(mode?: BSplineWrapMode): boolean;
-    /** Test matching degree and knot values */
+    /** Test matching degree and knot values. */
     isAlmostEqual(other: KnotVector): boolean;
     /** Compute the multiplicity of the input knot, or zero if not a knot. */
     getKnotMultiplicity(knot: number): number;
     /** Compute the multiplicity of the knot at the given index. */
     getKnotMultiplicityAtIndex(knotIndex: number): number;
-    /** Transform knots to span [0,1].
-     * @returns false if and only if this.knotLength01 is trivial
+    /**
+     * Transform knots such that the active knot range becomes [0,1].
+     * @returns false if and only if `this.knotLength01` is trivial.
      */
     normalize(): boolean;
-    /** install knot values from an array, optionally ignoring first and last.
-     */
+    /** Install knot values from an array, optionally ignoring first and last. */
     setKnots(knots: number[] | Float64Array, skipFirstAndLast?: boolean): void;
-    /** Set knots to input array (CAPTURED)  */
+    /** Set knots to input array (CAPTURED).  */
     setKnotsCapture(knots: Float64Array): void;
     /**
      * Create knot vector with {degree-1} replicated knots at start and end, and uniform knots between.
-     * @param numPoles Number of poles
-     * @param degree degree of polynomial
-     * @param a0 left knot value for active interval
-     * @param a1 right knot value for active interval
+     * @param numPoles number of poles.
+     * @param degree degree of polynomial.
+     * @param a0 left knot value for active interval.
+     * @param a1 right knot value for active interval.
      */
     static createUniformClamped(numPoles: number, degree: number, a0: number, a1: number): KnotVector;
     /**
      * Create knot vector with wraparound knots at start and end, and uniform knots between.
-     * @param  numInterval number of intervals in knot space.  (NOT POLE COUNT)
-     * @param degree degree of polynomial
-     * @param a0 left knot value for active interval
-     * @param a1 right knot value for active interval
+     * @param numInterval the number of intervals into which to uniformly divide the active knot interval `[a0,a1]`,
+     * creating `numInterval-1` equally spaced interior knots between `a0` and `a1`.
+     * This number is equal to the number of Bezier spans in the associated B-spline object.
+     * It is _not_ the pole count.
+     * @param degree degree of polynomial.
+     * @param a0 left knot value for active interval.
+     * @param a1 right knot value for active interval.
      */
     static createUniformWrapped(numInterval: number, degree: number, a0: number, a1: number): KnotVector;
     /**
      * Create knot vector with given knot values and degree.
-     * @param knotArray knot values
-     * @param degree degree of polynomial
+     * @param knotArray knot values.
+     * @param degree degree of polynomial.
      * @param skipFirstAndLast true to skip copying the first and last knot values.
      */
     static create(knotArray: number[] | Float64Array, degree: number, skipFirstAndLast?: boolean): KnotVector;
     /**
      * Return the average of degree consecutive knots beginning at knotIndex.
+     * * If `knotIndex` is negative, return `leftKnot`.
+     * * If `knotIndex > rightKnotIndex` return `rightKnot`.
      */
     grevilleKnot(knotIndex: number): number;
-    /** Return an array sized for a set of the basis function values. */
+    /** Return an array of size `degree + 1`, e.g., to hold the set of relevant basis function values at a parameter. */
     createBasisArray(): Float64Array;
     /** Convert localFraction within the interval following an indexed knot to a knot value. */
     baseKnotFractionToKnot(knotIndex0: number, localFraction: number): number;
@@ -126,43 +143,48 @@ export declare class KnotVector {
     spanFractionToFraction(spanIndex: number, localFraction: number): number;
     /** Return fraction of active knot range to knot value. */
     fractionToKnot(fraction: number): number;
+    private isKnotInValidSpan;
     /**
-     * Evaluate basis functions f[] at knot value u.
-     *
-     * @param u knot value for evaluation
-     * @param f preallocated output array of order basis function values
-     * @returns true if and only if output array is sufficiently sized
+     * Evaluate the B-spline basis functions f[] at a parameter u in a knot span.
+     * * This method implements the Mansfield-Cox-de Boor recurrence relation.
+     * @param knotIndex0 index of the left knot of the span.
+     * @param u value in the knot span: knot[knotIndex0] <= u <= knot[knotIndex0 + 1].
+     * @param f preallocated output array of order basis function values.
+     * @returns true if and only if output array is sufficiently sized.
      */
     evaluateBasisFunctions(knotIndex0: number, u: number, f: Float64Array): boolean;
     /**
-     * Evaluate basis functions f[], derivatives df[], and optional second derivatives ddf[] at knot value u.
-     *
-     * @param u knot value for evaluation
-     * @param f preallocated output array of order basis function values
-     * @param df preallocated output array of order basis derivative values
-     * @param ddf optional preallocated output array of order basis second derivative values
-     * @returns true if and only if output arrays are sufficiently sized
+     * Evaluate basis functions f[], derivatives df[], and optional second derivatives ddf[] at a parameter u
+     * in a knot span.
+     * @param knotIndex0 index of the left knot of the span.
+     * @param u value in the knot span: knot[knotIndex0] <= u <= knot[knotIndex0 + 1].
+     * @param f preallocated output array of order basis function values.
+     * @param df preallocated output array of order basis derivative values.
+     * @param ddf optional preallocated output array of order basis second derivative values.
+     * @returns true if and only if output arrays are sufficiently sized.
      */
     evaluateBasisFunctions1(knotIndex0: number, u: number, f: Float64Array, df: Float64Array, ddf?: Float64Array): boolean;
-    /** Find the knot span bracketing knots[i] <= u < knots[i+1] and return i.
+    /**
+     * Find the knot span bracketing knots[i] <= u < knots[i+1] and return i.
      * * If u has no such bracket, return the smaller index of the closest nontrivial bracket.
-     * @param u value to bracket
+     * @param u value to bracket.
      */
     knotToLeftKnotIndex(u: number): number;
     /**
      * Given a span index, return the index of the knot at its left.
-     * @param spanIndex index of span
+     * @param spanIndex index of span.
      */
     spanIndexToLeftKnotIndex(spanIndex: number): number;
     /** Return the knot interval length of indexed bezier span. */
     spanIndexToSpanLength(spanIndex: number): number;
     /**
      * Given a span index, test if it is within range and has nonzero length.
-     * * note that a false return does not imply there are no more spans.  This may be a double knot (zero length span) followed by more real spans
+     * * note that a false return does not imply there are no more spans. This may be a double knot (zero length span)
+     * followed by more real spans
      * @param spanIndex index of span to test.
      */
     isIndexOfRealSpan(spanIndex: number): boolean;
-    /** Reflect all knots so `leftKnot` and `rightKnot` are maintained but interval lengths reverse. */
+    /** Reflect all knots so `leftKnot` and `rightKnot` are maintained but interval lengths are reversed. */
     reflectKnots(): void;
     /** Return a simple array form of the knots. Optionally replicate the first and last in classic over-clamped manner. */
     static copyKnots(knots: number[] | Float64Array, degree: number, includeExtraEndKnot?: boolean, wrapMode?: BSplineWrapMode): number[];

package/lib/cjs/bspline/KnotVector.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"KnotVector.d.ts","sourceRoot":"","sources":["../../../src/bspline/KnotVector.ts"],"names":[],"mappings":"AAIA;;GAEG;AAKH;;;;GAIG;AACH,oBAAY,eAAe;IACzB,+BAA+B;IAC/B,IAAI,IAAI;IACR;;;OAGG;IACH,yBAAyB,IAAI;IAC7B;;;OAGG;IACH,mBAAmB,IAAI;CACxB;AACD;;;;;;;;;;;;GAYG;AACH,qBAAa,UAAU;IACrB,uCAAuC;IAChC,KAAK,EAAE,YAAY,CAAC;IAC3B,mEAAmE;IAC5D,MAAM,EAAE,MAAM,CAAC;IACtB,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,MAAM,CAAS;IAEvB,OAAO,CAAC,SAAS,CAAC,CAAkB;IACpC,0DAA0D;IAC1D,gBAAuB,aAAa,QAAU;IAC9C,+FAA+F;IAC/F,IAAW,QAAQ,WAA0B;IAC7C,gGAAgG;IAChG,IAAW,SAAS,WAA0B;IAC9C,mEAAmE;IACnE,IAAW,aAAa,WAA8B;IACtD,oEAAoE;IACpE,IAAW,cAAc,WAA8C;IACvE,iMAAiM;IACjM,IAAW,SAAS,IACQ,eAAe,CAD4D;IACvG,IAAW,SAAS,CAAC,KAAK,EAAE,eAAe,EAA6B;IACxE,iHAAiH;IACjH,IAAW,QAAQ,WAAuD;IAC1E;;;;;;OAMG;IACH,OAAO;IAkBP,iDAAiD;IAC1C,KAAK,IAAI,UAAU;IAC1B,OAAO,CAAC,gBAAgB;IAMxB,4DAA4D;IAC5D,IAAW,YAAY,IAAI,MAAM,CAAsC;IACvE;;;OAGG;IACI,YAAY,CAAC,IAAI,CAAC,EAAE,eAAe,GAAG,OAAO;IAgCpD,2CAA2C;IACpC,aAAa,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO;IAKhD,yEAAyE;IAClE,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM;IAWhD,+DAA+D;IACxD,0BAA0B,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM;IAuB5D;;OAEG;IACI,SAAS,IAAI,OAAO;IAe3B;OACG;IACI,QAAQ,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,YAAY,EAAE,gBAAgB,CAAC,EAAE,OAAO;IAe1E,2CAA2C;IACpC,eAAe,CAAC,KAAK,EAAE,YAAY;IAK1C;;;;;;OAMG;WACW,oBAAoB,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,UAAU;IAWxG;;;;;;OAMG;WACW,oBAAoB,CAAC,WAAW,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,UAAU;IAU3G;;;;;OAKG;WACW,MAAM,CAAC,SAAS,EAAE,MAAM,EAAE,GAAG,YAAY,EAAE,MAAM,EAAE,MAAM,EAAE,gBAAgB,CAAC,EAAE,OAAO,GAAG,UAAU;IAOhH;;OAEG;IACI,YAAY,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM;IAQ9C,oEAAoE;IAC7D,gBAAgB,IAAI,YAAY;IACvC,2FAA2F;IACpF,sBAAsB,CAAC,UAAU,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,GAAG,MAAM;IAKhF,2EAA2E;IACpE,kBAAkB,CAAC,SAAS,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,GAAG,MAAM;IAK3E,4FAA4F;IACrF,sBAAsB,CAAC,SAAS,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,GAAG,MAAM;IAI/E,0DAA0D;IACnD,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM;IAI/C;;;;;;OAMG;IACI,sBAAsB,CAAC,UAAU,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,YAAY,GAAG,OAAO;IA+BtF;;;;;;;;OAQG;IACI,uBAAuB,CAAC,UAAU,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,YAAY,EAAE,EAAE,EAAE,YAAY,EAAE,GAAG,CAAC,EAAE,YAAY,GAAG,OAAO;IAmE7H;;;OAGG;IACI,mBAAmB,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM;IAY7C;;;OAGG;IACI,wBAAwB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM;IAK1D,8DAA8D;IACvD,qBAAqB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM;IAIvD;;;;OAIG;IACI,iBAAiB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO;IAKpD,mGAAmG;IAC5F,YAAY;IASnB,uHAAuH;WACzG,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,YAAY,EAAE,MAAM,EAAE,MAAM,EAAE,mBAAmB,CAAC,EAAE,OAAO,EAAE,QAAQ,CAAC,EAAE,eAAe,GAAG,MAAM,EAAE;IA0B5I,uHAAuH;IAChH,SAAS,CAAC,mBAAmB,EAAE,OAAO,GAAG,MAAM,EAAE;CAIzD"}
+{"version":3,"file":"KnotVector.d.ts","sourceRoot":"","sources":["../../../src/bspline/KnotVector.ts"],"names":[],"mappings":"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"}