reparameterize_by_arc_length() [2/2]

MAYAFLUX_API std::vector< Kakshya::LineVertex > MayaFlux::Kinesis::reparameterize_by_arc_length	(	const std::vector< Kakshya::LineVertex > &	path_vertices,
		size_t	num_samples
	)

Resample path vertices for arc-length parameterization.

Parameters

path_vertices	Input vertices (arbitrary spacing)
num_samples	Desired output sample count

Returns

Vertices uniformly distributed by arc length

Uses piecewise linear arc length estimation. Output vertices have constant spacing along curve.

Definition at line 392 of file GeometryPrimitives.cpp.

{
    if (path_vertices.size() < 2 || num_samples < 2) {
        return path_vertices;
    }
 
    std::vector<float> arc_lengths;
    arc_lengths.reserve(path_vertices.size());
    arc_lengths.push_back(0.0F);
 
    float total_length = 0.0F;
    for (size_t i = 1; i < path_vertices.size(); ++i) {
        float segment_length = glm::distance(
            path_vertices[i].position,
            path_vertices[i - 1].position);
        total_length += segment_length;
        arc_lengths.push_back(total_length);
    }
 
    if (total_length < 1e-6F) {
        return path_vertices;
    }
 
    std::vector<Kakshya::LineVertex> resampled;
    resampled.reserve(num_samples);
 
    for (size_t i = 0; i < num_samples; ++i) {
        float target_length = (static_cast<float>(i) / static_cast<float>(num_samples - 1)) * total_length;
 
        auto it = std::ranges::lower_bound(arc_lengths, target_length);
        size_t idx = std::distance(arc_lengths.begin(), it);
 
        if (idx == 0) {
            resampled.push_back(path_vertices[0]);
        } else if (idx >= path_vertices.size()) {
            resampled.push_back(path_vertices.back());
        } else {
            float s0 = arc_lengths[idx - 1];
            float s1 = arc_lengths[idx];
            float t = (target_length - s0) / (s1 - s0);
 
            glm::vec3 p0 = path_vertices[idx - 1].position;
            glm::vec3 p1 = path_vertices[idx].position;
            glm::vec3 position = glm::mix(p0, p1, t);
 
            glm::vec3 c0 = path_vertices[idx - 1].color;
            glm::vec3 c1 = path_vertices[idx].color;
            glm::vec3 color = glm::mix(c0, c1, t);
 
            resampled.push_back({ .position = position,
                .color = color,
                .thickness = 1.0F });
        }
    }
 
    return resampled;
}

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

Here is the caller graph for this function: