generate_interpolated_points()

Eigen::MatrixXd MayaFlux::Kinesis::generate_interpolated_points	(	const Eigen::MatrixXd &	control_points,
		Eigen::Index	num_samples,
		InterpolationMode	mode,
		double	tension = 0.5
	)

Generate interpolated points from control points.

Parameters

control_points	MxN matrix where columns are control points
num_samples	Number of interpolated points to generate
mode	Interpolation mode
tension	Tension parameter

Returns

Matrix where columns are interpolated points

Definition at line 321 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 (control_points.cols() < 2) {
        error<std::invalid_argument>(
            Journal::Component::Kinesis,
            Journal::Context::Runtime,
            std::source_location::current(),
            "Need at least 2 control points, but got {}",
            control_points.cols());
    }
 
    auto [points_per_segment, overlap, supports_multi] = get_segment_info(mode);
 
    if (!supports_multi) {
        if (control_points.cols() != 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>(mode), points_per_segment, control_points.cols());
        }
        return interpolate_single_segment(control_points, num_samples, mode, tension);
    }
 
    if (control_points.cols() == points_per_segment) {
        return interpolate_single_segment(control_points, num_samples, mode, tension);
    }
 
    ExtendedControls extended(control_points, mode, points_per_segment);
    Eigen::Index num_segments = compute_num_segments(extended.count, points_per_segment, 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>(mode), control_points.cols());
    }
 
    Eigen::MatrixXd result(control_points.rows(), num_samples);
 
    for (Eigen::Index i = 0; i < num_samples; ++i) {
        auto [seg_idx, t_local] = SegmentLocation::compute(i, num_samples, num_segments);
 
        Eigen::MatrixXd segment_controls = extract_segment_controls(
            *extended.controls,
            extended.count,
            seg_idx,
            points_per_segment,
            overlap,
            t_local);
 
        result.col(i) = interpolate(segment_controls, t_local, mode, tension);
    }
 
    return result;
}

References interpolate(), MayaFlux::Journal::Kinesis, overlap, points_per_segment, MayaFlux::Journal::Runtime, seg_idx, supports_multi, and t_local.

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

Here is the call graph for this function:

Here is the caller graph for this function: