fbpixel
Installation d’OpenCV sur Raspberry Pi

Installation d’OpenCV sur Raspberry Pi

Pour effectuer le traitement d’image nous allons procéder à l’installation d’OpenCV sur Raspberry PI. OpenCV est une bibliothèque graphique libre qui permet d’effectuer du traitement d’image relativement simplement. Avec OpenCV, il est possible de traiter les images de la Pi Camera V2.

Matériel

  • Raspberry PI avec une distribution Linux (par exemple Raspbian).
  • Accès internet

Libérer de l’espace mémoire sur votre Raspberry Pi

Pour permettre l’installation d’OpenCV sur Raspbian, il vous faudra libérer de la place sur votre carte SD si elle n’a pas la capacité suffisante.

Ouvrez un terminal et tapez ces quelques commandes.

N.B.: Ces commandes vont supprimer définitivement les logiciels Wolfram et libre office.

## Désinstallation de Wolfram et libreoffice
sudo apt-get -y purge wolfram-engine 
sudo apt-get -y purge libreoffice*

sudo apt-get -y clean
sudo apt-get -y autoremove

sudo apt -y update
sudo apt -y upgrade

Vous pouvez verifier l’espace disponible avec la commande

df -h

Option 1 : Commande PIP

Pour certaine version d’OS, il est possible d’installer OpenCV pour Python assez simplement avec la commande pip

pip install opencv-python

Testé sur Raspberry Pi 3B+ avec Raspbian Bullseye

Si vous avez certaines librairies déjà installées, il peut y avoir des incompatibilités notamment avec numpy

Vous pouvez désinstaller puis réinstaller ou upgrader

pip install numpy --upgrade

ou des dépendances manquantes comme libatlas

sudo apt-get install libatlas-base-dev

Dans d’autres cas, il vous faudra compiler OpenCV à partir des fichiers sources.

Option 2 : Commande d’installation d’OpenCV

A partir de cette ligne nous allons créer un fichier .sh que nous allons rendre exécutable pour que toutes les commandes copiées dans le fichier .sh s’exécutent l’une après l’autre.

Placez vous sur votre bureau. Faites un clic droit ‘New file’ et donner le nom suivant : install.sh

Ouvrez ce fichier en double cliquant dessus. Par défaut il va s’ouvrir avec l’éditeur de texte de base de Raspbian.

Copier toutes les lignes de codes suivantes dans ce fichier. L’exécution de ces lignes va permettre de récupérer les fichiers sur un répertoire GIT, de créer les dépendances et de compiler OpenCV sur votre RaspberryPi.

sudo apt-get -y remove x264 libx264-dev

## Install dependencies
sudo apt-get -y install build-essential checkinstall cmake pkg-config yasm
sudo apt-get -y install git gfortran
sudo apt-get -y install libjpeg8-dev libjasper-dev libpng12-dev
sudo apt-get -y install libtiff5-dev
sudo apt-get -y install libtiff-dev
sudo apt-get -y install libavcodec-dev libavformat-dev libswscale-dev libdc1394-22-dev
sudo apt-get -y install libxine2-dev libv4l-dev
cd /usr/include/linux
sudo ln -s -f ../libv4l1-videodev.h videodev.h
cd $cwd
sudo apt-get -y install libgstreamer0.10-dev libgstreamer-plugins-base0.10-dev
sudo apt-get -y install libgtk2.0-dev libtbb-dev qt5-default
sudo apt-get -y install libatlas-base-dev
sudo apt-get -y install libmp3lame-dev libtheora-dev
sudo apt-get -y install libvorbis-dev libxvidcore-dev libx264-dev
sudo apt-get -y install libopencore-amrnb-dev libopencore-amrwb-dev
sudo apt-get -y install libavresample-dev
sudo apt-get -y install x264 v4l-utils

# Optional dependencies
sudo apt-get -y install libprotobuf-dev protobuf-compiler
sudo apt-get -y install libgoogle-glog-dev libgflags-dev
sudo apt-get -y install libgphoto2-dev libeigen3-dev libhdf5-dev doxygen

sudo apt-get -y install python3-dev python3-pip
sudo -H pip3 install -U pip numpy
sudo apt-get -y install python3-testresources


git clone https://github.com/opencv/opencv.git
cd opencv
git checkout $cvVersion
cd ..	 
git clone https://github.com/opencv/opencv_contrib.git
cd opencv_contrib
git checkout $cvVersion
cd ..

cd opencv
mkdir build
cd build

cmake -D CMAKE_BUILD_TYPE=RELEASE \-D CMAKE_INSTALL_PREFIX=$cwd/installation/OpenCV-"$cvVersion" \-D INSTALL_C_EXAMPLES=ON \-D INSTALL_PYTHON_EXAMPLES=ON \-D WITH_TBB=ON \-D WITH_V4L=ON \-D OPENCV_PYTHON3_INSTALL_PATH=$cwd/OpenCV-$cvVersion-py3/lib/python3.5/site-packages \-D WITH_QT=ON \-D WITH_OPENGL=ON \-D OPENCV_EXTRA_MODULES_PATH=../../opencv_contrib/modules \-D BUILD_EXAMPLES=ON ..

make -j$(nproc)
sudo make install

sudo sed -i 's/CONF_SWAPSIZE=1024/CONF_SWAPSIZE=100/g' /etc/dphys-swapfile
sudo /etc/init.d/dphys-swapfile stop
sudo /etc/init.d/dphys-swapfile start

Une fois copiées, lancez la commande suivante pour rendre exécutable le fichier que l’on vient de créer :

chmod +x install.sh

Maintenant nous allons exécuter ce fichier avec la commande suivante :

./install.sh

L’installation risque de prendre quelques heures sur RaspberryPi3, vous pouvez laisser tourner sans aucun souci.

Une fois les commandes finies, il ne vous reste plus qu’à taper les dernières commandes dans le terminal :

pip3 install opencv-python
sudo apt install libqtgui4
sudo apt install libqt4-test
pip install opencv-contrib-python==4.1.0.25

Une fois l’installation effectuée, pour vérifier que l’installation s’est bien faite, créez un fichier python avec uniquement la ligne de code suivante :

$ import cv2

Exécutez le fichier avec :

python3 NOM_DU_FICHIER

Applications

Sources

Détection d’une ligne avec Python et OpenCV

Détection d’une ligne avec Python et OpenCV

Une application intéressante en robotique est la reconnaissance de forme. Dans ce tutoriel nous allons utiliser la librairie OpenCV dans un code en Python qui permettra de détecter le centre d’une ligne. Afin de réaliser ce suivi de ligne nous allons effectuer du traitement d’image avec OpenCV.

Cela vous permettra ensuite de pouvoir réaliser votre régulation pour toujours garder le centre de la ligne au milieu de la caméra et donc suivre la trajectoire ! Nous avons donc décidé de réaliser ce tutoriel sur Raspberry Pi puisque ce tutoriel a pour vocation d’effectuer du traitement d’image pour un robot en utilisant la Pi Caméra.

Matériel

Mise en place

  • L’installation d’OpenCV sur Raspberry Pi
  • Une photo d’un câble ou ligne noire (par défaut télécharger la photo ci-dessous pour travailler sur le même exemple, elle a été prise avec la Pi Caméra)

Code

Pour commencer, afin que vous puissiez réutiliser la détection d’une ligne ou d’un câble sur une vidéo (succession d’images), nous allons implémenter une Classe. Cette classe prendra en paramètre le chemin de l’image. Par défaut si l’image se trouve dans le même dossier que le code il suffira de mettre le nom de l’image, par exemple : “cam.jpg”).

Ensuite, enregistrer le code python ci-dessous dans un fichier nommé : suivi_ligne.py

# -*- coding: utf-8 -*-
"""
@author: AranaCorp
"""
import cv2
import time
import numpy as np
import matplotlib.pyplot as plt


class LineTracking():
	"""
	Classe permettant le traitement d'image, la délimitation d'un contour et permet de trouver le centre de la
	forme detectée
	"""
	def __init__(self,img_file):
		"""The constructor."""
		self.img = cv2.imread(img_file)
		self.img_inter = self.img
		self.img_final = self.img
		self.cendroids = []
		self.mean_centroids = [0,0]

	def processing(self):
		"""Méthode permettant le traitement d'image"""
		#self.img=cv2.resize(self.img,(int(self.img.shape[1]*0.2),int(self.img.shape[0]*0.2))) #redimensionner l'image d'origine
		print(self.img.shape)
		#self.img = self.img[199:391, 149:505] #on recentre l'image en excluant les zones extérieures afin d'avoir une plus grande précision pour la suite
		gray = cv2.cvtColor(self.img, cv2.COLOR_BGR2GRAY) #on passe l'image en nuances de gris
		blur = cv2.GaussianBlur(gray,(5,5),0) #on floute l'image
		ret,thresh = cv2.threshold(blur,60,255,cv2.THRESH_BINARY_INV) #on binarise l'image

		self.img_inter=thresh
		"""Une ouverture permet d'enlever tous les élements qui sont plus petits que l'élement structurant (ou motif)
		Une fermeture permet de "combler" les trous qui ont une taille inférieur à l'élement structurant """
		kernel_open = cv2.getStructuringElement(cv2.MORPH_ELLIPSE,(5,5)) #on créé l'élement structurant de l'ouverture
		kernel_close = cv2.getStructuringElement(cv2.MORPH_ELLIPSE,(10,10)) #on créé l'élement structurant de la fermeture

		thresh = cv2.morphologyEx(thresh, cv2.MORPH_OPEN, kernel_open) #on fait une ouverture suivant un motif
		thresh = cv2.morphologyEx(thresh, cv2.MORPH_CLOSE, kernel_close) #on fait une fermeturesuivant un motif

		connectivity = 8

		output = cv2.connectedComponentsWithStats(thresh, connectivity, cv2.CV_32S) #permet de délimiter une forme
		num_labels = output[0]
		labels = output[1]
		stats = output[2]
		self.centroids = output[3] #donne les centres de la ou des formes de l'image

		for c in self.centroids :
			"""Permet de faire la moyenne des centres de la forme, en effet sur l'image test,
			   il y a deux centres qui sont très proches et la moyenne de deux convient.
			   On pourra imaginer que dans un cas général on modifie cela
			"""
			self.mean_centroids[0] += c[0]/len(self.centroids)
			self.mean_centroids[1] += c[1]/len(self.centroids)

		self.img_final = cv2.cvtColor(thresh, cv2.COLOR_GRAY2BGR)

		#permet de rajouter un carré rouge à l'endroit du centre de la forme
		#self.img_final[int(self.mean_centroids[1])-10 : int(self.mean_centroids[1])+20, int(self.mean_centroids[0])-10 : int(self.mean_centroids[0])+20] = [0,0,255]
		for c in self.centroids :
			self.img_final[int(c[1])-5 : int(c[1])+10, int(c[0])-5 : int(c[0])+10] = [0,255,0]

Enfin, créez un nouveau script python, par exemple : test_tracking.py

if __name__ == '__main__' :
	test = LineTracking('cam.png') #créer un objet LineTracking qui est la Classe créée au dessus .png ou .jpg
	test.processing() #lance le traitement d'image
	while True :
		cv2.imshow('image',test.img) #affiche l'image original après redimensionnement
		#cv2.imshow('process',test.img_inter ) #affiche l'image après traitement
		cv2.imshow('cable',test.img_final) #affiche l'image après traitement
		key= cv2.waitKey(1);
		if  key == ord(' '): #pour fermer les fenêtres appuyer sur la barre 'espace'
			break
	cv2.destroyAllWindows()

Vous avez maintenant tous les codes pour tester votre traitement d’image. Lancez dans un terminal la commande :

python3 test_tracking.py

Résultat

Deux fenêtres s’ouvre avec l’image originale et l’image traitée. On peut observer qu’un carré vert repère la position du câble. Ce point pourra être utilisé pour diriger un robot ou une caméra mobile.

Pour stopper l’affichage appuyer sur la barre “espace”.

Pour conclure, le traitement vient d’être effectué sur une image. Vous pouvez maintenant l’implémenter dans une boucle de traitement pour une vidéo.

Application

Vous pouvez maintenant utilisez la classe LineTracking dans votre fichier principal qui ouvre la caméra de la Raspberry. Pour plus d’informations sur l’installation d’une PiCam sur Raspberry Pi vous pouvez suivre notre tutoriel : gestion d’une PiCam avec Raspberry Pi

Source