resolve()

MAYAFLUX_API std::vector< ResolvedSequence > MayaFlux::Kinesis::Vision::resolve

(

const VisionQuery &

query

)

Resolve a VisionQuery into the ResolvedSequences needed to satisfy every active intent.

TrackObjects and EstimateMotion, when both active, resolve into one sequence sharing a tail; neither can be split back apart afterward. Every other active intent gets its own sequence, seeded from whichever leading steps it has in common with the first sequence (matched by VisionOp and params) instead of recomputing them. Sharing happens only when neither sequence runs a step that overwrites the executor's shared output images after the shared prefix, because such a step would already have destroyed the seed. Seeded sequences are returned right after the first, unseeded ones last, and DetectEdges last of all so the edge image it hands back is not overwritten by a later sequence.

Parameters

query

Active intents and their parameters.

Returns

Ordered ResolvedSequences to run against the same frame; empty when no intent in query.intents has a populated parameter field.

Definition at line 170 of file VisionQuery.cpp.

{
    std::vector<VisionStep> flow_lane;
    std::vector<std::vector<VisionStep>> other_chains;
 
    auto append_to_flow_lane = [&](VisionSequence chain) {
        auto steps = std::move(chain.steps);
        if (!flow_lane.empty() && !steps.empty() && steps.front().op == VisionOp::RgbaToGray)
            steps.erase(steps.begin());
        flow_lane.insert(flow_lane.end(),
            std::make_move_iterator(steps.begin()),
            std::make_move_iterator(steps.end()));
    };
 
    if (has_flag(query.intents, VisionIntent::TrackObjects) && query.track_objects)
        append_to_flow_lane(track_objects_chain(*query.track_objects));
 
    if (has_flag(query.intents, VisionIntent::EstimateMotion) && query.estimate_motion)
        append_to_flow_lane(estimate_motion_chain(*query.estimate_motion));
 
    if (has_flag(query.intents, VisionIntent::FindElements) && query.find_elements)
        other_chains.push_back(find_elements_chain(*query.find_elements).steps);
 
    if (has_flag(query.intents, VisionIntent::DetectFeatures) && query.detect_features)
        other_chains.push_back(detect_features_chain(*query.detect_features).steps);
 
    if (has_flag(query.intents, VisionIntent::MeasureAppearance) && query.measure_appearance)
        other_chains.push_back(measure_appearance_chain(*query.measure_appearance).steps);
 
    if (has_flag(query.intents, VisionIntent::DetectEdges) && query.detect_edges)
        other_chains.push_back(detect_edges_chain(*query.detect_edges).steps);
 
    std::vector<ResolvedSequence> sequences;
    sequences.reserve(1 + other_chains.size());
    std::optional<size_t> reference_index;
 
    if (!flow_lane.empty()) {
        sequences.push_back({ .sequence = VisionSequence { .steps = std::move(flow_lane) } });
        reference_index = 0;
    }
 
    std::vector<ResolvedSequence> seeded;
    std::vector<ResolvedSequence> unseeded;
 
    for (auto& steps : other_chains) {
        if (!reference_index) {
            sequences.push_back({ .sequence = VisionSequence { .steps = std::move(steps) } });
            reference_index = 0;
            continue;
        }
 
        const auto& reference = sequences[*reference_index].sequence.steps;
        ResolvedSequence resolved;
        const size_t shared = shared_prefix_length(reference, steps);
        if (shared > 0) {
            resolved.seed_lane = *reference_index;
            resolved.seed_field = seed_accessor_for(reference[shared - 1].op);
            steps.erase(steps.begin(), steps.begin() + static_cast<std::ptrdiff_t>(shared));
        }
        resolved.sequence = VisionSequence { .steps = std::move(steps) };
        (resolved.seed_field ? seeded : unseeded).push_back(std::move(resolved));
    }
 
    sequences.insert(sequences.end(), std::make_move_iterator(seeded.begin()), std::make_move_iterator(seeded.end()));
    sequences.insert(sequences.end(), std::make_move_iterator(unseeded.begin()), std::make_move_iterator(unseeded.end()));
 
    return sequences;
}

References chain, MayaFlux::Kinesis::Vision::VisionQuery::detect_edges, MayaFlux::Kinesis::Vision::VisionQuery::detect_features, DetectEdges, DetectFeatures, MayaFlux::Kinesis::Vision::VisionQuery::estimate_motion, EstimateMotion, MayaFlux::Kinesis::Vision::VisionQuery::find_elements, FindElements, MayaFlux::Kinesis::Vision::VisionQuery::intents, MayaFlux::Kinesis::Vision::VisionQuery::measure_appearance, MeasureAppearance, RgbaToGray, MayaFlux::Kinesis::Vision::ResolvedSequence::seed_field, MayaFlux::Kinesis::Vision::ResolvedSequence::seed_lane, MayaFlux::Kinesis::Vision::ResolvedSequence::sequence, MayaFlux::Kinesis::Vision::VisionSequence::steps, MayaFlux::Kinesis::Vision::VisionQuery::track_objects, and TrackObjects.

Referenced by MayaFlux::Yantra::VisionAnalyzer::advance(), MayaFlux::Yantra::VisionAnalyzer::analyze_resolved(), and MayaFlux::Yantra::Vision::VisionMatrix::result().

Here is the caller graph for this function: