Module de vision embarquée

La vision industrielle classique continue d’évoluer très rapidement vers la vision embarquée. Les systèmes compacts, pour lesquels le facteur coût joue un rôle essentiel, consomment moins d’énergie et leurs capacités ne cessent d’augmenter. Cependant, le développement d’un appareil de vision embarquée peut être très gourmand en temps et en argent. Les limites de ces appareils hautement spécialisés résident cependant dans leurs interfaces, leurs performances, l’espace mémoire ainsi que leurs options d’affichage et de saisie, qui compliquent nettement la manipulation matérielle et le développement logiciel par comparaison à une station de travail de bureau dotée de composants standard. Rien que dans le cadre de développements internes (plateforme matérielle, firmware et logiciel), il faut consacrer beaucoup de temps, entre autres choses, avant de pouvoir constater les premiers résultats.

Pourtant, dès la phase de pré-développement, il existe aujourd’hui une série de composants standard intégrés et adaptés qui permet de réaliser immédiatement les premiers tests. Ces composants associés à des solutions logicielles adéquates permettent d’arriver très rapidement aux premiers résultats de la future application de vision.

Notre astuce technique montre en quelques étapes claires comment réaliser une application de vision embarquée simple avec une caméra uEye et un Raspberry Pi 3.

Application de vision embarquée avec interface uEye Python et OpenCV
Application de vision embarquée avec interface uEye Python et OpenCV

Étape 1 : préparation du matériel

Installez un Raspberry Pi 3 avec le système d’exploitation Raspbian et actualisez le système avec la dernière version logicielle.

pi@raspberrypi:~ $ sudo apt-get update && apt-get upgrade

Vous trouverez sur Internet des instructions pour installer un Raspberry Pi. Théoriquement, vous pouvez utiliser pour la démonstration n’importe quelle autre carte intégrée compatible ARMv7 (p. ex. Odroid XU4). Cependant, le Raspberry Pi3, avec son processeur quadricœur, a suffisamment de puissance pour réaliser des tests de traitement d’image simples, et le système d’exploitation Raspbian n’est pas en reste avec les composants requis pré-installés. L’ensemble se réinstalle très aisément avec les paquets source.

Raccordez une caméra USB uEye à un port USB du Raspberry Pi.

pi@raspberrypi:~ $ sudo pip install pyueye

L’interface uEye Python est alors installée sur le système et peut être utilisée avec Python 2.7. Les dépendances de module nécessaires sont directement installées en même temps par le PIP. Pour vérifier si l’installation est correcte, démarrez l’interpréteur Python et importez le module uEye.

pi@raspberrypi:~ $ python
Python 2.7.9 (default, Sep 17 2016, 20:26:04)
[GCC 4.9.2] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> from pyueye import ueye
>>>

Si aucun message d’erreur ne s’affiche, l’installation a réussi.

Étape 3 : installation d’OpenCV

Les bibliothèques de développement OpenCV s’installent très simplement à partir des paquets source Raspbian. Il s’agit en fait d’une version antérieure (2.4.9.1), mais qui suffit amplement pour notre démonstration. La liaison Python des bibliothèques OpenCV pour Python 2.7 se trouve également dans les paquets source. Pour une utilisation avec Python 3, vous devez les compiler vous-même à partir du code source pour la plateforme intégrée. Vous trouverez aussi sur Internet des instructions simples à ce sujet.

pi@raspberrypi:~ $ sudo apt-get install libopencv-dev python-opencv

Vous pouvez également contrôler cette installation dans l’interpréteur Python en important le module OpenCV « cv2 ».

Étape 4 : téléchargement d’un exemple d’application PyuEye et test

Comme point de départ de vos propres applications de traitement d’image avec uEye et l’interface Python, téléchargez l’exemple de code source sous forme de lien sur la page Web Astuce technique et dézippez-le dans un répertoire quelconque de votre Raspberry Pi.

L’exemple de code source a été entièrement créé dans Python. Par conséquent, vous n’avez pas besoin d’effectuer de compilation croisée pour l’architecture système (ARMv7 A) du Raspberry Pi. Vous pouvez l’exécuter directement grâce à l’interpréteur Python. Il ne dépend pas de la plateforme. Cela signifie que vous pouvez aussi exécuter cet exemple de code source sur un système informatique Windows ou Linux si les configurations préalables requises (pilote uEye, interface PyuEye, Python 2.7) sont présentes sur ce système.

L’exemple de code source PyuEye est réparti dans quatre fichiers Python, qui fournissent les classes et fonctionnalités aux différentes parties du programme de démonstration :

1) pyueye_example_camera.py

Met à disposition la classe « Camera » avec les fonctions fréquemment utilisées pour manipuler la caméra.

2) pyueye_example_gui.py

Avec les classes « PyuEyeQtView » et « PyuEyeQtApp », vous pouvez créer un widget Qt simple, et donc, le cadre d’une application GUI. Ce module repose sur Qt4 et utilise en conséquence les bindings Qt4 Python (PyGt4). Qt4 est déjà intégré à la version Jessie de Raspbian. Vous pouvez installer les bindings Python via les paquets source :

pi@raspberrypi:~ $ sudo apt-get install python-qt4 python-qt4-doc

3) pyueye_example_utils.py

Ce module fournit des fonctions et des classes Convenience importantes, qui sont très utiles pour traiter une application de caméra. Tout est là : de la gestion des exceptions (Exception-Handling) au traitement des données de caméra et des mémoires d’images.

4) pyueye_example_main.py

Le module principal crée une structure d’application Qt simple, active et initialise la caméra raccordée et met à votre disposition une fonction de rappel de traitement d’image (Image Processing Callback), qui permet de traiter aisément les images avec OpenCV. Si vous exécutez la démonstration, vous verrez l’image en direct de la caméra raccordée et les résultats du traitement des images.

pi@raspberrypi:~/example $ python pyueye_example_main.py

Traitement des images OpenCV

Notre traitement simple des images avec OpenCV recherche des cercles dans l’image et les repère.

Quelques lignes de code dans le module principal suffisent, car OpenCV comporte pour cette tâche une implémentation complète avec la fonction cv2.HoughCircles, que nous utilisons à cette fin. Pour pouvoir travailler avec OpenCV, « cv2 » et « numpy » ont été importés :

from pyueye_example_camera import Camera
from pyueye_example_utils import FrameThread
from pyueye_example_gui import PyuEyeQtApp, PyuEyeQtView
from PyQt4 import QtGui

from pyueye import ueye

import cv2
import numpy as np
def process_image(self, image_data):

    # reshape the image data as 1dimensional array
    image = image_data.as_1d_image()    
    # make a gray image
    image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
    #image = cv2.medianBlur(image,5)
    # find circles in the image
    circles = cv2.HoughCircles(image, cv2.cv.CV_HOUGH_GRADIENT, 1.2, 100)
    # make a color image again to mark the circles in green
    image = cv2.cvtColor(image, cv2.COLOR_GRAY2BGR)
    
    if circles is not None:
	   # convert the (x, y) coordinates and radius of the circles to integers
	   circles = np.round(circles[0, :]).astype("int") 
	   # loop over the (x, y) coordinates and radius of the circles
	   for (x, y, r) in circles:
		  # draw the circle in the output image, then draw a rectangle
		  # corresponding to the center of the circle
		  cv2.circle(image, (x, y), r, (0, 255, 0), 6)
    
    # show the image with Qt
    return QtGui.QImage(image.data,
                        image_data.mem_info.width,
                        image_data.mem_info.height,
                        QtGui.QImage.Format_RGB888)
OpenCV trouve et re-père des cercles dans les données gra-phiques.
OpenCV trouve et re-père des cercles dans les données graphiques.

Typiquement avec Python, vous pouvez exécuter directement l’application modifiée. Vous pouvez apporter d’autres modifications à l’application sans trop d’efforts et tester d’autres tâches de traitement avec OpenCV.