main.cpp 5.2 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238
  1. #include <QCoreApplication>
  2. #include <iostream>
  3. #include "modulecomm.h"
  4. #include "rawpic.pb.h"
  5. #include <opencv2/opencv.hpp>
  6. #include <opencv2/core.hpp>
  7. #include <opencv2/imgproc.hpp>
  8. //#include "opencv2/imgcodecs/legacy/constants_c.h"
  9. #include <opencv2/imgproc/types_c.h>
  10. extern "C"
  11. {
  12. #include "darknet.h"
  13. }
  14. #include <memory>
  15. #include <thread>
  16. #include <mutex>
  17. #include <condition_variable>
  18. image ** gpalphabet;
  19. network * gpnet;
  20. static void * gpa;
  21. cv::Mat gmat;
  22. bool gbUpdate = false;
  23. std::mutex gmutex;
  24. std::mutex gmutexcv;
  25. std::condition_variable gcv;
  26. bool gbrun = true;
  27. char ** names;
  28. int gnclasses = 80;
  29. double gfthresh = 0.5;
  30. namespace iv {
  31. image mat_to_image(cv::Mat mat)
  32. {
  33. IplImage ipl = cvIplImage(mat);
  34. IplImage * src = &ipl;
  35. int h = src->height;
  36. int w = src->width;
  37. int c = src->nChannels;
  38. image im = make_image(w, h, c);
  39. unsigned char *data = (unsigned char *)src->imageData;
  40. int step = src->widthStep;
  41. int i, j, k;
  42. for(i = 0; i < h; ++i){
  43. for(k= 0; k < c; ++k){
  44. for(j = 0; j < w; ++j){
  45. im.data[k*w*h + i*w + j] = data[i*step + j*c + k]/255.;
  46. }
  47. }
  48. }
  49. for(i = 0; i < im.w*im.h; ++i){
  50. float swap = im.data[i];
  51. im.data[i] = im.data[i+im.w*im.h*2];
  52. im.data[i+im.w*im.h*2] = swap;
  53. }
  54. return im;
  55. }
  56. IplImage *image_to_ipl(image im)
  57. {
  58. int x,y,c;
  59. IplImage *disp = cvCreateImage(cvSize(im.w,im.h), IPL_DEPTH_8U, im.c);
  60. int step = disp->widthStep;
  61. for(y = 0; y < im.h; ++y){
  62. for(x = 0; x < im.w; ++x){
  63. for(c= 0; c < im.c; ++c){
  64. float val = im.data[c*im.h*im.w + y*im.w + x];
  65. disp->imageData[y*step + x*im.c + c] = (unsigned char)(val*255);
  66. }
  67. }
  68. }
  69. return disp;
  70. }
  71. cv::Mat image_to_mat(image im)
  72. {
  73. image copy = copy_image(im);
  74. constrain_image(copy);
  75. if(im.c == 3) rgbgr_image(copy);
  76. IplImage *ipl = image_to_ipl(copy);
  77. cv::Mat m = cv::cvarrToMat(ipl, true);
  78. cvReleaseImage(&ipl);
  79. free_image(copy);
  80. return m;
  81. }
  82. void dodetec(cv::Mat mat)
  83. {
  84. image im = iv::mat_to_image(mat);
  85. image sized = letterbox_image(im, gpnet->w, gpnet->h);
  86. layer l = gpnet->layers[gpnet->n-1];
  87. std::cout<<" net layer: "<<gpnet->n<<"class: "<<l.classes<<std::endl;
  88. float *X = sized.data;
  89. double time=what_time_is_it_now();
  90. network_predict(gpnet, X);
  91. printf("Predicted in %f seconds.\n", what_time_is_it_now()-time);
  92. int nboxes = 0;
  93. float thresh = gfthresh;
  94. detection *dets = get_network_boxes(gpnet, im.w, im.h, thresh,thresh, 0, 1, &nboxes);
  95. float nms=.45;
  96. if(nms)do_nms_sort(dets, nboxes, gnclasses, nms);
  97. draw_detections(im, dets, nboxes, thresh, names, gpalphabet, gnclasses);
  98. free_detections(dets, nboxes);
  99. std::cout<<" nbox: "<<nboxes<<std::endl;
  100. #ifdef SHOW_RESULT
  101. cv::Mat matres = image_to_mat(im);
  102. cv::namedWindow("image" + std::to_string(0), cv::WINDOW_NORMAL);
  103. cv::imshow("image"+std::to_string(0), matres);
  104. cv::waitKey(1);
  105. #endif
  106. free_image(im);
  107. free_image(sized);
  108. return;
  109. }
  110. }
  111. void threaddetect()
  112. {
  113. while (gbrun) {
  114. std::unique_lock<std::mutex> lk(gmutexcv);
  115. if(gcv.wait_for(lk, std::chrono::milliseconds(3000)) == std::cv_status::timeout)
  116. {
  117. lk.unlock();
  118. }
  119. else
  120. {
  121. lk.unlock();
  122. }
  123. if(gbUpdate)
  124. {
  125. cv::Mat xMat;
  126. gmutex.lock();
  127. xMat = gmat.clone();
  128. gbUpdate = false;
  129. gmutex.unlock();
  130. iv::dodetec(xMat);
  131. }
  132. }
  133. }
  134. static void CallDetect(iv::vision::rawpic & xrawpic)
  135. {
  136. cv::Mat mat(xrawpic.height(),xrawpic.width(),xrawpic.mattype());
  137. if(xrawpic.type() == 1)
  138. memcpy(mat.data,xrawpic.picdata().data(),mat.rows*mat.cols*mat.elemSize());
  139. else
  140. {
  141. std::vector<unsigned char> buff(xrawpic.picdata().data(),
  142. xrawpic.picdata().data()+xrawpic.picdata().size());
  143. mat = cv::imdecode(buff,1);
  144. }
  145. // cv::cvtColor(mat, mat, CV_BGR2RGB);
  146. gmutex.lock();
  147. gmat = mat.clone();
  148. gbUpdate = true;
  149. gmutex.unlock();
  150. gcv.notify_all();
  151. //Call Detect Funcion use mat
  152. }
  153. void Listenpic(const char * strdata,const unsigned int nSize,
  154. const unsigned int index,const QDateTime * dt,const char * strmemname)
  155. {
  156. (void)index; (void)dt; (void)strmemname;
  157. iv::vision::rawpic pic;
  158. if(false == pic.ParseFromArray(strdata,nSize))
  159. {
  160. std::cout<<"picview Listenpic fail."<<std::endl;
  161. return;
  162. }
  163. CallDetect(pic);
  164. }
  165. int main(int argc, char *argv[])
  166. {
  167. QCoreApplication a(argc, argv);
  168. char * cfgfile = "./cfg/yolov3.cfg";
  169. char * weightfile = "./yolov3.weights";
  170. names = get_labels("./data/coco.names");
  171. gpalphabet = load_alphabet();
  172. gnclasses = 80;
  173. gfthresh = 0.5;
  174. network *net = load_network(cfgfile, weightfile, 0);
  175. set_batch_network(net, 1);
  176. gpnet = net;
  177. gpa = iv::modulecomm::RegisterRecv("image00",Listenpic);
  178. #ifdef SHOW_RESULT
  179. threaddetect();
  180. #else
  181. std::thread * pthreaddet = new std::thread(threaddetect);
  182. (void)pthreaddet;
  183. #endif
  184. return a.exec();
  185. }