op_harris_response()

GpuVisionPass::Completed MayaFlux::Yantra::VisionGpuExecutor::op_harris_response ( VisionGpuContexts &  contexts, const Kinesis::Vision::HarrisParams &  p  )

private

Compute the Harris response of the current image.

Packs and smooths image gradients before evaluating the response. The response image becomes the working image for a following ExtractPeaks.

Returns

The response image and the original input image.

Zero PeakBuf (binding 2) before pass 0 so its atomicMax starts clean; clear the staged bytes before pass 1 so the accumulated max survives.

Definition at line 10 of file VisionFeatureDispatch.cpp.

{
    auto& pixel_ctx = contexts.pixel;
    auto w = contexts.pass.w;
    auto h = contexts.pass.h;
    auto& foundry = Portal::Graphics::get_shader_foundry();
 
    const auto radius = static_cast<uint32_t>(std::ceil(p.sigma * 3.0F));
    const auto& weights = gaussian_kernel_2d(radius, p.sigma);
 
    const auto harris_input = contexts.pass.current;
 
    pixel_ctx.swap_shader({ .shader_path = "harris_grad_pack.comp.spv", .workgroup_size = k_wg2d });
    pixel_ctx.stage_image(harris_input);
    pixel_ctx.prepare_output_image(w, h);
    {
        const auto f = pixel_ctx.dispatch_async({});
        foundry.wait_for_fence(f);
        foundry.release_fence(f);
    }
    auto packed = pixel_ctx.get_output_image(0);
 
    const auto blur_cfg = VisionGpuExecutor::config(VisionOp::GaussianBlur, GaussianBlurParams { .sigma = p.sigma });
    pixel_ctx.swap_shader(blur_cfg);
    pixel_ctx.stage_image(packed);
    pixel_ctx.set_binding_data(2, std::span<const float>(weights));
    pixel_ctx.set_push_constants(GaussianPC { .radius = radius, .width = w, .height = h });
    pixel_ctx.prepare_output_image(w, h);
    {
        const auto f = pixel_ctx.dispatch_async({});
        foundry.wait_for_fence(f);
        foundry.release_fence(f);
    }
    auto smoothed = pixel_ctx.get_output_image(0);
 
    const GpuComputeConfig harris_resp_cfg {
        .shader_path = "harris_response.comp.spv",
        .workgroup_size = k_wg2d,
        .push_constant_size = sizeof(HarrisPC),
    };
    pixel_ctx.swap_shader(harris_resp_cfg);
    pixel_ctx.stage_image(smoothed);
 
    /** Zero PeakBuf (binding 2) before pass 0 so its atomicMax starts clean;
     *  clear the staged bytes before pass 1 so the accumulated max survives. */
    const uint32_t peak_reset = 0U;
    pixel_ctx.set_binding_data(2, std::span<const uint32_t>(&peak_reset, 1));
    const auto rect = region_rect(p.region, w, h);
    pixel_ctx.set_push_constants(HarrisPC { .k = p.k, .pass = 0U, .width = w, .height = h, .rect = rect });
    pixel_ctx.prepare_output_image(w, h);
    {
        const auto f = pixel_ctx.dispatch_async({});
        foundry.wait_for_fence(f);
        foundry.release_fence(f);
    }
 
    pixel_ctx.set_binding_data(2, std::span<const uint32_t>(&peak_reset, 0));
    pixel_ctx.set_push_constants(HarrisPC { .k = p.k, .pass = 1U, .width = w, .height = h, .rect = rect });
    {
        const auto f = pixel_ctx.dispatch_async({});
        foundry.wait_for_fence(f);
        foundry.release_fence(f);
    }
 
    contexts.pass.current = pixel_ctx.get_output_image(0);
    contexts.pass.result.structured = std::monostate {};
    contexts.pass.result.images.harris_response = contexts.pass.current;
 
    contexts.bound_config = harris_resp_cfg;
    contexts.bound_staged = smoothed;
 
    return { .output = contexts.pass.current, .input = harris_input };
}

References MayaFlux::Yantra::VisionGpuContexts::bound_config, MayaFlux::Yantra::VisionGpuContexts::bound_staged, config(), MayaFlux::Kinesis::Vision::VisionPass< Handle >::current, gaussian_kernel_2d(), MayaFlux::Portal::Graphics::get_shader_foundry(), MayaFlux::Kinesis::Vision::VisionPass< Handle >::h, h, MayaFlux::Kinesis::Vision::ImageOutputs::harris_response, MayaFlux::Kinesis::Vision::VisionResult::images, MayaFlux::Kinesis::Vision::HarrisParams::k, MayaFlux::Yantra::VisionInternal::HarrisPC::k, MayaFlux::Yantra::VisionInternal::k_wg2d, MayaFlux::Yantra::VisionGpuContexts::pass, MayaFlux::Yantra::VisionGpuContexts::pixel, radius, MayaFlux::Yantra::VisionInternal::GaussianPC::radius, MayaFlux::Kinesis::Vision::HarrisParams::region, MayaFlux::Yantra::VisionInternal::region_rect(), MayaFlux::Kinesis::Vision::VisionPass< Handle >::result, MayaFlux::Portal::Graphics::GpuComputeConfig::shader_path, MayaFlux::Kinesis::Vision::GaussianBlurParams::sigma, MayaFlux::Kinesis::Vision::HarrisParams::sigma, MayaFlux::Kinesis::Vision::VisionResult::structured, and MayaFlux::Kinesis::Vision::VisionPass< Handle >::w.

Here is the call graph for this function: