Method run

src/core/CPP/kernels/CPPNonMaximumSuppressionKernel.cpp:117–231

}

void CPPNonMaximumSuppressionKernel::run(const Window &window, const ThreadInfo &info)
{
    ARM_COMPUTE_UNUSED(info);
    ARM_COMPUTE_UNUSED(window);
    ARM_COMPUTE_ERROR_ON_UNCONFIGURED_KERNEL(this);
    ARM_COMPUTE_ERROR_ON_INVALID_SUBWINDOW(ICPPKernel::window(), window);

    // Auxiliary tensors
    std::vector<int>   indices_above_thd;
    std::vector<float> scores_above_thd;
    for (unsigned int i = 0; i < _num_boxes; ++i)
    {
        const float score_i = *(reinterpret_cast<float *>(_input_scores->ptr_to_element(Coordinates(i))));
        if (score_i >= _score_threshold)
        {
            scores_above_thd.emplace_back(score_i);
            indices_above_thd.emplace_back(i);
        }
    }

    // Sort selected indices based on scores
    const unsigned int        num_above_thd = indices_above_thd.size();
    std::vector<unsigned int> sorted_indices;
    sorted_indices.resize(num_above_thd);
    std::iota(sorted_indices.data(), sorted_indices.data() + num_above_thd, 0);
    std::sort(std::begin(sorted_indices), std::end(sorted_indices),
              [&](unsigned int first, unsigned int second)
              { return scores_above_thd[first] > scores_above_thd[second]; });

    // Number of output is the minimum between max_detection and the scores above the threshold
    const unsigned int num_output = std::min(_max_output_size, num_above_thd);
    unsigned int       output_idx = 0;
    std::vector<bool>  visited(num_above_thd, false);

    // Keep only boxes with small IoU
    for (unsigned int i = 0; i < num_above_thd; ++i)
    {
        // Check if the output is full
        if (output_idx >= num_output)
        {
            break;
        }

        // Check if it was already visited, if not add it to the output and update the indices counter
        if (!visited[sorted_indices[i]])
        {
            *(reinterpret_cast<int *>(_output_indices->ptr_to_element(Coordinates(output_idx)))) =
                indices_above_thd[sorted_indices[i]];
            visited[sorted_indices[i]] = true;
            ++output_idx;
        }
        else
        {
            continue;
        }

        // Once added one element at the output check if the next ones overlap and can be skipped
        for (unsigned int j = i + 1; j < num_above_thd; ++j)