BSplineCurve3dBase Class

Base class for BSplineCurve3d and BSplineCurve3dH.

• A B-spline curve consists of an array of knots, an array of poles, and a degree.
• The knot array is a non-decreasing sequence of numbers. It is also called a "knot vector".
  • The curve is a parametric function whose domain is a sub-range of its knots.
  • The API sometimes refers to a domain parameter u as a "knot", even if u is not actually an entry in the knot array.
• The curve loosely "follows" the line string formed by the poles, aka the "control polygon".
• The curve is a chain of polynomial segments, aka "spans" or "fragments". B-spline theory identifies these as Bezier curves.
• The polynomial spans all have same degree.
• Each span is controlled by order = degree + 1 contiguous points in the pole array.
• There is a strict relationship between knot and poles counts: `numPoles + order = numKnots + 2'.
• The number of spans is numSpan = numPoles - degree.
• For a span with index spanIndex:
  • The order relevant poles begin at pole index spanIndex.
  • The 2*degree relevant knots begin at knot index spanIndex.
  • The span domain is the knot range [knot[spanIndex+degree-1], knot[spanIndex+degree]].
• The curve domain is the knot range [knot[degree-1], knot[numSpan+degree-1]], or equivalently [knot[degree-1], knot[numPoles-1]]. The API refers to this domain as the "active knot interval" of the curve.

Nearly all B-spline curves are "clamped".

• This means that in the knots array, the first degree knots are equal, and the last degree knots are equal. We say the smallest knot and the largest knot have multiplicity degree.

• Clamping make the curve pass through its first and last poles, with tangents directed along the first and last edges of the control polygon.

• For instance, a cubic B-spline curve with knot vector [0,0,0,1,2,3,3,3]

  • can be evaluated at parameter values in the range [0, 3]
  • has 3 spans, with domains [0, 1], [1, 2], and [2, 3]
  • has 6 poles
  • passes through its first and last poles.

• The create methods may allow the classic convention that has an extra knot at the beginning and end of the knot vector.

  • These two extra knots are not actually needed to define the B-spline curve.
  • When the create methods recognize the classic setup (numPoles + order = numKnots), the extra knots are not saved with the BSplineCurve3dBase knots.

• The weighted variant BSplineCurve3dH has the problem that CurvePrimitive 3D typing does not allow the undefined result where a homogeneous pole has zero weight; the convention in this case is to return 000.

• Note the class relationships:

  • BSpline1dNd knows the definitional B-spline recurrence relation with no physical interpretation for the poles.
  • BsplineCurve3dBase owns a protected BSpline1dNd.
  • BsplineCurve3dBase is derived from CurvePrimitive, which creates obligation to act as a 3D curve, e.g.,
    • evaluate fraction to point and derivatives wrt fraction.
    • compute intersection with plane.
  • BSplineCurve3d and BSplineCurve3dH have variant logic driven by whether or not there are "weights" on the poles.
    • For BSplineCurve3d, the xyz value of pole calculations are "final" values for 3d evaluation.
    • For BSplineCurve3dH, various BSpline1dNd results with xyzw have to be normalized back to xyz.

• These classes do not support "periodic" variants.

  • Periodic curves historically have carried a flag (e.g., "closed") indicating that certain un-stored leading/trailing knots and poles are understood to wrap around periodically.
  • Instead, these classes carry no such flag. They represent such curves with explicitly wrapped knots/poles.

• Visualization can be found at https://www.itwinjs.org/sandbox/SaeedTorabi/BSpline/

Extends

• CurvePrimitive

Extended by

• BSplineCurve3d
• BSplineCurve3dH

Methods

Inherited methods

Properties

Inherited properties

Defined in

• bspline/BSplineCurve.ts Line 98