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, const std::string &caller_name)

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::string	_caller_name
	Name of the object working with this class, used for error reporting.

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,
		const std::string &	caller_name
	)

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),
    _caller_name(caller_name),
    _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 63 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(_caller_name +
               ": 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 102 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 53 of file BSpline.C.

{
  std::vector<libMesh::Point> cps;
  cps = SplineUtils::bSplineControlPoints(
      _start_point, _end_point, _start_dir, _end_dir, _cps_per_half, _sharpness, _caller_name);
  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 116 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 40 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 128 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

◆ _caller_name

const std::string Moose::BSpline::_caller_name

private

Name of the object working with this class, used for error reporting.

Declared before the control points and knot vector because their construction may report errors

Definition at line 100 of file BSpline.h.

Referenced by buildKnotVector(), and createControlPoints().

◆ _control_points

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

private

The control points.

Definition at line 102 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 95 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 85 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 93 of file BSpline.h.

Referenced by createControlPoints().

◆ _end_point

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

private

ending point of spline

Definition at line 89 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 106 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 97 of file BSpline.h.

Referenced by createControlPoints().

◆ _start_dir

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

private

starting direction of spline

Definition at line 91 of file BSpline.h.

Referenced by createControlPoints().

◆ _start_point

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

private

starting point of spline

Definition at line 87 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

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ BSpline()

Member Function Documentation

◆ buildKnotVector()

◆ CdBBasis()

◆ createControlPoints()

◆ firstCoeff()

◆ getPoint()

◆ secondCoeff()

Member Data Documentation

◆ _caller_name

◆ _control_points

◆ _cps_per_half

◆ _degree

◆ _end_dir

◆ _end_point

◆ _knot_vector

◆ _sharpness

◆ _start_dir

◆ _start_point