BSplineCurve3d Class
A BSplineCurve3d is a bspline curve whose poles are Point3d. See BSplineCurve3dBase for description of knots, order, degree.
Extends
Methods
| Name | Description | |
|---|---|---|
| constructor(poleDimension: number, numPoles: number, order: number, knots: KnotVector): BSplineCurve3d Protected | ||
| clone(): BSplineCurve3d | Return a deep clone | |
| cloneTransformed(transform: Transform): BSplineCurve3d | Return a transformed deep clone. | |
| computeStrokeCountForOptions(options?: StrokeOptions): number | Assess length and turn to determine a stroke count. | |
| copyKnots(includeExtraEndKnot: boolean): number[] | return a simple array form of the knots. | |
| copyPoints(): any[] | Return a simple array of arrays with the control points as [[x,y,z],[x,y,z],..] |
|
| copyPointsFloat64Array(): Float64Array | Return a simple array of the control points coordinates | |
| dispatchToGeometryHandler(handler: GeometryHandler): any | Second step of double dispatch: call handler.handleBSplineCurve3d(this) |
|
| emitStrokableParts(handler: IStrokeHandler, options?: StrokeOptions): void | Emit beziers or strokes (selected by the stroke options) to the handler. | |
| emitStrokes(dest: LineString3d, options?: StrokeOptions): void | Append strokes to a linestring. | |
| evaluatePointAndDerivativeInSpan(spanIndex: number, spanFraction: number): Ray3d | Evaluate point and derivative vector at a position given by fractional position within a span. | |
| evaluatePointInSpan(spanIndex: number, spanFraction: number): Point3d | Evaluate at a position given by fractional position within a span. | |
| extendRange(rangeToExtend: Range3d, transform?: Transform): void | Extend a range so in includes the range of this curve | |
| fractionToPoint(fraction: number, result?: Point3d): Point3d | Evaluate the curve point at a fractional of the entire knot range. | |
| fractionToPointAnd2Derivatives(fraction: number, result?: Plane3dByOriginAndVectors): Plane3dByOriginAndVectors | Construct a plane with | |
| fractionToPointAndDerivative(fraction: number, result?: Ray3d): Ray3d | Evaluate the curve point at a fractional of the entire knot range. | |
| getPolePoint3d(poleIndex: number, result?: Point3d): Point3d | undefined | Get a pole as simple Point3d. | |
| getPolePoint4d(poleIndex: number, result?: Point4d): Point4d | undefined | Get a pole as Point4d with weight 1 | |
| getSaturatedBezierSpan3d(spanIndex: number, result?: BezierCurveBase): BezierCurveBase | undefined | Return a CurvePrimitive (which is a BezierCurve3d) for a specified span of this curve. | |
| getSaturatedBezierSpan3dH(spanIndex: number, result?: BezierCurveBase): BezierCurve3dH | undefined | Return a CurvePrimitive (which is a BezierCurve3dH) for a specified span of this curve. | |
| getSaturatedBezierSpan3dOr3dH(spanIndex: number, prefer3dH: boolean, result?: BezierCurveBase): BezierCurveBase | undefined | Return a BezierCurveBase for this curve. | |
| isAlmostEqual(other: any): boolean | test if almost the same curve as other |
|
| isInPlane(plane: Plane3dByOriginAndUnitNormal): boolean | test if this curve is entirely within plane. | |
| isSameGeometryClass(other: any): boolean | test of other is an instance of BSplineCurve3d |
|
| knotToPoint(u: number, result?: Point3d): Point3d | Evaluate at a position given by a knot value. | |
| knotToPointAnd2Derivatives(u: number, result?: Plane3dByOriginAndVectors): Plane3dByOriginAndVectors | Evaluate at a position given by a knot value. | |
| knotToPointAndDerivative(u: number, result?: Ray3d): Ray3d | Evaluate at a position given by a knot value. | |
| quickLength(): number | Return the control polygon length as approximation (always overestimate) of the curve length. | |
| setWrappable(value: BSplineWrapMode): void | Set the flag indicating the bspline might be suitable for having wrapped "closed" interpretation. | |
| spanFractionToKnot(span: number, localFraction: number): number | Convert spanIndex and localFraction to a knot. |
|
| tryTransformInPlace(transform: Transform): boolean | Apply transform to the poles. |
|
| create(poleArray: Float64Array | Point3d[], knotArray: Float64Array | number[], order: number): BSplineCurve3d | undefined Static | Create a bspline with given knots. | |
| createUniformKnots(poles: Point3d[] | Float64Array | GrowableXYZArray, order: number): BSplineCurve3d | undefined Static | Create a bspline with uniform knots. |
Inherited methods
| Name | Inherited from | Description |
|---|---|---|
| addMappedStrokesToLineString3D(map: StrokeCountMap, linestring: LineString3d): number | CurvePrimitive | * evaluate strokes at fractions indicated in a StrokeCountMap. |
| announceClipIntervals(_clipper: Clipper, _announce?: AnnounceNumberNumberCurvePrimitive): boolean | CurvePrimitive | Find intervals of this curvePrimitive that are interior to a clipper |
| appendPlaneIntersectionPoints(plane: PlaneAltitudeEvaluator, result: CurveLocationDetail[]): number | BSplineCurve3dBase | Implement CurvePrimitive.appendPlaneIntersections |
| clonePartialCurve(_fractionA: number, _fractionB: number): CurvePrimitive | undefined | CurvePrimitive | Return (if possible) a curve primitive which is a portion of this curve. |
| closestPoint(spacePoint: Point3d, _extend: boolean): CurveLocationDetail | undefined | BSplineCurve3dBase | Search for the curve point that is closest to the spacePoint. |
| collectBezierSpans(prefer3dH: boolean): BezierCurveBase[] | BSplineCurve3dBase | Return an array with this curve's bezier fragments. |
| collectCurvePrimitives(collectorArray?: CurvePrimitive[], smallestPossiblePrimitives: boolean = false): CurvePrimitive[] | CurvePrimitive | Return an array containing only the curve primitives. |
| collectCurvePrimitivesGo(collectorArray: CurvePrimitive[], _smallestPossiblePrimitives: boolean): void | CurvePrimitive | Return an array containing only the curve primitives. |
| curveLength(): number | CurvePrimitive | return the length of the curve. |
| curveLengthBetweenFractions(fraction0: number, fraction1: number): number | CurvePrimitive | Returns a (high accuracy) length of the curve between fractional positions |
| curveLengthWithFixedIntervalCountQuadrature(fraction0: number, fraction1: number, numInterval: number, numGauss: number = 5): number | CurvePrimitive | * Run an integration (with a default gaussian quadrature) with a fixed fractional step |
| endPoint(): Point3d | BSplineCurve3dBase | Return the end point of the curve |
| fractionAndDistanceToPointOnTangent(fraction: number, distance: number): Point3d | CurvePrimitive | Construct a point extrapolated along tangent at fraction. |
| fractionToFrenetFrame(fraction: number, result?: Transform): Transform | undefined | CurvePrimitive | Construct a frenet frame: |
| fractionToPointAndUnitTangent(fraction: number, result?: Ray3d): Ray3d | CurvePrimitive | Returns a ray whose origin is the curve point and direction is the unit tangent. |
| getFractionToDistanceScale(): number | undefined | CurvePrimitive | * If the curve primitive has distance-along-curve strictly proportional to curve fraction, return true |
| moveSignedDistanceFromFraction(startFraction: number, signedDistance: number, allowExtension: boolean, result?: CurveLocationDetail): CurveLocationDetail | CurvePrimitive | * (Attempt to) find a position on the curve at a signed distance from start fraction. |
| moveSignedDistanceFromFractionGeneric(startFraction: number, signedDistance: number, allowExtension: boolean, result?: CurveLocationDetail): CurveLocationDetail Protected | CurvePrimitive | Generic algorithm to search for point at signed distance from a fractional startPoint. |
| poleIndexToDataIndex(poleIndex: number): number | undefined | BSplineCurve3dBase | Given a pole index, return the starting index for the contiguous array. |
| range(transform?: Transform, result?: Range3d): Range3d | GeometryQuery | return the range of the entire (tree) GeometryQuery |
| reverseInPlace(): void | BSplineCurve3dBase | Reverse the curve in place. |
| startPoint(): Point3d | BSplineCurve3dBase | Return the start point of the curve. |
| tryTranslateInPlace(dx: number, dy: number = 0, dz: number = 0): boolean | GeometryQuery | try to move the geometry by dx,dy,dz |
| installStrokeCountMap(curve: CurvePrimitive, curveMap: StrokeCountMap, parentMap?: StrokeCountMap): void Static | CurvePrimitive | final install step to save curveMap in curve. |
Properties
| Name | Type | Description | |
|---|---|---|---|
| isClosable Accessor ReadOnly | BSplineWrapMode | Test knots, control points, and wrappable flag to see if all agree for a possible wrapping. |
Inherited properties
| Name | Type | Inherited from | Description |
|---|---|---|---|
| _bcurve Protected | BSpline1dNd | BSplineCurve3dBase | The underlying blocked-pole spline, with simple x,y,z poles |
| children Accessor ReadOnly | GeometryQuery[] | undefined | GeometryQuery | return GeometryQuery children for recursive queries. * leaf classes do not need to implement. |
| curvePrimitiveType | "bsplineCurve" = "bsplineCurve" | BSplineCurve3dBase | String name for schema properties |
| degree Accessor ReadOnly | number | BSplineCurve3dBase | Return the degree (one less than the order) of the curve |
| geometryCategory | "curvePrimitive" = "curvePrimitive" | CurvePrimitive | String name for schema properties |
| isExtensibleFractionSpace Accessor ReadOnly | boolean | CurvePrimitive | * Returns true if the curve's fraction queries extend beyond 0..1. * Base class default implementation returns false. * These class (and perhaps others in the future) will return true: * LineSegment3d * LineString3d * Arc3d |
| numPoles Accessor ReadOnly | number | BSplineCurve3dBase | Return the number of poles |
| numSpan Accessor ReadOnly | number | BSplineCurve3dBase | Return the number of bezier spans in the curve. Note that this number includes the number of null spans at repeated knows |
| order Accessor ReadOnly | number | BSplineCurve3dBase | Return the order (one more than degree) of the curve |
| strokeData | undefined | StrokeCountMap | CurvePrimitive | data attached during stroking for facets. |
Defined in
Last Updated: 13 June, 2024