Function orb

src/backend/opencl/kernel/orb.hpp:100–496

template<typename T, typename convAccT>
void orb(unsigned* out_feat, Param& x_out, Param& y_out, Param& score_out,
         Param& ori_out, Param& size_out, Param& desc_out, Param image,
         const float fast_thr, const unsigned max_feat, const float scl_fctr,
         const unsigned levels, const bool blur_img) {
    using cl::Buffer;
    using cl::EnqueueArgs;
    using cl::NDRange;
    using std::vector;

    auto kernels = getOrbKernels<T>();

    unsigned patch_size = REF_PAT_SIZE;

    unsigned min_side   = std::min(image.info.dims[0], image.info.dims[1]);
    unsigned max_levels = 0;
    float scl_sum       = 0.f;
    for (unsigned i = 0; i < levels; i++) {
        min_side /= scl_fctr;

        // Minimum image side for a descriptor to be computed
        if (min_side < patch_size || max_levels == levels) break;

        max_levels++;
        scl_sum += 1.f / (float)pow(scl_fctr, (float)i);
    }

    vector<Buffer*> d_x_pyr(max_levels);
    vector<Buffer*> d_y_pyr(max_levels);
    vector<Buffer*> d_score_pyr(max_levels);
    vector<Buffer*> d_ori_pyr(max_levels);
    vector<Buffer*> d_size_pyr(max_levels);
    vector<Buffer*> d_desc_pyr(max_levels);

    vector<unsigned> feat_pyr(max_levels);
    unsigned total_feat = 0;

    // Compute number of features to keep for each level
    vector<unsigned> lvl_best(max_levels);
    unsigned feat_sum = 0;
    for (unsigned i = 0; i < max_levels - 1; i++) {
        float lvl_scl = (float)pow(scl_fctr, (float)i);
        lvl_best[i]   = ceil((max_feat / scl_sum) / lvl_scl);
        feat_sum += lvl_best[i];
    }
    lvl_best[max_levels - 1] = max_feat - feat_sum;

    // Maintain a reference to previous level image
    Param prev_img;
    Param lvl_img;

    const unsigned gauss_len = 9;
    T* h_gauss               = nullptr;
    Param gauss_filter;
    gauss_filter.data = nullptr;

    for (unsigned i = 0; i < max_levels; i++) {
        const float lvl_scl = (float)pow(scl_fctr, (float)i);