grid.h

Go to the documentation of this file.

//part of the source code of master thesis, source code produced by Jiri Divis
#ifndef VSLAM_GRID_H_INCLUDED
#define VSLAM_GRID_H_INCLUDED

#include "utils.h"

namespace vslam{

struct Cell{
    int row;
    int col;
    Cell(int _r, int _c) : row(_r), col(_c) {}
};

inline int col(const Cell& c) { 
    return c.col; 
}

inline int row(const Cell& c) { 
    return c.row; 
}

class Grid{
    protected:
        int rowsize;
        int colsize;
        int rownum;
        int colnum;
        vector<int> ** grid;

    public:
        Grid(int _rowsize, int _colsize, const vector<cv::KeyPoint>& keypoints) : 
            rowsize(_rowsize), colsize(_colsize){
                rownum=PanoramaParams::height / rowsize + 1;
                colnum=PanoramaParams::width / colsize + 1;
                grid = new vector<int>*[rownum];
                for(int i=0; i<rownum;i++){
                    grid[i] = new vector<int>[colnum];
                }
                vector<cv::KeyPoint>::const_iterator it = keypoints.begin();
                int i=0;
                while(it!=keypoints.end()){
                    Cell cell = getCell(Vector2d(it->pt.x, it->pt.y));
                    (grid[row(cell)][col(cell)]).push_back(i);
                    ++it;
                    i++;
                }
            }
        Cell getCell(const Vector2d& image_coords) const{
            return Cell(image_coords(1) / rowsize, image_coords(0) / colsize);
        }

        vector<int> getNearKeypoints(const Cell& cell) const{
            return grid[row(cell)][col(cell)];
        };

        ~Grid(){
            /*for(int i=0; i<rownum;i++){
                    delete grid[i];
            }
            delete grid;*/
        }
};

inline void nonMaximaSuppresion(
        const vector<cv::KeyPoint>& keypoints, double max_num, vector<int>& supressed_keypoint_idxs){
    supressed_keypoint_idxs.clear();
    vector<bool> included_idxs = vector<bool>(keypoints.size(), false);
    double radius=std::sqrt((PanoImCoord::Params::width * PanoImCoord::Params::height) / (3*max_num));
    Grid grid(radius, radius, keypoints);
    for(size_t i=0; i<keypoints.size(); i++) {
        vector<int> keypoint_idxs = grid.getNearKeypoints(grid.getCell(
                Vector2d(keypoints[i].pt.x, keypoints[i].pt.y)));

        vector<int>::const_iterator it = keypoint_idxs.begin();
        double max=-1;
        int mr_keypoint_idx;
        while(it!=keypoint_idxs.end()){
            if(keypoints[*it].response >= max){
                max = keypoints[*it].response;
                mr_keypoint_idx = *it;
            }
            ++it;
        }
        if(max != -1 && !included_idxs[mr_keypoint_idx]){
            supressed_keypoint_idxs.push_back(mr_keypoint_idx);
            included_idxs[mr_keypoint_idx]=true;
        }
    }
}
} //namespace vslam
#endif