extract_implementation()

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

output_type MayaFlux::Yantra::VisionExtractor< InputType, OutputType >::extract_implementation ( const input_type &  input )

inlineoverrideprotectedvirtual

Pure virtual extraction implementation - derived classes implement this.

Parameters

input

Input data with metadata

Returns

Raw extraction output before scope processing

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

Definition at line 175 of file VisionExtractor.hpp.

    {
        const auto analysis_it = input.metadata.find("vision_analysis");
        if (analysis_it == input.metadata.end() || !analysis_it->second.has_value()) {
            error<std::runtime_error>(
                Journal::Component::Yantra,
                Journal::Context::ComputeMatrix,
                std::source_location::current(),
                "VisionExtractor: no vision_analysis in input metadata");
        }
 
        const auto& analysis = safe_any_cast_or_throw<VisionAnalysis>(
            analysis_it->second);
 
        if (analysis.pixel_image.empty()) {
            error<std::runtime_error>(
                Journal::Component::Yantra,
                Journal::Context::ComputeMatrix,
                std::source_location::current(),
                "VisionExtractor: VisionAnalysis carries no pixel data");
        }
 
        const uint32_t w = analysis.w;
        const uint32_t h = analysis.h;
        const auto channels = static_cast<uint32_t>(
            analysis.pixel_image.size() / (static_cast<size_t>(w) * h));
 
        const auto [nx, ny, nw, nh] = compute_normalised_rect(analysis);
 
        Kakshya::Region region = Kakshya::normalised_rect_to_region(nx, ny, nw, nh, w, h);
 
        const auto crop_w = static_cast<uint32_t>(
            region.end_coordinates[1] - region.start_coordinates[1] + 1);
        const auto crop_h = static_cast<uint32_t>(
            region.end_coordinates[0] - region.start_coordinates[0] + 1);
 
        const uint32_t stride = w * channels;
        const uint32_t crop_stride = crop_w * channels;
        std::vector<float> cropped(static_cast<size_t>(crop_w) * crop_h * channels);
 
        const float* src = analysis.pixel_image.data();
        float* dst = cropped.data();
 
        const auto y0 = static_cast<uint32_t>(region.start_coordinates[0]);
        const auto x0 = static_cast<uint32_t>(region.start_coordinates[1]);
 
        for (uint32_t row = 0; row < crop_h; ++row) {
            std::memcpy(
                dst + static_cast<size_t>(row * crop_stride),
                src + (static_cast<size_t>(y0 + row) * stride) + static_cast<size_t>(x0 * channels),
                crop_stride * sizeof(float));
        }
 
        if (m_mode == VisionExtractionMode::CONTOUR_MASKED) {
            const auto& contour = analysis.frame.contours[m_index];
            const float origin_x = nx;
            const float origin_y = ny;
            const float scale_x = nw / static_cast<float>(crop_w);
            const float scale_y = nh / static_cast<float>(crop_h);
            Kinesis::Vision::apply_contour_mask(
                std::span<float>(cropped),
                crop_w, crop_h, channels,
                contour,
                origin_x, origin_y, scale_x, scale_y);
        }
 
        output_type out;
        if constexpr (std::is_same_v<OutputType, std::vector<Kakshya::DataVariant>>) {
            out.data = std::vector<Kakshya::DataVariant> { std::move(cropped) };
        } else {
            out.data = OperationHelper::reconstruct_from_double<OutputType>({}, {});
        }
 
        out.dimensions = { Kakshya::DataDimension::spatial_2d(crop_w, crop_h) };
        out.modality = (channels == 1)
            ? Kakshya::DataModality::IMAGE_2D
            : Kakshya::DataModality::IMAGE_COLOR;
        out.metadata = input.metadata;
        out.metadata["crop_w"] = crop_w;
        out.metadata["crop_h"] = crop_h;
        out.metadata["vision_extractor_mode"] = static_cast<int>(m_mode);
        out.metadata["vision_extractor_index"] = m_index;
        return out;
    }

References MayaFlux::Kinesis::Vision::apply_contour_mask(), MayaFlux::Yantra::VisionExtractor< InputType, OutputType >::compute_normalised_rect(), MayaFlux::Journal::ComputeMatrix, MayaFlux::Yantra::CONTOUR_MASKED, MayaFlux::Yantra::Datum< T >::data, MayaFlux::Yantra::Datum< T >::dimensions, MayaFlux::Kakshya::Region::end_coordinates, h, MayaFlux::Kakshya::IMAGE_2D, MayaFlux::Kakshya::IMAGE_COLOR, input, MayaFlux::Yantra::VisionExtractor< InputType, OutputType >::m_index, MayaFlux::Yantra::VisionExtractor< InputType, OutputType >::m_mode, MayaFlux::Yantra::Datum< T >::metadata, MayaFlux::Yantra::Datum< T >::modality, MayaFlux::Kakshya::normalised_rect_to_region(), MayaFlux::Kakshya::DataDimension::spatial_2d(), MayaFlux::Kakshya::Region::start_coordinates, and MayaFlux::Journal::Yantra.

Here is the call graph for this function: