从Raspberry Pi捕获jpeg图像并发送到PC socket python？

我想把从Rasberry pi摄像头拍摄的图像像流一样实时发送到PC，但不是流，因为我没有那么多带宽。 我现在的代码是

客户端

import io
import cv2
import socket
import struct
from PIL import Image
import numpy

# Start a socket listening for connections on 0.0.0.0:8000 (0.0.0.0 means
# all interfaces)
cv2.namedWindow('Network Image')
server_socket = socket.socket()
server_socket.bind(('0.0.0.0', 8200))
server_socket.listen(0)

# Accept a single connection and make a file-like object out of it
connection = server_socket.accept()[0].makefile('rb')
try:
    while True:
        # Read the length of the image as a 32-bit unsigned int. If the
        # length is zero, quit the loop
        image_len = struct.unpack('<L', connection.read(struct.calcsize('<L')))[0]
        if not image_len:
            break
        # Construct a stream to hold the image data and read the image
        # data from the connection
        image_stream = io.BytesIO()
        image_stream.write(connection.read(image_len))
        # Rewind the stream, open it as an image with PIL and do some
        # processing on it
        image_stream.seek(0)
        image = Image.open(image_stream).convert('RGB')
        open_cv_image = numpy.array(image)
        open_cv_image = open_cv_image[:, :, ::-1].copy()
        cv2.imshow('Network Image',open_cv_image)
        cv2.waitKey(0)
        print('Image is %dx%d' % image.size)
        image.verify()
        print('Image is verified')
finally:
    connection.close()
    server_socket.close()

导入io
进口cv2
导入套接字
导入结构
从PIL导入图像
进口numpy
#启动一个套接字，监听0.0.0:8000（0.0.0.0）上的连接
#所有接口）
cv2.namedWindow（“网络映像”）
服务器\u套接字=socket.socket（）
服务器套接字绑定（（'0.0.0.0'，8200））
服务器\u套接字。侦听（0）
#接受单个连接并从中生成类似文件的对象
connection=server\u socket.accept（）[0]。生成文件（'rb'）
尝试：
尽管如此：
#将图像的长度读取为32位无符号整数。如果
#长度为零，退出循环
image_len=struct.unpack（'use

使用

尝试使用线程如果可以接受200毫秒的延迟，则可以使用缓冲区。从服务器中取出对套接字的写入，以测试原始采集帧速率。同样，从服务器中取出相机读取的数据，通过有线发送静态帧，以查看原始传输速率。然后考虑优化。顺便问一下，您是否使用有线传输是s还是有线以太网？@MarkSetchell我正在使用以太网。去年，我在我的Raspi中插入了一个USB千兆以太网适配器，进行了一些测试，它的速度几乎是内置100Mbit/s适配器的两倍——因此不是真正的千兆速度，但仍然是两倍。这是一个TRENDnet TU3-ETG USB 3.0千兆以太网适配器，在英国亚马逊上售价为15英镑。它不需要任何软件修补程序、驱动程序或任何东西-开箱即用。尝试使用线程如果可以接受200毫秒的延迟，则可以使用缓冲区。从服务器中写入套接字以测试原始采集帧速率。同样，从服务器中取出相机读取的数据，并通过导线发送静态帧以查看原始数据传输速率。然后考虑优化。顺便问一下，你使用的是无线还是有线以太网？@MarkSetchell我使用的是以太网。去年我用插入我的Raspi的USB千兆以太网适配器做了一些测试，它的速度几乎是内置100Mbit/s适配器的两倍-因此不是真正的千兆速度，但仍然是两倍。这是一个TRENDnetTU3-ETG USB 3.0千兆以太网适配器在Amazon UK上售价为15英镑。它不需要任何软件补丁、驱动程序或其他任何东西——可以开箱即用。
import io
import socket
import struct
import time
import picamera

# Connect a client socket to my_server:8000 (change my_server to the
# hostname of your server)
client_socket = socket.socket()
client_socket.connect(('192.168.2.225', 8200))

# Make a file-like object out of the connection
connection = client_socket.makefile('wb')
try:
    with picamera.PiCamera() as camera:
        camera.framerate=15
        camera.resolution = (480, 480)
        # Start a preview and let the camera warm up for 2 seconds
        camera.start_preview()
        time.sleep(2)

        # Note the start time and construct a stream to hold image data
        # temporarily (we could write it directly to connection but in this
        # case we want to find out the size of each capture first to keep
        # our protocol simple)
        start = time.time()
        stream = io.BytesIO()
        for foo in camera.capture_continuous(stream, 'jpeg'):
            # Write the length of the capture to the stream and flush to
            # ensure it actually gets sent
            connection.write(struct.pack('<L', stream.tell()))
            connection.flush()
            # Rewind the stream and send the image data over the wire
            stream.seek(0)
            connection.write(stream.read())
            # If we've been capturing for more than 30 seconds, quit
            if time.time() - start > 30:
                break
            # Reset the stream for the next capture
            stream.seek(0)
            stream.truncate()
    # Write a length of zero to the stream to signal we're done
    connection.write(struct.pack('<L', 0))
finally:
    connection.close()
    client_socket.close()

client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
for foo in camera.capture_continuous(stream, 'jpeg', use_video_port = True):