op_open_close()

GpuVisionPass::Completed MayaFlux::Yantra::VisionGpuExecutor::op_open_close ( VisionGpuContexts &  contexts, Kinesis::Vision::VisionOp  op, const Kinesis::Vision::MorphParams &  p  )

private

Apply morphological opening or closing to the current image.

Opening erodes then dilates; closing dilates then erodes. The final image becomes the working image for the following step.

Returns

The resulting image and the image it was derived from.

Definition at line 164 of file VisionImageDispatch.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 morph_input = contexts.pass.current;
    const auto radius = p.radius;
    const bool is_open = (op == VisionOp::Open);
    const MorphPC morph_pc { .radius = radius };
 
    const GpuComputeConfig first_cfg {
        .shader_path = is_open ? "erode.comp.spv" : "dilate.comp.spv",
        .workgroup_size = k_wg2d,
        .push_constant_size = sizeof(MorphPC),
    };
    const GpuComputeConfig second_cfg {
        .shader_path = is_open ? "dilate.comp.spv" : "erode.comp.spv",
        .workgroup_size = k_wg2d,
        .push_constant_size = sizeof(MorphPC),
    };
    const std::array<uint32_t, 3> image_groups { (w + k_wg2d[0] - 1U) / k_wg2d[0], (h + k_wg2d[1] - 1U) / k_wg2d[1], 1U };
 
    std::shared_ptr<Core::VKImage> intermediate;
    std::shared_ptr<Core::VKImage> opened_closed;
 
    std::vector<DependencyStage> morph_stages;
    morph_stages.reserve(2);
    morph_stages.push_back({
        .config = first_cfg,
        .stage_fn = [&pixel_ctx, &intermediate, morph_input, morph_pc, w, h](GpuDispatchCore& ctx) {
                pixel_ctx.stage_image(morph_input);
                pixel_ctx.prepare_output_image(w, h);
                intermediate = pixel_ctx.get_output_image(0);
                ctx.set_push_constants(morph_pc); },
        .hazard_fn = [&intermediate](GpuDispatchCore&) { return std::vector<HazardResource> {
                                                             { .binding = { .set = 0, .binding = 1, .direction = GpuBufferBinding::Direction::INPUT_OUTPUT, .element_type = GpuBufferBinding::ElementType::IMAGE_STORAGE },
                                                                 .image = intermediate->get_image() },
                                                         }; },
        .explicit_groups = image_groups,
    });
    morph_stages.push_back({
        .config = second_cfg,
        .stage_fn = [&pixel_ctx, &intermediate, &opened_closed, morph_pc, w, h](GpuDispatchCore& ctx) {
                pixel_ctx.stage_image(intermediate);
                pixel_ctx.prepare_output_image(w, h);
                opened_closed = pixel_ctx.get_output_image(0);
                ctx.set_push_constants(morph_pc); },
        .explicit_groups = image_groups,
    });
 
    {
        ExecutionContext morph_ctx;
        morph_ctx.mode = ExecutionMode::DEPENDENCY;
        DependencyParams morph_params;
        morph_params.stages = morph_stages;
        morph_params.async = true;
        morph_ctx.parameters = morph_params;
        const auto result = pixel_ctx.execute(Datum<> {}, morph_ctx);
        const auto f = result.get_metadata<FenceID>("gpu_fence").value_or(INVALID_FENCE);
        foundry.wait_for_fence(f);
        foundry.release_fence(f);
    }
 
    if (is_open) {
        contexts.pass.result.images.open = opened_closed;
    } else {
        contexts.pass.result.images.close = opened_closed;
    }
    contexts.pass.current = opened_closed;
    contexts.pass.result.structured = std::monostate {};
 
    return { .output = opened_closed, .input = morph_input };
}

References MayaFlux::Yantra::DependencyParams::async, MayaFlux::Kinesis::Vision::ImageOutputs::close, MayaFlux::Kinesis::Vision::VisionPass< Handle >::current, MayaFlux::Yantra::DEPENDENCY, MayaFlux::Portal::Graphics::get_shader_foundry(), MayaFlux::Kinesis::Vision::VisionPass< Handle >::h, h, MayaFlux::Portal::Graphics::GpuBufferBinding::IMAGE_STORAGE, MayaFlux::Kinesis::Vision::VisionResult::images, MayaFlux::Portal::Graphics::GpuBufferBinding::INPUT_OUTPUT, MayaFlux::Portal::Graphics::INVALID_FENCE, MayaFlux::Yantra::VisionInternal::k_wg2d, MayaFlux::Yantra::ExecutionContext::mode, MayaFlux::Kinesis::Vision::ImageOutputs::open, MayaFlux::Yantra::ExecutionContext::parameters, MayaFlux::Yantra::VisionGpuContexts::pass, MayaFlux::Yantra::VisionGpuContexts::pixel, radius, MayaFlux::Kinesis::Vision::MorphParams::radius, MayaFlux::Yantra::VisionInternal::MorphPC::radius, MayaFlux::Kinesis::Vision::VisionPass< Handle >::result, MayaFlux::Portal::Graphics::GpuComputeConfig::shader_path, MayaFlux::Yantra::DependencyParams::stages, MayaFlux::Kinesis::Vision::VisionResult::structured, and MayaFlux::Kinesis::Vision::VisionPass< Handle >::w.

Here is the call graph for this function: