Splines_Module

Classes
struct	Eigen::SplineFitting< SplineType >
	Spline fitting methods. More...
struct	Eigen::SplineTraits< Spline< Scalar_, Dim_, Degree_ >, Dynamic >
	Compile-time attributes of the Spline class for Dynamic degree. More...
struct	Eigen::SplineTraits< Spline< Scalar_, Dim_, Degree_ >, _DerivativeOrder >
	Compile-time attributes of the Spline class for fixed degree. More...
class	Eigen::Spline< Scalar_, Dim_, Degree_ >
	A class representing multi-dimensional spline curves. More...

Functions
template<typename KnotVectorType >
void	Eigen::KnotAveraging (const KnotVectorType &parameters, DenseIndex degree, KnotVectorType &knots)
	Computes knot averages. More...
template<typename KnotVectorType , typename ParameterVectorType , typename IndexArray >
void	Eigen::KnotAveragingWithDerivatives (const ParameterVectorType &parameters, const unsigned int degree, const IndexArray &derivativeIndices, KnotVectorType &knots)
	Computes knot averages when derivative constraints are present. Note that this is a technical interpretation of the referenced article since the algorithm contained therein is incorrect as written. More...
template<typename PointArrayType , typename KnotVectorType >
void	Eigen::ChordLengths (const PointArrayType &pts, KnotVectorType &chord_lengths)
	Computes chord length parameters which are required for spline interpolation. More...

Detailed Description

Function Documentation

ChordLengths()

template<typename PointArrayType , typename KnotVectorType >

void Eigen::ChordLengths	(	const PointArrayType &	pts,
		KnotVectorType &	chord_lengths
	)

Computes chord length parameters which are required for spline interpolation.

Parameters

[in]	pts	The data points to which a spline should be fit.
[out]	chord_lengths	The resulting chord length vector.

See also

Les Piegl and Wayne Tiller, The NURBS book (2nd ed.), 1997, 9.2.1 Global Curve Interpolation to Point Data

                                                                            {
  typedef typename KnotVectorType::Scalar Scalar;
 
  const DenseIndex n = pts.cols();
 
  // 1. compute the column-wise norms
  chord_lengths.resize(pts.cols());
  chord_lengths[0] = 0;
  chord_lengths.rightCols(n - 1) =
      (pts.array().leftCols(n - 1) - pts.array().rightCols(n - 1)).matrix().colwise().norm();
 
  // 2. compute the partial sums
  std::partial_sum(chord_lengths.data(), chord_lengths.data() + n, chord_lengths.data());
 
  // 3. normalize the data
  chord_lengths /= chord_lengths(n - 1);
  chord_lengths(n - 1) = Scalar(1);
}

References matrix(), and n.

Referenced by check_global_interpolation2d(), check_global_interpolation_with_derivatives2d(), Eigen::SplineFitting< SplineType >::Interpolate(), and Eigen::SplineFitting< SplineType >::InterpolateWithDerivatives().

KnotAveraging()

template<typename KnotVectorType >

void Eigen::KnotAveraging	(	const KnotVectorType &	parameters,
		DenseIndex	degree,
		KnotVectorType &	knots
	)

Computes knot averages.

The knots are computed as

\begin{align*} u_0 & = \hdots = u_p = 0 \\ u_{m-p} & = \hdots = u_{m} = 1 \\ u_{j+p} & = \frac{1}{p}\sum_{i=j}^{j+p-1}\bar{u}_i \quad\quad j=1,\hdots,n-p \end{align*}

where \(p\) is the degree and \(m+1\) the number knots of the desired interpolating spline.

Parameters

[in]	parameters	The input parameters. During interpolation one for each data point.
[in]	degree	The spline degree which is used during the interpolation.
[out]	knots	The output knot vector.

See also

Les Piegl and Wayne Tiller, The NURBS book (2nd ed.), 1997, 9.2.1 Global Curve Interpolation to Point Data

                                                                                               {
  knots.resize(parameters.size() + degree + 1);
 
  for (DenseIndex j = 1; j < parameters.size() - degree; ++j) knots(j + degree) = parameters.segment(j, degree).mean();
 
  knots.segment(0, degree + 1) = KnotVectorType::Zero(degree + 1);
  knots.segment(knots.size() - degree - 1, degree + 1) = KnotVectorType::Ones(degree + 1);
}

References constants::degree, j, and oomph::PseudoSolidHelper::Zero.

Referenced by Eigen::SplineFitting< SplineType >::Interpolate(), and Eigen::KnotAveragingWithDerivatives().

KnotAveragingWithDerivatives()

template<typename KnotVectorType , typename ParameterVectorType , typename IndexArray >

void Eigen::KnotAveragingWithDerivatives	(	const ParameterVectorType &	parameters,
		const unsigned int	degree,
		const IndexArray &	derivativeIndices,
		KnotVectorType &	knots
	)

Computes knot averages when derivative constraints are present. Note that this is a technical interpretation of the referenced article since the algorithm contained therein is incorrect as written.

Parameters

[in]	parameters	The parameters at which the interpolation B-Spline will intersect the given interpolation points. The parameters are assumed to be a non-decreasing sequence.
[in]	degree	The degree of the interpolating B-Spline. This must be greater than zero.
[in]	derivativeIndices	The indices corresponding to parameters at which there are derivative constraints. The indices are assumed to be a non-decreasing sequence.
[out]	knots	The calculated knot vector. These will be returned as a non-decreasing sequence

See also

Les A. Piegl, Khairan Rajab, Volha Smarodzinana. 2008. Curve interpolation with directional constraints for engineering design. Engineering with Computers

                                                                                              {
  typedef typename ParameterVectorType::Scalar Scalar;
 
  DenseIndex numParameters = parameters.size();
  DenseIndex numDerivatives = derivativeIndices.size();
 
  if (numDerivatives < 1) {
    KnotAveraging(parameters, degree, knots);
    return;
  }
 
  DenseIndex startIndex;
  DenseIndex endIndex;
 
  DenseIndex numInternalDerivatives = numDerivatives;
 
  if (derivativeIndices[0] == 0) {
    startIndex = 0;
    --numInternalDerivatives;
  } else {
    startIndex = 1;
  }
  if (derivativeIndices[numDerivatives - 1] == numParameters - 1) {
    endIndex = numParameters - degree;
    --numInternalDerivatives;
  } else {
    endIndex = numParameters - degree - 1;
  }
 
  // There are (endIndex - startIndex + 1) knots obtained from the averaging
  // and 2 for the first and last parameters.
  DenseIndex numAverageKnots = endIndex - startIndex + 3;
  KnotVectorType averageKnots(numAverageKnots);
  averageKnots[0] = parameters[0];
 
  int newKnotIndex = 0;
  for (DenseIndex i = startIndex; i <= endIndex; ++i)
    averageKnots[++newKnotIndex] = parameters.segment(i, degree).mean();
  averageKnots[++newKnotIndex] = parameters[numParameters - 1];
 
  newKnotIndex = -1;
 
  ParameterVectorType temporaryParameters(numParameters + 1);
  KnotVectorType derivativeKnots(numInternalDerivatives);
  for (DenseIndex i = 0; i < numAverageKnots - 1; ++i) {
    temporaryParameters[0] = averageKnots[i];
    ParameterVectorType parameterIndices(numParameters);
    int temporaryParameterIndex = 1;
    for (DenseIndex j = 0; j < numParameters; ++j) {
      Scalar parameter = parameters[j];
      if (parameter >= averageKnots[i] && parameter < averageKnots[i + 1]) {
        parameterIndices[temporaryParameterIndex] = j;
        temporaryParameters[temporaryParameterIndex++] = parameter;
      }
    }
    temporaryParameters[temporaryParameterIndex] = averageKnots[i + 1];
 
    for (int j = 0; j <= temporaryParameterIndex - 2; ++j) {
      for (DenseIndex k = 0; k < derivativeIndices.size(); ++k) {
        if (parameterIndices[j + 1] == derivativeIndices[k] && parameterIndices[j + 1] != 0 &&
            parameterIndices[j + 1] != numParameters - 1) {
          derivativeKnots[++newKnotIndex] = temporaryParameters.segment(j, 3).mean();
          break;
        }
      }
    }
  }
 
  KnotVectorType temporaryKnots(averageKnots.size() + derivativeKnots.size());
 
  std::merge(averageKnots.data(), averageKnots.data() + averageKnots.size(), derivativeKnots.data(),
             derivativeKnots.data() + derivativeKnots.size(), temporaryKnots.data());
 
  // Number of knots (one for each point and derivative) plus spline order.
  DenseIndex numKnots = numParameters + numDerivatives + degree + 1;
  knots.resize(numKnots);
 
  knots.head(degree).fill(temporaryKnots[0]);
  knots.tail(degree).fill(temporaryKnots.template tail<1>()[0]);
  knots.segment(degree, temporaryKnots.size()) = temporaryKnots;
}

References constants::degree, i, j, k, and Eigen::KnotAveraging().

Referenced by Eigen::SplineFitting< SplineType >::InterpolateWithDerivatives().