compute_shapes()

void MayaFlux::Yantra::VisionAnalyzer::compute_shapes ( Kinesis::Vision::FindElementsAnalysis &  fe, uint32_t  w, uint32_t  h  )

private

Shape descriptors (element_shape.comp) and nearest-neighbour distances (nearest_neighbor.comp) over fe.boxes, filled in place.

No-op when fe.boxes is empty.

Definition at line 204 of file VisionAnalyzer.cpp.

{
    const auto n = fe.boxes.size();
    fe.shapes.assign(n, {});
    fe.nearest_neighbor_distance_px.assign(n, 0.0F);
    if (n == 0)
        return;
 
    const auto fw = static_cast<float>(w);
    const auto fh = static_cast<float>(h);
 
    std::vector<float> element_data;
    element_data.reserve(n * 4);
    std::vector<float> centroid_data;
    centroid_data.reserve(n * 2);
 
    for (const auto& b : fe.boxes) {
        const auto it = std::ranges::find_if(fe.contours,
            [&](const auto& c) { return c.label_id == b.label_id; });
        const float area_px = (it != fe.contours.end()) ? it->area * fw * fh : 0.0F;
        const float perimeter_px = (it != fe.contours.end()) ? it->perimeter : 0.0F;
        element_data.push_back(area_px);
        element_data.push_back(perimeter_px);
        element_data.push_back(b.w * fw);
        element_data.push_back(b.h * fh);
 
        centroid_data.push_back((b.x + b.w * 0.5F) * fw);
        centroid_data.push_back((b.y + b.h * 0.5F) * fh);
    }
 
    if (!m_shape_ctx) {
        m_shape_ctx = std::make_shared<ShaderExecutionContext<>>(
            GpuComputeConfig {
                .shader_path = "element_shape.comp.spv",
                .workgroup_size = { 256, 1, 1 },
                .push_constant_size = sizeof(TrackReducePC) });
    }
    m_shape_ctx->input(0, element_data)
        .output(1, n * sizeof(glm::vec2))
        .push(TrackReducePC { .count = static_cast<uint32_t>(n) });
 
    const auto shape_output = m_shape_ctx->execute(Datum<std::vector<Kakshya::DataVariant>> {}, ExecutionContext {});
    const auto shape_raw = ShaderExecutionContext<>::read_output<float>(shape_output, 1);
    for (size_t i = 0; i < n && (i + 1) * 2 <= shape_raw.size(); ++i) {
        fe.shapes[i].compactness = shape_raw[i * 2];
        fe.shapes[i].aspect_ratio = shape_raw[i * 2 + 1];
    }
 
    if (n < 2)
        return;
 
    if (!m_neighbor_ctx) {
        m_neighbor_ctx = std::make_shared<ShaderExecutionContext<>>(
            GpuComputeConfig {
                .shader_path = "nearest_neighbor.comp.spv",
                .workgroup_size = { 256, 1, 1 },
                .push_constant_size = sizeof(TrackReducePC) });
    }
    m_neighbor_ctx->input(0, centroid_data)
        .output(1, n * sizeof(float))
        .push(TrackReducePC { .count = static_cast<uint32_t>(n) });
 
    const auto dist_output = m_neighbor_ctx->execute(Datum<std::vector<Kakshya::DataVariant>> {}, ExecutionContext {});
    const auto dist_raw = ShaderExecutionContext<>::read_output<float>(dist_output, 1);
    for (size_t i = 0; i < n && i < dist_raw.size(); ++i)
        fe.nearest_neighbor_distance_px[i] = dist_raw[i];
}

References b, MayaFlux::Kinesis::Vision::FindElementsAnalysis::boxes, MayaFlux::Kinesis::Vision::FindElementsAnalysis::contours, h, m_neighbor_ctx, m_shape_ctx, MayaFlux::Kinesis::Vision::FindElementsAnalysis::nearest_neighbor_distance_px, MayaFlux::Portal::Graphics::GpuComputeConfig::shader_path, and MayaFlux::Kinesis::Vision::FindElementsAnalysis::shapes.

Referenced by assemble().

Here is the caller graph for this function: