Capturer de la vidéo à partir de deux caméras dans OpenCV à la fois

Comment capturer de la vidéo à partir de deux ou plusieurs caméras à la fois (ou presque) avec OpenCV, à l'aide de l'API Python?

J'ai trois webcams, tous capables de vidéo en streaming, situé à /dev/video0, /dev/video1, et /dev/video2.

À l'aide de la tutoriel comme un exemple, la capture d'images à partir d'une seule caméra est tout simplement:

import cv2
cap0 = cv2.VideoCapture(0)
ret0, frame0 = cap0.read()
cv2.imshow('frame', frame0)
cv2.waitKey()

Et cela fonctionne bien.

Cependant, si j'essaie d'initialiser une deuxième caméra, en essayant de read() de il retourne Aucun:

import cv2
cap0 = cv2.VideoCapture(0)
cap1 = cv2.VideoCapture(1)
ret0, frame0 = cap0.read()
assert ret0 # succeeds
ret1, frame1 = cap1.read()
assert ret1 # fails?!

Juste pour m'assurer que je n'étais pas accidentellement donnant OpenCV un mauvais appareil de l'index, j'ai testé chaque caméra index individuellement et ils fonctionnent tous par eux-mêmes. par exemple,

import cv2
#cap0 = cv2.VideoCapture(0)
cap1 = cv2.VideoCapture(1)
#ret0, frame0 = cap0.read()
#assert ret0
ret1, frame1 = cap1.read()
assert ret1 # now it works?!

Ce que je fais mal?

Edit: Mon matériel est un Macbook Pro sous Ubuntu. Des recherches sur la question spécifiquement sur les Macbooks, j'ai trouvé d'autres personnes qui ont rencontré ce problème aussi, à la fois sur OSX et avec différents types de caméras. Si j'ai accès à l'iSight, les deux appels dans mon code échouer.

Si vous modifiez l'ordre de la videoCapture déclarations de l'erreur se produit sur l'autre canal?
Cela semble fonctionner très bien pour moi sur windows.
Sont les caméras à la fois intégré ou USB? Il est possible qu'ils ne peuvent pas fonctionner en même temps, si ils sont sur le même bus série parce que un bus série, de série.
c'est une question de saturation. usb2 peine à gérer le débit d'une simple webcam, si vous voulez exécuter plusieurs cams, vous avez besoin de plus (indépendant) les contrôleurs usb. pc classique est généralement eu un avant , et un autre dans le dos
J'ai parlé trop vite. Il s'avère read() fonctionne avec de multiples caméras quand je l'ai mis à 160x120. Je suppose que c'est entièrement une largeur de bande d'émission.

OriginalL'auteur Cerin | 2015-04-16

5

Oui, vous êtes certainement limitée par la bande passante du bus USB. Tenter de lire les deux appareils à pleine-rez vous avez probablement eu une erreur:
```
libv4l2: error turning on stream: No space left on device
VIDIOC_STREAMON: No space left on device
Traceback (most recent call last):
  File "p.py", line 7, in <module>
    assert ret1 # fails?!
AssertionError
```
Et puis quand vous réduisez le res à 160x120:
```
import cv2
cap0 = cv2.VideoCapture(0)
cap0.set(3,160)
cap0.set(4,120)
cap1 = cv2.VideoCapture(1)
cap1.set(3,160)
cap1.set(4,120)
ret0, frame0 = cap0.read()
assert ret0 # succeeds
ret1, frame1 = cap1.read()
assert ret1 # fails?!
```
maintenant, il semble fonctionner! Je parie que vous avez tous les deux cames connecté sur la même carte USB. Vous pouvez exécuter lsusb commande pour vous assurer, et il doit l'indiquer quelque chose comme:
```
Bus 001 Device 006: ID 046d:081b Logitech, Inc. Webcam C310
Bus 001 Device 004: ID 0409:005a NEC Corp. HighSpeed Hub
Bus 001 Device 007: ID 046d:0990 Logitech, Inc. QuickCam Pro 9000
Bus 001 Device 005: ID 0409:005a NEC Corp. HighSpeed Hub
Bus 001 Device 003: ID 0409:005a NEC Corp. HighSpeed Hub
Bus 001 Device 002: ID 1058:0401 Western Digital Technologies, Inc. 
Bus 001 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub
Bus 003 Device 001: ID 1d6b:0001 Linux Foundation 1.1 root hub
Bus 002 Device 001: ID 1d6b:0001 Linux Foundation 1.1 root hub
```
(Notez les deux appareils sur le même bus.) Si possible, vous pouvez ajouter une autre carte USB à votre ordinateur pour obtenir plus de bande passante. J'ai fait cela avant, afin d'exécuter plusieurs cames en pleine résolution sur une seule machine. Mais c'était un tour de la station de travail avec les slots de la carte mère, et, malheureusement, vous ne pouvez pas avoir cette option sur un MacBook ordinateur portable.

Bizarrement, ça ne fonctionne pas toujours à 160x120. J'ai acheté 6 identique à bas prix des webcams et avec certaines combinaisons de caméras, la réduction de la résolution fonctionne très bien, et avec d'autres combinaisons de caméras, ils ne parviennent toujours pas.
Il peut dépendre de ce que la résolution native de votre webcam prend en charge. Essayez d'exécuter v4l2-ctl --all ou v4l-info ou v4l-conf ou d'autres personnes à trouver un peu de res votre cames en charge, puis de travailler votre chemin jusqu'à l'échec.

OriginalL'auteur Velimir Mlaker

À l'aide d'OPENCV et de deux caméras USB, j'ai été capable de faire cela en utilisant le multithreading. Essentiellement, définir une fonction qui ouvre un opencv fenêtre et VideoCapture élément. Ensuite, on crée deux threads avec l'ID de la caméra et le nom de la fenêtre en tant qu'entrées.

import cv2
import threading

class camThread(threading.Thread):
    def __init__(self, previewName, camID):
        threading.Thread.__init__(self)
        self.previewName = previewName
        self.camID = camID
    def run(self):
        print "Starting " + self.previewName
        camPreview(self.previewName, self.camID)

def camPreview(previewName, camID):
    cv2.namedWindow(previewName)
    cam = cv2.VideoCapture(camID)
    if cam.isOpened():  # try to get the first frame
        rval, frame = cam.read()
    else:
        rval = False

    while rval:
        cv2.imshow(previewName, frame)
        rval, frame = cam.read()
        key = cv2.waitKey(20)
        if key == 27:  # exit on ESC
            break
    cv2.destroyWindow(previewName)

# Create two threads as follows
thread1 = camThread("Camera 1", 1)
thread2 = camThread("Camera 2", 2)
thread1.start()
thread2.start()

Grande ressource pour l'apprentissage de threads en python: https://www.tutorialspoint.com/python/python_multithreading.htm

Cela ne fonctionne pas pour moi, la vidéo de la fenêtre pop-up s'ouvre et le gris.
Ne ce ne viennent que lorsque vous essayez de multi-thread? Peut-être l'adresse de la caméra (port usb de l'adresse) que vous demandez est mal, certains ordinateurs ont différentes usb mappage d'adresses. [Désolé pour la réponse tardive]

OriginalL'auteur TheoreticallyNick

2

J'ai utiliser "imutils" et de lire show webcam sur l'image.

importation imutils

capture vedio cadres

--- WebCam1

cap = cv2.VideoCapture(0)
la pac.set(cv2.CAP_PROP_FRAME_WIDTH,300)
la pac.set(cv2.CAP_PROP_FRAME_HEIGHT,300)

--- WebCam2

cap1 = cv2.VideoCapture(1)
cap1.set(cv2.CAP_PROP_FRAME_WIDTH,300)
cap1.set(cv2.CAP_PROP_FRAME_HEIGHT,300)

--- WebCam3

cap2 = cv2.VideoCapture(2)
cap2.set(cv2.CAP_PROP_FRAME_WIDTH,300)
cap2.set(cv2.CAP_PROP_FRAME_HEIGHT,300)

--- WebCame4

cap3 = cv2.VideoCapture(3)
cap3.set(cv2.CAP_PROP_FRAME_WIDTH,300)
cap3.set(cv2.CAP_PROP_FRAME_HEIGHT,300)

j'ai crée une fonction read_frame() envoyer un paramètre à propos de l'Image.fromarray et affichage

def read_frame():
webCameShow(cap.read(),display1)
webCameShow(cap1.read(),display2)
webCameShow(cap2.read(),display6)
webCameShow(cap3.read(),display7)

de la fenêtre.après(10, read_frame)

et finale de montrer la fonction vidéo sur le "imageFrame"

def webCameShow(N,Affichage):
_, frameXX = N
cv2imageXX = cv2.cvtColor(frameXX, cv2.COLOR_BGR2RGBA)
imgXX = Image.fromarray(cv2imageXX)
#imgtkXX = ImageTk.PhotoImage(image=imgXX)
D'affichage.imgtk = imgtkXX
D'affichage.configurer(image=imgtkXX)

exemple.
4-webcam

Youtube:
Youtube

OriginalL'auteur บัวลอย แสนดี
0

Cela a été une douleur pour moi un long moment, j'ai donc fait une bibliothèque sur le dessus de OpenCV pour gérer plusieurs caméras et les fenêtres. Je suis tombé sur un tas de problèmes comme des vidéos sans compression par défaut, ou windows uniquement de l'affichage dans le thread principal. Je suis capable d'afficher deux 720p webcams en temps réel sur Windows jusqu'à présent.

Essayer:
```
pip install CVPubSubs
```
Puis, en python:
```
import cvpubsubs.webcam_pub as w
from cvpubsubs.window_sub import SubscriberWindows

t1 = w.VideoHandlerThread(0)
t2 = w.VideoHandlerThread(1)

t1.start()
t2.start()

SubscriberWindows(window_names=['cammy', 'cammy2'],
              video_sources=[0,1]
              ).loop()

t1.join()
t1.join()
```
C'est relativement nouveau mais, dites-moi tout de bugs ou unoptimized code.

OriginalL'auteur SimLeek

essayez d'utiliser ce code...
il a travaillé comme prévu...
c'est pour les deux cams,si vous voulez encore plus de caméras, il suffit de créer le "VideoCapture()" objets...par exemple, 3ème cam : cv2.VideoCapture(3) et le code correspondant dans la boucle while

import cv2

frame0 = cv2.VideoCapture(1)
frame1 = cv2.VideoCapture(2)
while 1:

   ret0, img0 = frame0.read()
   ret1, img00 = frame1.read()
   img1 = cv2.resize(img0,(360,240))
   img2 = cv2.resize(img00,(360,240))
   if (frame0):
       cv2.imshow('img1',img1)
   if (frame1):
       cv2.imshow('img2',img2)

   k = cv2.waitKey(30) & 0xff
   if k == 27:
      break

frame0.release()
frame1.release()
cv2.destroyAllWindows()

TOUT LE MEILLEUR !

OriginalL'auteur Sajil Vohra

frame0 = cv2.VideoCapture(1)
frame1 = cv2.VideoCapture(2)

doit être:

frame0 = cv2.VideoCapture(0)  # index 0
frame1 = cv2.VideoCapture(1)  # index 1

De sorte qu'il s'exécute

OriginalL'auteur Gio Lac Cagliari

L'ajout d'un peu de ce que @TheoreticallyNick posté plus tôt:

import cv2
import threading

class camThread(threading.Thread):
    def __init__(self, previewName, camID):
        threading.Thread.__init__(self)
        self.previewName = previewName
        self.camID = camID
    def run(self):
        print("Starting " + self.previewName)
        camPreview(self.previewName, self.camID)

def camPreview(previewName, camID):
    cv2.namedWindow(previewName)
    cam = cv2.VideoCapture(camID)
    if cam.isOpened():
        rval, frame = cam.read()
    else:
        rval = False

    while rval:
        cv2.imshow(previewName, frame)
        rval, frame = cam.read()
        key = cv2.waitKey(20)
        if key == 27:  # exit on ESC
            break
    cv2.destroyWindow(previewName)

# Create threads as follows
thread1 = camThread("Camera 1", 0)
thread2 = camThread("Camera 2", 1)
thread3 = camThread("Camera 3", 2)

thread1.start()
thread2.start()
thread3.start()
print()
print("Active threads", threading.activeCount())

Cela permettra d'ouvrir un nouveau thread pour chaque webcam que vous avez. Dans mon cas, j'ai voulu ouvrir trois aliments différents. Testé sur Python 3.6. Laissez-moi savoir si vous avez des questions, merci également à TheoreticallyNick pour le lisible et le fonctionnement de code!

OriginalL'auteur Jacob W. Dallas

Vous devez vous connecter pour publier un commentaire.

--- WebCam1

--- WebCam2

--- WebCam3

--- WebCame4