Moose::BSpline Class Reference

Class implementing a uniform clamped B-Spline curve. More...

#include <BSpline.h>

Public Member Functions
	BSpline (const unsigned int degree, const libMesh::Point &start_point, const libMesh::Point &end_point, const libMesh::RealVectorValue &start_direction, const libMesh::RealVectorValue &end_direction, const unsigned int cps_per_half, const libMesh::Real sharpness)
libMesh::Point	getPoint (const libMesh::Real t) const
	Evaluate the BSpline interpolation at given value of t.

Private Member Functions
std::vector< libMesh::Real >	buildKnotVector () const
	Internal method for building the knot vector given the degree and control points.
std::vector< libMesh::Point >	createControlPoints () const
	Creates a vector control points from the SplineUtils set of functions.
libMesh::Real	CdBBasis (const libMesh::Real t, const unsigned int i, const unsigned int j) const
	Evaluates the the basis function for a B-Spline according to the Cox-de-Boor recursive formula.
libMesh::Real	firstCoeff (const libMesh::Real t, const unsigned int i, const unsigned int j) const
	Submethod used in CdBBasis routine.
libMesh::Real	secondCoeff (const libMesh::Real t, const unsigned int i, const unsigned int j) const
	Submethod used in CdBBasis routine.

Private Attributes
const unsigned int	_degree
	The polynomial degree of the B-Spline.
const libMesh::Point	_start_point
	starting point of spline
const libMesh::Point	_end_point
	ending point of spline
const libMesh::RealVectorValue	_start_dir
	starting direction of spline
const libMesh::RealVectorValue	_end_dir
	ending direction of spline
const unsigned int	_cps_per_half
	number of control points per half of the spline (vertex is auto-included)
const libMesh::Real	_sharpness
	sharpness of the curve
const std::vector< libMesh::Point >	_control_points
	The control points.
const std::vector< libMesh::Real >	_knot_vector
	The knot vector.

Detailed Description

Class implementing a uniform clamped B-Spline curve.

Reference used for implementation: https://mat.fsv.cvut.cz/gcg/sbornik/prochazkova.pdf The B-Spline is uniform because of the spacings in the knot vector The B-Spline is clamped because the knot vector starts (and ends) with (degree + 1) 0s (and 1s) Clamped means that it passes through the specified start and end points with specified slopes

Definition at line 25 of file BSpline.h.

Constructor & Destructor Documentation

BSpline()

Moose::BSpline::BSpline	(	const unsigned int	degree,
		const libMesh::Point &	start_point,
		const libMesh::Point &	end_point,
		const libMesh::RealVectorValue &	start_direction,
		const libMesh::RealVectorValue &	end_direction,
		const unsigned int	cps_per_half,
		const libMesh::Real	sharpness
	)

Definition at line 18 of file BSpline.C.

  : _degree(degree),
    _start_point(start_point),
    _end_point(end_point),
    _start_dir(start_direction),
    _end_dir(end_direction),
    _cps_per_half(cps_per_half),
    _sharpness(sharpness),
    _control_points(createControlPoints()),
    _knot_vector(buildKnotVector())
{
}

Member Function Documentation

buildKnotVector()

std::vector< libMesh::Real > Moose::BSpline::buildKnotVector ( ) const

private

Internal method for building the knot vector given the degree and control points.

Definition at line 61 of file BSpline.C.

{
  std::vector<libMesh::Real> knot_vector(_degree, 0); // initialize bottom to zeros
 
  const unsigned int num_points_left = _control_points.size() + 1 - _degree;
  if (_control_points.size() < _degree + 1)
    mooseError("Number of control points must be greater than or equal to degree + 1!");
 
  for (const auto i : make_range(num_points_left))
  {
    knot_vector.push_back(i); // count up
    mooseAssert(i < _control_points.size(),
                "i must be less than the number of control points because of 0 indexing.");
  }
 
  // Filling with int(degree + 1) 0s at the beginning and 1s at the end makes the B-spline go
  // through the start and end point Note: the "+1" comes from the loop above which starts at 0 and
  // ends at num_points_left - 1
  for (const auto i : make_range(_degree))
  {
    libmesh_ignore(i);
    knot_vector.push_back(num_points_left - 1);
  }
 
  // Normalize values s.t. the the max value is 1.
  // This must be done to have a constant domain of t to be between 0 and 1 (inclusive).
  // NOTE: the spacing is uniform, making this a uniform BSpline
  for (auto & value : knot_vector)
  {
    value /= (num_points_left - 1);
    mooseAssert(value <= 1.0 && value >= 0.0,
                "knot_vector must be normalized to 1 with minimum value 0.");
  }
 
  return knot_vector;
}

CdBBasis()

libMesh::Real Moose::BSpline::CdBBasis ( const libMesh::Real  t, const unsigned int  i, const unsigned int  j  ) const

private

Evaluates the the basis function for a B-Spline according to the Cox-de-Boor recursive formula.

Parameters

t	parameter t in [0,1]
i	index corresponding to which control point
j	degree of the basis funtion

Returns

scalar quantity for the contribution of the basis function at i in the sum.

Definition at line 99 of file BSpline.C.

{
  mooseAssert(i + 1 < _knot_vector.size(), "Out of bounds access in knot vector");
  mooseAssert(_knot_vector[i] <= _knot_vector[i + 1],
              "Knot vector is ill-formatted. Ensure values are increasing." +
                  Moose::stringify(_knot_vector));
  if (j == 0)
    return ((t < _knot_vector[i + 1]) && (_knot_vector[i] <= t)) ? 1 : 0;
  else
    return BSpline::firstCoeff(t, i, j) * BSpline::CdBBasis(t, i, j - 1) +
           BSpline::secondCoeff(t, i, j) * BSpline::CdBBasis(t, i + 1, j - 1);
}

Referenced by CdBBasis(), and getPoint().

createControlPoints()

std::vector< libMesh::Point > Moose::BSpline::createControlPoints ( ) const

private

Creates a vector control points from the SplineUtils set of functions.

call SplineUtils function

Definition at line 51 of file BSpline.C.

{
  std::vector<libMesh::Point> cps;
  cps = SplineUtils::bSplineControlPoints(
      _start_point, _end_point, _start_dir, _end_dir, _cps_per_half, _sharpness);
  return cps;
}

firstCoeff()

libMesh::Real Moose::BSpline::firstCoeff ( const libMesh::Real  t, const unsigned int  i, const unsigned int  j  ) const

private

Submethod used in CdBBasis routine.

Parameters

t	parameter t in [0,1]
i	index corresponding to which control point
j	degree of the basis funtion

Definition at line 113 of file BSpline.C.

{
  mooseAssert(i + j < _knot_vector.size(), "Out of bounds access in knot vector");
  const auto ti = _knot_vector[i];
  const auto tij = _knot_vector[i + j];
  if (ti != tij)
    return (t - ti) / (tij - ti);
  else
    return 0;
}

Referenced by CdBBasis().

getPoint()

libMesh::Point Moose::BSpline::getPoint

(

const libMesh::Real

t

)

const

Evaluate the BSpline interpolation at given value of t.

Parameters

t	the parameter value, must lie in [0,1]

Returns

libMesh::Point type with format (x,y,z)

Definition at line 38 of file BSpline.C.

{
  mooseAssert((t >= 0) && (t <= 1), "t should be in [0, 1]. t=" + std::to_string(t));
  libMesh::Point returnPoint(0, 0, 0);
  if (t == 1.0)
    return _control_points.back();
  for (const auto i : index_range(_control_points))
    returnPoint += BSpline::CdBBasis(t, i, _degree) * _control_points[i];
 
  return returnPoint;
}

Referenced by BSplineCurveGenerator::generate().

secondCoeff()

libMesh::Real Moose::BSpline::secondCoeff ( const libMesh::Real  t, const unsigned int  i, const unsigned int  j  ) const

private

Submethod used in CdBBasis routine.

Parameters

t	parameter t in [0,1]
i	index corresponding to which control point
j	degree of the basis funtion

Definition at line 125 of file BSpline.C.

{
  mooseAssert(i + j + 1 < _knot_vector.size(), "Out of bounds access in knot vector");
  libMesh::Real ti1 = _knot_vector[i + 1];
  libMesh::Real tij1 = _knot_vector[i + j + 1];
  if (ti1 != tij1)
    return (tij1 - t) / (tij1 - ti1);
  else
    return 0;
}

Referenced by CdBBasis().

Member Data Documentation

_control_points

const std::vector<libMesh::Point> Moose::BSpline::_control_points

private

The control points.

Definition at line 98 of file BSpline.h.

Referenced by buildKnotVector(), and getPoint().

_cps_per_half

const unsigned int Moose::BSpline::_cps_per_half

private

number of control points per half of the spline (vertex is auto-included)

Definition at line 94 of file BSpline.h.

Referenced by createControlPoints().

_degree

const unsigned int Moose::BSpline::_degree

private

The polynomial degree of the B-Spline.

Definition at line 84 of file BSpline.h.

Referenced by buildKnotVector(), and getPoint().

_end_dir

const libMesh::RealVectorValue Moose::BSpline::_end_dir

private

ending direction of spline

Definition at line 92 of file BSpline.h.

Referenced by createControlPoints().

_end_point

const libMesh::Point Moose::BSpline::_end_point

private

ending point of spline

Definition at line 88 of file BSpline.h.

Referenced by createControlPoints().

_knot_vector

const std::vector<libMesh::Real> Moose::BSpline::_knot_vector

private

The knot vector.

Size: degree + n_control_points + 1 The multiplicity of each knot influences the continuity of the spline

Definition at line 102 of file BSpline.h.

Referenced by CdBBasis(), firstCoeff(), and secondCoeff().

_sharpness

const libMesh::Real Moose::BSpline::_sharpness

private

sharpness of the curve

Definition at line 96 of file BSpline.h.

Referenced by createControlPoints().

_start_dir

const libMesh::RealVectorValue Moose::BSpline::_start_dir

private

starting direction of spline

Definition at line 90 of file BSpline.h.

Referenced by createControlPoints().

_start_point

const libMesh::Point Moose::BSpline::_start_point

private

starting point of spline

Definition at line 86 of file BSpline.h.

Referenced by createControlPoints().

---

The documentation for this class was generated from the following files:

• include/utils/BSpline.h
• src/utils/BSpline.C