process()

void MayaFlux::Kakshya::SpatialRegionProcessor::process ( const std::shared_ptr< SignalSourceContainer > &  container )

overridevirtual

Extract all active regions from processed_data[0] in parallel.

   For each OrganizedRegion in m_organized_regions, extracts pixel
   data via extract_nd_region and appends to processed_data.
   Sets OrganizedRegion::state to ACTIVE during extraction and
   PROCESSED on completion.  Failed extractions are logged and
   skipped without aborting the frame.

Parameters

container

Source container; processed_data[0] must hold the full-surface buffer.

Implements MayaFlux::Kakshya::DataProcessor.

Definition at line 84 of file SpatialRegionProcessor.cpp.

{
    if (!container) {
        MF_RT_ERROR(Journal::Component::Kakshya, Journal::Context::ContainerProcessing,
            "SpatialRegionProcessor::process — null container");
        return;
    }
 
    auto& processed = container->get_processed_data();
 
    if (processed.empty()) {
        MF_RT_TRACE(Journal::Component::Kakshya, Journal::Context::ContainerProcessing,
            "SpatialRegionProcessor: processed_data empty, no readback available");
        container->update_processing_state(ProcessingState::IDLE);
        return;
    }
 
    const bool src_empty = std::visit(
        [](const auto& v) { return v.empty(); }, processed[0]);
 
    if (src_empty) {
        MF_RT_TRACE(Journal::Component::Kakshya, Journal::Context::ContainerProcessing,
            "SpatialRegionProcessor: processed_data[0] empty, skipping extraction");
        container->update_processing_state(ProcessingState::IDLE);
        return;
    }
 
    if (m_organized_regions.empty()) {
        container->update_processing_state(ProcessingState::IDLE);
        return;
    }
 
    m_is_processing.store(true, std::memory_order_release);
    container->update_processing_state(ProcessingState::PROCESSING);
 
    const auto& dims = container->get_structure().dimensions;
 
    std::vector<DataVariant> extracts;
    extracts.reserve(m_organized_regions.size());
 
    std::visit([&](const auto& src_vec) {
        using T = typename std::decay_t<decltype(src_vec)>::value_type;
 
        if constexpr (std::is_same_v<T, uint8_t>
            || std::is_same_v<T, uint16_t>
            || std::is_same_v<T, uint32_t>
            || std::is_same_v<T, float>) {
 
            const std::span<const T> src { src_vec.data(), src_vec.size() };
 
            for (auto& org : m_organized_regions) {
                if (org.segments.empty()) {
                    MF_RT_WARN(Journal::Component::Kakshya, Journal::Context::ContainerProcessing,
                        "SpatialRegionProcessor: OrganizedRegion '{}[{}]' has no segments, skipping",
                        org.group_name, org.region_index);
                    continue;
                }
 
                org.state = RegionState::ACTIVE;
 
                try {
                    extracts.emplace_back(
                        extract_nd_region<T>(src, org.segments[0].source_region, dims));
                    org.state = RegionState::READY;
                } catch (const std::exception& e) {
                    MF_RT_WARN(Journal::Component::Kakshya, Journal::Context::ContainerProcessing,
                        "SpatialRegionProcessor: extraction failed for '{}[{}]' — {}",
                        org.group_name, org.region_index, e.what());
                    org.state = RegionState::IDLE;
                }
            }
        } else {
            MF_RT_WARN(Journal::Component::Kakshya, Journal::Context::ContainerProcessing,
                "SpatialRegionProcessor: processed_data[0] holds a type not suitable "
                "for spatial pixel extraction ({}); no regions extracted",
                typeid(T).name());
        }
    },
        processed[0]);
 
    processed = std::move(extracts);
 
    m_is_processing.store(false, std::memory_order_release);
    container->update_processing_state(ProcessingState::PROCESSED);
}

References MayaFlux::Kakshya::ACTIVE, MayaFlux::Journal::ContainerProcessing, MayaFlux::Kakshya::IDLE, MayaFlux::Journal::Kakshya, MayaFlux::Kakshya::RegionProcessorBase::m_is_processing, MayaFlux::Kakshya::RegionProcessorBase::m_organized_regions, MF_RT_ERROR, MF_RT_TRACE, MF_RT_WARN, MayaFlux::Kakshya::PROCESSED, MayaFlux::Kakshya::PROCESSING, and MayaFlux::Kakshya::READY.