◆ run() [2/2]

VisionResult MayaFlux::Yantra::VisionGpuExecutor::run	(	VisionGpuContexts &	contexts,
		const Kinesis::Vision::VisionSequence &	sequence,
		const std::shared_ptr< Core::VKImage > &	image,
		uint32_t	w,
		uint32_t	h
	)
Execute a VisionSequence on the GPU through an explicit context set.
contexts is caller-supplied rather than the instance's own lazily-built m_contexts. Reused across calls with no reset needed; construction is the caller's responsibility and never happens inside this function.
Parameters
contexts	Long-lived context set. Never constructed internally.
sequence	Ordered steps to execute.
image	Input frame in eShaderReadOnlyOptimal layout.
w	Frame width in pixels.
h	Frame height in pixels.
Returns: VisionResult matching the VisionExecutor::run() contract.
Definition at line 450 of file VisionGpuDispatch.cpp.
{
    auto& pixel_ctx = contexts.pixel;
    auto& structured_ctx = contexts.structured;
    auto& label_ctx = contexts.labels;
    auto& cc_pipeline = contexts.component_contours;
 
    auto& foundry = Portal::Graphics::get_shader_foundry();
    std::unordered_map<size_t, CompletedOp> completed_ops;
    size_t begin = 0;
 
    if (contexts.suspended.is_active()) {
        if (&sequence != contexts.pass.sequence) {
            MF_WARN(Journal::Component::Yantra, Journal::Context::ComputeMatrix,
                "run_gpu: polling a suspension with a different sequence; "
                "the walk continues on the sequence the run started from");
        }
 
        if (!foundry.is_fence_signaled(contexts.suspended.fence)) {
            VisionResult pending;
            pending.status = VisionStatus::SUSPENDED;
            pending.suspended_at = contexts.pass.index;
            return pending;
        }
 
        foundry.release_fence(contexts.suspended.fence);
        contexts.suspended.fence = Portal::Graphics::INVALID_FENCE;
 
        if (auto finalize = std::move(contexts.suspended.finalize)) {
            contexts.suspended.finalize = nullptr;
            finalize(contexts);
        }
 
        begin = contexts.pass.index + 1;
    } else {
        reap_fences(contexts);
        contexts.flow_state.curr_ready = false;
        contexts.pass.begin(sequence, w, h);
        contexts.pass.storage_w = 0;
        contexts.pass.storage_h = 0;
        contexts.bound_staged.reset();
        const auto seed = op_ingest(contexts, image, w, h);
        contexts.pass.current = seed;
        contexts.source = seed;
    }
 
    for (contexts.pass.index = begin; contexts.pass.index < sequence.steps.size(); ++contexts.pass.index) {
        const auto& step = sequence.steps[contexts.pass.index];
 
        if (step.op == VisionOp::Snapshot) {
            op_snapshot(contexts);
            continue;
        }
 
        const uint32_t w = contexts.pass.w;
        const uint32_t h = contexts.pass.h;
 
        const auto cfg = config(step.op, step.params);
 
        if (cfg.shader_id == Portal::Graphics::INVALID_SHADER && cfg.shader_path.empty()) {
            MF_ERROR(Journal::Component::Yantra, Journal::Context::ComputeMatrix,
                "run_gpu: no GPU implementation for VisionOp {}",
                static_cast<int>(step.op));
            return VisionResult {};
        }
 
        if (cfg.shader_id != contexts.bound_config.shader_id
            || cfg.shader_path != contexts.bound_config.shader_path) {
            pixel_ctx.swap_shader(cfg);
            contexts.bound_config = cfg;
        }
        if (contexts.pass.current != contexts.bound_staged) {
            pixel_ctx.stage_image(contexts.pass.current);
            contexts.bound_staged = contexts.pass.current;
        }
        if (w != contexts.pass.storage_w || h != contexts.pass.storage_h
            || (contexts.pass.current && contexts.pass.current == pixel_ctx.get_output_image(0))) {
            pixel_ctx.prepare_output_image(w, h);
            contexts.pass.storage_w = w;
            contexts.pass.storage_h = h;
        }
        pixel_ctx.set_output_dimensions(w, h);
 
        switch (step.op) {
        case VisionOp::Downsample2x: {
            const uint32_t new_w = std::max(1U, w / 2);
            const uint32_t new_h = std::max(1U, h / 2);
 
            pixel_ctx.prepare_output_image(new_w, new_h);
            pixel_ctx.set_output_dimensions(new_w, new_h);
            {
                const auto f = pixel_ctx.dispatch_async({});
                foundry.wait_for_fence(f);
                foundry.release_fence(f);
            }
            pixel_ctx.clear_output_dimensions();
 
            auto downsampled = pixel_ctx.get_output_image(0);
            completed_ops[Kinesis::Vision::hash_vision_step(step.op, step.params)] = { .output = downsampled, .input = contexts.pass.current };
            contexts.pass.result.images.downsample_2x = downsampled;
            contexts.pass.current = downsampled;
            contexts.bound_staged.reset();
 
            contexts.pass.set_geometry(new_w, new_h);
            contexts.pass.storage_w = new_w;
            contexts.pass.storage_h = new_h;
 
            continue;
        }
        case VisionOp::Threshold: {
            const auto& p = std::get<ThresholdParams>(step.params);
            if (p.channels == ChannelMask::NONE) {
                pixel_ctx.set_push_constants(ThresholdPC { .value = p.value });
            } else {
                pixel_ctx.set_push_constants(ThresholdBandsPC {
                    .lo0 = p.bands[0].lo, .lo1 = p.bands[1].lo, .lo2 = p.bands[2].lo,
                    .hi0 = p.bands[0].hi, .hi1 = p.bands[1].hi, .hi2 = p.bands[2].hi,
                    .channels = static_cast<uint32_t>(p.channels) });
            }
            break;
        }
        case VisionOp::NormalizeRange: {
            const auto& p = std::get<NormalizeRangeParams>(step.params);
            const float scale = (p.hi > p.lo) ? 1.0F / (p.hi - p.lo) : 1.0F;
            const float off = (p.hi > p.lo) ? -p.lo / (p.hi - p.lo) : 0.0F;
            pixel_ctx.set_push_constants(NormalizePC { .scale = scale, .offset = off });
            break;
        }
        case VisionOp::RgbaToGray:
            pixel_ctx.set_push_constants(RgbaToGrayPC {
                .wr = 0.299F, .wg = 0.587F, .wb = 0.114F, .wa = 0.0F });
            break;
        case VisionOp::GaussianBlur: {
            const auto& p = std::get<GaussianBlurParams>(step.params);
            const auto radius = static_cast<uint32_t>(std::ceil(p.sigma * 3.0F));
            const auto& weights = gaussian_kernel_2d(radius, p.sigma);
            pixel_ctx.set_binding_data(2, std::span<const float>(weights));
            pixel_ctx.set_push_constants(GaussianPC { .radius = radius, .width = w, .height = h });
            break;
        }
        case VisionOp::Erode:
        case VisionOp::Dilate:
        case VisionOp::MorphGradient:
            pixel_ctx.set_push_constants(MorphPC {
                .radius = std::get<MorphParams>(step.params).radius });
            break;
        case VisionOp::ThresholdAdaptive: {
            const auto& p = std::get<ThresholdAdaptiveParams>(step.params);
            pixel_ctx.set_push_constants(ThresholdAdaptivePC { .block_size = p.block_size, .offset = p.offset, .channels = static_cast<uint32_t>(p.channels) });
            break;
        }
        case VisionOp::ThresholdOtsu: {
            const auto* otsu = std::get_if<OtsuParams>(&step.params);
            contexts.pass.completed[Kinesis::Vision::hash_vision_step(step.op, step.params)] = op_threshold_otsu(contexts, otsu ? *otsu : OtsuParams {});
            continue;
        }
        case VisionOp::Confine: {
            contexts.pass.completed[Kinesis::Vision::hash_vision_step(step.op, step.params)] = op_confine(contexts, std::get<ConfineParams>(step.params));
            continue;
        }
        case VisionOp::Open:
        case VisionOp::Close: {
            contexts.pass.completed[Kinesis::Vision::hash_vision_step(step.op, step.params)] = op_open_close(contexts, step.op, std::get<MorphParams>(step.params));
            continue;
        }
        case VisionOp::Canny: {
            auto done = op_canny(contexts, step.params, std::get<CannyParams>(step.params));
            contexts.pass.completed[Kinesis::Vision::hash_vision_step(step.op, step.params)] = done;
            continue;
        }
        case VisionOp::HarrisResponse: {
            contexts.pass.completed[Kinesis::Vision::hash_vision_step(step.op, step.params)] = op_harris_response(contexts, std::get<HarrisParams>(step.params));
            continue;
        }
        case VisionOp::ExtractPeaks: {
            op_extract_peaks(contexts, std::get<ExtractPeaksParams>(step.params));
            continue;
        }
        case VisionOp::ConnectedComponents: {
            if (!contexts.pass.current) {
                continue;
            }
            op_connected_components(contexts, std::get<Kinesis::Vision::ConnectedComponentsParams>(step.params));
            continue;
        }
        case VisionOp::FindContours: {
            if (!op_find_contours(contexts,
                    std::get<Kinesis::Vision::FindContoursParams>(step.params)))
                return VisionResult {};
            continue;
        }
        case VisionOp::TrackKeypoints: {
            if (op_track_keypoints(contexts, step)) {
                VisionResult pending;
                pending.status = VisionStatus::SUSPENDED;
                pending.suspended_at = contexts.pass.index;
                return pending;
            }
            continue;
        }
        case VisionOp::OpticalFlowDense: {
            if (op_dense_flow(contexts, step)) {
                VisionResult pending;
                pending.status = VisionStatus::SUSPENDED;
                pending.suspended_at = contexts.pass.index;
                return pending;
            }
            continue;
        }
        default:
            break;
        }
 
        auto dispatch_input = contexts.pass.current;
        const auto fence = pixel_ctx.dispatch_async({});
 
        if (step.deferred) {
            pixel_ctx.clear_output_dimensions();
            contexts.pass.current = pixel_ctx.get_output_image(0);
            contexts.bound_staged.reset();
 
            const Kinesis::Vision::GpuVisionPass::Completed done {
                .output = contexts.pass.current,
                .input = dispatch_input
            };
            contexts.pass.completed[Kinesis::Vision::hash_vision_step(step.op, step.params)] = done;
 
            contexts.suspended.fence = fence;
            contexts.suspended.finalize = [](VisionGpuContexts& c) { after_step(c, c.pass.index); };
 
            VisionResult pending;
            pending.status = VisionStatus::SUSPENDED;
            pending.suspended_at = contexts.pass.index;
            return pending;
        }
 
        foundry.wait_for_fence(fence);
        foundry.release_fence(fence);
 
        pixel_ctx.clear_output_dimensions();
        contexts.pass.current = pixel_ctx.get_output_image(0);
        contexts.bound_staged.reset();
        completed_ops[Kinesis::Vision::hash_vision_step(step.op, step.params)] = { .output = contexts.pass.current, .input = dispatch_input };
 
        switch (step.op) {
        case VisionOp::RgbaToGray:
            contexts.pass.result.gray = contexts.pass.current;
            break;
        case VisionOp::RgbaToHsv:
            contexts.pass.result.images.rgba_to_hsv = contexts.pass.current;
            break;
        case VisionOp::GrayToRgba:
            contexts.pass.result.images.gray_to_rgba = contexts.pass.current;
            break;
        case VisionOp::Threshold:
            contexts.pass.result.images.threshold = contexts.pass.current;
            break;
        case VisionOp::ThresholdAdaptive:
            contexts.pass.result.images.threshold_adaptive = contexts.pass.current;
            break;
        case VisionOp::NormalizeInplace:
            contexts.pass.result.images.normalize_inplace = contexts.pass.current;
            break;
        case VisionOp::NormalizeRange:
            contexts.pass.result.images.normalize_range = contexts.pass.current;
            break;
        case VisionOp::GaussianBlur:
            contexts.pass.result.images.gaussian_blur = contexts.pass.current;
            break;
        case VisionOp::FilterSeparable:
            contexts.pass.result.images.filter_separable = contexts.pass.current;
            break;
        case VisionOp::Sobel:
            contexts.pass.result.images.sobel = contexts.pass.current;
            break;
        case VisionOp::Scharr:
            contexts.pass.result.images.scharr = contexts.pass.current;
            break;
        case VisionOp::Erode:
            contexts.pass.result.images.erode = contexts.pass.current;
            break;
        case VisionOp::Dilate:
            contexts.pass.result.images.dilate = contexts.pass.current;
            break;
        case VisionOp::MorphGradient:
            contexts.pass.result.images.morph_gradient = contexts.pass.current;
            break;
        default:
            break;
        }
 
        after_step(contexts, contexts.pass.index);
    }
 
    return std::move(contexts.pass.result);
}
Here is the call graph for this function: