这里是测试主函数mainlib.cpp

#include <stdio.h>  // for snprintf
#include <string>
#include <vector>
#include <unistd.h>
#include <stdlib.h>
#include <iostream>
#include <fstream>
#include <strstream>
#include <signal.h>
#include <iconv.h>
#include "boost/algorithm/string.hpp"
#include "google/protobuf/text_format.h"
#include "leveldb/db.h"
#include "leveldb/write_batch.h"

#include "caffe/blob.hpp"
#include "caffe/common.hpp"
#include "caffe/net.hpp"
#include "caffe/proto/caffe.pb.h"
#include "caffe/util/io.hpp"

#include "caffe/layers/memory_data_layer.hpp"
#include "caffe/caffe.hpp"

#include "opencv2/opencv.hpp"

#include <opencv2/core/core.hpp>
#include <opencv2/highgui/highgui.hpp>
#include <opencv2/imgproc/imgproc.hpp>

#include <boost/thread.hpp>
#include <iosfwd>
#include <utility>
#include "caffe/Cut2Image.h"
#include "caffe/ocr.h"
#include "caffe/boxDetect.h"
#include "caffe/cutImage.h"
#include "caffe/ctc_ocr.h"
#include "classification.hpp"

#include "caffe/nms.h"

#include  <dirent.h>
#include  <sys/types.h>

#define K 4//4

using namespace caffe;
using namespace std;

extern "C" {
    Classifier *classifier[K];
    Classifier *classifier_isCWB;
    Detector *detector_textbox;
    ICNNPredict* pCNN;

    void getBoxImg(IplImage* img,vector<IplImage*> &box_imgs, int num,const char* imgfolder)
    {
        if(img==NULL)
        {
            cout<< "Unable to decode image "<<endl;
            return;
        }
        vector<vector<float> > detections = detector_textbox->Detect(cv::Mat(img));
        // vector<vector<float> > detections = detector_textbox->Multi_Scale_Detect(cv::Mat(img));  
        vector<proposal_type> proposals;
        // vector<Rect> proposals;//nms
        //std::vector<float> scores;

        /* Print the detection results. */
        for (int i = 0; i < detections.size(); ++i)
        {
            const vector<float>& d = detections[i];
            // Detection format: [det_conf, det_x1, det_y2, det_x2, det_y2, det_x3, det_y3, det_x4, det_y4].
            CHECK_EQ(d.size(), 9);
            const float score = d[0];
            float confidence_threshold=0.6;//0.01;
            //cout<<"score="<<score<<endl;
            if (score >= confidence_threshold)
            {
                int det_x1=static_cast<int>(d[1] * cv::Mat(img).cols);
                int det_y1=static_cast<int>(d[2] * cv::Mat(img).rows);
                int det_x2=static_cast<int>(d[3] * cv::Mat(img).cols);
                int det_y2=static_cast<int>(d[4] * cv::Mat(img).rows);
                int det_x3=static_cast<int>(d[5] * cv::Mat(img).cols);
                int det_y3=static_cast<int>(d[6] * cv::Mat(img).rows);
                int det_x4=static_cast<int>(d[7] * cv::Mat(img).cols);
                int det_y4=static_cast<int>(d[8] * cv::Mat(img).rows);
                det_x1 = max(1, min(det_x1, img->width-1));
                det_x2 = max(1, min(det_x2, img->width-1));
                det_x3 = max(1, min(det_x3, img->width-1));
                det_x4 = max(1, min(det_x4, img->width-1));
                det_y1 = max(1, min(det_y1, img->height-1));
                det_y2 = max(1, min(det_y2, img->height-1));
                det_y3 = max(1, min(det_y3, img->height-1));
                det_y4 = max(1, min(det_y4, img->height-1));
               
                 
                proposal_type pro;
                pro.x1=det_x1;
                pro.x2=det_x2;
                pro.x3=det_x3;
                pro.x4=det_x4;
                pro.y1=det_y1;
                pro.y2=det_y2;
                pro.y3=det_y3;
                pro.y4=det_y4;
                pro.score=score;
                proposals.push_back(pro);
            }
        }
        //cout<<"detection"<<endl;
        //nms(proposals, scores, 0.3);
        nms(proposals,0.2);

        cv::Mat image4(img,false);

        for(int i=0; i<proposals.size(); i++)
        {
            line(image4, cvPoint(proposals[i].x1, proposals[i].y1), cvPoint(proposals[i].x2, proposals[i].y2), Scalar(255, 0, 0),3, 1, 0);
            line(image4, cvPoint(proposals[i].x2, proposals[i].y2), cvPoint(proposals[i].x3, proposals[i].y3), Scalar(255, 0, 0),3, 1, 0);
            line(image4, cvPoint(proposals[i].x3, proposals[i].y3), cvPoint(proposals[i].x4, proposals[i].y4), Scalar(255, 0, 0),3, 1, 0);
            line(image4, cvPoint(proposals[i].x1, proposals[i].y1), cvPoint(proposals[i].x4, proposals[i].y4), Scalar(255, 0, 0),3, 1, 0);
            // cvRectangle(img,cvPoint(xmin, ymin),cvPoint(xmin+width, ymin+height),Scalar(255, 0, 0),3, 1, 0);
        }
        //cout<<"rect"<<endl;
        char img_name[2000];

        sprintf(img_name, "/data2/myfile/TextBoxes_plusplus/test_images/result_allimages/%s",imgfolder);
        cvSaveImage(img_name, img);
        printf("img_name:%s\n",img_name);
    }

// If image is CWB, cutting rows as text lines.
// Img: source image.
// BoxImg: vector to store cutted images.
    void CWB2BoxImg(IplImage* Img, vector<IplImage*>& BoxImg)
    {
        if(Img == NULL)
        {
            cout << "Image is NULL" << endl;
            return;
        }
        Cut2ImagesByBlank(Img, BoxImg);
        for(int i=0; i<BoxImg.size(); i++)
        {
            IplImage* tmp=BoxImg[i];
            char box_img_name[100];
            sprintf(box_img_name, "/root/ydb/ocr/box/%d.jpg", i);
            cvSaveImage(box_img_name, tmp);
            tmp=NULL;
        }
        char img_name[100];
        sprintf(img_name, "/root/workplace/iieproject_v1/media/ocr.jpg");
        cvSaveImage(img_name, Img);

    }

    void modelInit()
    {

        string model_file_box="/data2/myfile/TextBoxes_plusplus/models/deploy.prototxt";
        string trained_file_box="/data2/myfile/TextBoxes_plusplus/models/VGGNet/all/text_polygon_precise_fix_order_384x384/VGG_text_text_polygon_precise_fix_order_384x384_iter_35000.caffemodel";
        
        string mean_file_box="";
        string mean_value_box="104,117,123";

        Caffe::set_mode(Caffe::GPU);
        Caffe::SetDevice(1);

        detector_textbox = new Detector(model_file_box, trained_file_box, mean_file_box, mean_value_box);
    }

    void mainGetBoxes(char* rootname,char* imgfolder)
    {
        //用来存储图片路径
        vector<string> ImgNames;
        char str3[1000];
        //strcpy(str3, str1);
        //strcat(str3, str2);
        //得到图片路径
        sprintf(str3,"%s%s",rootname,imgfolder);
        cout<<str3<<endl;
        ImgNames.push_back(str3);
        Caffe::set_mode(Caffe::GPU);
        Caffe::SetDevice(1);
        int joasize = ImgNames.size();
        cout<<"joasize:"<<joasize<<endl;
        for(int i=0; i<joasize; i++)
        {
            string sImgPath = ImgNames[i];
            printf("img path of ocr is:%s %d\n",sImgPath.c_str(),i);
            //载入图片
            IplImage *Img_ipl=cvLoadImage(sImgPath.c_str());
            if(Img_ipl==NULL)
            {
                cout<<"can not open img!"<<endl;
                continue;
                //answer.append(string("]end"));
                //return answer;
            }
           
            vector<IplImage*> box_imgs;
            getBoxImg(Img_ipl,box_imgs, i,imgfolder);

        }
    }

}