process_to_stream()

Kriya::ChimeraBuilder MayaFlux::Yantra::Vision::VisionWorkflow::process_to_stream

(

const WorkflowStreamConfig &

config

)

Run config's matrix on its source live and return a Chimera builder over a new layer array, for any image the run produces.

Paced and sourced as process_to_buffer(). The layers, their sources and the rendering are declared on the returned builder, and the array itself, for a shader's mode, is its get_buffer(). Each analysis is handed to the matrix's extract(), so its analysis(), frame() and extraction() follow the run; the images of every sequence are read from its results() or, by intent, result(). Then each record entry appends its picked image, all together once per analysis, at the run's pace: one per interval, or as often as the work completes, which the matrix reports as analysis_rate(). The run stops as the other live runs do, and also once the Chimera that was started from the builder is stopped or dropped, or the builder is dropped unstarted. The Chimera outlives the run and keeps its last images.

Returns

The builder, or one without an array when the engine's managers are gone, the matrix is null or the stream cannot be hooked.

Definition at line 496 of file VisionWorkflow.cpp.

{
    if (!config.matrix) {
        MF_WARN(Journal::Component::Yantra, Journal::Context::ComputeMatrix,
            "VisionWorkflow::process_to_stream: no matrix");
        return { nullptr, nullptr };
    }
 
    const auto frames = source_frames(config.source, "process_to_stream");
    const auto buffers = m_buffer_manager.lock();
    if (!frames || !buffers)
        return { nullptr, nullptr };
 
    auto array = buffers->create_graphics_buffer<Buffers::TextureArrayBuffer>(
        Buffers::ProcessingToken::GRAPHICS_BACKEND, config.layers, config.fit);
    auto pipeline = Kriya::BufferPipeline::create(*m_scheduler.lock(), buffers, m_io_manager.lock());
 
    const auto name = run_name("stream");
    start(config.source, frames, config.live.value_or(LiveConfig {}), config.matrix, name,
        [matrix = config.matrix, record = config.record](const VisionIO& frame) {
            const auto analysis = Kakshya::get_metadata_value<Kinesis::Vision::VisionAnalysis>(frame.metadata, "vision_analysis");
            const auto image = Kakshya::get_metadata_value<std::shared_ptr<Core::VKImage>>(frame.metadata, "vision_image");
            if (!analysis || !image)
                return;
 
            matrix->extract(*analysis, *image);
 
            for (const auto& [collection, pick] : record) {
                if (!collection || !pick)
                    continue;
                if (const auto picked = pick(*matrix))
                    collection->append(picked);
            }
        },
        [weak_pipeline = std::weak_ptr(pipeline), seen_running = std::make_shared<bool>(false)]() {
            const auto chimera_pipeline = weak_pipeline.lock();
            if (!chimera_pipeline)
                return true;
            if (chimera_pipeline->is_running()) {
                *seen_running = true;
                return false;
            }
            return *seen_running;
        });
 
    return { std::move(array), std::move(pipeline) };
}

References MayaFlux::Journal::ComputeMatrix, MayaFlux::Kriya::BufferPipeline::create(), MayaFlux::Yantra::Vision::WorkflowStreamConfig::fit, MayaFlux::Buffers::GRAPHICS_BACKEND, MayaFlux::Yantra::Vision::WorkflowStreamConfig::layers, MayaFlux::Yantra::Vision::WorkflowStreamConfig::live, m_buffer_manager, m_io_manager, m_scheduler, MayaFlux::Yantra::Vision::WorkflowStreamConfig::matrix, MF_WARN, name, MayaFlux::Yantra::Vision::WorkflowStreamConfig::record, MayaFlux::Yantra::Vision::WorkflowStreamConfig::source, source_frames(), start(), and MayaFlux::Journal::Yantra.

Here is the call graph for this function: