TCP实时传图像

2023-05-16

目的：

QT+openCV，在Ubuntu16.04版本下，通过TCP实现图片的传输。

步骤：

客户端建一个相机线程，一个TCP线程，相机线程捕获画面并将Mat传到TCP线程，再通过TCP线程传到服务器，服务器通过死循环监听客户端，获取客户端发什么内容，并显示出来。

效果：

代码：

server：（接受客户端发送的Mat，并显示）

mainwindow.h

#ifndef MAINWINDOW_H
#define MAINWINDOW_H

#include <QMainWindow>
#include <socketmattransmissionserver.h>
#include<QDebug>
namespace Ui {
class MainWindow;
}

class MainWindow : public QMainWindow
{
    Q_OBJECT

public:
    explicit MainWindow(QWidget *parent = 0);
    QImage MatImageToQt(const cv::Mat &src);
    ~MainWindow();

private slots:
    void on_pushButton_clicked();

private:
    Ui::MainWindow *ui;
};

#endif // MAINWINDOW_H

mainwindow.cpp

#include "mainwindow.h"
#include "ui_mainwindow.h"
        cv::Mat image;
SocketMatTransmissionServer socketMat;
MainWindow::MainWindow(QWidget *parent) :
    QMainWindow(parent),
    ui(new Ui::MainWindow)
{
    ui->setupUi(this);
}

MainWindow::~MainWindow()
{
    delete ui;
}
QImage MainWindow::MatImageToQt(const cv::Mat &src)//Mat转成QImage
{
    //CV_8UC1 8位无符号的单通道---灰度图片
    if(src.type() == CV_8UC1)
    {
        //使用给定的大小和格式构造图像
        //QImage(int width, int height, Format format)
        QImage qImage(src.cols,src.rows,QImage::Format_Indexed8);
        //扩展颜色表的颜色数目
        qImage.setColorCount(256);

        //在给定的索引设置颜色
        for(int i = 0; i < 256; i ++)
        {
            //得到一个黑白图
            qImage.setColor(i,qRgb(i,i,i));
        }
        //复制输入图像,data数据段的首地址
        uchar *pSrc = src.data;
        //
        for(int row = 0; row < src.rows; row ++)
        {
            //遍历像素指针
            uchar *pDest = qImage.scanLine(row);
            //从源src所指的内存地址的起始位置开始拷贝n个
            //字节到目标dest所指的内存地址的起始位置中
            memcmp(pDest,pSrc,src.cols);
            //图像层像素地址
            pSrc += src.step;
        }
        return qImage;
    }
    //为3通道的彩色图片
    else if(src.type() == CV_8UC3)
    {
        //得到图像的的首地址
        const uchar *pSrc = (const uchar*)src.data;
        //以src构造图片
        QImage qImage(pSrc,src.cols,src.rows,src.step,QImage::Format_RGB888);
        //在不改变实际图像数据的条件下，交换红蓝通道
        return qImage.rgbSwapped();
    }
    //四通道图片，带Alpha通道的RGB彩色图像
    else if(src.type() == CV_8UC4)
    {
        const uchar *pSrc = (const uchar*)src.data;
        QImage qImage(pSrc, src.cols, src.rows, src.step, QImage::Format_ARGB32);
        //返回图像的子区域作为一个新图像
        return qImage.copy();
    }
    else
    {
        return QImage();
    }
}

void MainWindow::on_pushButton_clicked()
{
    if (socketMat.socketConnect(8000) < 0)
    {
    }

    while (1)
    {
        if(socketMat.receive(image) > 0)
        {
            QImage imag = MatImageToQt(image);
            ui->label_img->setPixmap(QPixmap::fromImage(imag));
            cv::waitKey(30);
        }
    }
    socketMat.socketDisconnect();
}

socketmattransmissionserver.h

#ifndef SOCKETMATTRANSMISSIONSERVER_H
#define SOCKETMATTRANSMISSIONSERVER_H

#include "opencv2/opencv.hpp"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
#include <sys/shm.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

using namespace cv;

#define PACKAGE_NUM 2

#define IMG_WIDTH 640
#define IMG_HEIGHT 480

#define BLOCKSIZE IMG_WIDTH*IMG_HEIGHT*3/PACKAGE_NUM

struct recvBuf
{
    char buf[BLOCKSIZE];
    int flag;
};


class SocketMatTransmissionServer
{
public:
    SocketMatTransmissionServer(void);
    ~SocketMatTransmissionServer(void);
    int sockConn;
private:
    struct recvBuf data;

    int needRecv;
    int count;

public:

    int socketConnect(int PORT);

    int receive(cv::Mat& image);

    void socketDisconnect(void);
};

#endif // SOCKETMATTRANSMISSIONSERVER_H

socketmattransmissionserver.cpp

#include "socketmattransmissionserver.h"

SocketMatTransmissionServer::SocketMatTransmissionServer(void)
{
}


SocketMatTransmissionServer::~SocketMatTransmissionServer(void)
{
}


int SocketMatTransmissionServer::socketConnect(int PORT)
{
    int server_sockfd = socket(AF_INET,SOCK_STREAM, 0);

    struct sockaddr_in server_sockaddr;
    server_sockaddr.sin_family = AF_INET;
    server_sockaddr.sin_port = htons(PORT);
    server_sockaddr.sin_addr.s_addr = htonl(INADDR_ANY);

    if(bind(server_sockfd,(struct sockaddr *)&server_sockaddr,sizeof(server_sockaddr))==-1)
    {
        perror("bind");
        return -1;
    }

    if(listen(server_sockfd,5) == -1)
    {
        perror("listen");
        return -1;
    }

    struct sockaddr_in client_addr;
    socklen_t length = sizeof(client_addr);

    sockConn = accept(server_sockfd, (struct sockaddr*)&client_addr, &length);
    if(sockConn<0)
    {
        perror("connect");
        return -1;
    }
    else
    {
        printf("connect successful!\n");
        return 1;
    }

    close(server_sockfd);
}


void SocketMatTransmissionServer::socketDisconnect(void)
{
    close(sockConn);
}

int SocketMatTransmissionServer::receive(cv::Mat& image)
{
    int returnflag = 0;
    cv::Mat img(IMG_HEIGHT, IMG_WIDTH, CV_8UC3, cv::Scalar(0));
    needRecv = sizeof(recvBuf);
    count = 0;
    memset(&data,0,sizeof(data));

    for (int i = 0; i < PACKAGE_NUM; i++)
    {
        int pos = 0;
        int len0 = 0;

        while (pos < needRecv)
        {
            len0 = recv(sockConn, (char*)(&data) + pos, needRecv - pos, 0);
            if (len0 < 0)
            {
                printf("Server Recieve Data Failed!\n");
                break;
            }
            pos += len0;
        }

        count = count + data.flag;

        int num1 = IMG_HEIGHT / PACKAGE_NUM * i;
        for (int j = 0; j < IMG_HEIGHT / PACKAGE_NUM; j++)
        {
            int num2 = j * IMG_WIDTH * 3;
            uchar* ucdata = img.ptr<uchar>(j + num1);
            for (int k = 0; k < IMG_WIDTH * 3; k++)
            {
                ucdata[k] = data.buf[num2 + k];
            }
        }

        if (data.flag == 2)
        {
            if (count == PACKAGE_NUM + 1)
            {
                image = img;
                returnflag = 1;
                count = 0;
            }
            else
            {
                count = 0;
                i = 0;
            }
        }
    }
    if(returnflag == 1)
        return 1;
    else
        return -1;
}

client：（通过cv打开相机，并把Mat传到服务器）

camthread.h

#include "socketmattransmissionserver.h"

SocketMatTransmissionServer::SocketMatTransmissionServer(void)
{
}


SocketMatTransmissionServer::~SocketMatTransmissionServer(void)
{
}


int SocketMatTransmissionServer::socketConnect(int PORT)
{
    int server_sockfd = socket(AF_INET,SOCK_STREAM, 0);

    struct sockaddr_in server_sockaddr;
    server_sockaddr.sin_family = AF_INET;
    server_sockaddr.sin_port = htons(PORT);
    server_sockaddr.sin_addr.s_addr = htonl(INADDR_ANY);

    if(bind(server_sockfd,(struct sockaddr *)&server_sockaddr,sizeof(server_sockaddr))==-1)
    {
        perror("bind");
        return -1;
    }

    if(listen(server_sockfd,5) == -1)
    {
        perror("listen");
        return -1;
    }

    struct sockaddr_in client_addr;
    socklen_t length = sizeof(client_addr);

    sockConn = accept(server_sockfd, (struct sockaddr*)&client_addr, &length);
    if(sockConn<0)
    {
        perror("connect");
        return -1;
    }
    else
    {
        printf("connect successful!\n");
        return 1;
    }

    close(server_sockfd);
}


void SocketMatTransmissionServer::socketDisconnect(void)
{
    close(sockConn);
}

int SocketMatTransmissionServer::receive(cv::Mat& image)
{
    int returnflag = 0;
    cv::Mat img(IMG_HEIGHT, IMG_WIDTH, CV_8UC3, cv::Scalar(0));
    needRecv = sizeof(recvBuf);
    count = 0;
    memset(&data,0,sizeof(data));

    for (int i = 0; i < PACKAGE_NUM; i++)
    {
        int pos = 0;
        int len0 = 0;

        while (pos < needRecv)
        {
            len0 = recv(sockConn, (char*)(&data) + pos, needRecv - pos, 0);
            if (len0 < 0)
            {
                printf("Server Recieve Data Failed!\n");
                break;
            }
            pos += len0;
        }

        count = count + data.flag;

        int num1 = IMG_HEIGHT / PACKAGE_NUM * i;
        for (int j = 0; j < IMG_HEIGHT / PACKAGE_NUM; j++)
        {
            int num2 = j * IMG_WIDTH * 3;
            uchar* ucdata = img.ptr<uchar>(j + num1);
            for (int k = 0; k < IMG_WIDTH * 3; k++)
            {
                ucdata[k] = data.buf[num2 + k];
            }
        }

        if (data.flag == 2)
        {
            if (count == PACKAGE_NUM + 1)
            {
                image = img;
                returnflag = 1;
                count = 0;
            }
            else
            {
                count = 0;
                i = 0;
            }
        }
    }
    if(returnflag == 1)
        return 1;
    else
        return -1;
}

camthread.cpp

#include "camthread.h"

camThread::camThread(QObject *parent) :
    QThread(parent)
{
    isStop = false;
}
void camThread::closeThread()
{
    isStop = true;
}
void camThread::waitThread()
{
    isStop = false;
}

void camThread::run()
{
    cap_ct.open(1);
    while (1)
    {
        if(isStop)
            return;
        cap_ct.read(src_image_ct);
        emit freshImg(src_image_ct);
        sleep(0.1);
    }

}

mainwindow.h

#ifndef MAINWINDOW_H
#define MAINWINDOW_H

#include <QMainWindow>
#include<QDebug>
#include <socketmattransmissionclient.h>
#include<camthread.h>
namespace Ui {
class MainWindow;
}

class MainWindow : public QMainWindow
{
    Q_OBJECT

public:
    explicit MainWindow(QWidget *parent = 0);
    QImage MatImageToQt(const cv::Mat &src);
    ~MainWindow();

private slots:
    void on_pushButton_clicked();
    void send_img(const cv::Mat &);
    void show_img(const cv::Mat &);

private:
    Ui::MainWindow *ui;
    camThread *thread1;
};

#endif // MAINWINDOW_H

mainwindow.cpp

#include "mainwindow.h"
#include "ui_mainwindow.h"
SocketMatTransmissionClient socketMat;

cv::Mat image;
MainWindow::MainWindow(QWidget *parent) :
    QMainWindow(parent),
    ui(new Ui::MainWindow)
{
    ui->setupUi(this);
    thread1 =new camThread();
    connect(thread1, SIGNAL(freshImg(const cv::Mat &)), this, SLOT(send_img(const cv::Mat &)),Qt::DirectConnection);
    connect(thread1, SIGNAL(freshImg(const cv::Mat &)), this, SLOT(show_img(const cv::Mat &)),Qt::DirectConnection);
}

MainWindow::~MainWindow()//析构
{
    socketMat.socketDisconnect();
    delete ui;
}
QImage MainWindow::MatImageToQt(const cv::Mat &src)//Mat转成QImage
{
    //CV_8UC1 8位无符号的单通道---灰度图片
    if(src.type() == CV_8UC1)
    {
        //使用给定的大小和格式构造图像
        //QImage(int width, int height, Format format)
        QImage qImage(src.cols,src.rows,QImage::Format_Indexed8);
        //扩展颜色表的颜色数目
        qImage.setColorCount(256);

        //在给定的索引设置颜色
        for(int i = 0; i < 256; i ++)
        {
            //得到一个黑白图
            qImage.setColor(i,qRgb(i,i,i));
        }
        //复制输入图像,data数据段的首地址
        uchar *pSrc = src.data;
        //
        for(int row = 0; row < src.rows; row ++)
        {
            //遍历像素指针
            uchar *pDest = qImage.scanLine(row);
            //从源src所指的内存地址的起始位置开始拷贝n个
            //字节到目标dest所指的内存地址的起始位置中
            memcmp(pDest,pSrc,src.cols);
            //图像层像素地址
            pSrc += src.step;
        }
        return qImage;
    }
    //为3通道的彩色图片
    else if(src.type() == CV_8UC3)
    {
        //得到图像的的首地址
        const uchar *pSrc = (const uchar*)src.data;
        //以src构造图片
        QImage qImage(pSrc,src.cols,src.rows,src.step,QImage::Format_RGB888);
        //在不改变实际图像数据的条件下，交换红蓝通道
        return qImage.rgbSwapped();
    }
    //四通道图片，带Alpha通道的RGB彩色图像
    else if(src.type() == CV_8UC4)
    {
        const uchar *pSrc = (const uchar*)src.data;
        QImage qImage(pSrc, src.cols, src.rows, src.step, QImage::Format_ARGB32);
        //返回图像的子区域作为一个新图像
        return qImage.copy();
    }
    else
    {
        return QImage();
    }
}

void MainWindow::on_pushButton_clicked()
{
    if (socketMat.socketConnect("127.0.0.1", 8000) < 0)
    {
        qDebug()<<"11111";
    }
    thread1->start();

}
void MainWindow::show_img(const cv::Mat & img)//线程显示图片
{
    if(img.data == NULL)
    {
        std::cout<<"Capture image failed!"<<std::endl;
        return;
    }
    QImage imag = MatImageToQt(img);
    ui->label_img->setPixmap(QPixmap::fromImage(imag));
}
void MainWindow::send_img(const cv::Mat & img)//线程发送图片
{
    socketMat.transmit(img);
}

socketmattransmissionclient.h

#ifndef SOCKETMATTRANSMISSIONCLIENT_H
#define SOCKETMATTRANSMISSIONCLIENT_H


#include "opencv2/opencv.hpp"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>


using namespace cv;

//待传输图像默认大小为 640*480，可修改
#define IMG_WIDTH 640	// 需传输图像的宽
#define IMG_HEIGHT 480	// 需传输图像的高
#define PACKAGE_NUM 2
//默认格式为CV_8UC3
#define BUFFER_SIZE IMG_WIDTH*IMG_HEIGHT*3/PACKAGE_NUM

struct sentbuf
{
    char buf[BUFFER_SIZE];
    int flag;
};

class SocketMatTransmissionClient
{
public:
    SocketMatTransmissionClient();
    ~SocketMatTransmissionClient();

private:
    int sockClient;
    struct sentbuf data;

public:

    int socketConnect(const char* IP, int PORT);

    int transmit(cv::Mat image);

    void socketDisconnect(void);
};


#endif // SOCKETMATTRANSMISSIONCLIENT_H

socketmattransmissionclient.cpp

#include "socketmattransmissionclient.h"


SocketMatTransmissionClient::SocketMatTransmissionClient()
{
}


SocketMatTransmissionClient::~SocketMatTransmissionClient()
{
}


int SocketMatTransmissionClient::socketConnect(const char* IP, int PORT)
{
    struct sockaddr_in    servaddr;

    if ((sockClient = socket(AF_INET, SOCK_STREAM, 0)) < 0)
    {
        printf("create socket error: %s(errno: %d)\n", strerror(errno), errno);
        return -1;
    }

    memset(&servaddr, 0, sizeof(servaddr));
    servaddr.sin_family = AF_INET;
    servaddr.sin_port = htons(PORT);
    if (inet_pton(AF_INET, IP, &servaddr.sin_addr) <= 0)
    {
        printf("inet_pton error for %s\n", IP);
        return -1;
    }

    if (connect(sockClient, (struct sockaddr*)&servaddr, sizeof(servaddr)) < 0)
    {
        printf("connect error: %s(errno: %d)\n", strerror(errno), errno);
        return -1;
    }
    else
    {
        printf("connect successful!\n");
    }
}


void SocketMatTransmissionClient::socketDisconnect()
{
    close(sockClient);
}

int SocketMatTransmissionClient::transmit(cv::Mat image)
{
    if (image.empty())
    {
        printf("empty image\n\n");
        return -1;
    }

    if(image.cols != IMG_WIDTH || image.rows != IMG_HEIGHT || image.type() != CV_8UC3)
    {
        printf("the image must satisfy : cols == IMG_WIDTH（%d）  rows == IMG_HEIGHT（%d） type == CV_8UC3\n\n", IMG_WIDTH, IMG_HEIGHT);
        return -1;
    }

    for(int k = 0; k < PACKAGE_NUM; k++)
    {
        int num1 = IMG_HEIGHT / PACKAGE_NUM * k;
        for (int i = 0; i < IMG_HEIGHT / PACKAGE_NUM; i++)
        {
            int num2 = i * IMG_WIDTH * 3;
            uchar* ucdata = image.ptr<uchar>(i + num1);
            for (int j = 0; j < IMG_WIDTH * 3; j++)
            {
                data.buf[num2 + j] = ucdata[j];
            }
        }

        if(k == PACKAGE_NUM - 1)
            data.flag = 2;
        else
            data.flag = 1;

        if (send(sockClient, (char *)(&data), sizeof(data), 0) < 0)
        {
            printf("send image error: %s(errno: %d)\n", strerror(errno), errno);
            return -1;
        }
    }
}

本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)

TCP实时传图像的相关文章

解决pip安装报错 “error: microsoft visual c++ 14.0 or greater is required”

今天在Windows的anaconda中使用pip安装工具包的时候出现报错信息 xff0c 如下图所示 xff1a 经排查发现主要错误是由 error microsoft visual c 43 43 14 0 or greater is
Linux离线状态下的Anaconda安装与Python环境创建

1 下载与安装说明下载下载地址 xff1a https repo anaconda com archive 版本 xff1a 此处以版本为2020 11的anaconda作示例 xff0c 其携带的python版本为3 8 5 下载 x
Linux离线状态下在anaconda中安装pytorch

1 下载与安装说明下载地址 xff08 按安装方法选取 xff09 bz2压缩包下载地址 xff1a https mirrors tuna tsinghua edu cn anaconda cloud pytorch win 64 C 6
Linux离线状态下安装cuda、cudnn、cudatoolkit

目录 1 下载与安装说明2 CUDA安装3 cuDNN安装4 cudatoolkit安装5 测试安装成功 1 下载与安装说明工具包下载地址 CUDA历史版本下载地址 xff1a https developer nvidia com cud
利用BP神经网络进行函数拟合

利用BP神经网络进行函数拟合摘要关键词问题描述算法设计结果分析与讨论结论Python源代码摘要数据拟合是在假设模型结构已知的条件下最优确定模型中未知参数使预测值与数据吻合度最高 xff0c 本文选取线性项加激活函数组成一个非线性模型
curl: (7) Failed to connect to raw.githubusercontent.com port 443: Connection refused的几种解决方式

curl 7 Failed to connect to raw githubusercontent com port 443 Connection refused的几种解决方式 xff1f 前言 xff1a 最近随着flutter的发布 x
js事件-笔记

这里写目录标题 js事件常见事件事件的注册方式事件处理分级1 DOM0级事件处理程序 xff1a 2 DOM2级事件处理程序 xff1a 3 DOM3级事件事件流三个阶段 js事件常见事件 onload 加载完成事件页面加载之后 xf
工程伦理2021年春季学期线上课程习题全部解答

工程伦理2021年春季学期线上课程习题全部解答提示 xff1a 在搜索题目时也可以关注学小易公众号进行查找题目及解答 xff0c 此处是个人总结的答案注意 xff1a 有一些题号是重复的 xff0c 按照题号一一对应即可第一章 B
vue中v-model详解

vue中v model详解 v model 本质上是一个语法糖 xff0c 是v bind和事件监听 xff08 64 input xff09 的合并操作 vue使用v model实现这些标签数据的双向绑定 xff0c 它会根据控件类型自动
强化学习进阶第七讲 TRPO

转载自知乎专栏天津包子馅儿的知乎今天开始我们的第七讲 xff0c TRPO 先简短地介绍一下 xff1a TRPO是英文单词Trust region policy optimization的简称 xff0c 翻译成中文是信赖域策略优化
防抖（debounce）、节流（throttle）以及前端锁（mutex）

节流和去抖的核心其实就是限制某一个方法被频繁触发节流 xff1a 间隔时间段触发一次去抖 xff1a 对于一定时间段的连续的函数调用 xff0c 只让其执行一次 xff0c 两者有时候不需要细分 xff0c 节流去抖也可以合在一起具体场
css3的动画属性总结
算法题：按图找最近的路（js/python3）

题目描述 xff1a 有一张 m n 的地图 xff0c 地图描述了起点和终点的位置 xff0c 也描述了两点间分布的高山湖泊 xff0c 高山湖泊挡住去路 xff0c 需要绕道行走 xff0c 请问从起点到终点的最短路径距离是多少 xff
git和远程仓库建立连接详细过程

git和远程仓库建立连接详细过程建立远程仓库首先在github gitee上创建自己的一个仓库 xff0c 并将自己的路径复制下来 xff0c 如下图建立本地仓库本地新建文件夹存储工程文件 xff0c 并且初始化仓库打开gitba
微信小程序封装请求

封装请求解决的问题很多页面中请求的url前半部分都是一样的 xff0c 重复书写导致页面代码冗余复杂同时逻辑容易不清晰 xff0c 所以采用单独将请求封装成一个文件 xff08 模块 xff09 使得这些问题得到解决前期基础知识 un
交响乐排布及乐器音色特点

交响乐布局乐器组成及音色特点木管组及铜管组代表乐器木管组铜管组钢琴键谱图国际谱和大小字组记录方式对比其他乐器在钢琴键盘上音域表示图示单簧管和长笛音色特点音色特点综合分析
【matlab】获取文件夹下文件名或路径保存到txt

获取某文件夹下的所有文件名并保存当需要在某一个文件夹下获取子文件的所有文件名 xff0c 并进行保存时 xff0c 可使用下面的代码 xff1a Path 61 39 D 文件夹 39 设置数据存放的文件夹路径 File 61 dir f
pycharm：新建虚拟环境和安装依赖

前言小编深有体会 xff0c 在刚开始用pycharm跑python的项目的时候 xff0c 一时间不知道如何下手 xff0c 特别是作为一个新手小白 xff0c 这里总结了一份新手避坑指南 xff0c 主要是新建虚拟环境 xff08 生
unbuntu安装 PyTorch 1.7.0+ torchvision 0.8.1

unbuntu安装 PyTorch 1 7 0 43 torchvision 0 8 1 一创建环境二启动环境三查看电脑CUDA版本 xff0c 若电脑只有CPU则忽略这一步四下载安装包到本地安装4 1 点击以下链接进入下载网站4
树莓派VNC界面不显示或显示不全问题_解决方案

刚开始上手树莓派的小伙伴们估计都遇到过这一问题 xff0c 用树莓派登录VNC时 xff0c 界面不显示或者界面显示的比例有问题先打开VNC xff0c 输入自己的IP地址 xff0c 登录VNC 我这里在登录VNC时 xff0c VNC

随机推荐

ArcGIS Engine：对COM组件的调用返回了错误HRESULT E_FAIL

最近做一个项目 xff0c 需要调用GP的通视性工具该工具在ARCScene中界面如下 xff1a 需要两个参数 xff08 必选 xff09 xff0c 即视线和障碍物 xff0c 在帮助中查看要求参数都是FeatureLaye
idea 2019.3之后的版本的项目使用gradle构建，编译时会出现中文乱码

目录背景1 修改gradle编译选项2 修改idea设置3 其他方法 xff08 尝试后没有效果 xff09 3 1 修改File Encdoing3 2 修改idea的custom VM option 背景把公司电脑的idea更新到了
shell编程3循环语句

文章目录 shell编程3循环语句1 for循环1 1 基本格式1 2 类C语言格式 2 while循环2 1 基本格式2 2 死循环 3 until循环4 跳出循环4 1 continue4 2 break 5 实验5 1 编写脚本实现计
ArduPilot飞控之ubuntu22.04-Gazebo模拟

ArduPilot飞控之ubuntu22 04 Gazebo模拟 1 源由2 Gazebo安装2 1 ubuntu22 04系统更新2 2 安装Gazebo Garden2 3 安装ArduPilot Gazebo插件2 3 1 基础库安装
ArduPilot飞控之DIY-F450计划

ArduPilot飞控之DIY F450计划 1 历史2 源由3 计划3 1 硬件3 2 软件 4 动手4 1 接线4 1 1 ELRS nano接收机4 1 2 BN880 GPS模块4 1 3 Radio Telemetry 4 2 配
ArduPilot Kakute F7 AIO DIYF450 without GPS配置

ArduPilot Kakute F7 AIO DIYF450 without GPS配置 1 源由2 配置2 1 Kakute F7 AIO相关配置2 1 1 串口规划2 1 2 电传配置2 1 3 GPS配置2 1 4 CRSF接收机配
ArduPilot之posHold&RTL实测

ArduPilot之posHold amp RTL实测 1 源由2 模式配置3 测试步骤4 飞行实测5 总结6 参考资料7 附录关于QGC 暂不支持MAVLink2 signing Protocol问题7 1 问题描述7 2 硬件配置7
BetaFlight统一硬件配置文件研读之resource命令

BetaFlight统一硬件配置文件研读之resource命令 1 源由2 代码分析3 实例分析4 配置情况4 1 resource4 2 resource show 5 参考资料统一硬件配置文件的设计是一种非常好的设计模式 xff0c
ArduPilot之开源代码UARTs and the Console使用

ArduPilot之开源代码UARTs and the Console使用 1 源由2 UART定义2 1 HAL Empty2 2 HAL ChibiOS2 3 HAL ESP322 4 HAL Linux2 5 HAL SITL 3 配
ArduPilot之开源代码调试技巧

ArduPilot之开源代码调试技巧 1 源由2 ArduPilot Code Debugging Part13 ArduPilot Code Debugging Part24 持续更新中 5 参考资料 1 源由对于如何调试和验证Ardu
ArduPilot飞控启动&运行过程简介

ArduPilot飞控启动 amp 运行过程简介 1 源由2 Copter飞控2 1 入口2 3 运行 main loop 3 Ardunio编程3 1 setup AP Vehicle setup3 2 loop AP Vehicle l
WIN7 64位系统 CDC类虚拟串口驱动无法安装的解决办法

最近用STM32装个USB转虚拟串口 xff0c 但是驱动怎么也安装不上百度了一些网页 xff0c 方法很多 xff0c 但是我这里按如下步骤处理 xff1a 首先 xff0c 确保C Windows System32 drivers u
ubuntu桌面版打开终端Terminal的几种方法

1 Ctrl 43 Alt 43 T 快捷键直接打开 2 在Ubuntu左上角选择File Open in Terminal 3 快捷键alt 43 F2调出Run a Command xff0c 输入gnome terminal 4 添加
什么是对称加密（对称加密简介)

什么是对称加密 1 什么是对称加密2 编码3 加密算法3 1 DES3 1 1 什么是DES3 1 2 加密和解密 4 3DES4 3 1 什么是3DES4 3 2 3DES加密解密 5 AES5 1 什么是AES5 2 AES加密解密 1
Linux应用程序之Helloworld入门

对于初学者来说 xff08 本人就是 xff09 xff0c 如何开始写第一个程序至关重要有的时候一个简单的问题会严重影响到学习的积极性和自信心这里结合实际工作中的一些经验 xff0c 总结方法步骤 xff0c 对Linux下应用程序H
ctags简明使用方法

ctags xff08 Generate tag files for source code xff09 是vim下方便代码阅读的工具 xff0c 它可以在命令行下帮助程序员很容易地浏览源代码 ctags 最先是用来生成C代码的tags文件
char和unsigned char强制转换成int后的差异

最近有人提到char和unsigned char有什么区别 xff0c 当然这个问题如果刚学计算机或者编程语言的人来说 xff0c 非常简单我也这么认为 xff0c 无非就是有符号和无符号的差别嘛这个问题让我想到了以前学习计算机常识的时
如何使用mstsc进行远程登录？

如何使用mstsc进行远程登录 xff1f 步骤一 xff1a 点击开始 gt 运行 xff0c 输入mstsc xff0c 如下图所示 xff1a 步骤二 xff1a 输入连接PC的IP地址 xff0c 如下图所示 xff1a 步骤三
VNC远程ubuntu时，右击无法打开terminal

参考博客 xff1a https blog csdn net qq 44132116 article details 103960393 问题描述 xff1a 我通过命令行连接实验室服务器 xff0c 装了anaconda xff0c 之后
TCP实时传图像

目的 xff1a QT 43 openCV xff0c 在Ubuntu16 04版本下 xff0c 通过TCP实现图片的传输步骤 xff1a 客户端建一个相机线程 xff0c 一个TCP线程 xff0c 相机线程捕获画面并将Mat传到TC

TCP实时传图像

目的：

步骤：

效果：

代码：

server：（接受客户端发送的Mat，并显示）

client：（通过cv打开相机，并把Mat传到服务器）

TCP实时传图像 的相关文章

随机推荐

热门标签

TCP实时传图像的相关文章