analyze_implementation()

template<ComputeData InputType = std::vector<Kakshya::DataVariant>, ComputeData OutputType = std::vector<Kakshya::DataVariant>>

output_type MayaFlux::Yantra::VisionAnalyzer< InputType, OutputType >::analyze_implementation ( const input_type &  input )

inlineoverrideprotectedvirtual

Pure virtual analysis implementation - derived classes implement this.

Parameters

input

Input data with metadata

Returns

Raw analysis output before granularity formatting

Implements MayaFlux::Yantra::UniversalAnalyzer< InputType, OutputType >.

Definition at line 171 of file VisionAnalyzer.hpp.

    {
        try {
            auto [native_spans, structure_info] = OperationHelper::extract_structured_native(
                const_cast<input_type&>(input));
 
            if (native_spans.empty()) {
                error<std::runtime_error>(
                    Journal::Component::Yantra,
                    Journal::Context::ComputeMatrix,
                    std::source_location::current(),
                    "VisionAnalyzer: no pixel data in input");
            }
 
            uint32_t w = 0;
            uint32_t h = 0;
            for (const auto& dim : structure_info.dimensions) {
                if (dim.role == Kakshya::DataDimension::Role::SPATIAL_X) {
                    w = static_cast<uint32_t>(dim.size);
                } else if (dim.role == Kakshya::DataDimension::Role::SPATIAL_Y) {
                    h = static_cast<uint32_t>(dim.size);
                }
            }
            if (w == 0)
                w = Kakshya::get_metadata_value<uint32_t>(input.metadata, "width").value_or(0);
            if (h == 0)
                h = Kakshya::get_metadata_value<uint32_t>(input.metadata, "height").value_or(0);
 
            if (w == 0 || h == 0) {
                error<std::runtime_error>(
                    Journal::Component::Yantra,
                    Journal::Context::ComputeMatrix,
                    std::source_location::current(),
                    "VisionAnalyzer: width/height not resolvable from dimensions or metadata");
            }
 
            auto frame = std::visit([&](const auto& span) -> std::span<const float> {
                using ElemT = typename std::decay_t<decltype(span)>::value_type;
                if constexpr (std::is_same_v<ElemT, float>) {
                    return span;
                } else {
                    using VecT = std::vector<ElemT>;
                    VecT tmp(span.begin(), span.end());
                    Kakshya::DataVariant var(std::move(tmp));
                    return Kakshya::as_normalised_float(var, m_float_storage);
                }
            },
                native_spans[0]);
 
            if (frame.empty()) {
                error<std::runtime_error>(
                    Journal::Component::Yantra,
                    Journal::Context::ComputeMatrix,
                    std::source_location::current(),
                    "VisionAnalyzer: normalisation produced empty frame");
            }
 
            const Kinesis::Vision::VisionResult vr = m_executor.run(m_sequence, frame, w, h);
 
            VisionAnalysis analysis;
            if (const auto* v = std::get_if<std::vector<float>>(&vr.pixel_image))
                analysis.pixel_image = *v;
 
            analysis.w = vr.w;
            analysis.h = vr.h;
 
            std::visit([&](const auto& s) {
                using T = std::decay_t<decltype(s)>;
                if constexpr (std::is_same_v<T, Kinesis::Vision::GradientResult>) {
                    analysis.frame.gradient = s;
                } else if constexpr (std::is_same_v<T, Kinesis::Vision::ComponentResult>) {
                    analysis.frame.components = s;
                    analysis.frame.boxes = s.boxes;
                } else if constexpr (std::is_same_v<T, std::vector<Kinesis::Vision::Contour>>) {
                    analysis.frame.contours = s;
                } else if constexpr (std::is_same_v<T, std::vector<Kinesis::Vision::Keypoint>>) {
                    analysis.frame.keypoints = s;
                } else if constexpr (std::is_same_v<T, std::vector<Kinesis::Vision::TrackResult>>) {
                    analysis.frame.tracks = s;
                }
            },
                vr.structured);
 
            this->store_current_analysis(analysis);
 
            return create_pipeline_output(input, vr, structure_info);
 
        } catch (const std::exception& e) {
            MF_ERROR(Journal::Component::Yantra, Journal::Context::ComputeMatrix,
                "VisionAnalyzer: {}", e.what());
            output_type err;
            err.metadata = input.metadata;
            err.metadata["error"] = std::string(e.what());
            return err;
        }
    }

References MayaFlux::Kakshya::as_normalised_float(), MayaFlux::Yantra::DetectionSummary::boxes, MayaFlux::Yantra::DetectionSummary::components, MayaFlux::Journal::ComputeMatrix, MayaFlux::Yantra::DetectionSummary::contours, MayaFlux::Yantra::VisionAnalyzer< InputType, OutputType >::create_pipeline_output(), MayaFlux::Yantra::OperationHelper::extract_structured_native(), MayaFlux::Yantra::VisionAnalysis::frame, MayaFlux::Yantra::DetectionSummary::gradient, MayaFlux::Kinesis::Vision::VisionResult::h, h, MayaFlux::Yantra::VisionAnalysis::h, input, MayaFlux::Yantra::DetectionSummary::keypoints, MayaFlux::Yantra::VisionAnalyzer< InputType, OutputType >::m_executor, MayaFlux::Yantra::VisionAnalyzer< InputType, OutputType >::m_float_storage, MayaFlux::Yantra::VisionAnalyzer< InputType, OutputType >::m_sequence, MayaFlux::Yantra::Datum< T >::metadata, MF_ERROR, MayaFlux::Kinesis::Vision::VisionResult::pixel_image, MayaFlux::Yantra::VisionAnalysis::pixel_image, MayaFlux::Kinesis::Vision::VisionExecutor::run(), MayaFlux::Kakshya::DataDimension::SPATIAL_X, MayaFlux::Kakshya::DataDimension::SPATIAL_Y, MayaFlux::Yantra::UniversalAnalyzer< InputType, OutputType >::store_current_analysis(), MayaFlux::Kinesis::Vision::VisionResult::structured, MayaFlux::Yantra::DetectionSummary::tracks, MayaFlux::Kinesis::Vision::VisionResult::w, MayaFlux::Yantra::VisionAnalysis::w, and MayaFlux::Journal::Yantra.

Here is the call graph for this function: