faster rcnn windows 下c++版本

faster rcnn windows 下c++版本

参考了http://www.cnblogs.com/louyihang-loves-baiyan/p/5485955.html，和http://blog.youkuaiyun.com/oYangZi12/article/details/53290426。
上面两个分别是参考在linux下参考python版本的faster rcnn改写成c++版本的。不过其中用到了python的rpn layer，以及其中的 nms库，不能完全脱离python。
第二篇是改写的matlab版的faster rcnn。把rpn的操作在代码中间实现，中间有一层转接，感觉不太统一。
我主要是参考这两篇，用c++实现rpn层，并融入到caffe中，使用起来比较方便。其中主要流程参考的python版的faster rcnn。具体一些细节参考了http://blog.youkuaiyun.com/oYangZi12/article/details/53290426这里的内容。

环境：win8 + cuda8 +opencv2.4.11+微软的windows版本caffe。可在github上下载。

1.添加rpn层，直接上代码。

• rpn_layer.hpp

#ifndef CAFFE_RPN_LAYER_HPP_
#define CAFFE_RPN_LAYER_HPP_

#include <vector>

#include "caffe/blob.hpp"
#include "caffe/layer.hpp"
#include "caffe/proto/caffe.pb.h"
#include"opencv2/opencv.hpp"
#define mymax(a,b) ((a)>(b))?(a):(b)
#define mymin(a,b) ((a)>(b))?(b):(a)
namespace caffe {

    /**
    * @brief implement RPN layer for faster rcnn
    */

    template <typename Dtype>
    class RPNLayer : public Layer<Dtype> {
    public:
        explicit RPNLayer(const LayerParameter& param)
            : Layer<Dtype>(param) {}
        virtual void LayerSetUp(const vector<Blob<Dtype>*>& bottom,
            const vector<Blob<Dtype>*>& top);
        virtual void Reshape(const vector<Blob<Dtype>*>& bottom,
            const vector<Blob<Dtype>*>& top){}
        virtual inline const char* type() const { return "RPN"; }

    protected:
        virtual void Forward_cpu(const vector<Blob<Dtype>*>& bottom,
            const vector<Blob<Dtype>*>& top);
        virtual void Forward_gpu(const vector<Blob<Dtype>*>& bottom,
            const vector<Blob<Dtype>*>& top);
        virtual void Backward_cpu(const vector<Blob<Dtype>*>& top,
            const vector<bool>& propagate_down, const vector<Blob<Dtype>*>& bottom){};

        private:

        int feat_stride_;
        int base_size_;
        vector<int> anchor_scales_;
        vector<float> ratios_;
        vector<vector<float>> gen_anchors_;
        int anchors_[9][4];
        int anchors_nums_;
        int min_size_;
        int pre_nms_topN_;
        int post_nms_topN_;
        float nms_thresh_;
        int src_height_;
        int src_width_;
        float src_scale_;
        private:
        void generate_anchors();
        vector<vector<float>> ratio_enum(vector<float>);
        vector<float> whctrs(vector<float>);
        vector<float> mkanchor(float w,float h,float x_ctr,float y_ctr);
        vector<vector<float>> scale_enum(vector<float>);
        cv::Mat proposal_local_anchor(int width, int height);

        void filter_boxs(cv::Mat& pre_box, cv::Mat& score, vector<RPN::abox>& aboxes);

    };
}  // namespace caffe
#endif  // CAFFE_RPN_LAYER_HPP_

• rpn_layer.cpp

#include <algorithm>
#include <vector>

#include "caffe/layers/rpn_layer.hpp"
#include "caffe/util/math_functions.hpp"

int debug = 0;
int  tmp[9][4] = {
    { -83, -39, 100, 56 },
    { -175, -87, 192, 104 },
    { -359, -183, 376, 200 },
    { -55, -55, 72, 72 },
    { -119, -119, 136, 136 },
    { -247, -247, 264, 264 },
    { -35, -79, 52, 96 },
    { -79, -167, 96, 184 },
    { -167, -343, 184, 360 }
};
namespace caffe {

    template <typename Dtype>
    void RPNLayer<Dtype>::LayerSetUp(
        const vector<Blob<Dtype>*>& bottom, const vector<Blob<Dtype>*>& top) {
        feat_stride_ = layer_param_.rpn_param().feat_stride();
        base_size_ = layer_param_.rpn_param().basesize();
        min_size_ = layer_param_.rpn_param().boxminsize();
        pre_nms_topN_ = layer_param_.rpn_param().per_nms_topn();
        post_nms_topN_ = layer_param_.rpn_param().post_nms_topn();
        nms_thresh_ = layer_param_.rpn_param().nms_thresh();
        int scales_num = layer_param_.rpn_param().scale_size();
        for (int i = 0; i < scales_num; ++i)
        {
            anchor_scales_.push_back(layer_param_.rpn_param().scale(i));
        }
        int ratios_num = layer_param_.rpn_param().ratio_size();
        for (int i = 0; i < ratios_num; ++i)
        {
            ratios_.push_back(layer_param_.rpn_param().ratio(i));
        }
        generate_anchors();

        //memcpy(anchors_, tmp, 9 * 4 * sizeof(int));
        //anchors_nums_ = 9;
        for (int i = 0; i<gen_anchors_.size(); ++i)
        {
            for (int j = 0; j<gen_anchors_[i].size(); ++j)
            {
                anchors_[i][j] = gen_anchors_[i][j];
                if (debug)
                    LOG(INFO) << anchors_[i][j] << std::endl;;
            }
        }
        anchors_nums_ = gen_anchors_.size();

        top[0]->Reshape(