经验首页 前端设计 程序设计 Java相关 移动开发 数据库/运维 软件/图像 大数据/云计算 其他经验
当前位置：技术经验 » 程序设计 » C++ » 查看文章
混合编程python与C++
来源：cnblogs　　作者：Rurouni　　时间：2023/6/8 9:26:25　　对本文有异议

上个版本: 只是用到ctypes进行传输, 这次将python服务端更改为C++服务端,方便后续维护.
本文实现功能: python传输图片给C++, C++接受图片后对图片进行处理,并将结果返回给python客户端, pass image from python to C++

C++ 服务端

.h文件

注意文中的model

  1. // .h
  2. #pragma once
  3. #include <stdio.h>
  4. #include <stdlib.h>
  5. #include <string.h>
  6. #include <unistd.h>
  7. #include <sys/socket.h>
  8. #include <arpa/inet.h>
  9. #include <netinet/in.h>
  10. #include <signal.h>
  11. #include <opencv2/opencv.hpp>
  13. using namespace std;
  14. using namespace cv;
  16. class ModelManager;
  18. class ServerManager
  19. {
  20. private:
  21. 	int m_port;
  22. 	char *m_addr;
  23. 	cv::VideoCapture m_cap;
  24. 	int m_server;
  25. 	int m_accept; // client conn
  26. public:
  27. 	bool initialization(const int &port, const cv::VideoCapture &cap, char *addr = nullptr);
  28. 	bool initialization(const int &port, char *addr = nullptr);
  29. 	bool build_connect();
  30. 	bool acceptClient();
  31. 	void error_print(const char *ptr);
  32. 	bool free_connect();
  34. 	bool send_data_frame(ModelManager& model);
  35. 	bool receive_data_frame(cv::Mat &frame, ModelManager& model);
  36. };

.cpp文件

  1. #include "ServerManager.h"
  2. #include "ModelManager.h"
  3. #define BUFFER_SIZE 65538
  5. void ServerManager::error_print(const char * ptr) {
  6.         perror(ptr);
  7.         exit(EXIT_FAILURE);
  8. }
  10. bool ServerManager::initialization(const int& port, const cv::VideoCapture& cap, char* addr){
  11.     m_port = htons(port);
  12. 	m_addr = addr;
  13. 	m_cap = cap;
  14. 	return true;
  15. }
  17. bool ServerManager::initialization(const int& port, char* addr){
  18.     m_port = htons(port);
  19.     m_addr = addr;
  20. 	return true;
  21. }
  23. bool ServerManager::build_connect() {
  24. 	struct sockaddr_in server_addr;
  25.     bzero(&server_addr,sizeof(server_addr));
  26. 	server_addr.sin_family = AF_INET;
  27. 	server_addr.sin_addr.s_addr = m_addr?inet_addr(m_addr):INADDR_ANY;  
  28. 	server_addr.sin_port = m_port;
  29. 	// create socket 
  30. 	m_server = socket(AF_INET, SOCK_STREAM, 0);
  31. 	if(m_server < 0)
  32.         error_print("socket bind error");
  33. 	// can reuse port
  34.     int on = 1;
  35.     if(setsockopt(m_server,SOL_SOCKET,SO_REUSEADDR,&on,sizeof(on)) < 0)
  36.         error_print("setsockopt error");
  37.     // bind addr
  38.     if(bind(m_server, (struct sockaddr*)&server_addr, sizeof(server_addr)) < 0)
  39.         error_print("bind error");
  40.     // listen only one client
  41.     if(listen(m_server, 1) < 0)
  42.         error_print("listen failed");
  43.     
  44. 	cout << "ServerManager is listening, plesae wait..." << endl;
  45. 	
  46. 	return true;
  47. }
  49. bool ServerManager::acceptClient(){
  50. 	struct sockaddr_in accept_addr;
  51. 	socklen_t accept_len = sizeof(accept_addr);
  52. 	bzero(&accept_addr,sizeof(accept_addr));
  53. 	// accept client connection
  54.     if((m_accept = accept(m_server,(struct sockaddr*)&accept_addr,&accept_len)) < 0)
  55.         error_print("accept error");
  56. 	std::cout << "Connection established" << std::endl;
  57. 	return true;
  58. }
  60. bool ServerManager::send_data_frame(ModelManager& model) {
  61. 	char *json_output = nullptr;
  62. 	json_output = model.createJson();
  63. 	if (json_output == nullptr) {
  64. 		return false;
  65. 	}
  66. 	
  67. 	// printf("send data %s\n", json_output);
  68. 	// just send json_output, dont memcpy new char*!!! it wastes me two hours
  69. 	// send json
  70. 	int result = send(m_accept, json_output, strlen(json_output), 0);
  71. 	if (result == -1) {
  72. 		cout << "send fail" << endl;
  73. 		return false;
  74. 	}
  75. 	return true;
  76. }
  79. bool ServerManager::receive_data_frame(Mat& frame, ModelManager& model) {
  80. 	// recv frame size
  81. 	int data_size;
  82. 	if (recv(m_accept, &data_size, sizeof(data_size), 0) != sizeof(data_size)) {
  83. 		// when client close, then close connection
  84. 		close(m_accept);
  85. 		cout << "close connection to client" << endl;
  86. 		acceptClient(); // restart a new accept, to accept new connection
  87. 		return false;
  88. 	}
  89. 	cout << data_size << endl;
  90. 	// recv frame data
  91.     
  92. 	// char buf[data_size];
  93. 	// std::vector<uchar> decode;
  94. 	// int bytes_received = 0;
  95. 	// do
  96. 	// {
  97. 	// 	int nBytes = recv(m_accept, buf, data_size - bytes_received, 0);
  98. 	// 	for (int i = 0; i < nBytes; i++)  // maybe can use memcpy, maybe faster
  99. 	// 	{
  100. 	// 		decode.emplace_back(buf[i]);
  101. 	// 	}
  102. 	// 	cout << bytes_received << endl;
  103. 	// 	bytes_received += nBytes;
  104. 	// } while (bytes_received < data_size);
  105.     char *recv_char = new char[data_size];
  106. 	std::vector<uchar> decode(data_size, 0);
  107. 	int index = 0;
  108. 	int bytes_received = 0;
  109. 	int count = data_size;
  110. 	while (count > 0)// if count >= 0, dead loop
  111. 	{
  112. 		int iRet = recv(m_accept, recv_char, count, 0);
  113. 		if (index >= data_size) index = data_size;
  114. 		memcpy(&decode[index], recv_char , iRet);
  115. 		index += iRet;
  116. 		if (!iRet) { return -1; }
  117. 		count -= iRet;
  118. 	}
  119. 	// decode message
  120. 	frame = imdecode(decode, cv::IMREAD_COLOR);
  121. 	// push into Model's queueMat
  122. 	model.mtxQueueImg.lock();
  123. 	model.queueMat.push(frame);
  124. 	model.mtxQueueImg.unlock();
  125. 	return true;
  126. }
  128. bool ServerManager::free_connect() {
  129. 	m_cap.release();
  130. 	close(m_accept);
  131.     close(m_server);
  132. 	return true;
  133. }

C++ model部分代码

.h文件

  1. #pragma once
  2. #include "CV_Classify.h"
  3. #include "CV_Detect.h"
  4. #include "ServerManager.h"
  5. #include <opencv2/opencv.hpp>
  6. #include <mutex>
  7. #include <queue>
  8. #include <unistd.h> // usleep
  9. #include <thread>
  10. #include "cJSON.h"
  11. #include <string>
  13. using namespace std;
  14. using namespace cv;
  16. class ModelManager{
  17. public:
  18.     Detect objdetect;
  19.     Classify objclassify;
  20.     std::mutex mtxQueueDet;  // mutex for detect queue
  21.     std::mutex mtxQueueImg;  // mutex for image queue
  22.     std::mutex mtxQueueCls;  // mutex for classify queue
  23.     std::queue<cv::Mat> queueMat;
  24.     std::queue<ObjDetectOutput> queueDetOut;// Detect queue
  25.     std::queue<ObjClassifyOutput> queueClsOut;// Classify queue
  26.     
  27.     bool DetectFlag = true;
  28.     bool ClassifyFlag = true;
  29.     bool empty_flag = false;
  30.     friend class ServerManager;
  31. public:
  32.     void initDetectModel() ;
  33.     void initClassifyModel() ;
  34.     void DetectImg();
  35.     void ClassifyImg();
  36.     void getClsResult(ObjClassifyOutput &output);
  37.     // ObjClassifyOutput getClsResult();
  38.     char* createJson();
  39. };

.cpp文件

部分有删减,createJson可参考使用,利用json来传递值

  1. #include "ModelManager.h"
  3. void ModelManager::initDetectModel() 
  4. {
  5.     std::string config_path = "DetectConfig.yaml";
  6.     objdetect.Init(config_path, 1);
  7. }
  8. void ModelManager::initClassifyModel() 
  9. {
  10.     std::string config_path = "ClassiflyConfig.yaml";
  11.     objclassify.Init(config_path, 1);
  12. }
  14. void ModelManager::DetectImg()
  15. {
  16.     DetectInput detect_input;
  17.     DetectOutput detect_output;
  18.     cv::Mat frame;
  19.     size_t mm = 0;
  20.     while(1)
  21.     { 
  22.         if (queueMat.empty()) 
  23.         {
  24.             if(!DetectFlag)
  25.             {
  26.                 break;
  27.             }
  28. 			usleep(2000);
  29.             continue;
  30. 		}
  31.         // get image from queueMat
  32.         mtxQueueImg.lock();
  33.         frame = queueMat.front();
  34.         queueMat.pop();
  35.         mtxQueueImg.unlock();
  36.         // run model
  37.         objdetect.Run(detect_input, detect_output);
  38.         // push detect result into queueDetOut
  39.         mtxQueueDet.lock();
  40.         queueDetOut.push(detect_output);
  41.         // cout << "detect run !!" << endl;
  42.         mtxQueueDet.unlock();
  43.     }
  44.     return;
  45. }
  46. void ModelManager::ClassifyImg()
  47. {
  48.     ObjClassifyInput input;
  49.     ObjClassifyOutput output;
  50.     cv::Mat frame;
  51.     Detoutput detect_result;
  52.     while(1)
  53.     {
  54.         if (queueDetOut.empty()) 
  55.         {
  56.             if(!ClassifyFlag)
  57.             {
  58.                 break;
  59.             }
  60. 			usleep(2000);
  61.             continue;
  62. 		}
  63.         // get detect from queueDetOut
  64.         mtxQueueDet.lock();
  65.         detect_result = queueDetOut.front();
  66.         queueDetOut.pop();
  67.         mtxQueueDet.unlock();
  68.         // run model
  69.         objclassify.Run(input, output);
  70.         // push cls result into queueClsOut
  71.         mtxQueueCls.lock();
  72.         queueClsOut.push(output);
  73.         mtxQueueCls.unlock();  
  74.     }
  75.     return;
  76. }
  78. void ModelManager::getClsResult(ObjClassifyOutput& output){
  79.     if (queueClsOut.empty()){
  80.         output.object_list.object_num = -1;  // -1 is now empty;
  81.         return; // must return in thread otherwise cant use &output
  82.     }
  83.     output = queueClsOut.front();
  84.     queueClsOut.pop();
  85.     return;
  86. }
  88. char* ModelManager::createJson()  // dont know why cant use &value, need return value
  89. {
  90.     mtxQueueCls.lock();
  91.     ObjClassifyOutput output;
  92.     getClsResult(output); 
  93.     mtxQueueCls.unlock();
  94. 	
  95. 	if (output.object_list.object_num == -1){
  96. 		return nullptr;
  97. 	}
  98. 	// prepare send data json
  99. 	cJSON* json_object_list = NULL;
  100. 	cJSON* json_ObjClassifyOutput = NULL;
  101. 	
  102. 	json_ObjClassifyOutput = cJSON_CreateObject();
  103. 	json_object_list = cJSON_CreateObject();
  104. 	cJSON_AddItemToObject(json_ObjClassifyOutput, "object_list", json_object_list);
  105. 	
  106. 	int obj_num = output.object_list.object_num;
  107. 	cJSON_AddNumberToObject(json_object_list, "object_num", obj_num);
  108. 	for (int i = 0; i < obj_num; ++i){
  109. 		cJSON* json_object = cJSON_CreateObject();
  110. 		cJSON* json_box = cJSON_CreateObject();
  111. 		cJSON_AddNumberToObject(json_box,"x", output.object_list.object[i].bbox.x);
  112. 		cJSON_AddNumberToObject(json_box,"y", output.object_list.object[i].bbox.y);
  113. 		cJSON_AddNumberToObject(json_box,"w", output.object_list.object[i].bbox.w);
  114. 		cJSON_AddNumberToObject(json_box,"h", output.object_list.object[i].bbox.h);
  115. 		cJSON_AddItemToObject(json_object,"bbox", json_box);
  116. 		cJSON_AddNumberToObject(json_object, "classes", output.object_list.object[i].classes);
  117. 		cJSON_AddNumberToObject(json_object, "objectness", output.object_list.object[i].objectness);
  118.         // double prob = output.object_list.object[i].prob;
  119. 		// cJSON_AddNumberToObject(json_object, "prob", prob); // pointer cant use?
  120. 		string str = "object" + to_string(i);
  121.         cJSON_AddItemToObject(json_object_list, str.c_str(), json_object);
  122.         // printf("prob: %f", output.object_list.object[i].prob);
  123. 	}
  124. 	
  125. 	char* json_output = cJSON_Print(json_ObjClassifyOutput);
  126.     cJSON_Delete(json_ObjClassifyOutput);
  127.     return json_output;
  128. }

C++ 服务端运行

  1. #include <../include/ServerManager.h>
  2. #include <../include/ModelManager.h>
  3. #include <thread>
  4. #define PORT 8080
  5. void recvServer(ServerManager& s, ModelManager& model){
  6.     int idx = 0;
  7.     
  8.     while (true){
  9.         // auto start = std::chrono::steady_clock::now();
  10.         cv::Mat frame;
  11.         s.receive_data_frame(frame, model);
  12.         // cal time cost
  13.         // auto end = std::chrono::steady_clock::now();
  14.         // std::chrono::duration<double, std::milli> elapsed = end - start;
  15.         // std::cout << "recv execution time: " << elapsed.count() << " ms\n";
  16.         if (frame.empty()) {
  17.             usleep(2000);
  18.             continue;
  19.         }
  20.         // cv::imwrite("image"+to_string(idx++)+".jpg", frame);
  21.         std::cout << "Image " << idx++ <<" received !!" << std::endl;
  22.     }
  23. }
  25. void sendServer(ServerManager& s, ModelManager& model){
  26.     while (true){
  27.         if (s.send_data_frame(model)) {
  28.             cout << "send success!!" << endl;
  29.             cout << endl;
  30.         }else{
  31.             // cout << "send fail!!" << endl;
  32.             usleep(2000);
  33.         }
  34.     }
  35. }
  36.  
  37. int main()
  38. {
  39.     ServerManager s;
  40.     ModelManager model;
  41.     model.initDetectModel();
  42.     model.initClassifyModel();
  43.     cout << endl;
  44.     s.initialization(PORT);
  45.     s.build_connect();
  46.     s.acceptClient();
  47.     
  48.     thread recv_server(recvServer, std::ref(s), std::ref(model));
  49.     thread send_server(sendServer, std::ref(s), std::ref(model));
  50.     thread detect(&ModelManager::DetectImg, &model);
  51.     thread classfy(&ModelManager::ClassifyImg, &model);
  52.     detect.join();
  53.     classfy.join();
  54.     recv_server.join();
  55.     send_server.join();
  56.     return 0;
  57. }

python客户端

  1. import json
  2. import socket
  3. import struct
  4. import time
  5. from multiprocessing import JoinableQueue
  6. from threading import Thread
  8. import os
  9. from natsort import ns, natsorted
  11. host = '192.168.0.2'  # '192.168.0.2' 'localhost'
  12. port = 8080
  15. def img_encode(img_path):
  16.     img = cv2.imread(img_path)
  17.     # img = cv2.resize(img, (500, 500), interpolation=cv2.INTER_CUBIC)
  18.     img_param = [95]  # 图片压缩率0-100
  19.     _, img = cv2.imencode('.jpg', img, img_param)
  20.     img = img.tobytes()
  21.     return img
  24. def img_product(img_queue, path, path_mode='image'):
  25.     if path_mode == 'image':
  26.         image = img_encode(path)
  27.         img_queue.put(image)
  28.     elif path_mode == 'dir':
  29.         dir_list = os.listdir(path)
  30.         files = natsorted(dir_list, alg=ns.PATH)  # 顺序读取文件名
  31.         for filename in files:
  32.             img_path = path + '/' + filename
  33.             image = img_encode(img_path)
  34.             img_queue.put(image)
  35.         img_queue.put('E')
  36.     img_queue.join()
  39. def server_consumer(img_queue):
  40.     while True:
  41.         start = int(round(time.time() * 1000))
  42.         # 1. get img from queue
  43.         img_obj = img_queue.get()
  44.         img_queue.task_done()
  45.         # get end signal
  46.         if img_obj[0] == 'E':
  47.         client.close()
  48.         break
  49.         # 2. send package(img_bytes_size, img_bytes)
  50.         pack_size = struct.pack("i", len(img_obj))
  51.         client.send(pack_size + img_obj)
  52.         end = int(round(time.time() * 1000))
  54.         data = client.recv(65536)
  55.         json_str = data.decode('utf8', 'ignore').strip(b'\x00'.decode())
  56.         results = json.loads(json_str)
  57.         end = int(round(time.time() * 1000))
  58.         end_time = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
  59.         print('send and recv cost time: ', (end - start))
  60.         print(results)
  63.         if __name__ == '__main__':
  64.         client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
  65.         client.connect((host, port))
  66.         img_dir = 'data'
  67.         one_img = './data/image.jpg'
  68.         mode = 'dir'
  70.         img_jq = JoinableQueue()
  71.         producer = Thread(target=img_product, args=(img_jq, img_dir, mode,))
  72.         consumer = Thread(target=server_consumer, args=(img_jq,))
  73.         producer.daemon = True  # set daemon but not set join()
  75.         producer.start()
  76.         consumer.start()
  78.     # producer.join() // 让生产者先关闭,防止close错误
  79.         consumer.join()

总结

  • 其实这个项目真正做完感觉还是挺简单, 就是对socket通信不太熟悉, 以及传图片没做过.
  • 实际上传图片只需要读取图片后,imencode,然后tobytes,最后发送size和data即可.而接受端只需要拼接数组,然后imdecode即可.
  • 另外传输结果的话利用json传输可以让结果可读性可高, 传输也比较方便, 当时copy别人的发送代码, 没有细看,导致使用memcpy让json格式乱码,导致无法解码json.
  • 如果你感觉接收端没问题,一定要看看发送端.
  • 之后的新任务就是视频传输利用rtsp流,敬请期待

参考博客

原文链接：https://www.cnblogs.com/zds1366/p/17464756.html

 友情链接：直通硅谷 　点职佳 　北美留学生论坛

C++热门文章

  • C/C++编程笔记：编写不会在C ++中编译的C程序，我教你呀！
  • 洛谷 P2085 最小函数值
  • 使用C++界面框架ImGUI开发一个简单程序
  • C++ Json解析CJsonObject的详细使用
  • C++编译错误杂记
  • 二分法（二）：采用二分法解决“最小化最大值问题”
  • C++实现json字符串与map的转换
  • C++借助curses库实现俄罗斯方块
  • 长乐培训Day5
  • 【OpenFOAM】——OpenFOAM入门算例学习

    • C++推荐文章

  • #8. 「模板」树链剖分
  • 预设型 DP
  • Standard Template Libary or C++ Standard Library
  • 一种优秀的虚拟机内存架构 - AQ
  • 如何让 MGR 不从 Primary 节点克隆数据？
  • TLScanary：Pwn中的利器
  • c++临时对象导致的生命周期问题
  • C++(Qt)-GIS开发-简易瓦片地图下载器
  • 逆向通达信 x 逆向微信 x 逆向Qt
  • C++面向对象

    • 本站QQ群：前端 618073944 | Java 606181507 | Python 626812652 | C/C++ 612253063 | 微信 634508462 | 苹果 692586424 | C#/.net 182808419 | PHP 305140648 | 运维 608723728

    W3xue 的所有内容仅供测试，对任何法律问题及风险不承担任何责任。通过使用本站内容随之而来的风险与本站无关。
    关于我们  |  意见建议  |  捐助我们  |  报错有奖  |  广告合作、友情链接（目前9元/月）请联系QQ：27243702 沸活量
    皖ICP备17017327号-2　皖公网安备34020702000426号