实战小项目之基于yolo的目标检测web api实现

　　上个月，对微服务及web service有了一些想法，看了一本app后台开发及运维的书，主要是一些概念性的东西，对service有了一些基本了解。互联网最开始的构架多是cs构架，浏览器兴起以后，变成了bs，最近几年，随着移动互联网的兴起，cs构架再次火了起来，有了一个新的概念，web service。

　　最近两天，想结合自己这段时间学的东西，实现一个cs构架的service接口。说一下大体流程，client上传图片到http服务器，http后台使用yolo进行图片的检测，之后将检测结果封装成json返回到client，client进行解析显示。



client

　　使用libcurl作为http请求工具，使用rapidjson进行结果json数据的解析

　　上传图片时，没有使用标准的http多媒体方式，而是使用post 二进制流的方式，比较笨，有待改进。

server

　　物体检测识别使用yolo c语言版本，修改原工程darknet的main，引入自己的main，实现直接检测的功能，main的流程：

导入yolo参数--必要初始化--fork子进程--安装信号--初始化fifo--sleep等待图片上传 接收信号唤醒--读取图像--预测-写入json文件--fifo写唤醒子进程

　　　　　　　　　　　　　|　　　　　　　　　　　　　　　　　　　　　　　　　　　　　|　　　　　　　　　　　　　　　　　　　|

　　　　　　　　　　　执行libevent实现的http server--eventloop监听--有文件上传结束--signal 父进程--阻塞在fifo读 读取json，http返回

具体代码

client

extern "C"{
#include <unistd.h>
#include <sys/types.h>
#include <time.h>
#include <errno.h>
#include <stdio.h>
#include <signal.h>
#include <arpa/inet.h>
#include <sys/socket.h>
#include <sys/stat.h>
#include <sys/time.h>
#include <fcntl.h>

//iso
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

//others
#include "curl/curl.h"
}

//c++
#include <iostream>
#include <string>
#include <fstream>
#include "rapidjson/document.h"
#include "rapidjson/stringbuffer.h"
#include "rapidjson/writer.h"

#define psln(x) std::cout << #x " = " << (x) << std::endl

using namespace std;

size_t WriteFunction(void *input, size_t uSize, size_t uCount, void *arg) {
size_t uLen = uSize * uCount;
string *pStr = (string*) (arg);
pStr->append((char*) (input), uLen);
return uLen;
}

int main(int argc,char **argv){
if(argc<3){
printf("usage:./a.out uri pic\n");
exit(-1);
}
CURL *pCurl = NULL;
CURLcode code;
code = curl_global_init(CURL_GLOBAL_DEFAULT);
if (code != CURLE_OK) {
cout << "curl global init err" << endl;
return -1;
}
pCurl = curl_easy_init();
if (pCurl == NULL) {
cout << "curl easy init err" << endl;
return -1;
}

curl_slist *pHeaders = NULL;
string sBuffer;
string header = "username:tla001";
pHeaders = curl_slist_append(pHeaders, header.c_str());

ifstream in;
in.open(argv[2], ios::in | ios::binary);
if (!in.is_open()) {
printf("open err\n");
exit(-1);
}
in.seekg(0, ios_base::end);
const size_t maxSize = in.tellg();
in.seekg(0);
char * picBin = new char[maxSize];
in.read(picBin, maxSize);
in.close();
cout << maxSize << endl;

size_t sendSize = maxSize + sizeof(size_t);
char *sendBuff = new char[sendSize];
//    sprintf(sendBuff, "%d", maxSize);
memcpy(sendBuff, &maxSize, sizeof(size_t));
//    size_t tmp = 0;
//    memcpy(&tmp, sendBuff, sizeof(size_t));
//    cout << "tmp=" << tmp << endl;
memcpy(sendBuff + sizeof(size_t), picBin, maxSize);
curl_easy_setopt(pCurl, CURLOPT_URL, argv[1]);
curl_easy_setopt(pCurl, CURLOPT_HTTPHEADER, pHeaders);
curl_easy_setopt(pCurl, CURLOPT_TIMEOUT, 20);
//    curl_easy_setopt(pCurl, CURLOPT_HEADER, 1);
curl_easy_setopt(pCurl, CURLOPT_POST, 1L);
curl_easy_setopt(pCurl, CURLOPT_POSTFIELDS, sendBuff);
curl_easy_setopt(pCurl, CURLOPT_POSTFIELDSIZE, sendSize);
curl_easy_setopt(pCurl, CURLOPT_WRITEFUNCTION, &WriteFunction);
curl_easy_setopt(pCurl, CURLOPT_WRITEDATA, &sBuffer);

code = curl_easy_perform(pCurl);
if (code != CURLE_OK) {
cout << "curl perform err,retcode="<<code << endl;
return -1;
}
long retcode = 0;
code = curl_easy_getinfo(pCurl, CURLINFO_RESPONSE_CODE, &retcode);
if (code != CURLE_OK) {
cout << "curl perform err" << endl;
return -1;
}
//cout << "[http return code]: " << retcode << endl;
//cout << "[http context]: " << endl << sBuffer << endl;
using rapidjson::Document;
Document doc;
doc.Parse<0>(sBuffer.c_str());
if (doc.HasParseError()) {
rapidjson::ParseErrorCode code = doc.GetParseError();
psln(code);
return -1;
}
using rapidjson::Value;
Value &content = doc["content"];
if (content.IsArray()) {
for (int i = 0; i < content.Size(); i++) {
Value &v = content[i];
assert(v.IsObject());
cout<<"object "<<"["<<i+1<<"]"<<endl;
if (v.HasMember("class") && v["class"].IsString()) {
cout <<"\t[class]:"<<v["class"].GetString()<<endl;
}
if (v.HasMember("prob") && v["prob"].IsDouble()) {
cout <<"\t[prob]:"<<v["prob"].GetDouble()<<endl;
}
cout<<"\t***************************"<<endl;
if (v.HasMember("left") && v["left"].IsInt()) {
cout <<"\t[left]:"<<v["left"].GetInt()<<endl;
}
if (v.HasMember("right") && v["right"].IsInt()) {
cout <<"\t[right]:"<<v["right"].GetInt()<<endl;
}
if (v.HasMember("top") && v["top"].IsInt()) {
cout <<"\t[top]:"<<v["top"].GetInt()<<endl;
}
if (v.HasMember("bot") && v["bot"].IsInt()) {
cout <<"\t[bot]:"<<v["bot"].GetInt()<<endl;
}
cout<<endl;

}
}

delete[] picBin;
delete[] sendBuff;
curl_easy_cleanup(pCurl);

curl_global_cleanup();
return 0;
}

server

main.c

#include <time.h>
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <signal.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>

#include "parser.h"
#include "utils.h"
#include "cuda.h"
#include "blas.h"
#include "connected_layer.h"

extern void predict_classifier(char *datacfg, char *cfgfile, char *weightfile, char *filename, int top);
extern void test_detector(char *datacfg, char *cfgfile, char *weightfile, char *filename, float thresh, float hier_thresh, char *outfile, int fullscreen);
extern void run_voxel(int argc, char **argv);
extern void run_yolo(int argc, char **argv);
extern void run_detector(int argc, char **argv);
extern void run_coco(int argc, char **argv);
extern void run_writing(int argc, char **argv);
extern void run_captcha(int argc, char **argv);
extern void run_nightmare(int argc, char **argv);
extern void run_dice(int argc, char **argv);
extern void run_compare(int argc, char **argv);
extern void run_classifier(int argc, char **argv);
extern void run_regressor(int argc, char **argv);
extern void run_char_rnn(int argc, char **argv);
extern void run_vid_rnn(int argc, char **argv);
extern void run_tag(int argc, char **argv);
extern void run_cifar(int argc, char **argv);
extern void run_go(int argc, char **argv);
extern void run_art(int argc, char **argv);
extern void run_super(int argc, char **argv);
extern void run_lsd(int argc, char **argv);

void average(int argc, char *argv[])
{
char *cfgfile = argv[2];
char *outfile = argv[3];
gpu_index = -1;
network net = parse_network_cfg(cfgfile);
network sum = parse_network_cfg(cfgfile);

char *weightfile = argv[4];
load_weights(&sum, weightfile);

int i, j;
int n = argc - 5;
for(i = 0; i < n; ++i){
weightfile = argv[i+5];
load_weights(&net, weightfile);
for(j = 0; j < net.n; ++j){
layer l = net.layers[j];
layer out = sum.layers[j];
if(l.type == CONVOLUTIONAL){
int num = l.n*l.c*l.size*l.size;
axpy_cpu(l.n, 1, l.biases, 1, out.biases, 1);
axpy_cpu(num, 1, l.weights, 1, out.weights, 1);
if(l.batch_normalize){
axpy_cpu(l.n, 1, l.scales, 1, out.scales, 1);
axpy_cpu(l.n, 1, l.rolling_mean, 1, out.rolling_mean, 1);
axpy_cpu(l.n, 1, l.rolling_variance, 1, out.rolling_variance, 1);
}
}
if(l.type == CONNECTED){
axpy_cpu(l.outputs, 1, l.biases, 1, out.biases, 1);
axpy_cpu(l.outputs*l.inputs, 1, l.weights, 1, out.weights, 1);
}
}
}
n = n+1;
for(j = 0; j < net.n; ++j){
layer l = sum.layers[j];
if(l.type == CONVOLUTIONAL){
int num = l.n*l.c*l.size*l.size;
scal_cpu(l.n, 1./n, l.biases, 1);
scal_cpu(num, 1./n, l.weights, 1);
if(l.batch_normalize){
scal_cpu(l.n, 1./n, l.scales, 1);
scal_cpu(l.n, 1./n, l.rolling_mean, 1);
scal_cpu(l.n, 1./n, l.rolling_variance, 1);
}
}
if(l.type == CONNECTED){
scal_cpu(l.outputs, 1./n, l.biases, 1);
scal_cpu(l.outputs*l.inputs, 1./n, l.weights, 1);
}
}
save_weights(sum, outfile);
}

void speed(char *cfgfile, int tics)
{
if (tics == 0) tics = 1000;
network net = parse_network_cfg(cfgfile);
set_batch_network(&net, 1);
int i;
time_t start = time(0);
image im = make_image(net.w, net.h, net.c*net.batch);
for(i = 0; i < tics; ++i){
network_predict(net, im.data);
}
double t = difftime(time(0), start);
printf("\n%d evals, %f Seconds\n", tics, t);
printf("Speed: %f sec/eval\n", t/tics);
printf("Speed: %f Hz\n", tics/t);
}

void operations(char *cfgfile)
{
gpu_index = -1;
network net = parse_network_cfg(cfgfile);
int i;
long ops = 0;
for(i = 0; i < net.n; ++i){
layer l = net.layers[i];
if(l.type == CONVOLUTIONAL){
ops += 2l * l.n * l.size*l.size*l.c * l.out_h*l.out_w;
} else if(l.type == CONNECTED){
ops += 2l * l.inputs * l.outputs;
}
}
printf("Floating Point Operations: %ld\n", ops);
printf("Floating Point Operations: %.2f Bn\n", (float)ops/1000000000.);
}

void oneoff(char *cfgfile, char *weightfile, char *outfile)
{
gpu_index = -1;
network net = parse_network_cfg(cfgfile);
int oldn = net.layers[net.n - 2].n;
int c = net.layers[net.n - 2].c;
scal_cpu(oldn*c, .1, net.layers[net.n - 2].weights, 1);
scal_cpu(oldn, 0, net.layers[net.n - 2].biases, 1);
net.layers[net.n - 2].n = 9418;
net.layers[net.n - 2].biases += 5;
net.layers[net.n - 2].weights += 5*c;
if(weightfile){
load_weights(&net, weightfile);
}
net.layers[net.n - 2].biases -= 5;
net.layers[net.n - 2].weights -= 5*c;
net.layers[net.n - 2].n = oldn;
printf("%d\n", oldn);
layer l = net.layers[net.n - 2];
copy_cpu(l.n/3, l.biases, 1, l.biases +   l.n/3, 1);
copy_cpu(l.n/3, l.biases, 1, l.biases + 2*l.n/3, 1);
copy_cpu(l.n/3*l.c, l.weights, 1, l.weights +   l.n/3*l.c, 1);
copy_cpu(l.n/3*l.c, l.weights, 1, l.weights + 2*l.n/3*l.c, 1);
*net.seen = 0;
save_weights(net, outfile);
}

void oneoff2(char *cfgfile, char *weightfile, char *outfile, int l)
{
gpu_index = -1;
network net = parse_network_cfg(cfgfile);
if(weightfile){
load_weights_upto(&net, weightfile, 0, net.n);
load_weights_upto(&net, weightfile, l, net.n);
}
*net.seen = 0;
save_weights_upto(net, outfile, net.n);
}

void partial(char *cfgfile, char *weightfile, char *outfile, int max)
{
gpu_index = -1;
network net = parse_network_cfg(cfgfile);
if(weightfile){
load_weights_upto(&net, weightfile, 0, max);
}
*net.seen = 0;
save_weights_upto(net, outfile, max);
}

#include "convolutional_layer.h"
void rescale_net(char *cfgfile, char *weightfile, char *outfile)
{
gpu_index = -1;
network net = parse_network_cfg(cfgfile);
if(weightfile){
load_weights(&net, weightfile);
}
int i;
for(i = 0; i < net.n; ++i){
layer l = net.layers[i];
if(l.type == CONVOLUTIONAL){
rescale_weights(l, 2, -.5);
break;
}
}
save_weights(net, outfile);
}

void rgbgr_net(char *cfgfile, char *weightfile, char *outfile)
{
gpu_index = -1;
network net = parse_network_cfg(cfgfile);
if(weightfile){
load_weights(&net, weightfile);
}
int i;
for(i = 0; i < net.n; ++i){
layer l = net.layers[i];
if(l.type == CONVOLUTIONAL){
rgbgr_weights(l);
break;
}
}
save_weights(net, outfile);
}

void reset_normalize_net(char *cfgfile, char *weightfile, char *outfile)
{
gpu_index = -1;
network net = parse_network_cfg(cfgfile);
if (weightfile) {
load_weights(&net, weightfile);
}
int i;
for (i = 0; i < net.n; ++i) {
layer l = net.layers[i];
if (l.type == CONVOLUTIONAL && l.batch_normalize) {
denormalize_convolutional_layer(l);
}
if (l.type == CONNECTED && l.batch_normalize) {
denormalize_connected_layer(l);
}
if (l.type == GRU && l.batch_normalize) {
denormalize_connected_layer(*l.input_z_layer);
denormalize_connected_layer(*l.input_r_layer);
denormalize_connected_layer(*l.input_h_layer);
denormalize_connected_layer(*l.state_z_layer);
denormalize_connected_layer(*l.state_r_layer);
denormalize_connected_layer(*l.state_h_layer);
}
}
save_weights(net, outfile);
}

layer normalize_layer(layer l, int n)
{
int j;
l.batch_normalize=1;
l.scales = calloc(n, sizeof(float));
for(j = 0; j < n; ++j){
l.scales[j] = 1;
}
l.rolling_mean = calloc(n, sizeof(float));
l.rolling_variance = calloc(n, sizeof(float));
return l;
}

void normalize_net(char *cfgfile, char *weightfile, char *outfile)
{
gpu_index = -1;
network net = parse_network_cfg(cfgfile);
if(weightfile){
load_weights(&net, weightfile);
}
int i;
for(i = 0; i < net.n; ++i){
layer l = net.layers[i];
if(l.type == CONVOLUTIONAL && !l.batch_normalize){
net.layers[i] = normalize_layer(l, l.n);
}
if (l.type == CONNECTED && !l.batch_normalize) {
net.layers[i] = normalize_layer(l, l.outputs);
}
if (l.type == GRU && l.batch_normalize) {
*l.input_z_layer = normalize_layer(*l.input_z_layer, l.input_z_layer->outputs);
*l.input_r_layer = normalize_layer(*l.input_r_layer, l.input_r_layer->outputs);
*l.input_h_layer = normalize_layer(*l.input_h_layer, l.input_h_layer->outputs);
*l.state_z_layer = normalize_layer(*l.state_z_layer, l.state_z_layer->outputs);
*l.state_r_layer = normalize_layer(*l.state_r_layer, l.state_r_layer->outputs);
*l.state_h_layer = normalize_layer(*l.state_h_layer, l.state_h_layer->outputs);
net.layers[i].batch_normalize=1;
}
}
save_weights(net, outfile);
}

void statistics_net(char *cfgfile, char *weightfile)
{
gpu_index = -1;
network net = parse_network_cfg(cfgfile);
if (weightfile) {
load_weights(&net, weightfile);
}
int i;
for (i = 0; i < net.n; ++i) {
layer l = net.layers[i];
if (l.type == CONNECTED && l.batch_normalize) {
printf("Connected Layer %d\n", i);
statistics_connected_layer(l);
}
if (l.type == GRU && l.batch_normalize) {
printf("GRU Layer %d\n", i);
printf("Input Z\n");
statistics_connected_layer(*l.input_z_layer);
printf("Input R\n");
statistics_connected_layer(*l.input_r_layer);
printf("Input H\n");
statistics_connected_layer(*l.input_h_layer);
printf("State Z\n");
statistics_connected_layer(*l.state_z_layer);
printf("State R\n");
statistics_connected_layer(*l.state_r_layer);
printf("State H\n");
statistics_connected_layer(*l.state_h_layer);
}
printf("\n");
}
}

void denormalize_net(char *cfgfile, char *weightfile, char *outfile)
{
gpu_index = -1;
network net = parse_network_cfg(cfgfile);
if (weightfile) {
load_weights(&net, weightfile);
}
int i;
for (i = 0; i < net.n; ++i) {
layer l = net.layers[i];
if (l.type == CONVOLUTIONAL && l.batch_normalize) {
denormalize_convolutional_layer(l);
net.layers[i].batch_normalize=0;
}
if (l.type == CONNECTED && l.batch_normalize) {
denormalize_connected_layer(l);
net.layers[i].batch_normalize=0;
}
if (l.type == GRU && l.batch_normalize) {
denormalize_connected_layer(*l.input_z_layer);
denormalize_connected_layer(*l.input_r_layer);
denormalize_connected_layer(*l.input_h_layer);
denormalize_connected_layer(*l.state_z_layer);
denormalize_connected_layer(*l.state_r_layer);
denormalize_connected_layer(*l.state_h_layer);
l.input_z_layer->batch_normalize = 0;
l.input_r_layer->batch_normalize = 0;
l.input_h_layer->batch_normalize = 0;
l.state_z_layer->batch_normalize = 0;
l.state_r_layer->batch_normalize = 0;
l.state_h_layer->batch_normalize = 0;
net.layers[i].batch_normalize=0;
}
}
save_weights(net, outfile);
}

void mkimg(char *cfgfile, char *weightfile, int h, int w, int num, char *prefix)
{
network net = load_network(cfgfile, weightfile, 0);
image *ims = get_weights(net.layers[0]);
int n = net.layers[0].n;
int z;
for(z = 0; z < num; ++z){
image im = make_image(h, w, 3);
fill_image(im, .5);
int i;
for(i = 0; i < 100; ++i){
image r = copy_image(ims[rand()%n]);
rotate_image_cw(r, rand()%4);
random_distort_image(r, 1, 1.5, 1.5);
int dx = rand()%(w-r.w);
int dy = rand()%(h-r.h);
ghost_image(r, im, dx, dy);
free_image(r);
}
char buff[256];
sprintf(buff, "%s/gen_%d", prefix, z);
save_image(im, buff);
free_image(im);
}
}

void visualize(char *cfgfile, char *weightfile)
{
network net = parse_network_cfg(cfgfile);
if(weightfile){
load_weights(&net, weightfile);
}
visualize_network(net);
#ifdef OPENCV
cvWaitKey(0);
#endif
}

int running=0;
int exitFlag=0;
void sigHandle(int signal){
if(signal==SIGUSR1){
printf("rec SIGUSR1\n");
running=1;
}
if(signal==SIGINT){
printf("rec SIGINT\n");
exitFlag=1;
}
}
int main(int argc, char **argv)
{
gpu_index = find_int_arg(argc, argv, "-i", 0);
if(find_arg(argc, argv, "-nogpu")) {
gpu_index = -1;
}

#ifndef GPU
gpu_index = -1;
#else
if(gpu_index >= 0){
cuda_set_device(gpu_index);
}
#endif

float thresh = find_float_arg(argc, argv, "-thresh", .24);
char *filename ="test.jpg";
char *outfile = find_char_arg(argc, argv, "-out", 0);
int fullscreen = find_arg(argc, argv, "-fullscreen");
char *cfgfile="cfg/yolo.cfg";
char *weightfile="yolo.weights";
char *datacfg="cfg/coco.data";
float hier_thresh=0.5;
list *options = read_data_cfg(datacfg);
char *name_list = option_find_str(options, "names", "data/names.list");
char **names = get_labels(name_list);

image **alphabet = load_alphabet();
network net = parse_network_cfg(cfgfile);
if(weightfile){
load_weights(&net, weightfile);
}
set_batch_network(&net, 1);
srand(2222222);
clock_t time;
char buff[256];
char *input = buff;
int j;
float nms=.4;
int ret;
int childPid=0;
if((ret=fork())<0)
exit(-1);
else if(ret==0){
printf("child pid :%d\n",childPid=getpid());
printf("parent pid:%d\n",getppid());
ServerRun();
}

if(signal(SIGUSR1,sigHandle)==SIG_ERR){
perror("set signal err");
}
if(signal(SIGINT,sigHandle)==SIG_ERR){
perror("set signal err");
}

const char * FIFO_NAME="/tmp/myfifo";
if(access(FIFO_NAME,F_OK)==-1){
int res=mkfifo(FIFO_NAME,0777);
if(res!=0){
printf("could not create fifo\n");
exit(-1);
}
}
int fifo_fd=open(FIFO_NAME,O_WRONLY);

layer l = net.layers[net.n-1];

box *boxes = calloc(l.w*l.h*l.n, sizeof(box));
float **probs = calloc(l.w*l.h*l.n, sizeof(float *));
for(j = 0; j < l.w*l.h*l.n; ++j) probs[j] = calloc(l.classes + 1, sizeof(float *));

while(!exitFlag){
while(!running){
if(exitFlag)
break;
sleep(1);
}
if(exitFlag)
break;
if(filename){
strncpy(input, filename, 256);
}
image im = load_image_color(input,0,0);
image sized = letterbox_image(im, net.w, net.h);
//image sized = resize_image(im, net.w, net.h);
//image sized2 = resize_max(im, net.w);
//image sized = crop_image(sized2, -((net.w - sized2.w)/2), -((net.h - sized2.h)/2), net.w, net.h);
//resize_network(&net, sized.w, sized.h);

float *X = sized.data;
time=clock();
network_predict(net, X);
printf("%s: Predicted in %f seconds.\n", input, sec(clock()-time));
get_region_boxes(l, im.w, im.h, net.w, net.h, thresh, probs, boxes, 0, 0, hier_thresh, 1);
if (nms) do_nms_obj(boxes, probs, l.w*l.h*l.n, l.classes, nms);
//else if (nms) do_nms_sort(boxes, probs, l.w*l.h*l.n, l.classes, nms);
draw_detections(im, l.w*l.h*l.n, thresh, boxes, probs, names, alphabet, l.classes);
if(outfile){
save_image(im, outfile);
}
else{
save_image(im, "predictions");
#ifdef OPENCV
cvNamedWindow("predictions", CV_WINDOW_NORMAL);
if(fullscreen){
cvSetWindowProperty("predictions", CV_WND_PROP_FULLSCREEN, CV_WINDOW_FULLSCREEN);
}
show_image(im, "predictions");
cvWaitKey(2000);
cvDestroyAllWindows();
#endif
}

free_image(im);
free_image(sized);

// if (filename) break;
running=0;
int res=write(fifo_fd,"1",1);
if(res==-1){
printf("write fifo err\n");
// exit(-1);
}
}
if(kill(childPid,9)==0){
waitpid(childPid,NULL,0);
}

close(fifo_fd);
free(boxes);
free_ptrs((void **)probs, l.w*l.h*l.n);

return 0;
}

eventserver.c

/*
* eventserver.c
*
*  Created on: Jun 13, 2017
*      Author: tla001
*/
#include <unistd.h>
#include <sys/types.h>
#include <time.h>
#include <errno.h>
#include <stdio.h>
#include <signal.h>
#include <sys/socket.h>
#include <sys/stat.h>
#include <sys/time.h>
#include <fcntl.h>
#include <netinet/in.h>
#include <arpa/inet.h>

//iso
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

//others
#include <event2/event-config.h>
#include <event2/bufferevent.h>
#include <event2/buffer.h>
#include <event2/listener.h>
#include <event2/util.h>
#include <event2/event.h>
#include <event2/http.h>
#include <event2/keyvalq_struct.h>
#include <event2/http_struct.h>
#include <event2/buffer_compat.h>

#include "cJSON.h"

void test_request_cb(struct evhttp_request *req, void *arg) {
int ppid=getppid();
int type = evhttp_request_get_command(req);
const char *requestUri = evhttp_request_get_uri(req);
if (EVHTTP_REQ_GET == type) {
printf("method:GET uri:%s\n", requestUri);
} else if (EVHTTP_REQ_POST == type) {
printf("method:POST uri:%s\n", requestUri);
}

char *post_data = (char *) EVBUFFER_DATA(req->input_buffer);
//    printf("post data: %s", post_data);
size_t maxSize = 0;
memcpy(&maxSize, post_data, sizeof(size_t));

FILE *fp = fopen("test.jpg", "wb");
fwrite(post_data + sizeof(size_t), 1, maxSize, fp);
fclose(fp);
kill(ppid,SIGUSR1);
const char *FIFO_NAME="/tmp/myfifo";
int fifo_fd=open(FIFO_NAME,O_RDONLY);
char tmp=0;
int res=read(fifo_fd,&tmp,1);
if(res==-1){
printf("read err\n");
goto THISEXIT;
}
close(fifo_fd);
printf("fifo tmp=%c\n", tmp);
char *resData="rec";
if(tmp=='1'){
FILE *fp=fopen("res.json","rb");
if(fp==NULL)
goto THISEXIT;
fseek(fp,0,SEEK_END);
size_t size=ftell(fp);
rewind(fp);
resData=NULL;
resData=(char*)malloc(sizeof(char)*size+1);
int readSize=fread(resData,1,size,fp);
if(readSize!=size){
printf("read err\n");
}
resData[sizeof(char)*size]='\0';
printf("%s\n", resData);
fclose(fp);
}

printf("rec data len:%d\n", strlen(resData));
struct evbuffer *buf1 = evbuffer_new();
evbuffer_add_printf(buf1, resData);
evhttp_send_reply(req, 200, "OK", buf1);
if(resData&&tmp=='1')
free(resData);
return ;
THISEXIT:
kill(ppid,SIGINT);

exit(-1);
}
void ServerRun() {
int port = 5555;

struct event_base *base;
struct evhttp *http;
struct evhttp_bound_socket *handle;

if (signal(SIGPIPE, SIG_IGN) == SIG_ERR) {
printf("signal error,error[%d],error[%s]", errno, strerror(errno));
exit(-1);
}
base = event_base_new();
if (!base) {
printf("create an event_base err\n");
exit(-1);
}
http = evhttp_new(base);
if (!http) {
printf("create evhttp err\n");
exit(-1);
}
evhttp_set_cb(http, "/test", test_request_cb, NULL);

handle = evhttp_bind_socket_with_handle(http, "0.0.0.0", port);
if (!handle) {
printf("bind to port[%d] err\n", port);
exit(-1);
}

{
struct sockaddr_storage ss;
evutil_socket_t fd;
ev_socklen_t socklen = sizeof(ss);
char addrbuf[128];
void *inaddr;
const char *addr;
int got_port = -1;
fd = evhttp_bound_socket_get_fd(handle);
memset(&ss, 0, sizeof(ss));
if (getsockname(fd, (struct sockaddr*) &ss, &socklen)) {
perror("getsockname failed");
exit(-1);
}
if (ss.ss_family == AF_INET) {
got_port = ntohs(((struct sockaddr_in*) &ss)->sin_port);
inaddr = &((struct sockaddr_in*) &ss)->sin_addr;
} else if (ss.ss_family == AF_INET6) {
got_port = ntohs(((struct sockaddr_in6*) &ss)->sin6_port);
inaddr = &((struct sockaddr_in6*) &ss)->sin6_addr;
} else {
printf("Weird address family\n");
exit(1);
}

addr = evutil_inet_ntop(ss.ss_family, inaddr, addrbuf, sizeof(addrbuf));
if (addr) {
printf("Listening on %s:%d\n", addr, got_port);
} else {
printf("evutil_inet_ntop failed\n");
exit(-1);
}
}
event_base_dispatch(base);
}

image.c修改一下函数

void draw_detections(image im, int num, float thresh, box *boxes, float **probs, char **names, image **alphabet, int classes)
{

int i;
cJSON *res=cJSON_CreateObject();
cJSON *content,*rec;
cJSON_AddItemToObject(res,"content",content=cJSON_CreateArray());
for(i = 0; i < num; ++i){
int class = max_index(probs[i], classes);
float prob = probs[i][class];
if(prob > thresh){

int width = im.h * .012;

if(0){
width = pow(prob, 1./2.)*10+1;
alphabet = 0;
}

//printf("%d %s: %.0f%%\n", i, names[class], prob*100);
// printf("%s: %.0f%%\n", names[class], prob*100);
int offset = class*123457 % classes;
float red = get_color(2,offset,classes);
float green = get_color(1,offset,classes);
float blue = get_color(0,offset,classes);
float rgb[3];

//width = prob*20+2;

rgb[0] = red;
rgb[1] = green;
rgb[2] = blue;
box b = boxes[i];

int left  = (b.x-b.w/2.)*im.w;
int right = (b.x+b.w/2.)*im.w;
int top   = (b.y-b.h/2.)*im.h;
int bot   = (b.y+b.h/2.)*im.h;

if(left < 0) left = 0;
if(right > im.w-1) right = im.w-1;
if(top < 0) top = 0;
if(bot > im.h-1) bot = im.h-1;

cJSON_AddItemToObject(content,"rec",rec=cJSON_CreateObject());
cJSON_AddStringToObject(rec,"class",names[class]);
cJSON_AddNumberToObject(rec,"prob",prob*100);
cJSON_AddNumberToObject(rec,"left",left);
cJSON_AddNumberToObject(rec,"right",right);
cJSON_AddNumberToObject(rec,"top",top);
cJSON_AddNumberToObject(rec,"bot",bot);

draw_box_width(im, left, top, right, bot, width, red, green, blue);
if (alphabet) {
image label = get_label(alphabet, names[class], (im.h*.03)/10);
draw_label(im, top + width, left, label, rgb);
free_image(label);
}
}
}
char *resStr=cJSON_Print(res);
cJSON_Delete(res);
// printf("%s\n", resStr);
FILE *fp=fopen("res.json","wb");
fwrite(resStr,1,strlen(resStr),fp);
fclose(fp);
}

Makefile做了必要的修改

GPU=1
CUDNN=1
OPENCV=1
DEBUG=0

ARCH= -gencode arch=compute_20,code=[sm_20,sm_21] \
-gencode arch=compute_30,code=sm_30 \
-gencode arch=compute_35,code=sm_35 \
-gencode arch=compute_50,code=[sm_50,compute_50] \
-gencode arch=compute_52,code=[sm_52,compute_52]

# This is what I use, uncomment if you know your arch and want to specify
# ARCH=  -gencode arch=compute_52,code=compute_52

VPATH=./src/
EXEC=myapp
OBJDIR=./obj/

CC=gcc
NVCC=nvcc
OPTS=-Ofast
LDFLAGS= -lm -pthread -L/usr/local/libevent/lib -levent
COMMON=-I/usr/local/libevent/include
CFLAGS=-Wall -Wfatal-errors

ifeq ($(DEBUG), 1)
OPTS=-O0 -g
endif

CFLAGS+=$(OPTS)

ifeq ($(OPENCV), 1)
COMMON+= -DOPENCV
CFLAGS+= -DOPENCV
LDFLAGS+= `pkg-config --libs opencv`
COMMON+= `pkg-config --cflags opencv`
endif

ifeq ($(GPU), 1)
COMMON+= -DGPU -I/usr/local/cuda/include/
CFLAGS+= -DGPU
LDFLAGS+= -L/usr/local/cuda/lib64 -lcuda -lcudart -lcublas -lcurand
endif

ifeq ($(CUDNN), 1)
COMMON+= -DCUDNN
CFLAGS+= -DCUDNN
LDFLAGS+= -lcudnn
endif

OBJ=main.o eventserver.o cJSON.o gemm.o utils.o cuda.o deconvolutional_layer.o convolutional_layer.o list.o image.o activations.o im2col.o col2im.o blas.o crop_layer.o dropout_layer.o maxpool_layer.o softmax_layer.o data.o matrix.o network.o connected_layer.o cost_layer.o parser.o option_list.o detection_layer.o captcha.o route_layer.o writing.o box.o nightmare.o normalization_layer.o avgpool_layer.o coco.o dice.o yolo.o detector.o layer.o compare.o regressor.o classifier.o local_layer.o swag.o shortcut_layer.o activation_layer.o rnn_layer.o gru_layer.o rnn.o rnn_vid.o crnn_layer.o demo.o tag.o cifar.o go.o batchnorm_layer.o art.o region_layer.o reorg_layer.o lsd.o super.o voxel.o tree.o
ifeq ($(GPU), 1)
LDFLAGS+= -lstdc++
OBJ+=convolutional_kernels.o deconvolutional_kernels.o activation_kernels.o im2col_kernels.o col2im_kernels.o blas_kernels.o crop_layer_kernels.o dropout_layer_kernels.o maxpool_layer_kernels.o network_kernels.o avgpool_layer_kernels.o
endif

OBJS = $(addprefix $(OBJDIR), $(OBJ))
DEPS = $(wildcard src/*.h) Makefile

all: obj backup results $(EXEC)

$(EXEC): $(OBJS)
$(CC) $(COMMON) $(CFLAGS) $^ -o $@ $(LDFLAGS)

$(OBJDIR)%.o: %.c $(DEPS)
$(CC) $(COMMON) $(CFLAGS) -c $< -o $@

$(OBJDIR)%.o: %.cu $(DEPS)
$(NVCC) $(ARCH) $(COMMON) --compiler-options "$(CFLAGS)" -c $< -o $@

obj:
mkdir -p obj
backup:
mkdir -p backup
results:
mkdir -p results

.PHONY: clean

clean:
rm -rf $(OBJS) $(EXEC)

　　

　　在使用进程控制的时候，有一些防止出错的机制。

本项目涉及的技术yolo检测 --libevent http server --libcurl http client --http json