Lire des Images à partir de Flux RTSP en Python

En fonction du type de flux, vous pouvez probablement prendre un coup d'oeil à ce projet pour quelques idées.

https://code.google.com/p/python-mjpeg-over-rtsp-client/

Si vous voulez être méga-pro, vous pouvez utiliser quelque chose comme http://opencv.org/ (modules Python disponible je crois) pour le traitement de la détection de mouvement.

OriginalL'auteur synthesizerpatel

À l'aide de la même méthode que celle décrite par "depu" a fonctionné parfaitement pour moi.
J'ai juste remplacé le "fichier vidéo" avec "RTSP" URL de la caméra.
L'exemple ci-dessous travaillé sur l'AXE de la Caméra IP.
(Ce n'était pas de travailler pour un tandis que dans les versions précédentes de OpenCV)
Fonctionne sur OpenCV 3.4.1 Windows 10)

import cv2
cap = cv2.VideoCapture("rtsp://root:[email protected]:554/axis-media/media.amp")

while(cap.isOpened()):
    ret, frame = cap.read()
    cv2.imshow('frame', frame)
    if cv2.waitKey(20) & 0xFF == ord('q'):
        break
cap.release()
cv2.destroyAllWindows()

OriginalL'auteur venkat

Ici est encore une option de plus

C'est beaucoup plus compliqué que les autres réponses. :-O

Mais de cette façon, avec une seule connexion à la caméra, de "la fourchette", le même flux simultanément à plusieurs multiprocesses, à l'écran, la refonte en multidiffusion, de l'écrire sur le disque, etc.

.. bien sûr, juste au cas où vous auriez besoin de quelque chose comme ça (sinon, vous préférez le plus tôt réponses)

Nous allons créer deux indépendants python programmes:

(1) programme Serveur (connexion rtsp, décodage) server.py

(2) programme Client (lit d'images à partir de la mémoire partagée) client.py

Serveur doit être démarré avant que le client, c'est à dire

python3 server.py

Et puis dans un autre terminal:

python3 client.py

Voici le code:

(1) server.py

import time
from valkka.core import *

# YUV => RGB interpolation to the small size is done each 1000 milliseconds and passed on to the shmem ringbuffer
image_interval=1000  
# define rgb image dimensions
width  =1920//4
height =1080//4
# posix shared memory: identification tag and size of the ring buffer
shmem_name    ="cam_example" 
shmem_buffers =10 

shmem_filter    =RGBShmemFrameFilter(shmem_name, shmem_buffers, width, height)
sws_filter      =SwScaleFrameFilter("sws_filter", width, height, shmem_filter)
interval_filter =TimeIntervalFrameFilter("interval_filter", image_interval, sws_filter)

avthread        =AVThread("avthread",interval_filter)
av_in_filter    =avthread.getFrameFilter()
livethread      =LiveThread("livethread")

ctx =LiveConnectionContext(LiveConnectionType_rtsp, "rtsp://user:[email protected]", 1, av_in_filter)

avthread.startCall()
livethread.startCall()

avthread.decodingOnCall()
livethread.registerStreamCall(ctx)
livethread.playStreamCall(ctx)

# all those threads are written in cpp and they are running in the
# background.  Sleep for 20 seconds - or do something else while
# the cpp threads are running and streaming video
time.sleep(20)

# stop threads
livethread.stopCall()
avthread.stopCall()

print("bye") 

(2) client.py

import cv2
from valkka.api2 import ShmemRGBClient

width  =1920//4
height =1080//4

# This identifies posix shared memory - must be same as in the server side
shmem_name    ="cam_example"
# Size of the shmem ringbuffer - must be same as in the server side
shmem_buffers =10              

client=ShmemRGBClient(
name          =shmem_name,
n_ringbuffer  =shmem_buffers,
width         =width,
height        =height,
mstimeout     =1000,        # client timeouts if nothing has been received in 1000 milliseconds
verbose       =False
) 

while True:
index, isize = client.pull()
if (index==None):
    print("timeout")
else:
    data =client.shmem_list[index][0:isize]
    img =data.reshape((height,width,3))
    img =cv2.GaussianBlur(img, (21, 21), 0)
    cv2.imshow("valkka_opencv_demo",img)
    cv2.waitKey(1)

Si vous êtes intéressé, consultez certains plus de https://elsampsa.github.io/valkka-examples/

OriginalL'auteur El Sampsa