evaluate_planar()

void MayaFlux::Kinesis::CurveEvaluator::evaluate_planar	(	std::span< const double >	control_points,
		size_t	dim,
		Eigen::Index	num_samples,
		std::vector< double > &	out,
		std::vector< double > &	tangents
	)

Evaluate a curve into coordinate-major position and tangent buffers.

Parameters

control_points	Point-major, dim * control_count doubles.
dim	Coordinate count per point, at least 1.
num_samples	Output sample count, at least 2.
out	Resized to dim * num_samples, coordinate-major.
tangents	Resized to dim * num_samples, coordinate-major.

A sample's state is its position and its direction, so both are produced together: the basis fold already yields the polynomial coefficients, and differentiating them is a scale by power feeding the same Horner kernel one degree lower. Callers that ignore tangents pay one extra pass over the parameter buffer already in cache.

tangents holds the derivative with respect to the segment parameter, so it is a direction and not a rate: its magnitude is not comparable across segments and changes under arc length reparameterization. At a cusp or a repeated control point the derivative is zero, and consumers must fall back to a difference of neighbouring positions there.

control_points must not alias out or tangents.

Definition at line 734 of file MotionCurves.cpp.

{
    if (num_samples < 2) {
        error<std::invalid_argument>(
            Journal::Component::Kinesis,
            Journal::Context::Runtime,
            std::source_location::current(),
            "num_samples must be at least 2, but got {}",
            num_samples);
    }
 
    if (dim == 0) {
        error<std::invalid_argument>(
            Journal::Component::Kinesis,
            Journal::Context::Runtime,
            std::source_location::current(),
            "dim must be at least 1");
    }
 
    const auto control_count = static_cast<Eigen::Index>(control_points.size() / dim);
 
    if (control_count < 2) {
        error<std::invalid_argument>(
            Journal::Component::Kinesis,
            Journal::Context::Runtime,
            std::source_location::current(),
            "Need at least 2 control points, but got {}",
            control_count);
    }
 
    if (m_points_per_segment == 0) {
        error<std::invalid_argument>(
            Journal::Component::Kinesis,
            Journal::Context::Runtime,
            std::source_location::current(),
            "Unsupported interpolation mode: {}",
            static_cast<int>(m_mode));
    }
 
    if (!m_supports_multi && control_count != m_points_per_segment) {
        error<std::invalid_argument>(
            Journal::Component::Kinesis,
            Journal::Context::Runtime,
            std::source_location::current(),
            "{} interpolation requires exactly {} control points, but got {}",
            static_cast<int>(m_mode), m_points_per_segment, control_count);
    }
 
    Eigen::Index active_count = 0;
    const double* active = extend(control_points, dim, active_count);
 
    const Eigen::Index num_segments = compute_num_segments(
        active_count, m_points_per_segment, m_overlap);
 
    if (num_segments < 1) {
        error<std::invalid_argument>(
            Journal::Component::Kinesis,
            Journal::Context::Runtime,
            std::source_location::current(),
            "Need sufficient control points for multi-segment {} interpolation, but got {}",
            static_cast<int>(m_mode), control_count);
    }
 
    const auto stride = static_cast<size_t>(num_samples);
    out.resize(dim * stride);
    tangents.resize(dim * stride);
 
    build_chunks(num_samples, num_segments, active_count);
 
    const Eigen::Index pps = m_points_per_segment;
    const bool trig = m_trigonometric;
    const double* basis = m_basis.data();
    double* out_base = out.data();
    double* tan_base = tangents.data();
 
    if (m_chunks.size() > 1 && num_samples >= k_parallel_min_samples) {
        std::for_each(std::execution::par_unseq, m_chunks.begin(), m_chunks.end(),
            [&](const CurveChunk& chunk) {
                const auto count = static_cast<size_t>(chunk.sample_count);
                std::vector<double> params(count);
                fill_parameters(params.data(), chunk, num_samples, num_segments);
 
                const auto offset = static_cast<size_t>(chunk.sample_begin);
                double* dst = out_base + offset;
                double* tan = tan_base + offset;
 
                if (trig) {
                    evaluate_chunk_cosine(active, chunk.start_col, params.data(),
                        dim, count, dst, stride);
                    evaluate_chunk_cosine_derivative(active, chunk.start_col, params.data(),
                        dim, count, tan, stride);
                    return;
                }
 
                std::vector<double> folded(dim * static_cast<size_t>(pps));
                fold_controls(active, chunk.start_col, dim, pps, basis, folded.data());
 
                evaluate_chunk_polynomial(folded.data(), params.data(),
                    dim, pps, count, dst, stride);
 
                std::vector<double> dfolded(dim * static_cast<size_t>(pps - 1));
                fold_derivative(folded.data(), dim, pps, dfolded.data());
 
                evaluate_chunk_polynomial(dfolded.data(), params.data(),
                    dim, pps - 1, count, tan, stride);
            });
 
        return;
    }
 
    for (const CurveChunk& chunk : m_chunks) {
        const auto count = static_cast<size_t>(chunk.sample_count);
 
        m_tbuf.resize(count);
        fill_parameters(m_tbuf.data(), chunk, num_samples, num_segments);
 
        const auto offset = static_cast<size_t>(chunk.sample_begin);
        double* dst = out_base + offset;
        double* tan = tan_base + offset;
 
        if (trig) {
            evaluate_chunk_cosine(active, chunk.start_col, m_tbuf.data(),
                dim, count, dst, stride);
            evaluate_chunk_cosine_derivative(active, chunk.start_col, m_tbuf.data(),
                dim, count, tan, stride);
            continue;
        }
 
        m_folded.resize(dim * static_cast<size_t>(pps));
        fold_controls(active, chunk.start_col, dim, pps, basis, m_folded.data());
 
        evaluate_chunk_polynomial(m_folded.data(), m_tbuf.data(),
            dim, pps, count, dst, stride);
 
        m_dfolded.resize(dim * static_cast<size_t>(pps - 1));
        fold_derivative(m_folded.data(), dim, pps, m_dfolded.data());
 
        evaluate_chunk_polynomial(m_dfolded.data(), m_tbuf.data(),
            dim, pps - 1, count, tan, stride);
    }
}

References build_chunks(), count, dst, extend(), MayaFlux::Journal::Kinesis, m_basis, m_chunks, m_mode, m_overlap, m_points_per_segment, m_supports_multi, m_trigonometric, out, MayaFlux::Journal::Runtime, and MayaFlux::Kinesis::CurveChunk::start_col.

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

Here is the call graph for this function:

Here is the caller graph for this function: