@itwin/core-geometry 4.3.0-dev.13 → 4.3.0-dev.14

package/lib/esm/bspline/BSplineSurface.js

@@ -22,14 +22,19 @@ export var UVSelect;
 (function (UVSelect) {
     /** index of u direction */
     UVSelect[UVSelect["uDirection"] = 0] = "uDirection";
-    /** index of v direction */
+    /**
+     * index of v direction
+     * @deprecated in 4.x. Use vDirection instead.
+     */
     UVSelect[UVSelect["VDirection"] = 1] = "VDirection";
+    /** index of v direction */
+    UVSelect[UVSelect["vDirection"] = 1] = "vDirection";
 })(UVSelect || (UVSelect = {}));
 /**
  * Enumeration of how weights are carried
  * * UnWeighted (0) -- there are no weights
- * * WeightsAlreadyAppliedToCoordinates (1) -- for real point (x,y,z) the homogeneous point has weight applied throughout as (wx,wy,wz,w)
- * * WeightsSeparateFromCoordinates (2) -- for real point (x,y,z) the homogeneous point is (x,y,z,w)
+ * * WeightsAlreadyAppliedToCoordinates (1) -- for real point (x,y,z) the homogeneous point (wx,wy,wx,w) is stored as (wx,wy,wz,w)
+ * * WeightsSeparateFromCoordinates (2) -- for real point (x,y,z) the homogeneous point (wx,wy,wx,w) is stored as (x,y,z,w)
  *   * Note that "internal" computations never use WeightsSeparateFromCoordinates.
  *   * WeightsSeparateFromCoordinates is only useful as input or output state in serializer.
  * @public
@@ -39,13 +44,13 @@ export var WeightStyle;
     /** There are no weights. */
     WeightStyle[WeightStyle["UnWeighted"] = 0] = "UnWeighted";
     /**
-     * * Data is weighted
-     * * point with normalized coordinate `[x,y,z]` and weight `w` has weights already multiplied in as `[x*w,y*w,z*w,w]`
+     * * Data is weighted.
+     * * The point with normalized coordinate `[x,y,z]` and weight `w` is stored as `[x*w,y*w,z*w,w]`
      * */
     WeightStyle[WeightStyle["WeightsAlreadyAppliedToCoordinates"] = 1] = "WeightsAlreadyAppliedToCoordinates";
     /**
-     * * Data is weighted
-     * * point with normalized coordinate `[x,y,z]` and weight `w` has is `[x,y,z,w]`
+     * * Data is weighted.
+     * * The point with normalized coordinate `[x,y,z]` and weight `w` is stored as `[x,y,z,w]`
      * */
     WeightStyle[WeightStyle["WeightsSeparateFromCoordinates"] = 2] = "WeightsSeparateFromCoordinates";
 })(WeightStyle || (WeightStyle = {}));
@@ -76,18 +81,30 @@ export class BSpline2dNd extends GeometryQuery {
             return false;
         return true;
     }
-    /** Get the Point3d by row and column.
+    /** Get the indexed Point3d.
      * * (IMPORTANT) This assumes this is an xyz surface.  Data will be incorrect if this is an xyzw surface.
+     * @param i index in [0, numPolesU)
+     * @param j index in [0, numPolesV)
      */
     getPoint3dPole(i, j, result) {
         return Point3d.createFromPacked(this.coffs, i + j * this._numPoles[0], result);
     }
-    /** Get the Point3d by row and column, projecting the weight away to get to xyz
+    /** Get the indexed Point3d, projecting the weight away to get to xyz.
      * * (IMPORTANT) This assumes this is an xyzw surface.  Data will be incorrect if this is an xyz surface.
+     * @param i index in [0, numPolesU)
+     * @param j index in [0, numPolesV)
      */
     getPoint3dPoleXYZW(i, j, result) {
         return Point3d.createFromPackedXYZW(this.coffs, i + j * this._numPoles[0], result);
     }
+    /** Get the indexed Point4d.
+     * * (IMPORTANT) This assumes this is an xyzw surface.  Data will be incorrect if this is an xyz surface.
+     * @param i index in [0, numPolesU)
+     * @param j index in [0, numPolesV)
+     */
+    getPoint4dPole(i, j, result) {
+        return Point4d.createFromPacked(this.coffs, (i + j * this._numPoles[0]) * 4, result);
+    }
     /**
      * Return 0 for 0 input, 1 for any nonzero input.
      * @param value numeric value to convert to strict 0 or 1.
@@ -181,6 +198,7 @@ export class BSpline2dNd extends GeometryQuery {
      * * choice of u or v
      * * span index
      * * local fraction within the span.
+     * @returns true if and only if output arrays are sufficiently sized
      */
     spanFractionsToBasisFunctions(select, spanIndex, spanFraction, f, df) {
         spanIndex = Geometry.clampToStartEnd(spanIndex, 0, this.numSpanUV(select));
@@ -210,9 +228,15 @@ export class BSpline2dNd extends GeometryQuery {
             kU += stepV;
         }
     }
-    // cSpell:word sumpole
-    /** sum derivatives by the weights in the basisBuffer, using poles for given span */
+    /**
+     * sum poles by the weights in the basisBuffer, using poles for given span
+     * @deprecated in 4.x. Use sumPoleBufferDerivativesForSpan instead.
+     */
     sumpoleBufferDerivativesForSpan(spanIndexU, spanIndexV) {
+        return this.sumPoleBufferDerivativesForSpan(spanIndexU, spanIndexV);
+    }
+    /** sum derivatives by the weights in the basisBuffer, using poles for given span */
+    sumPoleBufferDerivativesForSpan(spanIndexU, spanIndexV) {
         const poleBuffer1U = this._poleBuffer1UV[0];
         const poleBuffer1V = this._poleBuffer1UV[1];
         poleBuffer1U.fill(0);
@@ -266,7 +290,7 @@ export class BSpline2dNd extends GeometryQuery {
             this.knots[0].evaluateBasisFunctions1(knotIndex0U, u, this._basisBufferUV[0], this._basisBuffer1UV[0]);
             this.knots[1].evaluateBasisFunctions1(knotIndex0V, v, this._basisBufferUV[1], this._basisBuffer1UV[1]);
             this.sumPoleBufferForSpan(poleIndex0U, poleIndex0V);
-            this.sumpoleBufferDerivativesForSpan(poleIndex0U, poleIndex0V);
+            this.sumPoleBufferDerivativesForSpan(poleIndex0U, poleIndex0V);
         }
     }
     // Swap numSwap entries in coffs, starting at i0 and i1 (absolute indices -- not blocks)
@@ -305,31 +329,33 @@ export class BSpline2dNd extends GeometryQuery {
         this.knots[select].reflectKnots();
     }
     /**
-     * Set the flag indicating the bspline might be suitable for having wrapped "closed" interpretation.
+     * Get the flag indicating the surface might be suitable for having wrapped "closed" interpretation.
+     */
+    getWrappable(select) {
+        return this.knots[select].wrappable;
+    }
+    /**
+     * Set the flag indicating the surface might be suitable for having wrapped "closed" interpretation.
      */
     setWrappable(select, value) {
         this.knots[select].wrappable = value;
     }
     /**
-     * Test if `degree` leading and trailing (one of U or V) blocks match, as if the data is an unwrapped closed spline in the selected direction.
-     * @param select select U or V direction
-     * @returns true if coordinates matched.
+     * Test if leading and trailing blocks of points match in a given direction.
+     * @param data packed array of points in row-major order (numRows x numColumns x dimension numbers)
+     * @param numRows number of rows of points in the array
+     * @param numColumns number of columns of points in the array (equal to the number of points in each row)
+     * @param dimension point dimension (e.g., 2,3,4)
+     * @param blockLength number of leading/trailing points to check
+     * @param select 0 to test first/last columns of points; 1 to test first/last rows of points
+     * @returns true if coordinates matched
      */
-    isClosable(select) {
-        if (this.knots[select].wrappable === BSplineWrapMode.None)
-            return false;
-        if (!this.knots[select].testClosable())
-            return false;
-        const numU = this.numPolesUV(0);
-        const numV = this.numPolesUV(1);
-        const blockSize = this.poleDimension;
-        const rowToRowStep = numU * blockSize;
-        const degreeU = this.degreeUV(0);
-        const degreeV = this.degreeUV(1);
-        const data = this.coffs;
-        if (select === 0) {
-            const numTest = blockSize * degreeU; // degreeU contiguous poles.
-            for (let row = 0; row < numV; row++) {
+    static isWrappedGrid(data, numRows, numColumns, dimension, blockLength, select) {
+        const rowToRowStep = numColumns * dimension;
+        if (UVSelect.uDirection === select) {
+            // Test the contiguous block at the start/end of each row
+            const numTest = dimension * blockLength;
+            for (let row = 0; row < numRows; row++) {
                 const i0 = row * rowToRowStep;
                 const i1 = i0 + rowToRowStep - numTest;
                 for (let i = 0; i < numTest; i++) {
@@ -339,9 +365,9 @@ export class BSpline2dNd extends GeometryQuery {
             }
         }
         else {
-            // Test the entire multi-row contiguous block in one loop . ..
-            const numTest = degreeV * rowToRowStep;
-            const i1 = blockSize * numU * numV - numTest;
+            // Test the entire multi-row contiguous block at the start/end of the array
+            const numTest = blockLength * rowToRowStep;
+            const i1 = numRows * numColumns * dimension - numTest;
             for (let i = 0; i < numTest; i++) {
                 if (!Geometry.isSameCoordinate(data[i], data[i1 + i]))
                     return false;
@@ -349,6 +375,43 @@ export class BSpline2dNd extends GeometryQuery {
         }
         return true;
     }
+    /**
+     * Test if `degree` leading and trailing (one of U or V) blocks match, as if the data is a non-periodic physically closed spline in the selected direction.
+     * @param select select U or V direction
+     * @returns true if coordinates matched.
+     */
+    testClosableGrid(select, mode) {
+        if (mode === undefined)
+            mode = this.knots[select].wrappable;
+        if (mode === BSplineWrapMode.OpenByAddingControlPoints) // the last degree poles equal the first degree poles
+            return BSpline2dNd.isWrappedGrid(this.coffs, this.numPolesUV(UVSelect.vDirection), this.numPolesUV(UVSelect.uDirection), this.poleDimension, this.degreeUV(select), select);
+        if (mode === BSplineWrapMode.OpenByRemovingKnots) // the last pole equals the first pole
+            return BSpline2dNd.isWrappedGrid(this.coffs, this.numPolesUV(UVSelect.vDirection), this.numPolesUV(UVSelect.uDirection), this.poleDimension, 1, select);
+        return false;
+    }
+    /**
+     * Test knots and control points to determine if it is possible to close (aka "wrap") the surface in the selected parametric direction.
+     * @param select select U or V direction
+     * @return whether the surface can be wrapped in the given parametric direction.
+     */
+    isClosable(select) {
+        return BSplineWrapMode.None !== this.isClosableSurface(select);
+    }
+    /**
+     * Test knots and control points to determine if it is possible to close (aka "wrap") the surface in the selected parametric direction.
+     * @param select select U or V direction
+     * @return the manner of closing. See `BSplineWrapMode` for particulars of each mode.
+     */
+    isClosableSurface(select) {
+        const mode = this.knots[select].wrappable;
+        if (mode === BSplineWrapMode.None)
+            return BSplineWrapMode.None;
+        if (!this.knots[select].testClosable(mode))
+            return BSplineWrapMode.None;
+        if (!this.testClosableGrid(select, mode))
+            return BSplineWrapMode.None;
+        return mode;
+    }
 }
 /**  BSplineSurface3d is a parametric surface in xyz space.
  * * This (BSplineSurface3d) is an unweighted surface.   Use the separate class BSplineSurface3dH for a weighted surface.
@@ -389,7 +452,8 @@ export class BSplineSurface3d extends BSpline2dNd {
     getPointGridJSON() {
         const result = {
             points: Point3dArray.unpackNumbersToNestedArraysIJK(this.coffs, 3, this.numPolesUV(0)),
-            weighStyle: WeightStyle.UnWeighted,
+            weighStyle: WeightStyle.WeightsAlreadyAppliedToCoordinates,
+            weightStyle: WeightStyle.UnWeighted,
             numCartesianDimensions: 3,
         };
         return result;
@@ -401,23 +465,24 @@ export class BSplineSurface3d extends BSpline2dNd {
      * in classic over-clamped manner
      */
     copyKnots(select, includeExtraEndKnot) { return this.knots[select].copyKnots(includeExtraEndKnot); }
-    /** Create a bspline surface.
+    /**
+     * Create a bspline surface.
      * * This `create` variant takes control points in a "flattened" array, with
      *  points from succeeding U rows packed together in one array.  Use `createGrid` if the points are in
      *  a row-by-row grid structure
      * * knotArrayU and knotArrayV are optional -- uniform knots are implied if they are omitted (undefined).
-     * *  When knots are given, two knot count conditions are recognized:
-     * * + If poleArray.length + order == knotArray.length, the first and last are assumed to be the
+     * * When knots are given, two knot count conditions are recognized:
+     *     * If poleArray.length + order == knotArray.length, the first and last are assumed to be the
      *      extraneous knots of classic clamping.
-     * * + If poleArray.length + order == knotArray.length + 2, the knots are in modern form that does not have
+     *     * If poleArray.length + order == knotArray.length + 2, the knots are in modern form that does not have
      *      the classic unused first and last knot.
      * @param controlPointArray Array of points, ordered along the U direction.
-     * @param numPoleU number of poles in each row in the U direction.
+     * @param numPoleU number of poles in each row
      * @param orderU order for the U direction polynomial (`order` is one more than the `degree`.  "cubic" polynomial is order 4.)
-     * @param KnotArrayU knots for the V direction.  See note above about knot counts.
-     * @param numPoleV number of poles in each row in the U direction.
+     * @param knotArrayU knots for the V direction.  See note above about knot counts.
+     * @param numPoleV number of rows of poles
      * @param orderV order for the V direction polynomial (`order` is one more than the `degree`.  "cubic" polynomial is order 4.)
-     * @param KnotArrayV knots for the V direction.  See note above about knot counts.
+     * @param knotArrayV knots for the V direction.  See note above about knot counts.
      */
     static create(controlPointArray, numPolesU, orderU, knotArrayU, numPolesV, orderV, knotArrayV) {
         let numPoles = controlPointArray.length;
@@ -454,40 +519,41 @@ export class BSplineSurface3d extends BSpline2dNd {
         const surface = new BSplineSurface3d(numPolesU, numPolesV, knotsU, knotsV, coffs);
         return surface;
     }
-    /** Create a bspline surface.
+    /**
+     * Create a bspline surface.
      * * This `create` variant takes control points in a "grid" array, with the points from
-     * each grid row `[rowIndex]` being an independent array `points[rowIndex][indexAlongRow][x,y,z]`
+     *   each grid row `[rowIndex]` being an independent array `points[rowIndex][indexAlongRow][x,y,z]`
      * * knotArrayU and knotArrayV are optional -- uniform knots are implied if they are omitted (undefined).
-     * *  When knots are given, two knot count conditions are recognized:
-     * * + If poleArray.length + order == knotArray.length, the first and last are assumed to be the
+     * * When knots are given, two knot count conditions are recognized in each direction:
+     *    * If poleArray.length + order == knotArray.length, the first and last are assumed to be the
      *      extraneous knots of classic clamping.
-     * * + If poleArray.length + order == knotArray.length + 2, the knots are in modern form that does not have
+     *    * If poleArray.length + order == knotArray.length + 2, the knots are in modern form that does not have
      *      the classic unused first and last knot.
-     * @param controlPointArray Array of points, ordered along the U direction.
-     * @param numPoleU number of poles in each row in the U direction.
+     * @param points Array of points, ordered along the U direction.
      * @param orderU order for the U direction polynomial (`order` is one more than the `degree`.  "cubic" polynomial is order 4.)
-     * @param KnotArrayU knots for the V direction.  See note above about knot counts.
-     * @param numPoleV number of poles in each row in the U direction.
+     * @param knotArrayU knots for the V direction.  See note above about knot counts.
      * @param orderV order for the V direction polynomial (`order` is one more than the `degree`.  "cubic" polynomial is order 4.)
-     * @param KnotArrayV knots for the V direction.  See note above about knot counts.
+     * @param knotArrayV knots for the V direction.  See note above about knot counts.
      */
     static createGrid(points, orderU, knotArrayU, orderV, knotArrayV) {
         const numPolesV = points.length;
         const numPolesU = points[0].length;
         const numPoles = numPolesU * numPolesV;
+        if (3 !== points[0][0].length)
+            return undefined;
+        if (!this.validOrderAndPoleCounts(orderU, numPolesU, orderV, numPolesV, numPoles))
+            return undefined;
         // shift knots-of-interest limits for overclamped case ...
         const numKnotsU = knotArrayU ? knotArrayU.length : numPolesU + orderU - 2;
         const numKnotsV = knotArrayV ? knotArrayV.length : numPolesV + orderV - 2;
         const skipFirstAndLastU = (numPolesU + orderU === numKnotsU);
         const skipFirstAndLastV = (numPolesV + orderV === numKnotsV);
-        if (!this.validOrderAndPoleCounts(orderU, numPolesU, orderV, numPolesV, numPoles))
-            return undefined;
         const knotsU = knotArrayU ?
             KnotVector.create(knotArrayU, orderU - 1, skipFirstAndLastU) :
             KnotVector.createUniformClamped(numPolesU, orderU - 1, 0.0, 1.0);
         const knotsV = knotArrayV ?
             KnotVector.create(knotArrayV, orderV - 1, skipFirstAndLastV) :
-            KnotVector.createUniformClamped(numPolesU, orderU - 1, 0.0, 1.0);
+            KnotVector.createUniformClamped(numPolesV, orderV - 1, 0.0, 1.0);
         const coffs = new Float64Array(3 * numPolesU * numPolesV);
         let i = 0;
         for (const row of points) {
@@ -497,8 +563,7 @@ export class BSplineSurface3d extends BSpline2dNd {
                 coffs[i++] = xyz[2];
             }
         }
-        const surface = new BSplineSurface3d(numPolesU, numPolesV, knotsU, knotsV, coffs);
-        return surface;
+        return new BSplineSurface3d(numPolesU, numPolesV, knotsU, knotsV, coffs);
     }
     /**
      * Return a complete copy of the bspline surface.
@@ -553,6 +618,14 @@ export class BSplineSurface3d extends BSpline2dNd {
         const knotV = this.knots[1].fractionToKnot(fractionV);
         return this.knotToPointAndDerivatives(knotU, knotV, result);
     }
+    /** Implementation of the UVSurface interface; allows `PolyfaceBuilder.addUVGridBody` to facet this B-spline surface. */
+    uvFractionToPoint(u, v) {
+        return this.fractionToPoint(u, v);
+    }
+    /** Implementation of the UVSurface interface; allows `PolyfaceBuilder.addUVGridBody` to facet this B-spline surface. */
+    uvFractionToPointAndTangents(u, v, result) {
+        return this.fractionToPointAndDerivatives(u, v, result);
+    }
     /** test for identical counts and near-equal coordinates */
     isAlmostEqual(other) {
         if (other instanceof BSplineSurface3d) {
@@ -595,13 +668,20 @@ export class BSplineSurface3dH extends BSpline2dNd {
     constructor(numPolesU, numPolesV, knotsU, knotsV, coffs) {
         super(numPolesU, numPolesV, 4, knotsU, knotsV, coffs);
     }
-    /** Return a simple array of the control points. */
+    /** Unpack the control points to a Point4d array of form [wx,wy,wz,w]. */
     copyPoints4d() { return Point4dArray.unpackToPoint4dArray(this.coffs); }
-    /** Return a simple array of the control points. */
+    /**
+     * Unpack the control points to a Point3d array and an array of weights.
+     * @param points output xyz, weighted by default formatter
+     * @param weights output weights
+     * @param formatter optional xyz formatter. By default, returns a Point3d of form [wx,wy,wz].
+     */
     copyPointsAndWeights(points, weights, formatter = (x, y, z) => Point3d.create(x, y, z)) {
         Point4dArray.unpackFloat64ArrayToPointsAndWeights(this.coffs, points, weights, formatter);
     }
-    /** unpack from xyzw xyzw ... to packed xyz, optionally unweighted
+    /**
+     * Copy the control points to a packed 3D array.
+     * @param unweight if true, output array has form x,y,z; if false, output array has form wx,wy,wz.
      */
     copyXYZToFloat64Array(unweight) {
         const numPoints = Math.floor(this.coffs.length / 4);
@@ -623,7 +703,7 @@ export class BSplineSurface3dH extends BSpline2dNd {
         }
         return result;
     }
-    /** unpack from xyzw xyzw ... to packed xyz, optionally unweighted
+    /** unpack from xyzw xyzw ... to packed weights
      */
     copyWeightsToFloat64Array() {
         const numPoints = Math.floor(this.coffs.length / 4);
@@ -640,24 +720,23 @@ export class BSplineSurface3dH extends BSpline2dNd {
      * in classic over-clamped manner
      */
     copyKnots(select, includeExtraEndKnot) { return this.knots[select].copyKnots(includeExtraEndKnot); }
-    /** Create a weighted bspline surface, with control points and weights each organized as flattened array of points continuing from one U row to the next.
-     * * This `create` variant takes control points in a "flattened" array, with
-     *  points from succeeding U rows packed together in one array.  Use `createGrid` if the points are in
-     *  a deeper grid array structure.
+    /**
+     * Create a weighted bspline surface, with control points and weights each organized as flattened arrays continuing from one U row to the next.
+     * * Use `createGrid` if the control points are in a deeper grid array structure.
      * * knotArrayU and knotArrayV are optional -- uniform knots are implied if they are omitted (undefined).
-     * *  When knots are given, two knot count conditions are recognized:
-     * * * If poleArray.length + order == knotArray.length, the first and last are assumed to be the
+     * * When knots are given, two knot count conditions are recognized:
+     *    * If poleArray.length + order == knotArray.length, the first and last are assumed to be the
      *      extraneous knots of classic clamping.
-     * * * If poleArray.length + order == knotArray.length + 2, the knots are in modern form that does not have
+     *    * If poleArray.length + order == knotArray.length + 2, the knots are in modern form that does not have
      *      the classic unused first and last knot.
-     * @param controlPointArray Array of points, ordered along the U direction.
-     * @param weightArray array of weights, ordered along the U direction.
-     * @param numPoleU number of poles in each row in the U direction.
+     * @param controlPointArray Array of [wx,wy,wz] points, ordered along the U direction.
+     * @param weightArray array of weights, ordered along the U direction. If undefined, unit weights are installed.
+     * @param numPolesU number of poles in each row in the U direction.
      * @param orderU order for the U direction polynomial (`order` is one more than the `degree`.  "cubic" polynomial is order 4.)
-     * @param KnotArrayU optional knots for the V direction.  See note above about knot counts.
-     * @param numPoleV number of poles in each row in the U direction.
+     * @param knotArrayU optional knots for the V direction.  See note above about knot counts.
+     * @param numPolesV number of poles in each column in the V direction (the number of rows).
      * @param orderV order for the V direction polynomial (`order` is one more than the `degree`.  "cubic" polynomial is order 4.)
-     * @param KnotArrayV optional knots for the V direction.  See note above about knot counts.
+     * @param knotArrayV optional knots for the V direction.  See note above about knot counts.
      */
     static create(controlPointArray, weightArray, numPolesU, orderU, knotArrayU, numPolesV, orderV, knotArrayV) {
         const numPoles = numPolesU * numPolesV;
@@ -673,62 +752,95 @@ export class BSplineSurface3dH extends BSpline2dNd {
         const knotsV = knotArrayV ?
             KnotVector.create(knotArrayV, orderV - 1, skipFirstAndLastV) :
             KnotVector.createUniformClamped(numPolesV, orderV - 1, 0.0, 1.0);
+        if (undefined === weightArray)
+            weightArray = Array(numPoles).fill(1.0); // unit weights
         const coffs = Point4dArray.packPointsAndWeightsToFloat64Array(controlPointArray, weightArray);
         if (coffs === undefined || coffs.length !== 4 * numPolesU * numPolesV)
             return undefined;
         const surface = new BSplineSurface3dH(numPolesU, numPolesV, knotsU, knotsV, coffs);
         return surface;
     }
-    /** Create a bspline with given knots.
-     *
-     *   Two count conditions are recognized in each direction:
-     *
-     * ** If poleArray.length + order == knotArray.length, the first and last are assumed to be the
+    /**
+     * Create a bspline surface with given knots.
+     * * This `create` variant takes control points in a "grid" array, with the points from
+     *   each grid row `[rowIndex]` being an independent array `points[rowIndex][indexAlongRow][x,y,z,w]`
+     * * knotArrayU and knotArrayV are optional -- uniform knots are implied if they are omitted (undefined).
+     * * When knots are given, two count conditions are recognized in each direction:
+     *    * If poleArray.length + order == knotArray.length, the first and last are assumed to be the
      *      extraneous knots of classic clamping.
-     * ** If poleArray.length + order == knotArray.length + 2, the knots are in modern form.
-     *
+     *    * If poleArray.length + order == knotArray.length + 2, the knots are in modern form that does not have
+     *      the classic unused first and last knot.
+     * @param xyzwGrid Array of points, ordered along the U direction.
+     * @param weightStyle how the points are weighted
+     * @param orderU order for the U direction polynomial (`order` is one more than the `degree`.  "cubic" polynomial is order 4.)
+     * @param knotArrayU knots for the V direction.  See note above about knot counts.
+     * @param orderV order for the V direction polynomial (`order` is one more than the `degree`.  "cubic" polynomial is order 4.)
+     * @param knotArrayV knots for the V direction.  See note above about knot counts.
      */
     static createGrid(xyzwGrid, weightStyle, orderU, knotArrayU, orderV, knotArrayV) {
         const numPolesV = xyzwGrid.length;
         const numPolesU = xyzwGrid[0].length;
         const numPoles = numPolesU * numPolesV;
+        if (4 !== xyzwGrid[0][0].length)
+            return undefined;
         if (!this.validOrderAndPoleCounts(orderU, numPolesU, orderV, numPolesV, numPoles))
             return undefined;
-        // const numPoles = numPolesU * numPolesV;
-        // shift knots-of-interest limits for overclamped case ...
-        const numKnotsU = knotArrayU.length;
-        const numKnotsV = knotArrayV.length;
-        const skipFirstAndLastU = (numPolesU + orderU === numKnotsU);
-        const skipFirstAndLastV = (numPolesV + orderV === numKnotsV);
-        const knotsU = KnotVector.create(knotArrayU, orderU - 1, skipFirstAndLastU);
-        const knotsV = KnotVector.create(knotArrayV, orderV - 1, skipFirstAndLastV);
+        // validate knot counts
+        const numKnotsU = knotArrayU ? knotArrayU.length : numPolesU + orderU - 2;
+        const numKnotsV = knotArrayV ? knotArrayV.length : numPolesV + orderV - 2;
+        const skipFirstAndLastU = (numPolesU + orderU === numKnotsU); // classic over-clamped input knots
+        if (!skipFirstAndLastU && numPolesU + orderU !== numKnotsU + 2) // modern knots
+            return undefined;
+        const skipFirstAndLastV = (numPolesV + orderV === numKnotsV); // classic
+        if (!skipFirstAndLastV && numPolesV + orderV !== numKnotsV + 2) // modern
+            return undefined;
+        const knotsU = knotArrayU ?
+            KnotVector.create(knotArrayU, orderU - 1, skipFirstAndLastU) :
+            KnotVector.createUniformClamped(numPolesU, orderU - 1, 0.0, 1.0);
+        const knotsV = knotArrayV ?
+            KnotVector.create(knotArrayV, orderV - 1, skipFirstAndLastV) :
+            KnotVector.createUniformClamped(numPolesV, orderV - 1, 0.0, 1.0);
         const coffs = new Float64Array(4 * numPoles);
-        if (weightStyle === WeightStyle.WeightsSeparateFromCoordinates) {
-            let i = 0;
-            for (const row of xyzwGrid) {
-                for (const point of row) {
-                    const w = point[3];
-                    coffs[i++] = point[0] * w;
-                    coffs[i++] = point[1] * w;
-                    coffs[i++] = point[2] * w;
-                    coffs[i++] = point[3];
+        let i = 0;
+        switch (weightStyle) {
+            case WeightStyle.WeightsSeparateFromCoordinates: {
+                for (const row of xyzwGrid) {
+                    for (const point of row) {
+                        const w = point[3];
+                        coffs[i++] = point[0] * w;
+                        coffs[i++] = point[1] * w;
+                        coffs[i++] = point[2] * w;
+                        coffs[i++] = point[3];
+                    }
                 }
+                break;
             }
-        }
-        else {
-            // implicit WeightStyle.WeightsAlreadyAppliedToCoordinates
-            let i = 0;
-            for (const row of xyzwGrid) {
-                for (const point of row) {
-                    coffs[i++] = point[0];
-                    coffs[i++] = point[1];
-                    coffs[i++] = point[2];
-                    coffs[i++] = point[3];
+            case WeightStyle.WeightsAlreadyAppliedToCoordinates: {
+                for (const row of xyzwGrid) {
+                    for (const point of row) {
+                        coffs[i++] = point[0];
+                        coffs[i++] = point[1];
+                        coffs[i++] = point[2];
+                        coffs[i++] = point[3];
+                    }
+                }
+                break;
+            }
+            case WeightStyle.UnWeighted: {
+                for (const row of xyzwGrid) {
+                    for (const point of row) {
+                        coffs[i++] = point[0];
+                        coffs[i++] = point[1];
+                        coffs[i++] = point[2];
+                        coffs[i++] = 1.0;
+                    }
                 }
+                break;
             }
+            default:
+                return undefined; // unrecognized WeightStyle
         }
-        const surface = new BSplineSurface3dH(numPolesU, numPolesV, knotsU, knotsV, coffs);
-        return surface;
+        return new BSplineSurface3dH(numPolesU, numPolesV, knotsU, knotsV, coffs);
     }
     /** Return a deep clone */
     clone() {
@@ -753,27 +865,30 @@ export class BSplineSurface3dH extends BSpline2dNd {
         const result = {
             points: Point3dArray.unpackNumbersToNestedArraysIJK(this.coffs, 4, this.numPolesUV(0)),
             numCartesianDimensions: 3,
+            weighStyle: WeightStyle.WeightsAlreadyAppliedToCoordinates,
             weightStyle: WeightStyle.WeightsAlreadyAppliedToCoordinates,
         };
         return result;
     }
-    /** Evaluate at a position given by a knot value.  */
-    knotToPoint4d(u, v) {
+    /** Evaluate at a position given by a knot value. If deweight fails, returns 000. */
+    knotToPoint4d(u, v, result) {
         this.evaluateBuffersAtKnot(u, v);
-        return Point4d.createFromPackedXYZW(this._poleBuffer, 0);
+        result = Point4d.createFromPacked(this._poleBuffer, 0, result);
+        return result ? result : Point4d.createZero();
     }
     /** Evaluate at a position given by a knot value.  */
     knotToPointAndDerivatives(u, v, result) {
         this.evaluateBuffersAtKnot(u, v, 1);
         return Plane3dByOriginAndVectors.createOriginAndVectorsWeightedArrays(this._poleBuffer, this._poleBuffer1UV[0], this._poleBuffer1UV[1], result);
     }
-    /** Evaluate the Point4d (leaving weights in the point) at given fractional coordinates. */
-    fractionToPoint4d(fractionU, fractionV) {
-        return this.knotToPoint4d(this.knots[0].fractionToKnot(fractionU), this.knots[1].fractionToKnot(fractionV));
+    /** Evaluate the Point4d (leaving weights in the point) at given fractional coordinates. If deweight fails, returns 000. */
+    fractionToPoint4d(fractionU, fractionV, result) {
+        result = this.knotToPoint4d(this.knots[0].fractionToKnot(fractionU), this.knots[1].fractionToKnot(fractionV), result);
+        return result ? result : Point4d.createZero();
     }
     /**
-     * * evaluate the surface and return the cartesian (weight = 1) point.
-     * * if the surface XYZW point has weight0, returns point3d at 000.
+     * Evaluate the surface and return the Cartesian point (weight = 1).
+     * * If the surface XYZW point has weight 0, returns 000.
      * @param fractionU u direction fraction
      * @param fractionV v direction fraction
      * @param result optional result
@@ -806,6 +921,14 @@ export class BSplineSurface3dH extends BSpline2dNd {
         const knotV = this.knots[1].fractionToKnot(fractionV);
         return this.knotToPointAndDerivatives(knotU, knotV, result);
     }
+    /** Implementation of the UVSurface interface; allows `PolyfaceBuilder.addUVGridBody` to facet this B-spline surface. */
+    uvFractionToPoint(u, v) {
+        return this.fractionToPoint(u, v);
+    }
+    /** Implementation of the UVSurface interface; allows `PolyfaceBuilder.addUVGridBody` to facet this B-spline surface. */
+    uvFractionToPointAndTangents(u, v, result) {
+        return this.fractionToPointAndDerivatives(u, v, result);
+    }
     /** test for identical counts and near-equal coordinates */
     isAlmostEqual(other) {
         if (other instanceof BSplineSurface3dH) {