apply_operation_internal()

template<ComputeData InputType = std::shared_ptr<Kakshya::SignalSourceContainer>, ComputeData OutputType = InputType>

output_type MayaFlux::Yantra::VisionSorter< InputType, OutputType >::apply_operation_internal ( const input_type &  input, const ExecutionContext &  context  )

inlineoverrideprotectedvirtual

Internal execution method - ComputeMatrix can access this.

Parameters

input	Input data wrapped in IO
context	Execution context with mode, threading, etc.

Returns

Processed output

Reimplemented from MayaFlux::Yantra::ComputeOperation< InputType, OutputType >.

Definition at line 125 of file VisionSorter.hpp.

    {
        if (this->m_gpu_backend && this->m_gpu_backend->ensure_gpu_ready()) {
            const auto analysis_it = input.metadata.find("vision_analysis");
            if (analysis_it != input.metadata.end() && analysis_it->second.has_value()) {
                auto analysis = safe_any_cast_or_throw<VisionAnalysis>(analysis_it->second);
 
                const size_t n = !analysis.frame.boxes.empty()
                    ? analysis.frame.boxes.size()
                    : analysis.frame.contours.size();
 
                if (n > 1) {
                    uint32_t padded = 1;
                    while (padded < static_cast<uint32_t>(n))
                        padded <<= 1;
 
                    std::vector<float> keys(padded, std::numeric_limits<float>::infinity());
                    for (size_t i = 0; i < n; ++i)
                        keys[i] = compute_key(i, analysis);
 
                    std::vector<float> indices(padded);
                    for (uint32_t i = 0; i < padded; ++i)
                        indices[i] = static_cast<float>(i);
 
                    const auto k = static_cast<uint32_t>(
                        std::ceil(std::log2(static_cast<double>(padded))));
                    const uint32_t total_passes = k * (k + 1) / 2;
                    const uint32_t desc = (this->get_direction() == SortingDirection::DESCENDING) ? 1U : 0U;
                    const uint32_t count = padded;
 
                    auto* ctx = dynamic_cast<ShaderExecutionContext<>*>(
                        this->m_gpu_backend.get());
 
                    if (ctx) {
                        ctx->in_out(keys).in_out(indices);
                        ctx->set_multipass(total_passes,
                            [k, desc, count](uint32_t p, void* pc_ptr) {
                                uint32_t stage = 0, pass = 0, remaining = p;
                                for (uint32_t s = 0; s < k; ++s) {
                                    if (remaining <= s) {
                                        stage = s;
                                        pass = remaining;
                                        break;
                                    }
                                    remaining -= (s + 1);
                                }
                                struct PC {
                                    uint32_t stage, pass, count, descending;
                                };
                                *static_cast<PC*>(pc_ptr) = { stage, pass, count, desc };
                            });
 
                        auto* ctx = dynamic_cast<ShaderExecutionContext<InputType, OutputType>*>(
                            this->m_gpu_backend.get());
                        auto gpu_result = this->m_gpu_backend->execute(input, context);
 
                        std::vector<float> sorted_idx_floats(padded);
                        ctx->download_binding(1, sorted_idx_floats.data(),
                            padded * sizeof(float));
 
                        auto apply_permutation = [&]<typename T>(std::vector<T>& coll) {
                            std::vector<T> sorted(n);
                            for (size_t i = 0; i < n; ++i) {
                                const auto src = static_cast<size_t>(sorted_idx_floats[i]);
                                if (src < n)
                                    sorted[i] = coll[src];
                            }
                            coll = std::move(sorted);
                        };
 
                        if (!analysis.frame.boxes.empty())
                            apply_permutation(analysis.frame.boxes);
                        if (!analysis.frame.contours.empty())
                            apply_permutation(analysis.frame.contours);
 
                        output_type out { input.data };
                        out.metadata = input.metadata;
                        out.metadata["vision_analysis"] = std::move(analysis);
                        return out;
                    }
                }
            }
        }
 
        return UniversalSorter<InputType, OutputType>::apply_operation_internal(input, context);
    }

References MayaFlux::Yantra::ComputeOperation< InputType, OutputType >::apply_operation_internal(), MayaFlux::Yantra::VisionSorter< InputType, OutputType >::compute_key(), count, MayaFlux::Yantra::Datum< T >::data, MayaFlux::Yantra::ShaderExecutionContext< InputType, OutputType >::execute(), MayaFlux::Yantra::UniversalSorter< InputType, OutputType >::get_direction(), MayaFlux::Yantra::ShaderExecutionContext< InputType, OutputType >::in_out(), input, k, MayaFlux::Yantra::ComputeOperation< InputType, OutputType >::m_gpu_backend, MayaFlux::Yantra::Datum< T >::metadata, pass, and MayaFlux::Yantra::ShaderExecutionContext< InputType, OutputType >::set_multipass().

Here is the call graph for this function: