＜树莓派＞——基于Socket、Opencv、树莓派---实时拍摄并传输图片

最新推荐文章于 2024-02-15 00:01:47 发布
最新推荐文章于 2024-02-15 00:01:47 发布
阅读量4.1k 收藏 52
点赞数 2
分类专栏： 树莓派
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Kano365/article/details/90473641
版权
  • 1.器件
1上位机—笔记本
2下位机–树莓派zero w/树莓派3B+
3树莓派V2相机–800w像素

  • 2.基于SOCKET的通讯
    Server----作为服务器接收图片
    Client----作为客户端采集图片并通过socket的网口连接传输

  • 3.树莓派Linux，笔记本Windows/Linux

Server端代码-----（Linux）

1.main.cpp

#include<several_mat.h>


int main()
{

    getpicture img;

    if(img.socketConnect(8888)<0)   //建立socket通讯，端口为8888
    {
        cout<<"connect error!";
        return -1;
    }

    Mat image;

    if(img.acceptfile(image)>0)   //等待客户端的信号输入，接收图片
    {
        cout<<"accept is OK!";
    }

    img.socketDisconnect();

    return 0;
}

2.several_mat.h

#ifndef SEVERAL_IMGS_H
#define SEVERAL_IMGS_H

#endif // SEVERAL_IMGS_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>
#include <iostream>

using namespace std;
using namespace cv;

#define MAXLINE 1024*1024    //最大传输单张图片的大小
#define img_width 1920       //图片的分辨率
#define img_height 1080


#define img_num 30          //传输图片的张数
#define packet_num 8		//把一张图片划分成n部分传输



struct recvBuf             //接收的数据
{
    char buf[MAXLINE];
    int flag;              //来判断一张图片接收完成
};


class getpicture
{

public:
    getpicture(void);
    ~getpicture(void);

    int socketConnect(int PORT); //socket通讯
    int acceptfile(Mat& image);  //接收图片，每一个像素的接收


    void socketDisconnect(void);//关闭服务器

private:
        struct recvBuf data;

        int needRecv;
        int count;

        int sockConn;


};

3.several_mat.cpp

#include<several_mat.h>

getpicture::getpicture(void)
{

}
getpicture::~getpicture(void)
{

}

int getpicture::socketConnect(int PORT)
{
    int server_sockfd = socket(AF_INET,SOCK_STREAM, 0);//创建套接字，初始化信息

    struct sockaddr_in server_sockaddr;             //指向sockaddr地址的指针，该结构含有IP和PORT
    server_sockaddr.sin_family = AF_INET;           //ipv4
    server_sockaddr.sin_port = htons(PORT);         //端口
    server_sockaddr.sin_addr.s_addr = htonl(INADDR_ANY); //ip地址

    if(bind(server_sockfd,(struct sockaddr *)&server_sockaddr,sizeof(server_sockaddr))==-1)//bind函数将socket关联一个本地地址
    {
        perror("bind");
        return -1;
    }

    if(listen(server_sockfd,5) == -1)//listen来监听这个socket，如果客户端这时调用connect()发出连接请求，服务器端就会接收到这个请求。
    {
        perror("listen");
        return -1;
    }

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

    sockConn = accept(server_sockfd, (struct sockaddr*)&client_addr, &length);  //socket()、bind()、listen()之后，就会监听指定的socket地址了。
	                                                                            //TCP客户端依次调用socket()、connect()之后就想TCP服务器发送了一个连接请求。
																				//TCP服务器监听到这个请求之后，就会调用accept()函数取接收请求，这样连接就建立好了。
    if(sockConn<0)                                                              //之后就可以开始网络I/O操作了，即类同于普通文件的读写I/O操作。
    {
        perror("connect");
        return -1;
    }
    else
    {
        printf("connect successful!\n");
    }

//    int nRecvBuf = 1024 * 1024 * 20;
//    setsockopt(sockConn, SOL_SOCKET, SO_RCVBUF, (const char*)&nRecvBuf, sizeof(int));

}

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


int getpicture::acceptfile(Mat& image)
{
    int returnflag = 0;
    cv::Mat img(img_height, img_width, CV_8UC3, cv::Scalar(0));
    needRecv = sizeof(recvBuf);                //struct recvBuf    int needRecv
    count = 0;
    memset(&data,0,sizeof(data));


    for (int p=0;p<img_num;p++)               
    {


        for (int i = 0; i < packet_num; i++)        //一张图片划分为n个区域来传递，一个像素一个像素的传递
        {
            int pos = 0;
            int len0 = 0;

            while (pos < needRecv)                  //接收缓冲区中的数据可能大于buf，所以需要调用几次recv函数把接收缓冲区中的数据完全copy
            {
                len0 = recv(sockConn, (char*)(&data) + pos, needRecv - pos, 0);//3.needRecv>2buf   分多次传   每次传pos的数据量
                if (len0 < 0)//3
                {
                    printf("Server Recieve Data Failed!\n");
                    break;
                }
                pos += len0;//
            }

            count = count + data.flag;//1+1+1+1+1+1+1+.....2

            int num1 = img_height / packet_num * i;            //划分为每一行像素
            for (int j = 0; j < img_height / packet_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)        //一张图片的最后一块区域 data.flag=2
            {
                if (count == packet_num + 1)//表示一张图片是传输完整的
                {
                    image = img;
                    string str="/home/yqz/图片/"+to_string(p+1)+".jpg";
                    imwrite(str,img);
                    returnflag++;
                    count = 0;// one picture over,begin next
                }
                else
                {
                    count = 0;   //if (count != PACKAGE_NUM + 1)  restart transmit
                    i = 0;
                }
            }
        }
    }


    if(returnflag == img_num)
        return 1;
    else
        return -1;
}

Server端代码-----（Windows）

1.main.cpp

#include"several_mat.h"


int main()
{

	getpicture img;

	if (img.socketConnect(8888) < 0)
	{
		cout << "connect error!";
		return -1;
	}

	Mat image;
	if (img.acceptfile(image) > 0)
	{
		cout << "accept is OK!";
	}

	img.socketDisconnect();

	system("pause");
	return 0;
}

2.several_mat.h

#ifndef SEVERAL_IMGS_H
#define SEVERAL_IMGS_H

#endif // SEVERAL_IMGS_H

#include <opencv2/opencv.hpp>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <sys/types.h>
#include <iostream> 
#include <WinSock2.h>

#pragma comment(lib,"Ws2_32.lib ")

using namespace std;
using namespace cv;

#define MAXLINE 1024*1024
#define img_width 1920
#define img_height 1080


#define img_num 20
#define packet_num 8



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


class getpicture
{

public:
	getpicture(void);
	~getpicture(void);

	int socketConnect(int PORT);
	int acceptfile(Mat& image);


	void socketDisconnect(void);

private:
	struct recvBuf data;

	int needRecv;
	int count;
	SOCKET sockConn;
};

3.several_mat.cpp

#include"several_mat.h"

getpicture::getpicture(void)
{

}
getpicture::~getpicture(void)
{

}

int getpicture::socketConnect(int PORT)
{
		//初始化WSA
		WORD sockVersion = MAKEWORD(2, 2);
		WSADATA wsaData;
		if (::WSAStartup(MAKEWORD(2, 2), &wsaData) != 0)//初始化供进程调用的Winsock相关的dll
		{
			cout << "WSAStartup error" << endl;         //WSACleanup()释放Ws2_32.dl的l函数
			return 0;
		}


		SOCKET server_sockfd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);//socket函数将创建指定传输服务的socket
		if (server_sockfd == INVALID_SOCKET)
		{
			int er = WSAGetLastError();
			return 0;
		}
				
		u_long mode = 0;
		ioctlsocket(server_sockfd, FIONBIO, &mode);

		sockaddr_in server_sockaddr;             //指定一个未绑定的socket
		server_sockaddr.sin_family = AF_INET;
		server_sockaddr.sin_port = htons(PORT);
		server_sockaddr.sin_addr.S_un.S_addr = inet_addr("192.168.1.2");
		//server_sockaddr.sin_addr.S_un.S_addr = htonl(INADDR_ANY);
		if (::bind(server_sockfd, (const SOCKADDR*)&server_sockaddr, sizeof(SOCKADDR)) == SOCKET_ERROR)//bind函数将socket关联一个本地地址
		{
			perror("bind");
			return -1;
		}

		if (listen(server_sockfd, 5) == SOCKET_ERROR)
		{
			perror("listen");
			return -1;
		}
		printf("Listening To Client...\n");
		sockaddr_in client_addr;
		int 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");
		}


       /*int nRecvBuf = 1024 * 1024 * 20;
	   setsockopt(sockConn, SOL_SOCKET, SO_RCVBUF, (const char*)&nRecvBuf, sizeof(int));*/
}

void getpicture::socketDisconnect(void)
{
	closesocket(sockConn);
	WSACleanup();
}


int getpicture::acceptfile(Mat& image)
{
	int returnflag = 0;
	cv::Mat img(img_height, img_width, CV_8UC3, cv::Scalar(0));
	needRecv = sizeof(recvBuf);                //struct recvBuf    int needRecv
	count = 0;
	memset(&data, 0, sizeof(data));


	for (int p = 0; p < img_num; p++)
	{
		for (int i = 0; i < packet_num; i++)
		{
			int pos = 0;
			int len0 = 0;

			while (pos < needRecv)
			{
				len0 = recv(sockConn, (char*)(&data) + pos, needRecv - pos, 0);//3needRecv>2buf   fen duoci chuan   meicichuan pos
				if (len0 < 0)//3
				{
					printf("Server Recieve Data Failed!\n");
					break;
				}
				pos += len0;//
			}

			count = count + data.flag;//1+1+1+1+1+1+1+.....2

			int num1 = img_height / packet_num * i;
			for (int j = 0; j < img_height / packet_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)        //final area data.flag=2
			{
				if (count == packet_num + 1)
				{
					image = img;
					string str = "d:\\" + to_string(p + 1) + ".jpg";
					imwrite(str, img);
					returnflag++;
					count = 0;// one picture over,begin next
				}
				else
				{
					count = 0;   //if (count != PACKAGE_NUM + 1)  restart transmit
					i = 0;
				}
			}
		}
	}


	if (returnflag == img_num)
		return 1;
	else
		return -1;
}

Client-----(树莓派采集图片)

边拍变传
1.main.cpp

#include <severalimg.h>

int main()
{
    severalimg img;

    if(img.connectsocket("192.168.1.2",8888)<0)
    {
        cout<<"connect error!";
        return -1;
    }

    if(img.getandtransmit()>0)
    {
        cout<<"transmit is right!";
    }

    img.socketDisconnect();
    return 0;
}

2.severalimg.h



/severalimg.h
#ifndef SEVERALIMG_H
#define SEVERALIMG_H

#endif // SEVERALIMG_H


#include<iostream>
#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>
#include <netdb.h>

using namespace std;
using namespace cv;

#define img_width 1920
#define img_height 1080
#define img_exposure -20
#define img_fps 30
#define MAXLINE 1024*1024

#define delay 1000       //1s=1000ms
#define img_num 20
#define packet_num 8

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


class severalimg
{

public:
    severalimg(void);
    ~severalimg(void);


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

//    int transmit(vector<Mat>img);
//    vector<Mat> getimg();
    int getandtransmit();

    void socketDisconnect();

private:
    struct sentbuf data;
    int sockClient;
};

///severalimg.cpp
#include<severalimg.h>

severalimg::severalimg(void)
{
}

severalimg::~severalimg(void)
{
}
int severalimg::getandtransmit()
{

    VideoCapture capture(0);
    Mat img;
    int imgimg_num=0;
    capture.set(CV_CAP_PROP_FRAME_WIDTH,img_width);
    capture.set(CV_CAP_PROP_FRAME_HEIGHT,img_height);
    capture.set(CV_CAP_PROP_FPS,img_fps);
    capture.set(CV_CAP_PROP_EXPOSURE, img_exposure);

    if(!capture.isOpened())
     {
           cout<<"The camera can not open!"<<endl;
           //return -1;
     }

     while(1)
     {


         for(int i=0;i<img_num;i++)
         {

            Mat image;
            capture>>image;
            img=image;
            String img_name="/home/pi/imgimg/"+to_string(i+1)+".jpg";
            imwrite(img_name,image);

            for(int k = 0; k < packet_num; k++)//##划分每块区域
            {
                int num1 = img_height / packet_num * k;//720/8  *(0-7)  每块区域的第一个元素
                for (int i = 0; i < img_height/ packet_num; i++)  //##划分每块区域的每一行
                {
                    int num2 = i * img_width * 3;
                    uchar* ucdata = img.ptr<uchar>(i + num1);//第一行第一个元素，第二行第一个元素
                    for (int j = 0; j < img_width * 3; j++)//##划分每块区域每一行的每一个元素
                    {
                        data.buf[num2 + j] = ucdata[j];//每一行的元素每个元素相对应
                    }
                }

                if(k == packet_num - 1)
                {                            //最后一块区域data.flag为2,反之为1
                    data.flag = 2;
                }
                else
                {
                    data.flag = 1;
                }                        //发送8次数据

                if (send(sockClient, (char *)(&data), sizeof(data), 0) < 0)
                {
                    printf("send image error: %s(errno: %d)\n", strerror(errno), errno);
                    return -1;
                }
            }
            waitKey(delay);
            imgimg_num++;
        }
        capture.release();
        break;
     }

     if(img_num==imgimg_num)
        return 1;
     else
        return -1;
}

int severalimg::connectsocket(const char* IP, int PORT)//dingyi socket
{
    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
    {
        //int nsendbuf=1024*1024;
        //setsockopt(sockClient,SOL_SOCKET,SO_SNDBUF,(const char*)&nsendbuf,sizeof(int));

        printf("connect successful!\n");
        return 1;
    }
}

//int severalimg::transmit(vector<Mat>picture)
//{

//      if(picture.empty())
//      {
//          cout<<"empty picture";
//          return -1;
//      }

//      Mat img1;

//      for(int l=0;l<img_num;l++)
//      {
//          img1=picture[l];

//          for(int k = 0; k < packet_num; k++)//##划分每块区域
//          {
//              int num1 = img_height / packet_num * k;//720/8  *(0-7)  每块区域的第一个元素
//              for (int i = 0; i < img_height/ packet_num; i++)  //##划分每块区域的每一行
//              {
//                  int num2 = i * img_width * 3;
//                  uchar* ucdata = img1.ptr<uchar>(i + num1);//第一行第一个元素，第二行第一个元素
//                  for (int j = 0; j < img_width * 3; j++)//##划分每块区域每一行的每一个元素
//                  {
//                      data.buf[num2 + j] = ucdata[j];//每一行的元素每个元素相对应
//                  }
//              }

//              if(k == packet_num - 1)
//              {                            //最后一块区域data.flag为2,反之为1
//                  data.flag = 2;
//              }
//              else
//              {
//                  data.flag = 1;
//              }                        //发送8次数据

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

//      }

//}


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

3.severalimg.cpp

//也可以自行修改成，把全部照片拍摄完以后再传输
#include<severalimg.h>

severalimg::severalimg(void)
{
}

severalimg::~severalimg(void)
{
}
int severalimg::getandtransmit()
{

    VideoCapture capture(0);
    Mat img;
    int imgimg_num;
    capture.set(CV_CAP_PROP_FRAME_WIDTH,img_width);
    capture.set(CV_CAP_PROP_FRAME_HEIGHT,img_height);
    capture.set(CV_CAP_PROP_FPS,img_fps);
    capture.set(CV_CAP_PROP_EXPOSURE, img_exposure);

    if(!capture.isOpened())
     {
           cout<<"The camera can not open!"<<endl;
           //return -1;
     }

     while(1)
     {


         for(int i=0;i<img_num;i++)
         {

            Mat image;
            capture>>image;
            img=image;
            String img_name="/home/pi/imgimg/"+to_string(i+1)+".jpg";
            imwrite(img_name,image);

            for(int k = 0; k < packet_num; k++)//##划分每块区域
            {
                int num1 = img_height / packet_num * k;//720/8  *(0-7)  每块区域的第一个元素
                for (int i = 0; i < img_height/ packet_num; i++)  //##划分每块区域的每一行
                {
                    int num2 = i * img_width * 3;
                    uchar* ucdata = img.ptr<uchar>(i + num1);//第一行第一个元素，第二行第一个元素
                    for (int j = 0; j < img_width * 3; j++)//##划分每块区域每一行的每一个元素
                    {
                        data.buf[num2 + j] = ucdata[j];//每一行的元素每个元素相对应
                    }
                }

                if(k == packet_num - 1)
                {                            //最后一块区域data.flag为2,反之为1
                    data.flag = 2;
                }
                else
                {
                    data.flag = 1;
                }                        //发送8次数据

                if (send(sockClient, (char *)(&data), sizeof(data), 0) < 0)
                {
                    printf("send image error: %s(errno: %d)\n", strerror(errno), errno);
                    return -1;
                }
            }
            waitKey(delay);
            imgimg_num++;
        }
        capture.release();
        break;
     }

     if(img_num==imgimg_num)
        return 1;
     else
        return -1;
}

int severalimg::connectsocket(const char* IP, int PORT)//dingyi socket
{
    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
    {
        //int nsendbuf=1024*1024;
        //setsockopt(sockClient,SOL_SOCKET,SO_SNDBUF,(const char*)&nsendbuf,sizeof(int));

        printf("connect successful!\n");
        return 1;
    }
}

//int severalimg::transmit(vector<Mat>picture)
//{

//      if(picture.empty())
//      {
//          cout<<"empty picture";
//          return -1;
//      }

//      Mat img1;

//      for(int l=0;l<img_num;l++)
//      {
//          img1=picture[l];

//          for(int k = 0; k < packet_num; k++)//##划分每块区域
//          {
//              int num1 = img_height / packet_num * k;//720/8  *(0-7)  每块区域的第一个元素
//              for (int i = 0; i < img_height/ packet_num; i++)  //##划分每块区域的每一行
//              {
//                  int num2 = i * img_width * 3;
//                  uchar* ucdata = img1.ptr<uchar>(i + num1);//第一行第一个元素，第二行第一个元素
//                  for (int j = 0; j < img_width * 3; j++)//##划分每块区域每一行的每一个元素
//                  {
//                      data.buf[num2 + j] = ucdata[j];//每一行的元素每个元素相对应
//                  }
//              }

//              if(k == packet_num - 1)
//              {                            //最后一块区域data.flag为2,反之为1
//                  data.flag = 2;
//              }
//              else
//              {
//                  data.flag = 1;
//              }                        //发送8次数据

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

//      }

//}


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

参考博客：
https://blog.csdn.net/pengz0807/article/details/52204475

Kano365
关注
  • 2
    点赞
  • 踩
  • 52
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
『Python』树莓派定时采集图像上传到服务器
老陈聊架构
12-10 1万+
读完这篇文章里你能收获到，树莓派定时采集图像上传到服务器全流程，七牛云图片存储服务器的使用，树莓派实现定时执行脚本
树莓派通过socket传输图片流-Python(可跨平台使用)
学习、记录、分享
09-19 1847
我之前用过socket跨语言跨平台通信，不过那时传的字节都比较小，等我想传输图片时问题出现了，传输时报错，网上查了查，是传输数据过大导致的，于是客户端获取对应文件的size，并把它分段传输，服务端拿到分段的数据并把它重新合并成你想要的文件 废话不多说，直接放代码 客户端: # -*- coding: UTF-8 -*- import socket, os, struct import ti...
树莓派利用socket传图到pc端（Python）
风暴中心
08-17 2790
1.PC作为socket的服务器端： import socket import os import sys import struct def socket_service(): try: s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) #IP地址留空默认是本机IP地址
树莓派采用socket方式文件传输（python）
09-19
主要为大家详细介绍了树莓派采用socket方式文件传输，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
基于树莓派的图传监控系统+源代码+文档说明
最新发布
下载完，不懂运行可以私聊，看到会回
02-15 469
关于PicameraPicamera是使用Python开发的图传监控系统，基于树莓派和普通web摄像头硬件。系统包括运行于树莓派上的图像采集socket客户端;运行于linux系统下的socket服务器;linux系统下的http服务器。之后的版本将增加图像跟踪和识别功能。opencv3。
使用esp32cam和树莓派制作简易图传遥控器（基于UDP）
weixin_45179910的博客
09-23 5403
我们最近想开发一款图传小车，先用最简单最易上手的硬件，来自AI-Thinker的esp32cam来做图像采集、发送端，并使用树莓派来接收并显示吧。 小车端使用了esp32cam，这个模块非常好用，集成了wifi和摄像头，初测wifi性能还不错，在办公室环境下传480x320p的图像很流畅，偶尔卡顿是因为被水泥墙遮挡。 接收端使用树莓派4B加一块3.5寸的GPIO屏，这边应该是LCD屏走的SPI接口的原因就比较拉跨了，刷新率基本每秒一帧吧，后续换成HDMI的屏幕应该会好一些。不过好歹系统搭起来了.
android-sdk-opencv-4.5.5&opencv-contrib-4.5.5-arm64-v8a
07-07
1.android 版的opencv-4.5.5 sdk； 2.含有opencv-contrib-4.5.5 扩展模块； 3.可以在android studio 中加载，通过java 层调用，也可以添加so库+头文件的方式在jni 层调用； 4.适用于arm64-v8a架构，即64bit cpu。
树莓派 电脑 socket传输图片
weixin_41945913的博客
05-28 1540
参考链接: https://zhuanlan.zhihu.com/p/81512504.
树莓派摄像头远程拍照及传输
crabxd的博客
10-25 4039
树莓派得到很多人的喜欢（除了越来越贵之外），而给树莓派加摄像头，又使得它的应用场景非常广阔。相比于stm32摄像头（一般像素在几十万）等，树莓派的摄像头像素高（一般都在500w）以上，树莓派摄像头应用范围更广，较为清晰的照片可以结合图像识别等技术，打造出各种各样的应用系统。因此，下面来介绍树莓派摄像头的使用以及给出一个应用场景。
【树莓派】使用opencv获取摄像头画面并实时传输到电脑显示——python3
热门推荐
qq_44179528的博客
03-28 1万+
和分别在树莓派上和电脑上布置好了相关的库就可以完成视频的实时传送。注意WiFi信号一定要好，否则会卡，正常视频延时在一秒钟以内。主要使用了opencv进行图像获取，把每一帧图像。b) 安装计算库：numpy。c) 安装帧传输模块：zmq。e) 安装picamera。a) 安装：opencv。
树莓派与QT上位机之间通过socket进行实时图像传输
weixin_45888152的博客
03-07 8677
其中QT上位机作为服务器端，通过socket监听特定端口，当有设备连入时，会产生相应的信号，我们捕获此信号并且自定义槽函数来进行数据接收，当接收到完整的一帧图像信息后，将图像数据流复原成图像矩阵并通过Qlabel控件显示出来。 树莓派作为客户端，其通过opencv捕获到摄像头的图像，捕获图像之后可以根据自己需求对图像进行滤波、形态学腐蚀、膨胀处理、边缘检测等操作，最后将图像数据转化成字节流，同时通过socket嵌套字连接入QT上位机服务器，实现tcp通信.
树莓派-opencv-python.rar
02-23
opencv_python-3.4.3.18-cp37-cp37m-linux_armv7l.whl opencv_python-4.1.1.26-cp37-cp37m-linux_armv7l.whl opencv_python-4.1.1.26-cp35-cp35m-linux_armv7l.whl opencv_python-4.1.1.26-cp37-cp37m-linux_armv...
opencv-3.4.4-android-sdk/sdk/其他文件.zip
04-16
opencv-3.4.4-android-sdk/sdk/build.gradle opencv-3.4.4-android-sdk/sdk/etc opencv-3.4.4-android-sdk/sdk/java
AutoRun-Car：基于树莓派图像识别的智能循迹避障小车
02-05
树莓派：rasbian系统电脑：opencv2.45 麻木 具体原理 道路检测 本程序所使用的道路检测算法为最基础的检测算法，可升级至深度学习算法，但是没时间搞主要是不会对于道路检测而言，最基本的就是在图像上随机去除图像...
opencv4.7.0-opencv-contrib-4.7.0-windows-cuda编译版本
05-18
opencv4.7.0-opencv_contrib-4.7.0-windows-cuda编译版本 文件包括：include，lib，dll 可用于深度学习基于CUDA进行推理；
＜树莓派＞——树莓派通过csi摄像头实时传输rtsp流
Kano365的博客
05-26 4111
https://blog.csdn.net/u012736685/article/details/77131633/ 之前参考过以上的博客实时传输视频流，他是基于socket和opencv传递每个像素。 但是效果真的不是很好，在720p的情况下，帧数只有4左右，效果很差。 https://blog.csdn.net/secho1997/article/details/53526784 以上...
＜树莓派＞——VNC Viewer 远程桌面配置教程
Kano365的博客
03-10 3211
http://shumeipai.nxez.com/2018/08/31/raspberry-pi-vnc-viewer-configuration-tutorial.html?variant=zh-cn
＜树莓派＞——树莓派zero/zero w SPI网卡配置/外接网口
Kano365的博客
05-20 2742
完成状态。 需要1.enc28j60网卡 2.杜邦线 1. 打开SPI接口 树莓派要设置打开SPI接口才可以接入SPI网卡的，这个简单。输入sudo raspi-config指令，在interfaces选项中，找到SPI选项，选择enable即可。然后关掉树莓派，开始接线。 2. 开始接线 3. 激活enc28j60网卡 最后一步是激活enc28j60网卡，在 /boot/config.t...
树莓派 opencv 电子书
12-23
树莓派是一款迷你的单板计算机，可以运行不同的操作系统，并且具有丰富的接口和功能。而OpenCV是一个开源的计算机视觉库，可以用于实时图像处理、目标识别、人脸识别等应用。树莓派和OpenCV的结合可以实现很多有趣的项目，比如智能家居控制、智能监控系统等。 关于树莓派和OpenCV的电子书会涵盖从零开始搭建树莓派系统的基础知识，到如何安装OpenCV库和使用OpenCV进行图像处理的实际操作，以及如何将这些知识应用到实际的项目中。这本电子书将会介绍一些常用的图像处理算法和技术，并且会结合实际的案例来演示如何利用树莓派和OpenCV来完成一些有趣的项目。 此外，电子书还会包括一些实用的技巧和经验，帮助读者更好地理解树莓派和OpenCV的使用方法，以及遇到问题时如何进行故障排查和解决。最后，电子书还会介绍一些扩展应用和深入学习的资源，方便读者进一步探索树莓派和OpenCV的更多可能性。 这本电子书将适合对树莓派和OpenCV有兴趣的初学者和爱好者阅读，不仅可以帮助他们快速入门，并且可以为他们提供一些实用的项目案例和经验分享，帮助他们更好地理解和应用这些技术。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值