Utilisation de l'oeil de poisson sur Raspberry Pi 3 avec ROS - Partie 1

Bonjour chers lecteurs de Habr. Il y a quelques années, j'ai écrit sur l'utilisation de la carte de caméra Raspberry Pi sur le Raspberry Pi en conjonction avec ROS. Dans cet article et le suivant, je voudrais parler de l'utilisation d'une caméra grand angle telle que fish eye sur le Raspberry Pi 3 avec Ubuntu 16.04 installé. À qui c'est intéressant je demande sous kat.

Pour commencer, pourquoi la caméra fish eye? J'ai vu de nombreux articles sur l'utilisation de caméras grand angle pour l'odométrie visuelle et SLAM. Grâce à l'angle de vue plus grand de l'œil de poisson, la caméra améliore la précision de l'odométrie visuelle. Je voulais donc essayer un de ces appareils photo avec Raspberry Pi avec prise en charge ROS. J'ai acheté un appareil photo avec un angle de 160 degrés sur dx.com pour 28 $. Le kit de caméra comprend également deux lampes IR pour la vision nocturne:



Dans le premier article, je parlerai de l'installation des pilotes nécessaires, OpenCV 3 et des packages pour prendre en charge la carte de caméra Raspberry Pi dans ROS.

Installation du pilote de caméra Fish Eye sur le Raspberry Pi 3

Commençons donc. Connectez-vous à RPi 3 via SSH:

ssh -Y <user>@<ip> 

Le paramètre -Y résout le problème d'obtention de l'erreur «Impossible de se connecter à l'affichage» lors du démarrage de certaines applications GUI (Qt, fenêtre avec l'image du programme OpenCV). Apprenez-en plus ici .

Tout d'abord, nous devons activer la prise en charge du pilote de l'appareil photo dans les paramètres de raspi-config Raspberry Pi. Dans Raspbian, ce service est déjà activé, dans Ubuntu vous devez l'installer:

 sudo apt-get install raspi-config 

Exécutez raspi-config:

 sudo raspi-config 

Sélectionnez l'option d'interfaçage, puis la caméra Pi et cliquez sur Oui. Et enfin terminer.
Vérifiez que la prise en charge de la caméra est activée à l'aide de l'utilitaire raspistill:

 raspistill -o mypicture.jpg 

Si vous obtenez l'erreur «La caméra n'est pas détectée. Veuillez vérifier soigneusement que le module de la caméra est correctement installé »vérifiez si vous avez correctement connecté la caméra au Raspberry Pi. Vous pouvez également redémarrer le système (cela m'a aidé).

Essayons d'enregistrer une vidéo:

 raspivid -o myvideo.h264 

J'ai obtenu une image sur un moniteur connecté à un Raspberry Pi. Je n'ai pas pu obtenir de popup sur mon ordinateur lors de la connexion via ssh.

Utilisation d'OpenCV 3 avec une caméra fish eye sur un Raspberry Pi

Installez la bibliothèque picamera [array]:

 pip install "picamera[array]" 

Installez les dépendances nécessaires pour OpenCV. Tout d'abord, mettez à jour le gestionnaire de packages apt et mettez à niveau les packages préinstallés:

 sudo apt-get update sudo apt-get upgrade 

Installez quelques bibliothèques:

 sudo apt-get install build-essential cmake pkg-config sudo apt-get install libjpeg8-dev libtiff5-dev libjasper-dev libpng12-dev sudo apt-get install libavcodec-dev libavformat-dev libswscale-dev libv4l-dev sudo apt-get install libxvidcore-dev libx264-dev sudo apt-get install libgtk-3-dev sudo apt-get install libatlas-base-dev gfortran sudo apt-get install python2.7-dev python3.5-dev 

Nous allons installer OpenCV 3 à partir des sources.

 cd ~ wget -O opencv.zip https://github.com/Itseez/opencv/archive/3.1.0.zip unzip opencv.zip 

Nous devons également télécharger le référentiel opencv_contrib:

 wget -O opencv_contrib.zip https://github.com/Itseez/opencv_contrib/archive/3.1.0.zip unzip opencv_contrib.zip 

Le fait est que dans les packages OpenCV 3 avec des descripteurs de fonctionnalités (tels que SIFT et SURF) ont été déplacés vers un référentiel de contributions distinct. Maintenant, pour utiliser les descripteurs de balises, nous devons télécharger le dépôt contrib séparément.

Maintenant, nous sommes enfin prêts à installer OpenCV. Nous pouvons exécuter cmake pour compiler OpenCV avec les paramètres nécessaires:

 cd ~/opencv-3.1.0/ mkdir build cd build cmake -D CMAKE_BUILD_TYPE=RELEASE \ -D CMAKE_INSTALL_PREFIX=/usr/local \ -D INSTALL_PYTHON_EXAMPLES=ON \ -D INSTALL_C_EXAMPLES=OFF \ -D OPENCV_EXTRA_MODULES_PATH=~/opencv_contrib-3.1.0/modules \ -D PYTHON_EXECUTABLE=~/.virtualenvs/cv/bin/python \ -D BUILD_EXAMPLES=ON .. 

Si cmake a réussi sans erreur, exécutez make:

 make -j4 

Lors de la compilation, j'ai eu une erreur "Erreur de segmentation". Si vous obtenez la même erreur, nettoyez pour supprimer les résultats de la compilation et faites avec un seul noyau:

 make clean make 

Il m'a fallu 3 heures pour compiler. Enfin, installez OpenCV 3:

 sudo make install sudo ldconfig 

Il y a une nuance intéressante liée à ROS Kinetic. Si vous installez Rin Kinetic, alors ROS ajoute le chemin d'accès aux bibliothèques Python (/opt/ros/kinetic/lib/python2.7/dist-packages) au chemin système lors de l'exécution de la commande source /opt/ros/kinetic/setup.bash. Cela entraîne des problèmes lors de l'installation ultérieure d'OpenCV à partir des sources (plus d'informations à ce sujet sont écrites ici ). Pour résoudre le problème, supprimez la ligne «source /opt/ros/kinetic/setup.bash» du fichier .bashrc. N'oubliez pas de courir:

 source ~/.bashrc 

Vérifions que OpenCV établit désormais correctement des liens depuis Python.
Créez un dossier pour le projet et un script de test simple:

 mkdir PiCamera && cd PiCamera vim test_cam.py 

Ajoutez le code suivant au fichier:

 from picamera.array import PiRGBArray from picamera import PiCamera import time import cv2 # initialize the camera and reference the raw camera capture camera = PiCamera() rawCapture = PiRGBArray(camera) # allow camera to warmup time.sleep(0.1) # grab an image camera.capture(rawCapture, format="bgr") image = rawCapture.array cv2.imshow("Capture", image) cv2.waitKey(0) 

Exécutez le script:

 python test_cam.py 

En cas de succès, nous obtenons quelque chose comme ceci:



Essayons maintenant d'enregistrer la vidéo de la caméra.

 vim test_videom.py 

Ajoutez le code suivant au fichier:

 # import the necessary packages from picamera.array import PiRGBArray from picamera import PiCamera import time import cv2 # initialize the camera and grab a reference to the raw camera capture camera = PiCamera() camera.resolution = (640, 480) camera.framerate = 32 rawCapture = PiRGBArray(camera, size=(640, 480)) # allow the camera to warmup time.sleep(0.1) # capture frames from the camera for frame in camera.capture_continuous(rawCapture, format="bgr", use_video_port=True): # grab the raw NumPy array representing the image, then initialize the timestamp # and occupied/unoccupied text image = frame.array # show the frame cv2.imshow("Frame", image) key = cv2.waitKey(1) & 0xFF # clear the stream in preparation for the next frame rawCapture.truncate(0) # if the `q` key was pressed, break from the loop if key == ord("q"): break 

Essayons quelque chose de plus intéressant, par exemple, ajoutons la détection des contours. J'utilise le détecteur de Kenny ici (code tiré d'ici ):

 from picamera.array import PiRGBArray from picamera import PiCamera import time import cv2 import numpy as np # initialize the camera and grab a reference to the raw camera capture camera = PiCamera() camera.resolution = (640, 480) camera.framerate = 32 rawCapture = PiRGBArray(camera, size=(640, 480)) # allow the camera to warmup time.sleep(0.1) # capture frames from the camera for frame in camera.capture_continuous(rawCapture, format="bgr", use_video_port=True): # grab the raw NumPy array representing the image, then initialize the timestamp # and occupied/unoccupied text image = frame.array hsv = cv2.cvtColor(image, cv2.COLOR_BGR2HSV) lower_red = np.array([30,150,50]) upper_red = np.array([255,255,180]) mask = cv2.inRange(hsv, lower_red, upper_red) res = cv2.bitwise_and(image,image, mask= mask) edges = cv2.Canny(res,100,200) # show the frame cv2.imshow("Frame", image) cv2.imshow("Edges", edges) key = cv2.waitKey(1) & 0xFF # clear the stream in preparation for the next frame rawCapture.truncate(0) # if the `q` key was pressed, break from the loop if key == ord("q"): break 

Voici le résultat de l'exécution du programme:

Ajout de la prise en charge de la caméra Raspberry Pi à ROS

Ajoutons maintenant la possibilité de travailler avec une caméra fish eye pour le Raspberry Pi de ROS. Tout d'abord, installez le pilote V4L2 nécessaire pour la caméra Raspberry Pi (vous pouvez en savoir plus ici ). Exécutez la commande:

 sudo rpi-update 

et redémarrez le système. Ajoutez maintenant le pilote:

 sudo modprobe bcm2835-v4l2 

Vérifiez que le périphérique / dev / video0 est disponible:

 ll /dev/video0 

La sortie sera comme ceci:

 crw-rw----+ 1 root video 81, 0 Mar 17 15:47 /dev/video0 

Téléchargez le package usb_cam:

 sudo apt-get install ros-kinetic-usb-cam source /opt/ros/kinetic/setup.bash 

Exécutez le maître ROS et rqt_image_view:

 roscore roslaunch usb_cam usb_cam-test.launch rosrun rqt_image_view rqt_image_view 

Sélectionnez le sujet / usb_cam / image_raw. Nous obtenons l'image suivante:



Maintenant, la caméra fish eye peut être utilisée avec n'importe quel package de vision par ordinateur dans ROS. La prochaine fois, nous essaierons de détecter des objets. Bonne chance à tous dans les expériences et à bientôt!