APPLI

CATIO
NS DE
COMP
UTER
VISION
AVEC
RASPB
ERRY
PI
I.INTRODUCTION GENERALE :
*COMPUTER VISION, C’EST QUOI ?
La vision par ordinateur est le domaine de
l'informatique qui se concentre sur la création de
systèmes numériques capables de traiter, d'analyser
et de donner un sens aux données visuelles (images
ou vidéos) de la même manière que les humains.
Le concept de vision par ordinateur est basé sur
l'apprentissage des ordinateurs pour traiter une
image au niveau du pixel et la comprendre.
Techniquement, les machines tentent de récupérer
des informations visuelles, de les gérer et
d'interpréter les résultats grâce à des algorithmes
logiciels spéciaux.

*COMMENT CA FONCTIONNE ?

La technologie de vision par ordinateur a tendance à

imiter le fonctionnement du cerveau humain. Mais
comment notre cerveau résout-il la reconnaissance
visuelle des objets ? L'une des hypothèses les plus
courantes stipule que notre cerveau s'appuie sur des
modèles pour décoder des objets individuels. Ce
concept est utilisé pour créer des systèmes de vision
par ordinateur.

Les algorithmes de vision par ordinateur que nous

utilisons aujourd'hui sont basés sur la reconnaissance
de formes. Nous formons les ordinateurs sur une
quantité massive de données visuelles - les
ordinateurs traitent les images, étiquettent les objets
dessus et trouvent des motifs dans ces objets. Par
exemple, si nous envoyons un million d'images de
fleurs, l'ordinateur les analysera, identifiera des
motifs similaires à toutes les fleurs et, à la fin de ce
processus, créera un modèle de «fleur». En
conséquence, l'ordinateur sera en mesure de détecter
avec précision si une image particulière est une fleur
à chaque fois que nous leur envoyons des images.

*DOMAINES D’UTILISATION :
Classification d'objets : Le système analyse le
contenu visuel et classe l'objet sur une photo / vidéo
dans la catégorie définie. Par exemple, le système
peut trouver un chien parmi tous les objets de
l'image.
Identification des objets : Le système analyse le
contenu visuel et identifie un objet particulier sur une
photo / vidéo. Par exemple, le système peut trouver
un chien spécifique parmi les chiens de l'image.
Suivi d'objets : Le système traite la vidéo trouve
l'objet (ou les objets) qui correspondent aux critères
de recherche et suit son mouvement.

Les systèmes de vision humaine et de vision par

ordinateur traitent les données visuelles de la même
manière.

II. MATERIEL UTILISE :

1. CARTE RASPBERRY PI 4 :
Le Raspberry Pi est un nano-
ordinateur monocarte à processeur ARM de la
taille d'une carte de crédit conçu par des
professeurs du département informatique de
l'université de Cambridge dans le cadre de
la fondation Raspberry Pi .
 *Comparaison entre les différents modèles*

2.MODELE CAMERA PI V2 :

C’est un module miniature avec une définition de 5
Mégapixels et 1080p en vidéo. La caméra se
branche sur le connecteur CSI existant sur la carte
Raspberry Pi. Elle convient pour Raspberry Pi
modèle A ou B.
Caractéristiques :
 Capteur Omnivision 5647 avec objectif à
focale fixe
 Capteur 5 Mégapixels
 Résolution photo : 2592 x 1944
 Résolution vidéo maximum : 1080p
 Images par seconde maximum : 30fps
 Taille du module : 20 x 25 x 10mm
 Connexion par câble plat à l’interface 15-pin
MIPI Camera Serial Interface (CSI)
(Connecteur S5 du Raspberry Pi)
 connecter le module caméra avec la carte
Raspberry pi

III. FONCTIONNEMENT DE
L’ENSEMBLE ET MISE A JOUR
DE L’ENVIRONNEMENT :
Il est nécessaire de suivre les étapes suivantes :
a. Connecter l’ensembre {Carte+module
Caméra} à l’ordinateur :
Pour continuer, il faut insérer une carte SD de
16Gb (recommandé) , comme son nom l'indique
ceci permettra de stocker le système de base
du Raspberry Pi et des données (dans l'exemple
du Raspberry Pi utilisé comme caméra).
Pour continuer à utiliser Raspberry pi
correctement, on doit avoir un système
d’exploitation pouvant permettre la gestion des
ressources de cet appareil. En d'autres termes c’est
un logiciel qui, dans un appareil électronique,
pilote les dispositif matériels et reçoit des
instructions de l'utilisateur ou d'autres logiciels. Il
existe plusieurs types de système d’exploitation,
mais dans notre cas, nous nous intéressons au
Raspbian qui présente pour nous un intérêt
particulier. Raspbian est un système d’exploitation
libre basé sur la distribution GNU/Linux Debian,
et optimisé pour le plus petit ordinateur du monde,
la Raspberry Pi. Raspbian n'est pas un système
d’exploitation comme les autres. Il est livré avec
environ 35 000 paquets qui sont des logiciels pré-
compilés dans un format optimisé pour permettre
une facilité d’installation sur Raspberry Pi. Il est
encore en constante amélioration pour vous
permettre d’obtenir des performances sur un
maximum de logiciels développé.

b.Configurations :
Avant de parler de l’installation de Raspbian, il
est très important d’expliquer ce qu’est Noobs.
Noobs est un utilitaire qui simplifie grandement
l’installation d’un système d’exploitation sur le
Raspberry Pi. C’est un gestionnaire d’installation
spécialement conçu pour Raspberry Pi et il vous
permettra de choisir parmi une grande liste d’OS
et de l’installer très rapidement.
ETAPE N°1 : Télécharger NOOBS
Et ce à partir de ce lien fourni dessous 
https://www.raspberrypi.org/downloads/noobs/

ETAPE N°2 : Formater votre carte mémoire

en format FAT32 :
Pour Windows 10, il s’avère que cette tâche n’est
pas toujours évidente ,il est donc de suivre
minutieusement les instructions fournies dans le
lien dessous
https://www.easeus.fr/partition-manager-
tips/formater-carte-sd-windows-10.html

ETAPE N°3 : Extraire les fichiers de

l’archive .zip de NOOBS :
Etape N°4 : Copier le contenu de l’archive de
Noobs sur la carte SD formatée :
La carte SD est maintenant prête, on l’insère dans
le Raspberry Pi

ETAPE N°5 : Finaliser l’installation :

On Insére donc la carte SD contenant Noobs dans
le Raspberry Pi et on le démarre . Pour démarrer
un Raspberry Pi, il vous suffit de brancher
l’alimentation.

On branche également un clavier, une souris et un

écran en HDMI au Raspberry Pi pour procéder à
l’installation.
Le Raspberry Pi devrait donc booter sur l’utilitaire
NOOBS et on a une liste d’OS disponibles

On choisit Raspbian et on clique sur install

On patiente que l’OS s’installe sur la carte SD puis

le Raspberry Pi devrait redémarrer et affiche le
message « OS installed successfully ».

Maintenant on pourra exploiter le terminal

raspberry sur l’écran .
Vue du terminal Raspberry pi
 c. Installation des bibliothèques :
Il faut tout d’abord mettre à jour le Raspberry pi
Avec les commandes suivantes :
sudo apt-get update

Avant d'installer Python 3.8, nous devons installer

certaines dépendances. Utilisez la commande
suivante pour installer les dépendances requises.

sudo apt-get install -y build-

essential tk-dev libncurses5-dev
libncursesw5-dev libreadline6-dev
libdb5.3-dev libgdbm-dev libsqlite3-
dev libssl-dev libbz2-dev libexpat1-
dev liblzma-dev zlib1g-dev libffi-dev
tar wget vim

pour installer python 3.8 , on utilise la commande

suivante :

sudo tar zxf Python-3.8.0.tgz

cd Python-3.8.0
sudo ./configure --enable-
optimizations
sudo make -j 4
sudo make altinstall
*Installer OpenCV :

Initialement développée par Intel, OpenCV (Open

Computer Vision) est une bibliothèque graphique.
Elle est spécialisée dans le traitement d’images,
que ce soit pour de la photo ou de la vidéo.
Sa première version est sortie en juin 2000. Elle est
disponible sur la plupart des systèmes
d’exploitation et existe pour les langages Python,
C++ et Java.
OpenCV fournit un ensemble de plus de 2500
algorithmes de vision par ordinateur,
accessibles au travers d’API. Ce qui permet
d’effectuer tout un tas de traitements sur des
images (extraction de couleurs, détection de
visages, de formes, application de filtres,…). Ces
algorithmes se basent principalement sur des
calculs mathématiques complexes, concernant
surtout les traitements sur les matrices (car une
image peut être considérée comme une matrice de
pixels).
Après,on installe les dépendances requises pour
installer OpenCV sur le Raspberry Pi.

sudo apt-get install libhdf5-dev -y

sudo apt-get install libhdf5-serial-dev –y
sudo apt-get install libatlas-base-dev –y
sudo apt-get install libjasper-dev -y
sudo apt-get install libqtgui4 –y
sudo apt-get install libqt4-test –y

Enfin, on installe OpenCV avec cette commande :

sudo pip install opencv-contrib-python

* Installer imutils :
imutils est utilisé pour exécuter quelques fonctions
de traitement d'image nécessaires telles que la
traduction, la rotation, le redimensionnement, le
squelette et l'affichage des images Matplotlib plus
facilement avec OpenCV. Alors on installe imutils
en utilisant la commande ci-dessous:

pip3 install imutils

*Installer dlib :
dlib est la boîte à outils moderne qui contient des
algorithmes d'apprentissage automatique et des
outils pour les problèmes du monde réel. On
Utilise la commande ci-dessous pour installer le
dlib.

pip3 install dlib

*Installer NUMPY :
NumPy est la bibliothèque de base pour le calcul
scientifique qui contient un puissant objet tableau à
n dimensions, fournit des outils pour intégrer C, C
++, etc.
Pip3 install numpy
III. APPLICATION N°1 :
Détecter les parties du visage
avec dlib :

Pour cette première application, on va essayer de

détecter les parties du visage avec dlib.
Nous allons utiliser le détecteur de repère facial
pré-formé de la bibliothèque dlib pour détecter
l'emplacement de 68 coordonnées (x, y) qui
correspondent aux structures faciales du visage. Le
prédicteur de repère facial dlib est formé sur le jeu
de données iBUG 300-W. Une image contenant les
index des 68 coordonnées est donnée ci-dessous:
Ici, on va ouvrir un script python sous
l’extension .py , c’est là ou on va écrire le code de
cette application 

La première étape sera l’importation des

bibliothèques nécessaires
Le code est le suivant :

from imutils import face_utils

import numpy as np
import argparse
import imutils
import dlib
import cv2
from picamera.array import PiRGBArray
from picamera import PiCamera
from PIL import Image
camera = PiCamera()
camera.resolution = (640, 480)
camera.framerate = 30
rawCapture = PiRGBArray(camera, size=(640, 480))
 
# construct the argument parser and parse the arguments
ap = argparse.ArgumentParser()
ap.add_argument("-p", "--shape-predictor", required=True,
help="facial landmark predictor path")
args = vars(ap.parse_args())
detector = dlib.get_frontal_face_detector()
predictor = dlib.shape_predictor(args["shape_predictor"])
for frame in camera.capture_continuous(rawCapture,
format="bgr", use_video_port=True):
    image = frame.array
    cv2.imshow("Frame", image)
    key = cv2.waitKey(1) & 0xFF
    rawCapture.truncate(0)
    if key == ord("s"):
       image = imutils.resize(image, width=300)
       gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
       rects = detector(gray, 1)
 
# loop over the face detections
       for (i, rect) in enumerate(rects):
 
# determine the facial landmarks for the face region
          shape = predictor(gray, rect)
          shape = face_utils.shape_to_np(shape)
 
# loop over the face parts individually
          for (name, (i, j)) in
face_utils.FACIAL_LANDMARKS_IDXS.items():
 
# display the name of the face part on the image
                clone = image.copy()
                cv2.putText(clone, name, (10, 30),
cv2.FONT_HERSHEY_SIMPLEX,
0.7, (0, 0, 255), 2)
 
# Draw Circles on specific face part
                for (x, y) in shape[i:j]:
                       cv2.circle(clone, (x, y), 1, (0, 0, 255), -1)
 
# extract the ROI of the face region as a separate image
                (x, y, w, h) =
cv2.boundingRect(np.array([shape[i:j]]))
                roi = image[y:y + h, x:x + w]
                roi = imutils.resize(roi, width=250,
inter=cv2.INTER_CUBIC)
 
# show the particular face part
                cv2.imshow("ROI", roi)
                cv2.imshow("Image", clone)
                cv2.waitKey(0)
 
# visualize all facial landmarks
          for (x, y) in shape:
           cv2.circle(image, (x, y), 1, (0, 0, 255), -1)
           cv2.imshow("Image",image)
          cv2.waitKey(0)

Maintenant pour exécuter le fichier detect.py, on

utilise la commande suivante :
python3 detect.py --shape-predictor
shape_predictor_68_face_landmarks.dat

Vous verrez une fenêtre montrant une vue en direct

de votre caméra. Appuyez ensuite sur la touche
«S» pour sélectionner une image dans le flux en
direct. Vous verrez des points rouges sur votre
bouche. Utilisez la touche ESC pour voir les autres
parties du visage.

Exemple d’exécution
III. APPLICATION N°2 :
ESTIMATION DE LA TAILLE
D’UNE FOULE :
Ici, le module de caméra pi sera utilisé pour
capturer en continu les images, puis ces images
seront traitées avec HOG (Histogram Oriented
Object descriptor) pour détecter les objets dans
l'image. Après cela, ces cadres seront comparés au
modèle pré-formé d'OpenCV pour la détection de
personnes. Les personnes qui comptent seront
affichées sur le canal ThingSpeak qui peut être
surveillé de n'importe où dans le monde.

*ThingSpeak :

ThingSpeak est une plate-forme IoT très populaire

et en utilisant la plate-forme ThingSpeak, nous
pouvons surveiller nos données sur Internet de
n'importe où. Il est également utilisé pour contrôler
le système sur Internet, en utilisant les canaux et
les pages Web fournis par ThingSpeak. Nous
avons précédemment utilisé ThingSpeak pour créer
de nombreux projets basés sur l'IoT.
Pour créer d'abord une chaîne sur ThingSpeak,
commencez par vous inscrire sur ThingSpeak. Si
vous possédez déjà un compte sur ThingSpeak,
connectez-vous en utilisant votre identifiant et
votre mot de passe.

Apercu général de la plate-forme

Maintenant, après la connexion, créez une nouvelle
chaîne en cliquant sur le bouton «New Channel».

Après avoir cliqué sur «New Channel», entrez le

nom et la description des données que vous
souhaitez télécharger sur ce canal. Ici, nous avons
créé un champ nommé People. Plusieurs champs
peuvent être créés selon les besoins.

Après cela, cliquez sur le bouton Enregistrer la

chaîne pour enregistrer les détails.

Pour envoyer des données à ThingSpeak, entrez la

clé API et l'ID de canal dans le script Python,
copiez donc la clé API et l'ID de canal.
NB : Le même hardware est utilisé pour toutes
les Applications , c’est l’ensemble décrit au
préalable

*Installer imutils :
imutils est utilisé pour exécuter quelques fonctions
de traitement d'image nécessaires telles que la
traduction, la rotation, le redimensionnement, le
squelette et l'affichage des images Matplotlib plus
facilement avec OpenCV. Alors on installe imutils
en utilisant la commande ci-dessous:
 pip3 install imutils

*Installer matplotlib :
Après cela,on installe la bibliothèque matplotlib.
Matplotlib est une bibliothèque complète pour
créer des visualisations statiques, animées et
interactives en Python

pip3 install matplotlib

de même, dans un autre fichier .py, on exécute
ce code python :
import cv2
import imutils
from imutils.object_detection import non_max_suppression
import numpy as np
import requests
import time
import base64
from matplotlib import pyplot as plt
from urllib.request import urlopen
channel_id = 812060 # PUT CHANNEL ID HERE
WRITE_API  = 'X5AQ3EGIKMBYW31H' # PUT YOUR WRITE
KEY HERE
BASE_URL = "https://api.thingspeak.com/update?
api_key={}".format(WRITE_API)
hog = cv2.HOGDescriptor()
hog.setSVMDetector(cv2.HOGDescriptor_getDefaultPeopleDetector(
))
# In[3]:
def detector(image):
   image = imutils.resize(image, width=min(400, image.shape[1]))
   clone = image.copy()
   rects, weights = hog.detectMultiScale(image, winStride=(4, 4),
padding=(8, 8), scale=1.05)
   for (x, y, w, h) in rects:
       cv2.rectangle(image, (x, y), (x + w, y + h), (0, 0, 255), 2)
   rects = np.array([[x, y, x + w, y + h] for (x, y, w, h) in rects])
   result = non_max_suppression(rects, probs=None,
overlapThresh=0.7)
   return result
def record(sample_time=5):
   print("recording")
   camera = cv2.VideoCapture(0)
   init = time.time()
   # ubidots sample limit
   if sample_time < 3:
       sample_time = 1
   while(True):
       print("cap frames")
       ret, frame = camera.read()
       frame = imutils.resize(frame, width=min(400, frame.shape[1]))
       result = detector(frame.copy())
       result1 = len(result)
       print (result1)
       for (xA, yA, xB, yB) in result:
           cv2.rectangle(frame, (xA, yA), (xB, yB), (0, 255, 0), 2)
       plt.imshow(frame)
       plt.show()
       # sends results
       if time.time() - init >= sample_time:
           thingspeakHttp = BASE_URL + "&field1={}".format(result1)
           print(thingspeakHttp)
           conn = urlopen(thingspeakHttp)
           print("sending result")
           init = time.time()
   camera.release()
   cv2.destroyAllWindows()
# In[7]:
def main():
   record()
# In[8]:
if __name__ == '__main__':
   main()

Avant de lancer le script python, vérifiez d'abord si

votre caméra PI fonctionne ou non. Après avoir
examiné la caméra, lancez le script python en
exécutant la commande suivante:

Ensuite, vous trouverez une fenêtre avec votre flux

vidéo. Pi prendra la première image et la traitera en
utilisant OpenCV pour détecter le nombre de
personnes. S'il détecte les personnes, vous
trouverez une boîte autour de lui comme ceci:
Vérifiez maintenant votre chaîne ThingSpeak, où
vous pouvez surveiller la taille de la foule de
n'importe où dans le monde.
Ultérieurement, on pourra pousser un peu plus
jusqu’à implémenter un réseau de neurones et
installer Tenserflow pour réaliser des
applications plus exigeantes