【OpenCV-PyQt5-PyGame-imutils】探索Python中的图像和视频捕获：性能分析与选择指南

前言

随着计算机视觉和多媒体应用的不断发展，图像和视频捕获变得越来越重要。在Python中，有多种库和工具可供选择，用于打开摄像头、捕获图像、以及处理视频流。本文旨在为读者提供对这些捕获方法的全面了解，并介绍如何计算平均帧率以评估性能。

文章目录

前言
环境配置
- 新的空白解释器环境创建
- - Windows
  - Linux
  - 相关库配置
Python中的视频流处理：不同库和工具的使用
- 1. OpenCV
- 2. Pillow
- 3. Pygame
- 4. PyQt
- 5. imutils
- 6. av
- 7. SimpleCV
测试函数，捕捉100帧并返回平均帧率
- python3
- - 可处理摄像头或视频帧
  - - 1. OpenCV Frame Capture
    - 2. Pygame Frame Capture
    - 3. PyQt Frame Capture
    - 4. imutils Frame Capture
  - 分析和总结：
  - 捕获屏幕帧
  - - 1. pyautogui Frame Capture
  - 音频和视频捕捉
  - - 2. av Frame Capture
- python 2
- - SimpleCV Frame Capture
总结

环境配置

新的空白解释器环境创建

解释器环境创建方式基于
半自动化使用.bat手动打包迁移python项目

Windows

python -m venv venv
call venv\Scripts\activate.bat
python -m pip install -i https://mirrors.aliyun.com/pypi/simple/ --upgrade pip setuptools

注：以下报错是由于你在powershell输入了以上命令，你需要切换成cmd,直接输入cmd即可

PS E:\PRODUCE\dli\recognition-dlib\RetinaFace-FaceNet> call
venv\Scripts\activate.bat call : 无法将“call”项识别为
cmdlet、函数、脚本文件或可运行程序的名称。请检查名称的拼写，如果包括路径，请确保路径正确，然后再试一次。所在位置行:1 字符: 1
call venv\Scripts\activate.bat
  + CategoryInfo          : ObjectNotFound: (call:String) [], CommandNotFoundException
  + FullyQualifiedErrorId : CommandNotFoundException

Linux

python -m venv venv 
source venv/bin/activate
python -m pip install -i https://mirrors.aliyun.com/pypi/simple/ --upgrade pip setuptools

你也可以使用conda管理你的 Python 环境，但是我实际使用时的体验来看，以上方法当你的电脑已经安装了任意版本的python，打开cmd即可使用，且比conda安装新的包更快，速度与直接pip install在系统解释器中几乎一致
若使用conda，你必须先下载conda，但是conda可以很好的处理各种包不匹配的问题，也可以下载到的很多pip找不到的特殊版本

以上两种方法就对应PyCharm中的这两种方法
在这里插入图片描述

Python中的视频流处理：不同库和工具的使用

视频流处理在计算机视觉和多媒体应用中占据着重要地位。本文将介绍Python中的不同库和工具，用于摄像头捕捉、图像处理和视频流处理。我们将提供示例代码和描述，以帮助读者了解这些工具的使用方法。

1. OpenCV

OpenCV 是一个流行的计算机视觉库，可以用于摄像头捕捉和图像处理。以下是使用 OpenCV 打开摄像头并拍照的示例代码：

import cv2

# 初始化摄像头
cap = cv2.VideoCapture(0)

if not cap.isOpened():
    print("摄像头未找到或无法访问。")
else:
    while True:
        # 捕获一帧图像
        ret, frame = cap.read()

        cv2.imshow("Press Space to Capture", frame)

        key = cv2.waitKey(1)

        if key == 32:  # 按下空格键
            # 将图像保存为文件
            cv2.imwrite('captured_image.jpg', frame)
            print("拍照成功！图像已保存为captured_image.jpg")
            break

    # 释放摄像头
    cap.release()
    cv2.destroyAllWindows()

2. Pillow

Pillow 是一个强大的图像处理库，也可以用于摄像头捕捉。以下是使用 Pillow 打开摄像头并拍照的示例代码：

from PIL import Image
from io import BytesIO
import requests

# 初始化摄像头
with Image.open(requests.get('http://localhost:8080/picture/1/current/', stream=True).raw) as camera:
    # 拍照
    camera.save("pillow_capture.jpg")

3. Pygame

Pygame 是一个游戏开发库，也可以用于摄像头捕捉。以下是使用 Pygame 打开摄像头并拍照的示例代码：

import pygame
import pygame.camera
from pygame.locals import *

def main():
    pygame.init()
    pygame.camera.init()

    # 打开默认摄像头
    camera = pygame.camera.Camera(pygame.camera.list_cameras()[0])
    camera.start()

    # 设置窗口尺寸和标题
    screen = pygame.display.set_mode((640, 480))
    pygame.display.set_caption('Camera Feed')

    capturing = False

    while True:
        for event in pygame.event.get():
            if event.type == QUIT:
                camera.stop()
                pygame.quit()
                return
            elif event.type == KEYDOWN and event.key == K_c:
                # 按 'C' 键来拍照
                image = camera.get_image()
                pygame.image.save(image, 'captured_image.png')
                capturing = True

        if not capturing:
            # 从摄像头获取图像并显示
            image = camera.get_image()
            screen.blit(image, (0, 0))
            pygame.display.update()
        else:
            # 显示拍摄的照片
            captured_image = pygame.image.load('captured_image.png')
            screen.blit(captured_image, (0, 0))
            pygame.display.update()

if __name__ == "__main__":
    main()

4. PyQt

PyQt 是一个GUI库，它也提供了摄像头访问和图像捕捉功能。你可以使用 PyQt 的相机模块来实现这一功能。

import sys
from PyQt5.QtWidgets import QApplication, QMainWindow, QVBoxLayout, QWidget, QPushButton
from PyQt5.QtMultimedia import QCamera, QCameraInfo
from PyQt5.QtMultimediaWidgets import QCameraViewfinder
from PyQt5.QtCore import Qt
from PyQt5.QtGui import QImage

class CameraApp(QMainWindow):
    def __init__(self):
        super().__init__()
        self.initUI()

    def initUI(self):
        self.setWindowTitle('Camera App')
        self.setGeometry(100, 100, 640, 480)

        self.central_widget = QWidget(self)
        self.setCentralWidget(self.central_widget)
        self.layout = QVBoxLayout(self.central_widget)

        self.viewfinder = QCameraViewfinder(self)
        self.layout.addWidget(self.viewfinder)

        self.camera_info = QCameraInfo.defaultCamera()
        self.camera = QCamera(self.camera_info)
        self.camera.setViewfinder(self.viewfinder)
        self.camera.start()

        self.capture_button = QPushButton('拍照', self)
        self.layout.addWidget(self.capture_button)
        self.capture_button.clicked.connect(self.capture_image)

    def capture_image(self):
        image = self.viewfinder.grab()
        if not image.isNull():
            image.save('captured_image.png', 'PNG')

    def closeEvent(self, event):
        self.camera.stop()
        self.camera.unload()

if __name__ == '__main__':
    app = QApplication(sys.argv)
    window = CameraApp()
    window.show()
    sys.exit(app.exec_())

5. imutils

imutils 是一个用于图像处理的工具集，它包括了一些用于打开摄像头并捕捉图像的函数。

from imutils.video import VideoStream
import cv2

def main():
    vs = VideoStream(src=0).start()  # 打开默认摄像头

    frame_count = 0

    while True:
        frame = vs.read()  # 读取一帧图像

        # 显示图像
        cv2.imshow('Camera', frame)

        key = cv2.waitKey(1)

        if key == 32:  # 如果按下空格键，拍照
            # 保存图像
            cv2.imwrite(f'photo_{frame_count}.jpg', frame)
            frame_count += 1

        if key == 27:  # 如果按下ESC键，退出循环
            break

    # 释放摄像头和销毁窗口
    vs.stop()
    cv2.destroyAllWindows()

if __name__ == "__main__":
    capture_frame_count = 0
    main()

6. av

av 是一个多媒体处理库，它支持音频和视频捕捉。虽然它主要用于音视频处理，但也可以用于摄像头捕捉。

import av
import numpy as np
from av.video import VideoFrame

# 打开摄像头
container = av.open("R.mp4")

# 获取视频流
stream = container.streams.video[0]

# 读取图像帧
for frame in container.decode(stream):
    img = frame.to_image()
    img.save("av_capture.jpg")
    break  # 捕捉一帧后退出

7. SimpleCV

python2方法，python3不可用
SimpleCV 是一个计算机视觉库，内置了摄像头捕捉和图像处理工具。

from SimpleCV import Camera

# 初始化摄像头
camera = Camera()

# 拍照
image = camera.getImage()
image.save("simplecv_capture.jpg")

测试函数，捕捉100帧并返回平均帧率

平均帧率（Average Frame Rate）的计算方法是将总共捕获的帧数除以经过的时间，以得到每秒的帧数（FPS）。以下是具体的计算步骤：

记录一个起始时间 start_time，通常使用毫秒为单位。你可以使用类似 QTime.currentTime() 的方法来获取当前时间。
在每一帧捕获之后，递增一个帧数计数器 frame_count，用于跟踪已捕获的帧数。
当达到指定的帧数（例如100帧）时，停止捕获过程。
记录一个结束时间 end_time，通常也以毫秒为单位。
计算经过的时间，即结束时间减去起始时间，以毫秒为单位。这可以使用下面的方法计算：elapsed_time = end_time - start_time。
将经过的时间转换为秒，因为帧率通常以每秒的帧数（FPS）表示。这可以通过将elapsed_time除以1000来实现，得到经过的时间（秒）。
计算帧率 frame_rate，将已捕获的帧数 frame_count除以经过的时间（秒）。帧率的计算公式为：frame_rate = frame_count / elapsed_time。
最后，你可以将 frame_rate 打印出来，以表示捕获的平均帧率。

这个帧率表示了程序在捕获和显示帧的过程中的性能。通常，帧率越高，程序运行得越流畅。这个值对于评估图像处理应用程序的性能非常重要。

python3

可处理摄像头或视频帧

1. OpenCV Frame Capture

OpenCV 是一个流行的计算机视觉库，可以用于摄像头捕捉和图像处理。这个程序测试使用 OpenCV 打开摄像头并返回平均帧率。

import cv2
import timeit


def capture_and_display_opencv():
    cap = cv2.VideoCapture(0)
    frame_count = 0
    start_time = timeit.default_timer()

    while frame_count < 100:
        ret, frame = cap.read()
        frame_count += 1

        # 显示捕获的帧
        cv2.imshow("Camera Feed", frame)

        if cv2.waitKey(1) & 0xFF == 27:  # 按下 ESC 键退出
            break

    cap.release()
    cv2.destroyAllWindows()

    end_time = timeit.default_timer()
    elapsed_time = end_time - start_time
    frame_rate = frame_count / elapsed_time
    return frame_rate


if __name__ == "__main__":
    frame_rate = capture_and_display_opencv()
    print("OpenCV Frame Rate:", frame_rate)

OpenCV Frame Rate: 23.629290831107372

此程序使用 OpenCV 打开摄像头，捕捉100帧并返回平均帧率。请将此代码保存为一个单独的Python文件并运行。

2. Pygame Frame Capture

Pygame 是一个游戏开发库，也可以用于摄像头捕捉。以下是测试使用 Pygame 打开摄像头并返回平均帧率的程序：

import pygame.camera
from pygame.locals import *
import timeit
import pygame

def capture_and_display_pygame():
    pygame.init()
    pygame.camera.init()
    camera = pygame.camera.Camera(pygame.camera.list_cameras()[0])
    camera.start()

    # 创建 Pygame 窗口用于显示摄像头画面
    screen = pygame.display.set_mode((640, 480))
    pygame.display.set_caption("Camera Feed")

    frame_count = 0
    start_time = timeit.default_timer()

    running = True
    while running:
        for event in pygame.event.get():
            if event.type == QUIT:
                running = False

        # 捕获摄像头画面
        image = camera.get_image()

        # 将捕获的画面显示在 Pygame 窗口上
        screen.blit(image, (0, 0))
        pygame.display.flip()

        frame_count += 1

        if frame_count >= 100:
            running = False

    end_time = timeit.default_timer()
    elapsed_time = end_time - start_time
    frame_rate = frame_count / elapsed_time

    # 关闭 Pygame 窗口
    pygame.quit()

    return frame_rate

if __name__ == "__main__":
    frame_rate = capture_and_display_pygame()
    print("Pygame Frame Rate:", frame_rate)

此程序使用 Pygame 打开摄像头，捕捉100帧并返回平均帧率。请将此代码保存为一个单独的Python文件并运行。
Pygame Frame Rate: 28.42875197551398

3. PyQt Frame Capture

PyQt 是一个强大的GUI库，它包括了对摄像头的访问功能。以下是测试使用 PyQt 打开摄像头并返回平均帧率的程序：

import sys
from PyQt5.QtCore import Qt, QTimer, QTime
from PyQt5.QtWidgets import QApplication, QMainWindow, QVBoxLayout, QWidget
from PyQt5.QtMultimedia import QCamera, QCameraInfo
from PyQt5.QtMultimediaWidgets import QCameraViewfinder

class CameraApp(QMainWindow):
    def __init__(self, capture_frame_count):
        super().__init__()
        self.capture_frame_count = capture_frame_count
        self.initUI()

    def initUI(self):
        self.setWindowTitle('Camera Feed')
        self.setGeometry(100, 100, 640, 480)

        self.central_widget = QWidget(self)
        self.setCentralWidget(self.central_widget)
        self.layout = QVBoxLayout(self.central_widget)

        self.viewfinder = QCameraViewfinder(self)
        self.layout.addWidget(self.viewfinder)

        self.camera_info = QCameraInfo.defaultCamera()
        self.camera = QCamera(self.camera_info)
        self.camera.setViewfinder(self.viewfinder)
        self.camera.start()

        self.frame_count = 0
        self.start_time = QTime.currentTime()

        self.timer = QTimer(self)
        self.timer.timeout.connect(self.capture_frame)
        self.timer.start(30)  # 30毫秒更新一次

    def capture_frame(self):
        if self.frame_count < self.capture_frame_count:
            self.frame_count += 1
            # 实时显示捕获的帧
            self.viewfinder.show()
        else:
            self.timer.stop()
            self.camera.stop()
            self.camera.unload()
            self.close()

    def closeEvent(self, event):
        elapsed_time = self.start_time.msecsTo(QTime.currentTime())
        frame_rate = self.frame_count / (elapsed_time / 1000)
        print("PyQt5 Frame Rate:", frame_rate)

if __name__ == '__main__':
    app = QApplication(sys.argv)
    capture_frame_count = 100
    window = CameraApp(capture_frame_count)
    window.show()
    sys.exit(app.exec_())

PyQt5 Frame Rate: 26.32964718272775

此程序使用 PyQt 打开摄像头，捕捉100帧并返回平均帧率。请将此代码保存为一个单独的Python文件并运行。

接下来，我们将继续介绍使用 SimpleCV、imutils 和其他捕捉方法的程序。

4. imutils Frame Capture

使用 imutils 库可以方便地捕获视频帧，但要显示图像，您通常仍然需要使用 OpenCV 或其他类似的库。 imutils 用于帮助处理图像和视频帧的读取、处理和转换，但它本身不提供图像显示的功能。所以在捕获和实时显示视频帧时，通常需要结合使用 imutils 和 OpenCV。

import time
import timeit
import cv2
from imutils.video import VideoStream

def capture_imutils(capture_frame_count):
    vs = VideoStream(src=0).start()  # 打开默认摄像头
    time.sleep(2.0)  # 等待摄像头预热

    frame_count = 0
    start_time = timeit.default_timer()

    while frame_count < capture_frame_count:
        frame = vs.read()
        cv2.imshow("Frame", frame)

        if cv2.waitKey(1) & 0xFF == 27:  # 按下 ESC 键退出
            break

        frame_count += 1

    end_time = timeit.default_timer()
    vs.stop()
    cv2.destroyAllWindows()

    elapsed_time = end_time - start_time
    frame_rate = frame_count / elapsed_time
    return frame_rate

if __name__ == "__main__":
    capture_frame_count = 100  # 指定捕获帧数
    frame_rate = capture_imutils(capture_frame_count)
    print("imutils Frame Rate:", frame_rate)

imutils Frame Rate: 100.61413256692732

此程序使用 imutils 打开摄像头，捕捉100帧并返回平均帧率。请将此代码保存为一个单独的Python文件并运行。

分析和总结：

根据提供的数据，imutils 明显具有最高的帧速率，远高于其他库。这可能是因为 imutils 专注于提供快速的计算机视觉函数。
Pygame 也表现出相对较高的帧速率，但低于 imutils。
OpenCV 和 PyQt5 的帧速率较低，但仍然足够处理许多计算机视觉和多媒体应用程序的需求。
帧速率的选择通常取决于您的应用程序要求。如果您需要更高的性能和实时处理，imutils 或 Pygame 可能是更好的选择。如果您开发桌面应用程序或不需要高帧速率，OpenCV 和 PyQt5 可能足够满足您的需求。

捕获屏幕帧

1. pyautogui Frame Capture

如果您想在代码中使用pyautogui，您需要导入pyautogui模块。以下是修改后的代码：

import cv2
import numpy as np
import timeit
import pyautogui

def capture_and_display_frames(num_frames):
    frame_count = 0
    start_time = timeit.default_timer()

    # 创建一个窗口来显示捕获的屏幕帧
    cv2.namedWindow("Screen Capture", cv2.WINDOW_NORMAL)

    while frame_count < num_frames:
        # 截取屏幕上的帧
        screenshot = pyautogui.screenshot()
        screenshot = np.array(screenshot)

        # 显示捕获的屏幕帧
        cv2.imshow("Screen Capture", cv2.cvtColor(screenshot, cv2.COLOR_BGR2RGB))
        frame_count += 1

        # 按下q键退出循环
        if cv2.waitKey(1) & 0xFF == ord('q'):
            break

    end_time = timeit.default_timer()
    elapsed_time = end_time - start_time
    frame_rate = frame_count / elapsed_time
    return frame_rate

if __name__ == "__main__":
    num_frames = 100
    frame_rate = capture_and_display_frames(num_frames)
    print(f"Frame Rate for {num_frames} frames: {frame_rate:.2f} FPS")

    # 关闭窗口并释放资源
    cv2.destroyAllWindows()

这段代码已经导入了pyautogui模块，并可以使用pyautogui来捕获屏幕帧。按下"q"键可以提前退出捕获过程。确保您已经安装了相关库，然后运行这段代码以执行所需的操作。

音频和视频捕捉

2. av Frame Capture

av 是一个多媒体处理库，它支持音频和视频捕捉。虽然它主要用于音视频处理，但也可以用于摄像头捕捉。以下是测试使用 av 打开摄像头并返回平均帧率的程序：

import av
import timeit

def capture_av():
    container = av.open("R.mp4")
    stream = container.streams.video[0]

    frame_count = 0
    start_time = timeit.default_timer()

    while frame_count < 100:
        frame = next(container.decode(stream))
        img = frame.to_image()
        # Process the captured frame as needed
        pass
        frame_count += 1

    end_time = timeit.default_timer()
    elapsed_time = end_time - start_time
    frame_rate = frame_count / elapsed_time
    return frame_rate

if __name__ == "__main__":
    frame_rate = capture_av()
    print("av Frame Rate:", frame_rate)

此程序使用 av 打开摄像头，捕捉100帧并返回平均帧率。请将此代码保存为一个单独的Python文件并运行。

接下来，我们将继续介绍使用 Twisted 和其他捕捉方法的程序。

python 2

SimpleCV Frame Capture

SimpleCV 是一个用于计算机视觉任务的库，它内置了摄像头捕捉和图像处理功能。以下是测试使用 SimpleCV 打开摄像头并返回平均帧率的程序：

from SimpleCV import Camera
import timeit

def capture_simplecv():
    camera = Camera()

    frame_count = 0
    start_time = timeit.default_timer()

    while frame_count < 100:
        image = camera.getImage()
        # Process the captured frame as needed
        pass
        frame_count += 1

    end_time = timeit.default_timer()
    elapsed_time = end_time - start_time
    frame_rate = frame_count / elapsed_time
    return frame_rate

if __name__ == "__main__":
    frame_rate = capture_simplecv()
    print("SimpleCV Frame Rate:", frame_rate)

此程序使用 SimpleCV 打开摄像头，捕捉100帧并返回平均帧率。请将此代码保存为一个单独的Python文件并运行。

总结

图像和视频帧捕获是计算机视觉和多媒体应用的基本组成部分。在Python中，有多种库和工具可供选择，适用于不同的需求和场景。本文提供了一个全面的指南，帮助读者了解不同的捕获方法，包括OpenCV、Pillow、Pygame、PyQt、imutils、av和SimpleCV。我们还强调了计算平均帧率的重要性，以评估性能。通过本文的指南，读者可以更好地选择适合其项目的图像和视频帧捕获方法，从而实现更高质量