annotate()

std::shared_ptr< Core::VKImage > MayaFlux::Yantra::VisionExtractor::annotate	(	const std::shared_ptr< Core::VKImage > &	source,
		const Kinesis::Vision::VisionAnalysis &	analysis,
		uint32_t	source_w,
		uint32_t	source_h
	)

source with everything the analysis found drawn on it: element boxes (yellow) and contours (cyan), track arrows from previous to current position (green tracked, red lost) with their bounds and centroid (white), keypoints (magenta) with their bounds.

Definition at line 667 of file VisionExtractor.cpp.

{
    const glm::vec4 yellow { 1.0F, 1.0F, 0.0F, 1.0F };
    const glm::vec4 cyan { 0.0F, 1.0F, 1.0F, 1.0F };
    const glm::vec4 green { 0.0F, 1.0F, 0.0F, 1.0F };
    const glm::vec4 red { 1.0F, 0.0F, 0.0F, 1.0F };
    const glm::vec4 white { 1.0F, 1.0F, 1.0F, 1.0F };
    const glm::vec4 magenta { 1.0F, 0.0F, 1.0F, 1.0F };
 
    const glm::vec2 half { 3.0F / static_cast<float>(source_w), 3.0F / static_cast<float>(source_h) };
 
    std::vector<float> segments;
 
    if (analysis.find_elements) {
        for (const auto& box : analysis.find_elements->boxes)
            add_rect(segments, box, yellow);
        for (const auto& contour : analysis.find_elements->contours) {
            const auto n = contour.points.size();
            for (size_t i = 0; n > 1 && i < n; ++i)
                add_line(segments, contour.points[i], contour.points[(i + 1) % n], cyan);
        }
    }
 
    if (analysis.track_objects && !analysis.track_objects->tracks.empty()) {
        for (const auto& t : analysis.track_objects->tracks) {
            add_line(segments, t.previous, t.position, t.tracked ? green : red);
            add_cross(segments, t.position, half, t.tracked ? green : red);
        }
        add_rect(segments, analysis.track_objects->bounds, white);
        add_cross(segments, analysis.track_objects->centroid, half, white);
    }
 
    if (analysis.detect_features && !analysis.detect_features->keypoints.empty()) {
        for (const auto& k : analysis.detect_features->keypoints)
            add_cross(segments, k.position, half, magenta);
        add_rect(segments, analysis.detect_features->bounds, white);
    }
 
    const auto count = static_cast<uint32_t>(segments.size() / 8);
    if (segments.empty())
        segments.assign(8, 0.0F);
 
    auto& ctx = image_context();
    use_shader(ctx, "vision_crop.comp.spv", k_wg_image, sizeof(CropPC));
    ctx.stage_image(source);
    ctx.set_binding_data(3, std::span<const float>(segments));
    ctx.set_push_constants(CropPC {
        .src_x = 0.0F, .src_y = 0.0F, .src_w = 1.0F, .src_h = 1.0F,
        .out_w = source_w, .out_h = source_h });
    auto image = dispatch_image(ctx, source_w, source_h);
 
    if (count == 0)
        return image;
 
    ctx.swap_shader({
        .shader_path = "overlay_segments.comp.spv",
        .workgroup_size = k_wg_image,
        .push_constant_size = sizeof(SegmentsPC),
    });
    ctx.set_push_constants(SegmentsPC { .count = count, .width = source_w, .height = source_h });
    ctx.set_output_dimensions(source_w, source_h);
    dispatch_and_wait(ctx);
 
    return ctx.get_output_image(0);
}

References count, MayaFlux::Kinesis::Vision::VisionAnalysis::detect_features, MayaFlux::Kinesis::Vision::VisionAnalysis::find_elements, image, image_context(), and MayaFlux::Kinesis::Vision::VisionAnalysis::track_objects.

Referenced by run_operation().

Here is the call graph for this function:

Here is the caller graph for this function: