◆ op_canny()

GpuVisionPass::Completed MayaFlux::Yantra::VisionGpuExecutor::op_canny	(	VisionGpuContexts &	contexts,
		const Kinesis::Vision::VisionParams &	params,
		const Kinesis::Vision::CannyParams &	p
	)

private

Detect edges in the current image with the Canny pipeline.

Applies smoothing, gradients, suppression, threshold classification, and hysteresis. The final edge image becomes the working image and is published as VisionResult::images.canny.

Returns: The resulting edge image and the original input image.

Definition at line 243 of file VisionImageDispatch.cpp.

{
    auto& pixel_ctx = contexts.pixel;
    auto& label_ctx = contexts.labels;
    auto w = contexts.pass.w;
    auto h = contexts.pass.h;
    auto& foundry = Portal::Graphics::get_shader_foundry();
 
    const auto canny_input = contexts.pass.current;
 
    const auto radius = static_cast<uint32_t>(std::ceil(p.sigma * 3.0F));
    const auto& weights = gaussian_kernel_2d(radius, p.sigma);
    const auto blur_cfg = VisionGpuExecutor::config(VisionOp::GaussianBlur, GaussianBlurParams { .sigma = p.sigma });
    pixel_ctx.swap_shader(blur_cfg);
    pixel_ctx.stage_image(canny_input);
    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);
    }
    const auto blurred = pixel_ctx.get_output_image(0);
 
    const auto sobel_cfg = VisionGpuExecutor::config(VisionOp::Sobel, std::monostate {});
    pixel_ctx.swap_shader(sobel_cfg);
    pixel_ctx.stage_image(blurred);
    pixel_ctx.prepare_output_image(w, h);
    {
        const auto f = pixel_ctx.dispatch_async({});
        foundry.wait_for_fence(f);
        foundry.release_fence(f);
    }
    const auto grad = pixel_ctx.get_output_image(0);
 
    const GpuComputeConfig nms_cfg {
        .shader_path = "canny_nms.comp.spv",
        .workgroup_size = k_wg2d,
    };
    pixel_ctx.swap_shader(nms_cfg);
    pixel_ctx.stage_image(grad);
    pixel_ctx.prepare_output_image(w, h);
    {
        const auto f = pixel_ctx.dispatch_async({});
        foundry.wait_for_fence(f);
        foundry.release_fence(f);
    }
    auto suppressed = pixel_ctx.get_output_image(0);
 
    const auto classify_cfg = VisionGpuExecutor::config(VisionOp::Canny, params);
    pixel_ctx.swap_shader(classify_cfg);
    pixel_ctx.stage_image(suppressed);
    pixel_ctx.set_push_constants(ClassifyPC { .threshold = p.low_threshold, .value = 0.5F });
    pixel_ctx.prepare_output_image(w, h);
    {
        const auto f = pixel_ctx.dispatch_async({});
        foundry.wait_for_fence(f);
        foundry.release_fence(f);
    }
    auto classified_weak = pixel_ctx.get_output_image(0);
 
    pixel_ctx.stage_image(classified_weak);
    pixel_ctx.set_push_constants(ClassifyPC { .threshold = p.high_threshold, .value = 1.0F });
    pixel_ctx.prepare_output_image(w, h);
    {
        const auto f = pixel_ctx.dispatch_async({});
        foundry.wait_for_fence(f);
        foundry.release_fence(f);
    }
    auto classified = pixel_ctx.get_output_image(0);
 
    constexpr uint32_t k_max_hysteresis_rounds = 64;
    label_ctx.set_output_size(2, sizeof(uint32_t));
    label_ctx.set_output_dimensions(w, h);
    label_ctx.swap_shader({
        .shader_path = "canny_hysteresis.comp.spv",
        .workgroup_size = k_wg2d,
        .push_constant_size = sizeof(HysteresisPC),
    });
    label_ctx.stage_image_at(0, classified, GpuBufferBinding::ElementType::IMAGE_STORAGE);
    label_ctx.slot_binding(0).direction = GpuBufferBinding::Direction::INPUT_OUTPUT;
    {
        uint32_t zero = 0;
        label_ctx.set_binding_data(2, std::span<const uint32_t>(&zero, 1));
        const HysteresisPC hpc { .width = w, .height = h };
        ExecutionContext chained_ctx;
        chained_ctx.mode = ExecutionMode::CHAINED;
        chained_ctx.parameters = ChainedParams {
            .pass_count = k_max_hysteresis_rounds,
            .pc_updater = [hpc](uint32_t, void* dst) { std::memcpy(dst, &hpc, sizeof(HysteresisPC)); },
            .passes_per_batch = k_max_hysteresis_rounds,
        };
        label_ctx.execute(Datum<> {}, chained_ctx);
    }
    label_ctx.slot_binding(0).direction = GpuBufferBinding::Direction::OUTPUT;
    auto hysteresis_result = classified;
 
    const auto finalize_cfg = config_from_spec(
        ShaderSpec::Assemble {}
            .storage_image("out", BindingDirection::Output)
            .storage_image("src", BindingDirection::Input)
            .pc("threshold")
            .op(KernelOp::CompareGE)
            .workgroup(k_wg2d[0], k_wg2d[1])
            .build());
    pixel_ctx.swap_shader(finalize_cfg);
    pixel_ctx.stage_image(hysteresis_result);
    pixel_ctx.set_push_constants(FinalizePC { .threshold = 1.0F });
    pixel_ctx.prepare_output_image(w, h);
    {
        const auto f = pixel_ctx.dispatch_async({});
        foundry.wait_for_fence(f);
        foundry.release_fence(f);
    }
    auto finalized = pixel_ctx.get_output_image(0);
 
    contexts.pass.result.images.canny = finalized;
    contexts.pass.current = finalized;
    contexts.pass.result.structured = std::monostate {};
 
    contexts.bound_config = finalize_cfg;
    contexts.bound_staged = hysteresis_result;
 
    return { .output = finalized, .input = canny_input };
}

Here is the call graph for this function: