API Reference > geometry-core > Bspline > BSplineSurface3dH

BSplineSurface3dH Class

BsplinceCurve in xyzw homogeneous space

Extends

Implements

Methods

Name Description
constructor(numPolesU: number, numPolesV: number, poleLength: number, knotsU: KnotVector, knotsV: KnotVector): BSplineSurface3dH Protected initialize arrays for given spline dimensions.  
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.  
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): Point3d | undefined 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[], weightArray: number[], numPolesU: number, orderU: number, knotArrayU: number[] | undefined, numPolesV: number, orderV: number, knotArrayV: number[] | undefined): BSplineSurface3dH | undefined 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[]): BSplineSurface3dH | undefined 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): Transform | undefined BSpline2dNd evaluate the surface at u and v fractions.
getPoint3dPole(i: number, j: number, result?: Point3d): Point3d | undefined BSpline2dNd Get the Point3d by row and column.
getPoint3dPoleXYZW(i: number, j: number, result?: Point3d): Point3d | undefined 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 GeometryQuery 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, dz: number = 0): boolean GeometryQuery try to move the geometry by dx,dy,dz
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 GeometryQuery[] | undefined GeometryQuery 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 "bsurf" = "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 componets per pole.

Defined in

Last Updated: 13 June, 2024