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 auto* full_surface = std::get_if<std::vector<uint8_t>>(&processed[0]);
    if (!full_surface || full_surface->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;
    const std::span<const uint8_t> src { full_surface->data(), full_surface->size() };
 
    std::vector<DataVariant> extracts;
    extracts.reserve(m_organized_regions.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<uint8_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;
        }
    }
 
    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.