reparameterize_planar()

void MayaFlux::Kinesis::CurveEvaluator::reparameterize_planar	(	std::span< const double >	points,
		size_t	dim,
		Eigen::Index	point_count,
		Eigen::Index	num_samples,
		std::vector< double > &	out
	)

Resample a polyline to uniform arc length, coordinate-major.

Parameters

points	Coordinate-major, dim * point_count doubles.
dim	Coordinate count per point, at least 1.
point_count	Input sample count.
num_samples	Output sample count, at least 2.
out	Resized to dim * num_samples, coordinate-major.

points and out must not alias. A zero-length span between two consecutive points yields that span's start point rather than a division by zero.

Definition at line 881 of file MotionCurves.cpp.

{
    const auto n = static_cast<size_t>(point_count);
    const auto samples = static_cast<size_t>(num_samples);
 
    if (point_count < 2 || num_samples < 2) {
        out.assign(points.begin(), points.end());
        return;
    }
 
    const double* src = points.data();
 
    m_arc.assign(n, 0.0);
 
    for (size_t d = 0; d < dim; ++d) {
        const double* row = src + d * n;
        for (size_t i = 1; i < n; ++i) {
            const double delta = row[i] - row[i - 1];
            m_arc[i] += delta * delta;
        }
    }
 
    for (size_t i = 1; i < n; ++i) {
        m_arc[i] = std::sqrt(m_arc[i]);
    }
 
    std::inclusive_scan(m_arc.data() + 1, m_arc.data() + n, m_arc.data() + 1);
 
    const double total_length = m_arc[n - 1];
    if (total_length == 0.0) {
        out.assign(points.begin(), points.end());
        return;
    }
 
    m_lower.resize(samples);
    m_frac.resize(samples);
 
    const double step = total_length / static_cast<double>(num_samples - 1);
    size_t upper = 1;
 
    for (size_t i = 0; i < samples; ++i) {
        const double target = static_cast<double>(i) * step;
 
        while (upper < n - 1 && m_arc[upper] < target) {
            ++upper;
        }
 
        const size_t lower = upper - 1;
        const double span = m_arc[upper] - m_arc[lower];
 
        m_lower[i] = lower;
        m_frac[i] = (span > 0.0) ? ((target - m_arc[lower]) / span) : 0.0;
    }
 
    out.resize(dim * samples);
 
    for (size_t d = 0; d < dim; ++d) {
        const double* row = src + d * n;
        double* dst = out.data() + d * samples;
 
        for (size_t i = 0; i < samples; ++i) {
            const size_t lower = m_lower[i];
            const double t = m_frac[i];
            dst[i] = (1.0 - t) * row[lower] + t * row[lower + 1];
        }
    }
}

References dst, out, points, and src.

Referenced by MayaFlux::Nodes::GpuSync::TopologyGeneratorNode::build_interpolated_path(), and MayaFlux::Nodes::GpuSync::PathGeneratorNode::write_curve_segment().

Here is the caller graph for this function: