使用SOCKET TCP OPENCV 发送视频 mat格式及jpg格式

原创 已于 2022-07-25 09:27:04 修改 · 1.3k 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#tcp/ip #opencv #网络协议

于 2022-07-21 15:40:46 首次发布
该博客详细介绍了如何通过TCP/IP协议使用SOCKET进行图像的传输，包括从OpenCV的Mat格式转换为JPG并发送，以及接收MAT和JPG图像的过程。涉及到的关键函数包括image_base64.h和Mat2Img.h。同时，提供了多个参考资料，如关于JSON传输、TCP粘包问题以及SOCKET通信的解决方案。

SERVER SEND jpg

//常头文件
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>

//socket相关头文件
#include <sys/socket.h>
#include <arpa/inet.h>
#include <csignal>
#include "Mat2Img.h"			//自编头文件，注意带上

//opencv相关头文件
#include <opencv2/opencv.hpp>


const int PORT = 5678;                //端口号，客户端应与之保持一致

struct sockaddr_in server_addr, client_addr; //定义服务端和客户端的地址结构体

const int Width = 640;  //图片的宽
const int Heigth = 480; //图片的高

int connectfd;      //用于传输的socketID
int sockfd;         //初始化socketID

int SendImage(const cv::Mat &mat, int sockfd); //发送图像

void InitAddr( );				//初始化函数

int main(int argc, char **argv)
{

    cv::VideoCapture capture(0);	//初始化摄像头
    cv::Mat cap;			//初始化摄像头mat数组
    cv::Mat image;			//初始化发送mat数组
    int ret=1;
    InitAddr(); //初始化TCP连接，并将地址结构体绑定到套接字上

    while (true)
    {
        capture >> cap;
        cv::resize(cap,image,cv::Size(Width,Heigth));	
        cv::imshow("local image", image);		//本地显示，可注释掉
        cv::waitKey(10);				//本地显示，可注释掉
        ret = SendImage(image,connectfd);		//发送图像
        if (ret == -1)					//如发送失败，关闭socket重新初始化
        {
		close(connectfd);
		InitAddr();
        }
    }
    return 0;
}

void InitAddr(void)
{
    char client_IP[1024];
    signal(SIGPIPE,SIG_IGN);
    //创建套接字
    sockfd = socket(AF_INET, SOCK_STREAM, 0); //TCP传输
    if (sockfd == -1)
    {
        perror("socket error");
        exit(EXIT_FAILURE);
    }

    bzero(&server_addr, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(PORT);
    server_addr.sin_addr.s_addr = htonl(INADDR_ANY);

    //设置端口复用
    int opt = 1;
    setsockopt(sockfd, SOL_SOCKET, SO_REUSEPORT, &opt, sizeof(opt));

    //bind
    int ret = bind(sockfd, (struct sockaddr *)&server_addr, sizeof(server_addr));
    if (ret == -1)
    {
        perror("bind errno");
        exit(1);
    }

    //listen
    ret = listen(sockfd, 10);
    if (ret == -1)
    {
        perror("listen errno");
        exit(1);
    }

    //accept
    //阻塞等待客户端的连接请求
    bzero(&client_addr, sizeof(client_addr));
    socklen_t client_len = sizeof(client_addr);
    std::cout<<"wait"<<std::endl;
    connectfd = accept(sockfd, (struct sockaddr *)&client_addr, &client_len);
    if (connectfd == -1)
    {
        perror("accept errno");
        exit(1);
    }
    //打印客户端的IP地址和端口号
    printf("client ip:%s port:%d\n",
           inet_ntop(AF_INET, &client_addr.sin_addr.s_addr, client_IP, 1024),
           ntohs(client_addr.sin_port));

    //此时就可以读取connectfd中的数据
}


int SendImage(const cv::Mat &mat, int sockfd)
{
    // Mat 转化为jpg
	std::vector<unsigned char> buff_jpg;
	int ret = Mat2Img::MatToByteArray(mat, buff_jpg);
    // jpg 转化为Base64
	std::string str = ImageBase64::encode(buff_jpg.data(), buff_jpg.size());

    // 发送base64 长度  
    unsigned long count=0;
    count = str.size();
    int req = send (sockfd, &count, 4, MSG_NOSIGNAL);
    if(req == -1)
    {
        return -1;
    }
        
    // 发送base64 数据
    
    req = send (sockfd, str.c_str(), str.size(), MSG_NOSIGNAL);
    
    if(req == -1)
    {
        return -1;
    }
    return 1;
    
  
}

client receive jpg

//常用头文件
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>

//socket相关头文件
#include <sys/socket.h>
#include <arpa/inet.h>
#include "Mat2Img.h"			//自编jpg发送头文件，注意带上

//opencv相关头文件
#include <opencv2/opencv.hpp>

const int PORT = 5678;          	//端口号，应与server保持一致
const char *IP = "127.0.0.1"; 	//服务器IP地址，服务器在本机使用127.0.0.1
struct sockaddr_in server_addr;        //定义服务端的地址结构体

const int Width = 640;  //图片的宽 不需要
const int Heigth = 480; //图片的高 不需要


cv::Mat GetImage(int sockfd);

void InitAddr();

int main(int argc, char **argv)
{
    int sockfd = socket(AF_INET, SOCK_STREAM, 0); //TCP通信
    if (sockfd == -1)
    {
        perror("socket errno");
        exit(EXIT_FAILURE);
    }
    InitAddr();
    //std::cout<<"socket success"<<std::endl;
    int ret = connect(sockfd,(struct sockaddr *)&server_addr,sizeof(server_addr));
    if(ret == -1)
    {
        perror("connect error");
        exit(1);
    }
    std::cout<<"connect succedd"<<std::endl;


    while(1)
    {
        cv::Mat image = GetImage(sockfd);
        cv::imshow("remote image", image);
        cv::waitKey(1);
        std::cout<<"收到一帧！"<<std::endl;
    }

    return 0;

}

void InitAddr()
{
    //std::cout<<"Initing"<<std::endl;
    bzero(&server_addr, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(PORT);
    //需要将服务器端的IP地址进行转换
    int ret = inet_pton(AF_INET, IP, &server_addr.sin_addr.s_addr);
    if (ret == -1)
    {
        perror("inet_pton error");
        exit(EXIT_FAILURE);
    }

}


cv::Mat GetImage(int connectfd)
{
    unsigned long base64_size=0;
    cv::Mat mat = cv::Mat::zeros(Heigth, Width, CV_8UC3);

    //获得jpeg大小
    int byte1 = recv(connectfd, &base64_size, 4, 0);
    if (byte1 == -1)
    {
        std::cout << "status == -1   errno byte1 == " << errno << "  in Socket::recv\n";
        exit(EXIT_FAILURE);
    }
	//std::cout << "base64_size = " << base64_size << "bytes" << std::endl;

    //接收base64 string
    char base64_str[base64_size];
    int bytes = 0;
    int i = 0;
    for (i = 0; i < base64_size; i += bytes)
    {
        bytes = recv(connectfd, base64_str+ i, base64_size - i, 0);
        //std::cout << "succed receive  = " << bytes << "bytes" << std::endl;
        if (bytes == -1)
        {
            std::cout << "status == -1   errno == " << errno << "  in Socket::recv\n";
            exit(EXIT_FAILURE);
        }
    }



	// Base64 字符串转化为jpg 的string
	int outLen = 0;
	std::string str1 = ImageBase64::decode(base64_str, base64_size, outLen);
	
	// jpg string 拷贝到jpg 数组buffer
	std::vector<uchar> baseJpgVec;
	baseJpgVec.assign(&str1.data()[0], &str1.data()[outLen]);
	
	//jpg buffer 转化为Mat
	cv::Mat MatFromBase;
	Mat2Img::JPEGToMat(MatFromBase, baseJpgVec);
	

    return MatFromBase;

}

sever send mat

#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>

#include <sys/socket.h>
#include <arpa/inet.h>

#include <opencv2/opencv.hpp>

const int PORT = 48958;                //端口号

struct sockaddr_in server_addr, client_addr; //定义服务端和客户端的地址结构体

const int Width = 640;  //图片的宽
const int Heigth = 480; //图片的高

cv::Mat GetImage(int sockfd);
void SendImage(const cv::Mat &mat, int sockfd);

void InitAddr(int sokckfd);

int main(int argc, char **argv)
{
    char client_IP[1024];
    cv::VideoCapture capture(0);	
    cv::Mat cap;
    cv::Mat image;
    //创建套接字
    int sockfd = socket(AF_INET, SOCK_STREAM, 0); //TCP传输
    if (sockfd == -1)
    {
        perror("socket error");
        exit(EXIT_FAILURE);
    }
    InitAddr(sockfd); //初始化地址，并将地址结构体绑定到套接字上

    //阻塞等待客户端的连接请求
    while (true)
    {
        bzero(&client_addr, sizeof(client_addr));
        socklen_t client_len = sizeof(client_addr);
        std::cout<<"wait"<<std::endl;
        int connectfd = accept(sockfd, (struct sockaddr *)&client_addr, &client_len);
        if (connectfd == -1)
        {
            perror("accept errno");
            exit(1);
        }
        //打印客户端的IP地址和端口号
        printf("client ip:%s port:%d\n",
               inet_ntop(AF_INET, &client_addr.sin_addr.s_addr, client_IP, 1024),
               ntohs(client_addr.sin_port));

        //此时就可以读取connectfd中的数据
        while(1)
        {
	    capture >> cap;
	    cv::resize(cap,image,cv::Size(Width,Heigth));
	    cv::imshow("local image", image);
	    cv::waitKey(10);
	    SendImage(image,connectfd);       
        
        /*
    cv::Mat image = GetImage(connectfd);
        //保存图片
        //cv::imwrite("../Get/image.jpg", image);
    cv::imshow("remote image", image);
    cv::waitKey(10);
    */
        }
    }
    return 0;
}

void InitAddr(int sockfd)
{
    bzero(&server_addr, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(PORT);
    server_addr.sin_addr.s_addr = htonl(INADDR_ANY);

    //设置端口复用
    int opt = 1;
    setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));

    int ret = bind(sockfd, (struct sockaddr *)&server_addr, sizeof(server_addr));
    if (ret == -1)
    {
        perror("bind errno");
        exit(1);
    }
    std::cout<<"bind success"<<std::endl;

    ret = listen(sockfd, 10);
    if (ret == -1)
    {
        perror("listen errno");
        exit(1);
    }
    std::cout<<"listen success"<<std::endl;
}



void SendImage(const cv::Mat &mat, int sockfd)
{
    int ret = send (sockfd, mat.data, mat.cols * mat.rows * 3, MSG_NOSIGNAL );
    if(ret == -1)
    {
        perror("send error");
        exit(EXIT_FAILURE);
    }
}

client receive mat

#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>

#include <sys/socket.h>
#include <arpa/inet.h>

#include <opencv2/opencv.hpp>

const int PORT = 5678;          //端口号
const char *IP = "192.168.137.123"; //IP地址
struct sockaddr_in server_addr;        //定义服务端的地址结构体

const int Width = 640;  //图片的宽
const int Heigth = 480; //图片的高

void SendImage(const cv::Mat &mat, int sockfd);
cv::Mat GetImage(int sockfd);

void InitAddr();

int main(int argc, char **argv)
{
    int sockfd = socket(AF_INET, SOCK_STREAM, 0); //TCP通信
    if (sockfd == -1)
    {
        perror("socket errno");
        exit(EXIT_FAILURE);
    }
    InitAddr();
    //std::cout<<"socket success"<<std::endl;
    int ret = connect(sockfd,(struct sockaddr *)&server_addr,sizeof(server_addr));
	if(ret == -1)
	{
		perror("connect error");
		exit(1);
	}
    std::cout<<"connect succedd"<<std::endl;
    

    while(1)
    {
    cv::Mat image = GetImage(sockfd);
    cv::imshow("remote image", image);
    cv::waitKey(1);
    }
    //close(sockfd);
    return 0;
    
}

void InitAddr()
{
    //std::cout<<"Initing"<<std::endl;
    bzero(&server_addr, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(PORT);
    //需要将服务器端的IP地址进行转换
    int ret = inet_pton(AF_INET, IP, &server_addr.sin_addr.s_addr);
    if (ret == -1)
    {
        perror("inet_pton error");
        exit(EXIT_FAILURE);
    }

}

void SendImage(const cv::Mat &mat, int sockfd)
{
    int ret = send (sockfd, mat.data, mat.cols * mat.rows * 3, MSG_NOSIGNAL );
    if(ret == -1)
    {
        perror("send error");
        exit(EXIT_FAILURE);
    }
}

cv::Mat GetImage(int connectfd)
{
    cv::Mat mat = cv::Mat::zeros(Heigth, Width, CV_8UC3);
    //const int imgSize = mat.total() * mat.elemSize()*3;
    const int imgSize = Heigth * Width * 3 ;
    std::cout << "imgSize = " << imgSize << "bytes" << std::endl;
    uchar bufferData[imgSize*2];
    int bytes = 0;
    int i = 0;
    for (i = 0; i < imgSize; i += bytes)
    {
        bytes = recv(connectfd, bufferData + i, imgSize - i, 0);
        if (bytes == -1)
        {
            std::cout << "status == -1   errno == " << errno << "  in Socket::recv\n";
            exit(EXIT_FAILURE);
        }
    }
    // std::cout << "recv " << i << "bytes" << std::endl;
    mat = cv::Mat(Heigth, Width, CV_8UC3, bufferData);
    return mat;
}

相关函数

image_base64.h

#ifndef TESTFACEAPI_TESTFACEAPI_IMAGE_BASE64_H
#define TESTFACEAPI_TESTFACEAPI_IMAGE_BASE64_H
#include <string>
// 对图片进行base64编码解码类
class ImageBase64
{
public:

    /*编码
    DataByte
    [in]输入的数据长度,以字节为单位
    */
    static const std::string encode(const unsigned char* Data, int DataByte);
    /*解码
    DataByte
    [in]输入的数据长度,以字节为单位
    OutByte
    [out]输出的数据长度,以字节为单位,请不要通过返回值计算
    输出数据的长度
    */
    static const std::string decode(const char* Data, int DataByte, int& OutByte);
    // 传入图片地址进行base64编码示例
    static std::string file2base64(const std::string& file_path);
};
#endif

Mat2Img.h

#ifndef MAT2IMG_H
#define MAT2IMG_H
#include "opencv2/opencv.hpp"
#include <vector>
#include "image_base64.h"
#include "opencv2/imgcodecs/legacy/constants_c.h"

class Mat2Img 
{
		

public:
	static int MatToByteArray(const cv::Mat mat, std::vector<unsigned char>& buff)
	{
		if (mat.empty()) {
			return 0;
		}
		std::vector<int> param = std::vector<int>(2);
		param[0] = cv::IMWRITE_JPEG_QUALITY;
		param[1] = 95; // default(95) 0-100
		cv::imencode(".jpg", mat, buff, param);
		return 0;
	}
	
	static int JPEGToMat(cv::Mat &matImage, std::vector<unsigned char> buff)
	{
		if (buff.empty()) {
			return -1;
		}
		if ((buff[0] == 0xFF && buff[1] == 0xD8))
		{
			matImage = cv::imdecode(buff, CV_LOAD_IMAGE_COLOR);
		}
		else
		{
			buff.insert(buff.begin(), 0xFF);
			buff.insert(buff.begin()+1, 0xD8);
			matImage = cv::imdecode(buff, CV_LOAD_IMAGE_COLOR);
		}
		return 0;
	}

	static int Mat2Base64(cv::Mat &image, std::string &base64)
	{
		std::vector<unsigned char> cut_jpg;
		// Mat -> jpg
		cut_jpg.clear();
		Mat2Img::MatToByteArray(image, cut_jpg);

		base64 = ImageBase64::encode(cut_jpg.data(), cut_jpg.size());
		return 0;
	}
	static int Base2Mat(std::string &base64, cv::Mat &image)
	{
		
		int outLen = 0;
		std::string str1 = ImageBase64::decode(base64.c_str(), base64.size(), outLen);

		std::vector<uchar> baseJpgVec;
		baseJpgVec.assign(&str1.data()[0], &str1.data()[outLen]);

		int ret = Mat2Img::JPEGToMat(image, baseJpgVec);
		if (ret != 0)
		{
			return ret;
		}

		return 0;
	}
};
#endif

image_base64.cpp

#include "image_base64.h"
#include <vector>
#include <opencv2/opencv.hpp>


static const std::string base64_chars =
"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
"abcdefghijklmnopqrstuvwxyz"
"0123456789+/";

static inline bool is_base64(unsigned char c) {
    return (isalnum(c) || (c == '+') || (c == '/'));
}

const std::string ImageBase64::encode(const unsigned char* Data, int DataByte)
{
    //编码表  
    const char EncodeTable[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
    //返回值  
    std::string str_encode;
    unsigned char tmp[4] = { 0 };
    int line_length = 0;
    for (int i = 0; i < (int)(DataByte / 3); i++)
    {
        tmp[1] = *Data++;
        tmp[2] = *Data++;
        tmp[3] = *Data++;
        str_encode += EncodeTable[tmp[1] >> 2];
        str_encode += EncodeTable[((tmp[1] << 4) | (tmp[2] >> 4)) & 0x3F];
        str_encode += EncodeTable[((tmp[2] << 2) | (tmp[3] >> 6)) & 0x3F];
        str_encode += EncodeTable[tmp[3] & 0x3F];
        if (line_length += 4, line_length == 76)
        {
            str_encode += "\r\n"; 
            line_length = 0;
        }
    }
    //对剩余数据进行编码  
    int mod = DataByte % 3;
    if (mod == 1)
    {
        tmp[1] = *Data++;
        str_encode += EncodeTable[(tmp[1] & 0xFC) >> 2];
        str_encode += EncodeTable[((tmp[1] & 0x03) << 4)];
        str_encode += "==";
    }
    else if (mod == 2)
    {
        tmp[1] = *Data++;
        tmp[2] = *Data++;
        str_encode += EncodeTable[(tmp[1] & 0xFC) >> 2];
        str_encode += EncodeTable[((tmp[1] & 0x03) << 4) | ((tmp[2] & 0xF0) >> 4)];
        str_encode += EncodeTable[((tmp[2] & 0x0F) << 2)];
        str_encode += "=";
    }

    return str_encode;
}

const std::string ImageBase64::decode(const char* Data, int DataByte, int& OutByte)
{
    //解码表  
    const char DecodeTable[] =
    {
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        62, // '+'  
        0, 0, 0,
        63, // '/'  
        52, 53, 54, 55, 56, 57, 58, 59, 60, 61, // '0'-'9'  
        0, 0, 0, 0, 0, 0, 0,
        0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,
        13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, // 'A'-'Z'  
        0, 0, 0, 0, 0, 0,
        26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38,
        39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, // 'a'-'z'  
    };
    //返回值  
    std::string str_decode;
    int n_value = 0;
    int i = 0;
    while (i < DataByte)
    {
        if (*Data != '\r' && *Data != '\n')
        {
            n_value = DecodeTable[*Data++] << 18;
            n_value += DecodeTable[*Data++] << 12;
            str_decode += (n_value & 0x00FF0000) >> 16;
            OutByte++;
            if (*Data != '=')
            {
                n_value += DecodeTable[*Data++] << 6;
                str_decode += (n_value & 0x0000FF00) >> 8;
                OutByte++;
                if (*Data != '=')
                {
                    n_value += DecodeTable[*Data++];
                    str_decode += n_value & 0x000000FF;
                    OutByte++;
                }
            }
            i += 4;
        }
        else// 回车换行,跳过  
        {
            Data++;
            i++;
        }
    }
    return str_decode;
}

std::string ImageBase64::file2base64(const std::string& file_path)
{
    cv::Mat img = cv::imread(file_path);
    if (img.empty())
    {
        return "";
    }
    std::vector<uchar> vec_img;                               //Mat 图片数据转换为vector<uchar>  
    std::vector<int> vec_compression_params;
    vec_compression_params.push_back(cv::IMWRITE_JPEG_QUALITY);
    vec_compression_params.push_back(90);
    cv::imencode(".jpg", img, vec_img, vec_compression_params);
    // base64;
    std::string img_base64 = encode(vec_img.data(), vec_img.size());
    return img_base64;
}

opencv的Mat数据和JPG数据的相互转化参考:
https://blog.youkuaiyun.com/baidu_31872269/article/details/86010156
JSON传输
https://blog.youkuaiyun.com/weixin_37459951/article/details/108986095
http://www.cppblog.com/wanghaiguang/archive/2013/12/26/205020.html
TCP 粘包问题解决办法 （暂未遇到）
https://blog.youkuaiyun.com/qq_42839596/article/details/102765764

SOCKET通信
https://blog.youkuaiyun.com/HUSTIS1804/article/details/122637618
https://blog.youkuaiyun.com/weixin_42299076/article/details/124828768

主要借鉴：
https://www.it610.com/article/1282580053632237568.htm
https://blog.youkuaiyun.com/u012736685/article/details/77131633

使用Socket TCP和OpenCV发送视频（Mat格式）和图像（JPG格式）
带你成为别人眼中的大佬！
08-20 595
在上述代码中，我们创建了一个客户端套接字，并连接到服务器的IP地址为localhost、端口号为8000的套接字。在本文中，我们将介绍如何使用Socket TCP和OpenCV库来实现视频（以Mat格式）和图像（以JPG格式）的传输。接下来，我们通过循环读取视频的每一帧，将帧编码为字节流，并使用Socket发送给客户端。在上述代码中，我们首先创建了一个服务器套接字，绑定了IP地址为localhost、端口号为8000。接下来，我们需要创建一个服务器端程序和一个客户端程序，以便在它们之间传输视频和图像数据。
基于socket（TCP）和opencv的实时视频传输
LPAT_YP的博客
09-22 5936
基于socket的实时视频传输大概需要以下基本函数： **在服务端：建立socket-bind-listen-accept 在客户端：建立socket-connect 通俗看来说就是在创建socket后服务端的作用是连接服务端的IP，端口然后聆听等待客户端的连接之后接受服务端的数据，而客户端创建socket后就是连接服务端，传送数据。话不多说先上代码SERVER:#include "stdaf
C++实现Socket传输json封装的Mat
08-17
一般进行图片传输时，先用openCV把图片转换为Mat，然后封装到json当中，然后再从json中解析出来。这次是客户端向服务端传输。
用Socket保存OpenCV的CvMat结构
生命在于折腾
10-26 1360
接着上个月写的一篇发送IplImage结构的来说，因为Socket发送结构的部分上一篇写过了，所以不再多写了。 CvMat的结构如下： typedef struct CvMat { int type; int step; /* for internal use only */ int* refcount; int hdr_refcount; un
图片传输_OpenCV3 UDP协议实现低延迟实时视频传输与通信
weixin_42608318的博客
01-05 2760
UDP简介UDP是User Datagram Protocal的简称，中文名是用户数据报协议，是OSI(Open System Inter connect 开放式系统互联)参考模型中一种无连接的传输层协议，提供面向事务的简单不可靠信息传送服务。UDP适用范围UDP没有TCP的握手，确认，窗口，重传，拥塞控制等机制，UDP是一个无状态的传输协议，所以它在传输数据是非常快的，非常适合低延迟视...
python与C++利用socket通信进行Mat图像传输
ganwenbo2011的博客
06-06 5377
背景 ​​​​​做到项目涉及到c++与python进行混合编程，c++向python传递图像进行处理，python处理结束后在返回结果。对于这两种语言的通信问题，一直让我头疼。试了试socket通信，进行图像传输。废话不多说。 环境 win10+vs2015+opencv3.4+python3.5 代码 以下只是关键代码，读者根据实际情况，自行裁剪哈 C++端（客户端） #inc...
C++OpenCv利用Socket通讯类传输图片或者视频
07-12
2. **图像/视频数据预处理**：在发送前，需要将OpenCV中的Mat对象（表示图像或视频帧）转换为可网络传输的数据格式，例如JPEG或H264编码的字节流。这通常通过imencode()函数完成，可以指定合适的编码格式和质量。 3...
linux opencv视频通信,基于Socket和OpenCV的实时视频传输（On Linux）
weixin_42591908的博客
05-16 556
上一篇介绍了在Windows上实现基于Socket和openCV的实时视频传输，这一篇将继续讲解在Linux上的实现。环境：Server： Ubuntu 14.04 LTS + OpenCV2.4.10Client:：Ubuntu 14.04 LTS + OpenCV2.4.10我采用的仍是TCP协议的通信，Linux上的实现和Windows大同小异。TCP协议通信的一般步骤我再重新说一下：客户...
C++基于Socket传输JSON封装的OpenCV Mat数据
本项目标题为“C++实现Socket传输json封装的Mat”，其核心目标是通过网络将OpenCV中的Mat对象（即图像数据）从客户端传输至服务端，并在此过程中采用JSON格式对Mat数据进行封装与解析。该过程涉及多个关键技术点：...
【一】Opencv结合socket进行视频传输（TCP协议）
01-27
本附件包与博文配套，详见博文：http://blog.youkuaiyun.com/hujingshuang/article/details/43191461
【二】Opencv结合socket进行视频传输（TCP协议）——附件包
01-27
本附件包配套博文，博文详见：http://blog.youkuaiyun.com/hujingshuang/article/details/43193747
opencv tcp 视频传输
06-14
图像的获取采用的是opencv提供的接口，采用TCP协议进行图像传输。
利用Opencv较高效率的视频图像传输
12-16
这个是利用Opencv中imdecode和imencode对图像进行编码和解码的图像传输，比起像素传输，他的传输大小会小上10倍之多，处理的运算时间也比像素访问快许多，图像的流畅行有了很好的提升
Linux下 基于C++与Python的socket通信传输Mat图片并展示
三番鱼
03-24 1089
目的 实现客户端与服务器端通信,并传输Mat图片然后在服务器端显示 实现 Server int main(int argc, char** argv) { int listenfd, connfd; struct sockaddr_in servaddr; char buff[4096]; FILE *fp; int n; if ((listenfd = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
opencv中串口通讯
m0_52430942的博客
07-13 2121
先上代码 #include "WzSerialPort.h" #include <stdio.h> #include <string.h> #include <WinSock2.h> #include <windows.h> WzSerialPort::WzSerialPort() { } WzSerialPort::~WzSerialPort() { } bool WzSerialPort::open(const char* portname
利用gRPC C++传输opencv的mat类型图片-第一种方法原始方法---我是搬砖大学生
liyangbinbin的博客
09-04 3435
前言 因业务需求，需要用到grpc架构来传输图片，在网上找了很久也找不到很好的例子，一开始确实很没有头绪，别人的例子都是传输什么文件呀，数组之类的基本类型数据的东西，可是mat类图片，这可咋整，用我们广东来说：扑街咯。但是冷静一想，图像不就是一个二维数组表示的吗，它就是个矩阵。我只要把里面的数据读出来，放到数组里面再传输不就可以了吗？嘿嘿嘿。本例子的代码有足够详细的注释。一般的程序靓仔应该可以看...
OpenCV结合socket进行实时视频传输（TCP协议）
热门推荐
盛夏光年
08-12 2万+
一、概述内容：由Client客户端采集摄像头图像后经Socket传输到Server服务器端再显示出来。本实验在同一台电脑上实验，即运行服务器程序，又跑客户端程序，也就是说通过socket编程来实现数据的自发自收，这一步通过了接下来跑服务器和客户端分开的实验就简单了。 实验平台： VS2013 + opencv2.4.11（Windows 7） 说明：近期项目需要进行图像的采集传输任务，遂在网
c#的opencvsharp与c++封装opencv之间的mat对象传递（BitmapData造成图片扭曲的问题记录）
qq_39024280的博客
09-12 5730
c#的opencvsharp与c++封装opencv之间的mat对象传递 暨BitmapData造成图片扭曲的问题记录 最近韭菜在处理c#的opencvsharp与c++封装opencv之间传递mat数据时，被一个问题坑了一大把，在此将坑及解决方案贴出来，给各位一点解决问题的提示。 首先，我采用opencvsharp来进行c#端的简单图像处理，安装方法这里不再赘述，请自行百度。 我的封装使...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值