faster_rcnn c++版本的 caffe 封装，动态库（2）

最新推荐文章于 2021-02-17 02:02:30 发布
最新推荐文章于 2021-02-17 02:02:30 发布
阅读量3.2k 收藏 1
点赞数
分类专栏： faster-rcnn 文章标签： faster-rcnn

摘要: 转载请注明出处，楼燚(yì)航的blog，http://www.cnblogs.com/louyihang-loves-baiyan/
在上一篇文章中，我们是将对caffe的调用隔离了出来，可以说相当于原来caffe源码下的tools中cpp文件使用相同，然后自己写了个CMakeLists.txt进行编译。这里是进一步将代码进行分离，封装成libfaster_rcnn.so文件进行使用。对于部分接口，我可能做了一些改动。
目录结构
├── CMakeLists.txt
├── lib
│   ├── CMakeLists.txt
│   ├── faster_rcnn.cpp
│   ├── faster_rcnn.hpp
├── main.cpp
├── pbs_cxx_faster_rcnn_demo.job

在这里main.cpp就是直接调用faster_rcnn.cpp的接口，他的内容也很简单,只是在之前的基础上，再加上libfaster_rcnn.so这个动态库文件

#include "faster_rcnn.hpp"
int main()
{
    string model_file = "/home/lyh1/workspace/py-faster-rcnn/models/pascal_voc/VGG_CNN_M_1024/faster_rcnn_alt_opt/faster_rcnn_test.pt";
    string weights_file = "/home/lyh1/workspace/py-faster-rcnn/output/default/yuanzhang_car/vgg_cnn_m_1024_fast_rcnn_stage2_iter_40000.caffemodel";
    int GPUID=0;
    Caffe::SetDevice(GPUID);
    Caffe::set_mode(Caffe::GPU);
    Detector det = Detector(model_file, weights_file);
    det.Detect("/home/lyh1/workspace/py-faster-rcnn/data/demo/car.jpg");
    return 0;
}

可以看到这里只是include了faster_rcnn.hpp头文件，其对应的CMakeLists.txt文件如下：


#This part is used for compile faster_rcnn_demo.cpp
cmake_minimum_required (VERSION 2.8)

project (main_demo)

add_executable(main main.cpp)

include_directories ( "${PROJECT_SOURCE_DIR}/../caffe-fast-rcnn/include"
    "${PROJECT_SOURCE_DIR}/../lib/nms" 
    "${PROJECT_SOURCE_DIR}/lib" 
    /share/apps/local/include
    /usr/local/include 
    /opt/python/include/python2.7
    /share/apps/opt/intel/mkl/include 
    /usr/local/cuda/include )

target_link_libraries(main /home/lyh1/workspace/py-faster-rcnn/faster_cxx_lib/lib/libfaster_rcnn.so
    /home/lyh1/workspace/py-faster-rcnn/caffe-fast-rcnn/build/lib/libcaffe.so
    /home/lyh1/workspace/py-faster-rcnn/lib/nms/gpu_nms.so 
    /share/apps/local/lib/libopencv_highgui.so 
    /share/apps/local/lib/libopencv_core.so 
    /share/apps/local/lib/libopencv_imgproc.so 
    /share/apps/local/lib/libopencv_imgcodecs.so
    /share/apps/local/lib/libglog.so
    /share/apps/local/lib/libboost_system.so
    /share/apps/local/lib/libboost_python.so
    /share/apps/local/lib/libglog.so
    /opt/rh/python27/root/usr/lib64/libpython2.7.so
    )

对于faster_rcnn.hpp和faster_rcnn.cpp ，我们需要将他们编译成动态库，下面是他们对应的CMakeLists.txt，在文件中，可以看到跟上面这个区别是用了add_library语句，并且加入了SHARED关键字，SHARED代表动态库。其次，在编译动态库的过程中，是不需要链接的，但是我们知道这个库是依赖别的很多个库的，所以在最后形成可执行文件也就是上面这个CMakeLists.txt，我们需要添加这个动态库所依赖的那些动态库，至此就OK了。编译的话，非常傻瓜cmake .然后在执行make即可。

cmake_minimum_required (VERSION 2.8)

SET (SRC_LIST faster_rcnn.cpp)
include_directories ( "${PROJECT_SOURCE_DIR}/../../caffe-fast-rcnn/include"
    "${PROJECT_SOURCE_DIR}/../../lib/nms" 
    /share/apps/local/include
    /usr/local/include 
    /opt/python/include/python2.7
    /share/apps/opt/intel/mkl/include 
    /usr/local/cuda/include )

add_library(faster_rcnn SHARED ${SRC_LIST})

首先将原来的cpp文件中的声明提取出来，比较简单，就是hpp文件对应cpp文件。如下：

#ifndef FASTER_RCNN_HPP
#define FASTER_RCNN_HPP
#include <stdio.h>  // for snprintf
#include <string>
#include <vector>
#include <math.h>
#include <fstream>
#include <boost/python.hpp>
#include "caffe/caffe.hpp"
#include "gpu_nms.hpp"
#include <opencv2/core/core.hpp>
#include <opencv2/highgui/highgui.hpp>
#include <opencv2/imgproc/imgproc.hpp>
using namespace caffe;
using namespace std;

#define max(a, b) (((a)>(b)) ? (a) :(b))
#define min(a, b) (((a)<(b)) ? (a) :(b))

//background and car
const int class_num=2;

/*
 * ===  Class  ======================================================================
 *         Name:  Detector
 *  Description:  FasterRCNN CXX Detector
 * =====================================================================================
 */
class Detector {
public:
    Detector(const string& model_file, const string& weights_file);
    void Detect(const string& im_name);
    void bbox_transform_inv(const int num, const float* box_deltas, const float* pred_cls, float* boxes, float* pred, int img_height, int img_width);
    void vis_detections(cv::Mat image, int* keep, int num_out, float* sorted_pred_cls, float CONF_THRESH);
    void boxes_sort(int num, const float* pred, float* sorted_pred);

private:
    shared_ptr<Net<float> > net_;
    Detector(){}
};

//Using for box sort
struct Info
{
    float score;
    const float* head;
};
bool compare(const Info& Info1, const Info& Info2)
{
    return Info1.score > Info2.score;
}
#endif

相应的cpp文件

#include <stdio.h>  // for snprintf
#include <string>
#include <vector>
#include <math.h>
#include <fstream>
#include <boost/python.hpp>
#include "caffe/caffe.hpp"
#include "gpu_nms.hpp"
#include <opencv2/core/core.hpp>
#include <opencv2/highgui/highgui.hpp>
#include <opencv2/imgproc/imgproc.hpp>
#include "faster_rcnn.hpp"
using namespace caffe;
using namespace std;

/*
 * ===  FUNCTION  ======================================================================
 *         Name:  Detector
 *  Description:  Load the model file and weights file
 * =====================================================================================
 */
//load modelfile and weights
Detector::Detector(const string& model_file, const string& weights_file)
{
    net_ = shared_ptr<Net<float> >(new Net<float>(model_file, caffe::TEST));
    net_->CopyTrainedLayersFrom(weights_file);
}

/*
 * ===  FUNCTION  ======================================================================
 *         Name:  Detect
 *  Description:  Perform detection operation
 *                 Warning the max input size should less than 1000*600
 * =====================================================================================
 */
//perform detection operation
//input image max size 1000*600
void Detector::Detect(const string& im_name)
{
    float CONF_THRESH = 0.8;
    float NMS_THRESH = 0.3;
    const int  max_input_side=1000;
    const int  min_input_side=600;

    cv::Mat cv_img = cv::imread(im_name);
    cv::Mat cv_new(cv_img.rows, cv_img.cols, CV_32FC3, cv::Scalar(0,0,0));
    if(cv_img.empty())
    {
        std::cout<<"Can not get the image file !"<<endl;
        return ;
    }
    int max_side = max(cv_img.rows, cv_img.cols);
    int min_side = min(cv_img.rows, cv_img.cols);

    float max_side_scale = float(max_side) / float(max_input_side);
    float min_side_scale = float(min_side) /float( min_input_side);
    float max_scale=max(max_side_scale, min_side_scale);

    float img_scale = 1;

    if(max_scale > 1)
    {
        img_scale = float(1) / max_scale;
    }

    int height = int(cv_img.rows * img_scale);
    int width = int(cv_img.cols * img_scale);
    int num_out;
    cv::Mat cv_resized;

    std::cout<<"imagename "<<im_name<<endl;
    float im_info[3];
    float data_buf[height*width*3];
    float *boxes = NULL;
    float *pred = NULL;
    float *pred_per_class = NULL;
    float *sorted_pred_cls = NULL;
    int *keep = NULL;
    const float* bbox_delt;
    const float* rois;
    const float* pred_cls;
    int num;

    for (int h = 0; h < cv_img.rows; ++h )
    {
        for (int w = 0; w < cv_img.cols; ++w)
        {
            cv_new.at<cv::Vec3f>(cv::Point(w, h))[0] = float(cv_img.at<cv::Vec3b>(cv::Point(w, h))[0])-float(102.9801);
            cv_new.at<cv::Vec3f>(cv::Point(w, h))[1] = float(cv_img.at<cv::Vec3b>(cv::Point(w, h))[1])-float(115.9465);
            cv_new.at<cv::Vec3f>(cv::Point(w, h))[2] = float(cv_img.at<cv::Vec3b>(cv::Point(w, h))[2])-float(122.7717);

        }
    }

    cv::resize(cv_new, cv_resized, cv::Size(width, height));
    im_info[0] = cv_resized.rows;
    im_info[1] = cv_resized.cols;
    im_info[2] = img_scale;

    for (int h = 0; h < height; ++h )
    {
        for (int w = 0; w < width; ++w)
        {
            data_buf[(0*height+h)*width+w] = float(cv_resized.at<cv::Vec3f>(cv::Point(w, h))[0]);
            data_buf[(1*height+h)*width+w] = float(cv_resized.at<cv::Vec3f>(cv::Point(w, h))[1]);
            data_buf[(2*height+h)*width+w] = float(cv_resized.at<cv::Vec3f>(cv::Point(w, h))[2]);
        }
    }

    net_->blob_by_name("data")->Reshape(1, 3, height, width);
    net_->blob_by_name("data")->set_cpu_data(data_buf);
    net_->blob_by_name("im_info")->set_cpu_data(im_info);
    net_->ForwardFrom(0);
    bbox_delt = net_->blob_by_name("bbox_pred")->cpu_data();
    num = net_->blob_by_name("rois")->num();


    rois = net_->blob_by_name("rois")->cpu_data();
    pred_cls = net_->blob_by_name("cls_prob")->cpu_data();
    boxes = new float[num*4];
    pred = new float[num*5*class_num];
    pred_per_class = new float[num*5];
    sorted_pred_cls = new float[num*5];
    keep = new int[num];

    for (int n = 0; n < num; n++)
    {
        for (int c = 0; c < 4; c++)
        {
            boxes[n*4+c] = rois[n*5+c+1] / img_scale;
        }
    }

    bbox_transform_inv(num, bbox_delt, pred_cls, boxes, pred, cv_img.rows, cv_img.cols);
    for (int i = 1; i < class_num; i ++)
    {
        for (int j = 0; j< num; j++)
        {
            for (int k=0; k<5; k++)
                pred_per_class[j*5+k] = pred[(i*num+j)*5+k];
        }
        boxes_sort(num, pred_per_class, sorted_pred_cls);
        _nms(keep, &num_out, sorted_pred_cls, num, 5, NMS_THRESH, 0);
        //for visualize only
        vis_detections(cv_img, keep, num_out, sorted_pred_cls, CONF_THRESH);
    }

    cv::imwrite("vis.jpg",cv_img);
    delete []boxes;
    delete []pred;
    delete []pred_per_class;
    delete []keep;
    delete []sorted_pred_cls;

}

/*
 * ===  FUNCTION  ======================================================================
 *         Name:  vis_detections
 *  Description:  Visuallize the detection result
 * =====================================================================================
 */
void Detector::vis_detections(cv::Mat image, int* keep, int num_out, float* sorted_pred_cls, float CONF_THRESH)
{
    int i=0;
    while(sorted_pred_cls[keep[i]*5+4]>CONF_THRESH && i < num_out)
    {
        if(i>=num_out)
            return;
        cv::rectangle(image,cv::Point(sorted_pred_cls[keep[i]*5+0], sorted_pred_cls[keep[i]*5+1]),cv::Point(sorted_pred_cls[keep[i]*5+2], sorted_pred_cls[keep[i]*5+3]),cv::Scalar(255,0,0));
        i++;
    }
}

/*
 * ===  FUNCTION  ======================================================================
 *         Name:  boxes_sort
 *  Description:  Sort the bounding box according score
 * =====================================================================================
 */
void Detector::boxes_sort(const int num, const float* pred, float* sorted_pred)
{
    vector<Info> my;
    Info tmp;
    for (int i = 0; i< num; i++)
    {
        tmp.score = pred[i*5 + 4];
        tmp.head = pred + i*5;
        my.push_back(tmp);
    }
    std::sort(my.begin(), my.end(), compare);
    for (int i=0; i<num; i++)
    {
        for (int j=0; j<5; j++)
            sorted_pred[i*5+j] = my[i].head[j];
    }
}

/*
 * ===  FUNCTION  ======================================================================
 *         Name:  bbox_transform_inv
 *  Description:  Compute bounding box regression value
 * =====================================================================================
 */
void Detector::bbox_transform_inv(int num, const float* box_deltas, const float* pred_cls, float* boxes, float* pred, int img_height, int img_width)
{
    float width, height, ctr_x, ctr_y, dx, dy, dw, dh, pred_ctr_x, pred_ctr_y, pred_w, pred_h;
    for(int i=0; i< num; i++)
    {
        width = boxes[i*4+2] - boxes[i*4+0] + 1.0;
        height = boxes[i*4+3] - boxes[i*4+1] + 1.0;
        ctr_x = boxes[i*4+0] + 0.5 * width;
        ctr_y = boxes[i*4+1] + 0.5 * height;
        for (int j=0; j< class_num; j++)
        {
            dx = box_deltas[(i*class_num+j)*4+0];
            dy = box_deltas[(i*class_num+j)*4+1];
            dw = box_deltas[(i*class_num+j)*4+2];
            dh = box_deltas[(i*class_num+j)*4+3];
            pred_ctr_x = ctr_x + width*dx;
            pred_ctr_y = ctr_y + height*dy;
            pred_w = width * exp(dw);
            pred_h = height * exp(dh);
            pred[(j*num+i)*5+0] = max(min(pred_ctr_x - 0.5* pred_w, img_width -1), 0);
            pred[(j*num+i)*5+1] = max(min(pred_ctr_y - 0.5* pred_h, img_height -1), 0);
            pred[(j*num+i)*5+2] = max(min(pred_ctr_x + 0.5* pred_w, img_width -1), 0);
            pred[(j*num+i)*5+3] = max(min(pred_ctr_y + 0.5* pred_h, img_height -1), 0);
            pred[(j*num+i)*5+4] = pred_cls[i*class_num+j];
        }
    }
}
Fantasy_Fly
关注
专栏目录
『深度应用』一小时教你上手训练MaskRCNN·Keras开源实战（Windows&Linux）
简明AI工作室
08-16 2818
0. 前言介绍 开源地址：https://github.com/matterport/Mask_RCNN 个人主页：http://www.yansongsong.cn/ MaskRCNN是何凯明基于以往的faster rcnn架构提出的新的卷积网络，一举完成了object instance segmentation. 该方法在有效地目标的同时完成了高质量的语义分割。 文章的主要思路就是把...
faster_rcnn+Windows上配置，包括matlab版本，python版本以及C++Vs2013封装过程
08-19
本文档内容为：指导faster_rcnn在windows上的配置，包括matlab版本，python版本，以及在Vs2013的c++封装，文中附有我配置好的项目下载链接，可以用
纯C++版的Faster R-CNN（通过caffe自定义RPN层实现）
花泽
05-26 1万+
这里介绍的是通过添加自定义层（RPN层）代替python层，实现c++版的faster-rcnn，因为去掉python了，所以部署时不会因为牵扯到python库等其它的莫名其妙的错误，使用起来就跟单纯的caffe一样，更简单方便。 核心代码，借鉴的是这篇博客，这里的话，我们不扣具体的代码细节（比如rpn层是怎么产出候选框啊，非极大值抑制是具体怎么实现的等等），有兴趣的可以自己查下资料，所以主要是走
[目标检测]windows下实现c++版faster-rcnn
foreyang00
05-03 824
转自：http://blog.csdn.net/oYangZi12/article/details/53290426?locationNum=2&fps=1（2016.11.22） 版权声明：本文为博主原创文章，未经博主允许不得转载。 本版本为beta版，根据windows下matlab版改写而来后续会对程序的bug、性能、功能等问题持续更新。 工程可到http://
windows caffe的第三方库dll
03-21
windows下caffe的第三方库dll
faster-rcnn c++版本 codeblocks编译
03-22
在这个C++版本中，我们使用了**Caffe**，这是一个流行的深度学习库，由Berkeley Vision and Learning Center开发，以C++为主，同时支持Python接口。 在Code::Blocks这样的集成开发环境中编译Faster R-CNN的C++代码...
深度学习_21天实战Caffe.pdf
chenxuanhanhao的专栏
08-14 2887
深度学习_21天实战Caffe.pdf 原 深度学习21天实战caffe学习笔记《1:深度学习的过往》 1. 深度学习DL： 1.1、有监督学习、无监督学习、过拟合、训练样本、泛化、训练集、验证集、测试集这些和深度学习有关的知识需要实现明白，这里有一个深度学习的资料你们可以去下载； http://download.csdn.net/detail/julialove102123...
cpp-一个完全支持的FasterRCNNRFCN的Caffe版本
08-16
标题中的“cpp-一个完全支持的FasterRCNNRFCN的Caffe版本”指的是这是一个用C++语言编写的，全面支持Faster R-CNN和RFCN（Region-based Fully Convolutional Networks）两种深度学习模型的Caffe实现。Caffe是一个...
java调用caffe_opencv for java之——深度学习目标检测MobileNet-SSD
weixin_42377196的博客
02-17 421
前言当前，在目标检测领域，基于深度学习的目标检测方法在准确度上碾压传统的方法。基于深度学习的目标检测先后出现了RCNN,FastRCNN,FasterRCNN, 端到端目标检测方法YOLO,YOLO-9000,YOLO-v3, MobileNet-SSD,以及Mask-RCNN等。MobileNet是一种轻量级的网络，本文基于MobileNet-SSD+opencv实现目标检测。开发环境win...
windows下c++版faster -rcnn
11-24
windows下c++版faster -rcnn
深度学习之卷积神经网络CNN用于人脸检测C++库
02-19
深度学习的卷积神经网络CNN用于做人脸检测等CV算法的C++库。
编译caffe的dll库
戴笠人的专栏
05-30 9180
前一篇的测试程序只能编译通过，并不可用。 因为caffe windows版本默认的libcaffe是静态库，而静态库编译并不会把虚基类layer_factory和一系列子类包含进去。 这就导致在载入文件时会报错，无法识别layer的类型。 所以需要动态编译libcaffe。 1，首先当然把libcaffe工程配置类型从lib改成dll。但此时直接编译并不会产生lib文件，只
【机器学习】windows版caffe深度学习库编译
artzers的专栏
07-23 1479
caffe主要版本是基于Linux的，其Windows版本是由微软提交维护的。编译caffe的最低要求VS版本为2013，一开始让我很诧异，难道微软要用什么黑科技么？这让软件开发和推广很有难度啊。不多说了，先git clone下来再编译。
fastrcnn动态库的生成和调用（1）
junxiacaocao的专栏
02-28 532
接上一篇《[目标检测]windows下实现c++版faster-rcnn》 Detect模块右键属性->配置属性->常规->目标文件名（.exe改为.dll),配置属性->常规->配置类型（选择动态库(.dll), Detect.cpp中 main()函数改为普通函数void main_n(), 添加一行extern “C” _declspec(dllexport) void main_n()
Faster R -cnn C++ 版本
haithink的专栏
04-01 1374
Faster R -cnn C++ 版本 Windows VS2013 将py-faster-rcnn 改写成c++版本 https://blog.csdn.net/u010548772/article/details/79138562 纯C++版的Faster R-CNN（通过caffe自定义RPN层实现） https://blog.csdn.net/zxj942405301/article/d...
Faster R-CNN 纯C++版本 + 使用最新的caffe
FR的专栏
03-06 3840
本方法参照纯C++版的Faster-Rcnn（通过caffe自定义RPN层实现） 进行设置更改，略有改动。 核心思想：通过添加自定义层（RPN层）代替python层，实现c++版的Faster R-CNN Faster R-CNN 纯C++版本 融合 最新caffe （1） 添加自定义层 rpn_layer.hpp ，把它放在 caffe/include/caffe/layers/ ...
编译报错：std::basic_string与std::__cxx11::basic_string无法匹配的问题
热门推荐
n_o_n的博客
08-12 4万+
问题描述：报错函数未定义，实际上函数实现在一个动态库中，反复核实.pro文件写的没问题 查找原因： 1.查看动态库中有没有此函数 strings libfasterRCNN.so | grep init　＃init为报错的函数名 _ZN12TensorRT_SDK4initESsi #找到相关的信息 2.c++编译后会修改函数签名，用c++filt命令恢复 c++filt _Z...
C++调用faster r-cnn pb模型
zhaoguanhua的博客
09-27 1071
1、模型转换 2、C++调用 3、工程代码
faster_rcnn_resnet50_fpn faster_rcnn_resnet50_fpn 要怎么使用
最新发布
06-05
在 PyTorch 中使用 `faster_rcnn_resnet50_fpn` 模型，可以按照以下步骤进行： 1. 安装 PyTorch 和 TorchVision 库（如果未安装的话）。 2. 导入必要的库和模块： ```python import torch import torchvision from torchvision.models.detection.faster_rcnn import FastRCNNPredictor ``` 3. 加载预训练模型 `faster_rcnn_resnet50_fpn`： ```python model = torchvision.models.detection.fasterrcnn_resnet50_fpn(pretrained=True) ``` 4. 修改模型的分类器，将其调整为适合你的任务。由于 `faster_rcnn_resnet50_fpn` 是一个目标检测模型，它的分类器通常是用来检测物体类别的。如果你的任务不需要检测物体类别，可以将分类器替换为一个只有一个输出的线性层： ```python num_classes = 1 # 只检测一个类别 in_features = model.roi_heads.box_predictor.cls_score.in_features model.roi_heads.box_predictor = FastRCNNPredictor(in_features, num_classes) ``` 5. 将模型转换为训练模式，并将其移动到所选设备（如GPU）上： ```python device = torch.device('cuda') if torch.cuda.is_available() else torch.device('cpu') model.to(device) model.train() # 转换为训练模式 ``` 6. 训练模型，可以使用自己的数据集来训练模型，或者使用 TorchVision 中的数据集，如 Coco 或 Pascal VOC 数据集。 7. 在测试阶段，可以使用以下代码来检测图像中的物体： ```python # 定义图像 image = Image.open('test.jpg') # 转换为Tensor，并将其移动到设备上 image_tensor = torchvision.transforms.functional.to_tensor(image) image_tensor = image_tensor.to(device) # 执行推理 model.eval() with torch.no_grad(): outputs = model([image_tensor]) # 处理输出 boxes = outputs[0]['boxes'].cpu().numpy() # 物体框 scores = outputs[0]['scores'].cpu().numpy() # 物体分数 ``` 需要注意的是，`faster_rcnn_resnet50_fpn` 是一个较大的模型，需要较高的计算资源和训练时间。在训练和测试时，建议使用GPU来加速计算。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值