reduce_keypoints()

Kinesis::Vision::DetectFeaturesAnalysis MayaFlux::Yantra::VisionAnalyzer::reduce_keypoints ( const std::vector< Kinesis::Vision::Keypoint > &  keypoints )

private

Dispatch track_reduce.comp over keypoint positions (fed as their own previous, so velocity reduces to zero and is simply not surfaced) and fill centroid/bounds/mean_response on the result.

No-op (default fields) when keypoints is empty. Same shader as reduce_tracks, not a duplicate: a keypoint has no persistent identity or previous position of its own, but its bounds and centroid are the same min/max/sum reduction either way.

Definition at line 151 of file VisionAnalyzer.cpp.

{
    Kinesis::Vision::DetectFeaturesAnalysis result;
    result.keypoints = keypoints;
 
    if (keypoints.empty())
        return result;
 
    std::vector<float> point_data;
    point_data.reserve(keypoints.size() * 4);
    std::vector<float> extra_data;
    extra_data.reserve(keypoints.size() * 2);
    for (const auto& k : keypoints) {
        point_data.push_back(k.position.x);
        point_data.push_back(k.position.y);
        point_data.push_back(k.position.x);
        point_data.push_back(k.position.y);
        extra_data.push_back(k.response);
        extra_data.push_back(0.0F);
    }
 
    if (!m_track_reducer) {
        m_track_reducer = std::make_shared<ShaderExecutionContext<>>(
            GpuComputeConfig {
                .shader_path = "track_reduce.comp.spv",
                .workgroup_size = { 256, 1, 1 },
                .push_constant_size = sizeof(TrackReducePC) });
    }
 
    m_track_reducer->input(0, point_data)
        .output(1, 3 * sizeof(glm::vec4))
        .input(2, extra_data)
        .push(TrackReducePC { .count = static_cast<uint32_t>(keypoints.size()) });
 
    const auto output = m_track_reducer->execute(Datum<std::vector<Kakshya::DataVariant>> {}, ExecutionContext {});
    const auto raw = ShaderExecutionContext<>::read_output<float>(output, 1);
 
    if (raw.size() >= 12) {
        const auto n = static_cast<float>(keypoints.size());
        result.centroid = { raw[0] / n, raw[1] / n };
        result.mean_response = raw[8] / n;
        result.bounds = {
            .x = raw[4],
            .y = raw[5],
            .w = raw[6] - raw[4],
            .h = raw[7] - raw[5],
        };
    }
 
    return result;
}

References MayaFlux::Kinesis::Vision::DetectFeaturesAnalysis::bounds, MayaFlux::Kinesis::Vision::DetectFeaturesAnalysis::centroid, input, MayaFlux::Kinesis::Vision::DetectFeaturesAnalysis::keypoints, m_track_reducer, MayaFlux::Kinesis::Vision::DetectFeaturesAnalysis::mean_response, MayaFlux::Portal::Graphics::GpuComputeConfig::shader_path, and MayaFlux::Kinesis::Vision::BoundingBox::x.

Referenced by assemble().

Here is the caller graph for this function: