API Reference > geometry-core > Bspline > BSplineSurface3dH BSplineSurface3dH Class BSpline Surface in xyzw homogeneous space Extends BSpline2dNd Implements BSplineSurface3dQuery Methods Name Description clone(): BSplineSurface3dH Return a deep clone cloneTransformed(transform: Transform): BSplineSurface3dH Return a transformed clone copyKnots(select: UVSelect, includeExtraEndKnot: boolean): number[] return a simple array form of the knots. copyPoints4d(): Point4d[] Return a simple array of the control points. copyPointsAndWeights(points: Point3d[], weights: number[], formatter: (x: number, y: number, z: number) => any = Point3d.create): void Return a simple array of the control points. copyWeightsToFloat64Array(): Float64Array unpack from xyzw xyzw ... copyXYZToFloat64Array(unweight: boolean): Float64Array unpack from xyzw xyzw ... dispatchToGeometryHandler(handler: GeometryHandler): any Second step of double dispatch: call handler.handleBSplineSurface3dH(this) extendRange(rangeToExtend: Range3d, transform?: Transform): void extend a range to include the (optionally transformed) points of this surface fractionToPoint(fractionU: number, fractionV: number, result?: Point3d): Point3d * evaluate the surface and return the cartesian (weight = 1) point. fractionToPoint4d(fractionU: number, fractionV: number): Point4d Evaluate the Point4d (leaving weights in the point) at given fractional coordinates. fractionToPointAndDerivatives(fractionU: number, fractionV: number, result?: Plane3dByOriginAndVectors): Plane3dByOriginAndVectors evaluate the surface at u and v fractions. getPointGridJSON(): PackedPointGrid Return control points json arrays. getPole(i: number, j: number, result?: Point3d): undefined | Point3d Return a pole by u and v indices isAlmostEqual(other: any): boolean test for identical counts and near-equal coordinates isInPlane(plane: Plane3dByOriginAndUnitNormal): boolean Test if all poles are in a plane isSameGeometryClass(other: any): boolean Test if other is an instance of `BSplineSurface3dH knotToPoint(knotU: number, knotV: number, result?: Point3d): Point3d * evaluate the surface and return the cartesian (weight = 1) point. knotToPoint4d(u: number, v: number): Point4d Evaluate at a position given by a knot value. knotToPointAndDerivatives(u: number, v: number, result?: Plane3dByOriginAndVectors): Plane3dByOriginAndVectors Evaluate at a position given by a knot value. tryTransformInPlace(transform: Transform): boolean Apply the transform to the poles create(controlPointArray: Point3d[] | Float64Array, weightArray: number[] | Float64Array, numPolesU: number, orderU: number, knotArrayU: undefined | number[] | Float64Array, numPolesV: number, orderV: number, knotArrayV: undefined | number[] | Float64Array): undefined | BSplineSurface3dH Static 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. createGrid(xyzwGrid: number[][][], weightStyle: WeightStyle, orderU: number, knotArrayU: number[], orderV: number, knotArrayV: number[]): undefined | BSplineSurface3dH Static Create a bspline with given knots. Inherited methods Name Inherited from Description degreeUV(select: UVSelect): number BSpline2dNd Return the degree (one less than order) for the select direction (0 or 1) evaluateBuffersAtKnot(u: number, v: number, numDerivative: number = 0): void BSpline2dNd Evaluate the _basisBuffer, _poleBuffer and (optionally) _basisBuffer1 and _poleBuffer1 arrays at given knot. extendRangeXYZ(rangeToExtend: Range3d, transform?: Transform): void BSpline2dNd extend a range, treating each block as simple XYZ extendRangeXYZH(rangeToExtend: Range3d, transform?: Transform): void BSpline2dNd extend a range, treating each block as homogeneous xyzw, with weight at offset 3 fractionToRigidFrame(fractionU: number, fractionV: number, result?: Transform): undefined | Transform BSpline2dNd evaluate the surface at u and v fractions. getPoint3dPole(i: number, j: number, result?: Point3d): undefined | Point3d BSpline2dNd Get the Point3d by row and column. getPoint3dPoleXYZW(i: number, j: number, result?: Point3d): undefined | Point3d BSpline2dNd Get the Point3d by row and column, projecting the weight away to get to xyz isClosable(select: UVSelect): boolean BSpline2dNd 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. numPolesTotal(): number BSpline2dNd Return the total number of poles (product of x and y pole counts) numPolesUV(select: UVSelect): number BSpline2dNd Return the number of poles for the select direction (0 or 1) numSpanUV(select: UVSelect): number BSpline2dNd Return the number of spans (INCLUDING NULL SPANS) for the select direction (0 or 1) numberToUVSelect(value: number): UVSelect BSpline2dNd Return 0 for 0 input, 1 for any nonzero input. orderUV(select: UVSelect): number BSpline2dNd Return the order (one more than degree) for the select direction (0 or 1) poleStepUV(select: UVSelect): number BSpline2dNd Return the step between adjacent poles for the select direction (0 or 1) range(transform?: Transform, result?: Range3d): Range3d BSpline2dNd return the range of the entire (tree) GeometryQuery reverseInPlace(select: UVSelect): void BSpline2dNd Reverse the parameter direction for either u or v. setWrappable(select: UVSelect, value: BSplineWrapMode): void BSpline2dNd Set the flag indicating the bspline might be suitable for having wrapped "closed" interpretation. spanFractionToKnot(select: UVSelect, span: number, localFraction: number): number BSpline2dNd Map a position, specified as (uv direction, bezier span, fraction within the bezier), to an overall knot value. spanFractionsToBasisFunctions(select: UVSelect, spanIndex: number, spanFraction: number, f: Float64Array, df?: Float64Array): void BSpline2dNd Evaluate basis functions given sumPoleBufferForSpan(spanIndexU: number, spanIndexV: number): void BSpline2dNd sum poles by the weights in the basisBuffer, using poles for given span sumpoleBufferDerivativesForSpan(spanIndexU: number, spanIndexV: number): void BSpline2dNd sum derivatives by the weights in the basisBuffer, using poles for given span tryTranslateInPlace(dx: number, dy: number = 0.0, dz: number = 0.0): boolean BSpline2dNd try to move the geometry by dx,dy,dz areAlmostEqual(a: undefined | GeometryQuery, b: undefined | GeometryQuery): boolean Static BSpline2dNd apply instance method isAlmostEqual if both are defined. validOrderAndPoleCounts(orderU: number, numPolesU: number, orderV: number, numPolesV: number, numUV: number): boolean Static BSpline2dNd Confirm that order and pole counts agree for both u and v directions Inherited properties Name Type Inherited from Description _basisBuffer1UV Protected Float64Array[] BSpline2dNd a scratch array sized for order numbers _basisBufferUV Protected Float64Array[] BSpline2dNd a scratch array sized for order numbers _poleBuffer Protected Float64Array BSpline2dNd a scratch array sized for one pole _poleBuffer1UV Protected Float64Array[] BSpline2dNd array of 2 scratch array, each sized for one pole children Accessor ReadOnly undefined | GeometryQuery[] BSpline2dNd return GeometryQuery children for recursive queries.* leaf classes do not need to implement. coffs Float64Array BSpline2dNd flat array of coordinate daa, blocked by poleDimension and row geometryCategory Readonly "bsurf" BSpline2dNd String name for schema properties knots KnotVector[] BSpline2dNd Array of (exactly 2) knot vectors for the u, v directions poleDimension number BSpline2dNd Number of components per pole. Defined in bspline/BSplineSurface.ts Line 752 Last Updated: 11 June, 2024