OpenCV Zugriff auf die Kamera

OpenCV - Zugriff auf die Kamera

CV steht für Computer Vision -- also die Bilderkennung und -auswertung mithilfe von Computern. OpenCV ist eine Software-Bibliothek, die neben verschiedensten Algorithmen zu diesem Themengebiet auch praktische Utilities für Bildbearbeitung und Anzeige mitbringt.

Wie wir später sehen werden ist das Skript, um ein Livebild von der Kamera darzustellen, inklusive Reglern für Kontrast, Sättigung und Helligkeit, nur 50 Zeilen lang.

OpenCV ist für und in C/C++ geschrieben -- da wir aber keinem diese Sprache mit ihrer Komplexität zumuten möchten und der Raspberry Pi ohnehin nach der Programmiersprache Python benannt ist, nutzen wir die Python-Bindings.

Installation

DEBs (bevorzugt)

OpenCV wurde von uns bereits kompiliert und in ein Softwarepaket im Debian-Format gepackt (.deb). Diese müssen nun nur noch auf den Raspberry Pi heruntergeladen werden:

https://ch-st.de/assets/downloads/OpenCV-3.2.0-armv7l-libs.deb

https://ch-st.de/assets/downloads/OpenCV-3.2.0-armv7l-python.deb

Das erste Paket enthält die Software-Bibliothek, letzteres die Python-Bindings (Adapter). Um sie auf dem Raspberry Pi zu installieren, öffnet man eine Konsole und tippt folgendes ein:

$ curl -OO https://ch-st.de/assets/downloads/OpenCV-3.2.0-armv7l-{libs,python}.deb
$ sudo dpkg -i OpenCV-3.2.0-armv7l-libs.deb
$ sudo dpkg -i OpenCV-3.2.0-armv7l-python.deb

Kompilation

Natürlich lässt sich OpenCV auch aus dem Sourcecode erstellen -- Kompilieren. Es ist deutlich komplizierter und zeitaufwendiger.

Dependencies

Um OpenCV zu kompilieren, werden andere Softwarepakete benötigt, auf denen das Projekt aufbaut. Zu diesen gehört beispielsweise ein Compiler, diverse Buildtools wie cmake oder auch andere Softwarebibliotheken. Folgende Pakete werden für die Erstellung benötigt:

* build-essential    GNU Compiler Collection etc.
* cmake              Zur Erstellung von Makefiles
* pkg-config         findet Pakete und Compiler/Linker-Flags
* libjpeg-dev     ╮
* libtiff5-dev    │  Diverse Bildformate + Codecs
* libjasper-dev   │
* libpng12-dev    ╯
* libavcodec-dev     AVLibs für Videoen- und decoding
* libavformat-dev
* libswscale-dev
* libv4l-dev         Video 4 Linux
* libxvidcore-dev
* libx264-dev        H264 Video
* libgtk2.0-dev      GUI mit GTK
* libatlas-base-dev  Nur zur Optimierung
* gfortran  
* python3-dev        Headerdateien für Python 3
* python3-numpy      SciPy

Mit folgendem Kommando können sie installiert werden:

$ sudo apt update
$ sudo apt install build-essential cmake pkg-config libjpeg-dev libtiff5-dev libjasper-dev libpng12-dev libavcodec-dev libavformat-dev libswscale-dev libv4l-dev libxvidcore-dev libx264-dev libgtk2.0-dev libatlas-base-dev gfortran python3-dev python3-numpy

Jetzt wird es ernst:

$ tar xvf 3.2.0.tar.gz                               # [1]
$ cd opencv-3.2.0                                    
$ mkdir build                                        # [2]
$ cd build                                           
$ cmake -D CMAKE_BUILD_TYPE=RELEASE ..               # [3]
$ make -j 4                                          # [4]
$ cpack -R 3.2.0                                     # [5]
$ sudo make install                                  # [6]

Das Archiv mit dem Quellcode wird zuerst entpackt und geöffnet [1].

Dann wird in diesem ein Ordner build erstellt, in dem die kompilierten Dateien abgelegt werden [2].

Mit cmake werden dann die sogenannten Makefiles erstellt, die die Compiler-Anweisungen enthalten [3].

Diese Anweisungen werden mithilfe von make eingelesen und befolgt. Der -j 4 Switch gibt an, dass vier Prozesse gleichzeitig laufen sollen -- was der Anzahl der Kerne des Raspberry Pi entspricht [4]. Dennoch kann diese Anweisung rund eine Stunde dauern.

cpack packt dann die fertig kompilierten in Archive, wie beispielsweise .deb und .tar.gz [5]. -R gibt die Versionsnummer an. Diese befinden sich dann in dem aktuellen Verzeichnis(build) und lassen sich an andere weitergeben, damit sie nicht auch den ganzen Buildprozess durchstehen müssen.

Abschließend wird mit make install das Softwarepaket auf dem Rechner installiert [6].

Verwendung

Im /usr/lib/python3.4/site-packages Verzeichnis befindet sich nun eine cv2.cpython-34m.so Datei. Diese enthält nicht die ganze Softwarebibliothek, sondern verlinkt im Wesentlichen nur die Symbole mit Python.

Damit sie in Python importiert werden kann, muss der Interpreter sie erstmal finden. Deshalb kann man eine Umgebungsvariable PYTHONPATH definieren, die angibt, in welchen Verzeichnissen nach Python-Modulen gesucht werden soll. Folgende Anweisung startet den Python-Interpreter und gibt als Suchpfad das Verzeichnis unserer cv2.cpython-34m.so Datei an:

$ PYTHONPATH=/usr/lib/python3.4/site-packages python3

Hat alles geklappt, sollte der Interpreter uns mit einem dreifachen ">" begrüßen. Ein einfaches import cv2 importiert Funktionen und Klassen aus der OpenCV-Library - gibt es keine Fehlermeldung, ist alles geglückt.

Bevor wir allerdings richtig starten können, ist es sinnvoll, noch ein weiteres Softwarepaket zu installieren: imutils implementiert bereits einen wesentlichen Anteil unserer Belange.

$ sudo pip3 install imutils

Das war aber dann auch die letzte Installation -- versprochen. Zeit, eine einfache Anzeige für Bilder der Kamera zu schreiben!

Einfache (Live-)Bildanzeige

Nachdem python wie oben angegeben gestartet wurde, müssen die Bibliotheken importiert werden:

import cv2
from imutils.video.pivideostream import PiVideoStream
stream = PiVideoStream()

Mithilfe des imutils Pakets wurde ein Objekt stream vom Typ PiVideoStream erzeugt -- wofür diese Klasse zuständig, ist wohl selbsterklärend.

stream.start()
frame = stream.read()
frame

Nachdem der Videostream gestartet wurde, kann das aktuelle Bild mit read() ausgelesen werden. frame ist ein einfaches Array von Zahlenwerten -- was zu erwarten war.

cv2.imshow("Frame", frame)
cv2.waitKey()

Mit OpenCV kann dieses Bild auch angezeigt werden: Ein Fenster mit dem Titel "Frame" taucht auf, sobald die waitKey Methode ausgeführt wurde. Diese wartet nicht einfach nur auf eine Tasteneingabe, sondern sorgt auch dafür, dass das Fenster angezeigt wird. Mit einem Tastendruck können weitere Eingaben im Interpreter gemacht werden.

Obige Routine lässt sich wiederholen, um das nächste Bild von der Kamera anzuzeigen.

cv2.destroyAllWindows()
s.stop()
exit()

Damit werden alle Fenster geschlossen, der Stream geschlossen und Python beendet -- Weniger als 10 Zeilen um Bilder anzuzeigen ist ein ganz guter Wert.

PiCamView

Damit einige Kamera-Einstellungen über ein Interface verfügbar sind, folgt ein Skript, das den Videostream live anzeigt und manipulierbar macht. Um es zu beenden genügt ein einfaches Q

import sys
sys.path.insert(0, "/usr/lib/python3.4/site-packages")
import time
import cv2
from picamera import PiCamera
from imutils.video.pivideostream import PiVideoStream
from imutils.video import FPS
from imutils import resize

stream = PiVideoStream(resolution=(1280,720))
stream.start()
time.sleep(2)

def set_brightness(val):
	stream.camera.brightness = val
def set_contrast(val):
	# Ranges from -100 to 100
	stream.camera.contrast = val*2-100
def set_saturation(val):
	# Ranges from -100 to 100
	stream.camera.saturation = val*2-100

# Construct Window
cv2.namedWindow("Raspi Cam", cv2.WINDOW_NORMAL)
cv2.namedWindow("trackbars", cv2.WINDOW_NORMAL)
#cv2.setWindowProperty("Raspi Cam", cv2.WND_PROP_FULLSCREEN, cv2.WINDOW_FULLSCREEN)
cv2.moveWindow("trackbars", 100, 100)
cv2.createTrackbar("brightness", "trackbars", 50, 100, set_brightness)
cv2.createTrackbar("contrast", "trackbars", 50, 100, set_contrast)
cv2.createTrackbar("saturation", "trackbars", 50, 100, set_saturation)

fps = FPS()
fps.start()
while True:
	frame = stream.read()
	frame = resize(frame, width=400)
	cv2.imshow("Raspi Cam", frame)
	if cv2.waitKey(1) == ord('q'):
		break

	fps.update()
fps.stop()
print('Done in {:3f} seconds'.format(fps.elapsed()))
print('%f FPS on average' % fps.fps())

cv2.destroyAllWindows()
stream.stop()