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
	)

Evaluate a curve into a coordinate-major buffer.

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.

control_points and out must not alias.

Definition at line 617 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);
 
    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();
 
    if (m_chunks.size() > 1 && num_samples >= k_parallel_min_samples) {
        P::for_each(P::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);
 
                double* dst = out_base + static_cast<size_t>(chunk.sample_begin);
 
                if (trig) {
                    evaluate_chunk_cosine(active, chunk.start_col, params.data(),
                        dim, count, dst, 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);
            });
 
        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);
 
        double* dst = out_base + static_cast<size_t>(chunk.sample_begin);
 
        if (trig) {
            evaluate_chunk_cosine(active, chunk.start_col, m_tbuf.data(),
                dim, count, dst, 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);
    }
}

References build_chunks(), count, extend(), MayaFlux::Journal::Kinesis, m_basis, m_chunks, m_mode, m_overlap, m_points_per_segment, m_supports_multi, m_trigonometric, 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: