fill_elements()

std::shared_ptr< Core::VKImage > MayaFlux::Yantra::VisionExtractor::fill_elements ( const std::shared_ptr< Core::VKImage > &  source, const Kinesis::Vision::FindElementsAnalysis &  elements, const std::vector< size_t > &  indices, uint32_t  tile_w, uint32_t  tile_h  )

private

Definition at line 399 of file VisionExtractor.cpp.

{
    if (indices.empty() || tile_w == 0 || tile_h == 0)
        return nullptr;
 
    std::vector<float> points;
    std::vector<uint32_t> polygons;
    std::vector<uint32_t> table;
    table.reserve(indices.size() * 6);
 
    for (const auto index : indices) {
        const auto& box = elements.boxes[index];
        const uint32_t label = box.label_id != 0 ? box.label_id : static_cast<uint32_t>(index + 1U);
 
        const auto first_polygon = static_cast<uint32_t>(polygons.size() / 2);
        uint32_t polygon_count = 0;
        for (const auto& contour : elements.contours) {
            const bool owned = contour.label_id == label || (contour.label_id == 0 && contour.parent_label == label);
            if (!owned || contour.points.size() < 3)
                continue;
 
            polygons.push_back(static_cast<uint32_t>(points.size() / 2));
            polygons.push_back(static_cast<uint32_t>(contour.points.size()));
            for (const auto& p : contour.points)
                points.insert(points.end(), { p.x, p.y });
            ++polygon_count;
        }
 
        table.insert(table.end(), {
                                      std::bit_cast<uint32_t>(box.x),
                                      std::bit_cast<uint32_t>(box.y),
                                      std::bit_cast<uint32_t>(box.w),
                                      std::bit_cast<uint32_t>(box.h),
                                      first_polygon,
                                      polygon_count,
                                  });
    }
 
    if (points.empty())
        points.assign(2, 0.0F);
    if (polygons.empty())
        polygons.assign(2, 0U);
 
    const auto count = static_cast<uint32_t>(indices.size());
 
    auto& ctx = image_context();
    use_shader(ctx, "contour_fill.comp.spv", k_wg_image, sizeof(AtlasPC));
    ctx.stage_image(source);
    ctx.set_binding_data(3, std::span<const float>(points));
    ctx.set_binding_data(4, std::span<const uint32_t>(polygons));
    ctx.set_binding_data(5, std::span<const uint32_t>(table));
    ctx.set_push_constants(AtlasPC { .tile_w = tile_w, .tile_h = tile_h, .count = count });
    return dispatch_image(ctx, tile_w * count, tile_h);
}

References MayaFlux::Kinesis::Vision::FindElementsAnalysis::boxes, MayaFlux::Kinesis::Vision::FindElementsAnalysis::contours, count, image_context(), index, indices, label, points, tile_h, and tile_w.

Referenced by silhouette(), and silhouettes().

Here is the call graph for this function:

Here is the caller graph for this function: