op_extract_peaks()

void MayaFlux::Yantra::VisionGpuExecutor::op_extract_peaks ( VisionGpuContexts &  contexts, const Kinesis::Vision::ExtractPeaksParams &  p  )

private

Extract and rank keypoints from the current response image.

Produces structured host keypoints unless TrackKeypoints follows immediately. In that sequence, tracking extracts detections directly into its GPU buffers.

Definition at line 86 of file VisionFeatureDispatch.cpp.

{
    auto& structured_ctx = contexts.structured;
    auto w = contexts.pass.w;
    auto h = contexts.pass.h;
    auto& foundry = Portal::Graphics::get_shader_foundry();
 
    constexpr uint32_t k_max_kp = 4096;
 
    const auto* tracker = contexts.pass.ahead();
    if (tracker && tracker->op == VisionOp::TrackKeypoints) {
        contexts.pass.result.structured = std::monostate {};
        contexts.pass.result.w = w;
        contexts.pass.result.h = h;
        return;
    }
 
    structured_ctx.swap_shader({
        .shader_path = "extract_peaks.comp.spv",
        .workgroup_size = { 8, 8, 1 },
        .push_constant_size = sizeof(ExtractPeaksPC),
    });
 
    structured_ctx.set_output_size(1, sizeof(uint32_t));
    structured_ctx.set_output_size(2, static_cast<size_t>(k_max_kp) * 4 * sizeof(float));
    structured_ctx.ensure_shared_buffer(0, 3, (static_cast<size_t>(k_max_kp) + 1U) * 4U,
        GpuBufferBinding::ElementType::FLOAT32, Portal::Graphics::BufferUsageHint::COMPUTE);
 
    structured_ctx.stage_image(contexts.pass.current);
    structured_ctx.set_push_constants(ExtractPeaksPC {
        .threshold = p.threshold,
        .nms_radius = p.nms_radius,
        .width = w,
        .height = h,
        .max_keypoints = k_max_kp,
        .rect = region_rect(p.region, w, h),
    });
 
    structured_ctx.set_output_dimensions(w, h);
    const auto fence = structured_ctx.dispatch_async({});
    structured_ctx.clear_output_dimensions();
    foundry.wait_for_fence(fence);
    foundry.release_fence(fence);
 
    const auto gpu_result = structured_ctx.collect_result();
 
    uint32_t count = 0;
    if (auto it = gpu_result.aux.find(1); it != gpu_result.aux.end())
        std::memcpy(&count, it->second.data(), sizeof(uint32_t));
    count = std::min(count, k_max_kp);
 
    if (p.export_keypoints) {
        const glm::vec4 header { std::bit_cast<float>(count), 0.0F, 0.0F, 0.0F };
        structured_ctx.upload_shared_raw(0, 3, reinterpret_cast<const uint8_t*>(&header), sizeof(glm::vec4));
        contexts.pass.result.buffers.keypoints = std::make_shared<Portal::Graphics::GpuBufferHandle>(
            structured_ctx.shared_buffer_handle(0, 3));
    }
 
    struct GpuKp {
        float x, y, response, pad;
    };
    std::vector<GpuKp> raw(count);
    if (count > 0) {
        if (auto it = gpu_result.aux.find(2); it != gpu_result.aux.end())
            std::memcpy(raw.data(), it->second.data(), count * sizeof(GpuKp));
    }
 
    std::vector<Kinesis::Vision::Keypoint> kpts;
    kpts.reserve(count);
    for (const auto& kp : raw) {
        kpts.push_back({ .position = { kp.x, kp.y },
            .response = kp.response,
            .scale = 1.0F,
            .angle = 0.0F });
    }
    std::ranges::sort(kpts, [](const auto& a, const auto& b) { return a.response > b.response; });
 
    contexts.pass.result.structured = std::move(kpts);
    contexts.pass.result.w = 0;
    contexts.pass.result.h = 0;
}

References a, MayaFlux::Kinesis::Vision::VisionPass< Handle >::ahead(), b, MayaFlux::Kinesis::Vision::VisionResult::buffers, MayaFlux::Portal::Graphics::COMPUTE, count, MayaFlux::Kinesis::Vision::VisionPass< Handle >::current, MayaFlux::Kinesis::Vision::ExtractPeaksParams::export_keypoints, fence, MayaFlux::Portal::Graphics::GpuBufferBinding::FLOAT32, MayaFlux::Portal::Graphics::get_shader_foundry(), MayaFlux::Kinesis::Vision::VisionResult::h, MayaFlux::Kinesis::Vision::VisionPass< Handle >::h, h, MayaFlux::Kinesis::Vision::BufferOutputs::keypoints, MayaFlux::Kinesis::Vision::ExtractPeaksParams::nms_radius, MayaFlux::Yantra::VisionGpuContexts::pass, MayaFlux::Kinesis::Vision::ExtractPeaksParams::region, MayaFlux::Yantra::VisionInternal::region_rect(), MayaFlux::Kinesis::Vision::VisionPass< Handle >::result, MayaFlux::Kinesis::Vision::VisionResult::structured, MayaFlux::Yantra::VisionGpuContexts::structured, MayaFlux::Kinesis::Vision::ExtractPeaksParams::threshold, MayaFlux::Yantra::VisionInternal::ExtractPeaksPC::threshold, MayaFlux::Kinesis::Vision::VisionResult::w, and MayaFlux::Kinesis::Vision::VisionPass< Handle >::w.

Here is the call graph for this function: