resample_uniform()

std::vector< glm::vec2 > MayaFlux::Kinesis::resample_uniform ( std::span< const glm::vec2 >  path, size_t  count  )

inline

Resample a path to a fixed point count at uniform arc length.

Parameters

path	Positions in chronological order, at least two
count	Output point count, minimum 2

Returns

count points evenly spaced along the path by distance

Removes speed from the path entirely. Two strokes tracing the same shape, one hurried through its middle and one dwelling there, produce different sample distributions in time and identical ones after this, which is the precondition for comparing them point against point.

A path whose total length is below the epsilon guard is degenerate, every sample having landed in effectively one place, and is returned as count copies of its first point rather than dividing by zero.

MotionCurves::reparameterize_by_arc_length does the same thing over an Eigen::MatrixXd with columns as points. This exists so a caller holding glm::vec2 samples does not transpose into a matrix and back for what is a linear walk.

Definition at line 45 of file PathShape.hpp.

{
    count = count < 2 ? 2 : count;
    if (path.size() < 2)
        return std::vector<glm::vec2>(count, path.empty() ? glm::vec2 { 0.0F } : path[0]);
 
    std::vector<float> arc;
    arc.reserve(path.size());
    arc.push_back(0.0F);
    float total = 0.0F;
    for (size_t i = 1; i < path.size(); ++i) {
        total += glm::length(path[i] - path[i - 1]);
        arc.push_back(total);
    }
 
    if (total < 1e-6F)
        return std::vector<glm::vec2>(count, path[0]);
 
    std::vector<glm::vec2> out;
    out.reserve(count);
    const float step = total / static_cast<float>(count - 1);
 
    size_t upper = 1;
    for (size_t i = 0; i < count; ++i) {
        const float target = static_cast<float>(i) * step;
        while (upper < arc.size() - 1 && arc[upper] < target)
            ++upper;
        const size_t lower = upper - 1;
        const float segment = arc[upper] - arc[lower];
        const float t = (segment > 1e-9F) ? ((target - arc[lower]) / segment) : 0.0F;
        out.push_back(glm::mix(path[lower], path[upper], t));
    }
    return out;
}

References count, out, and total.

Referenced by shape_distance(), and turning_profile().

Here is the caller graph for this function: