Démarrer le développement de la vision par ordinateur avec OpenCV sur Ubuntu

Ici, je vais expliquer comment vous pouvez installer OpenCV sur votre système Ubuntu, comment créer des programmes C++ basés sur cette bibliothèque de vision par ordinateur Open Source, lire à partir de fichiers ou d'un appareil photo, effectuer des opérations de traitement d'image de base, dessiner ou écrire des choses et enregistrer notre travail.

Table des matières

• Intro
  • À propos d'OpenCV
  • Exigences
• Installation
  • Préparez votre système
  • Obtenir OpenCV
  • Construire
  • Configurer
• DévelopperavecOpenCV
  • Application 1 - Fenêtre simple
  • Construction du terminal
    • g++
    • faire
    • CMake
  • KDevelop Build
  • Application 2 - Charger img
  • Application 3 - Charger la vidéo
  • Application 4 :Dessiner et traiter

Présentation

Il s'agit d'un sujet de programmation, et certaines connaissances préalables en programmation dans n'importe quel langage vous aideront, mais je présenterai tous les outils et commandes nécessaires pour créer de petits programmes, afin que toute personne ayant de bonnes compétences en raisonnement logique puisse être en mesure de créer les exemples et d'en bénéficier. .

De plus, il s'agit d'un matériel d'introduction, et ne couvrira pas la programmation complexe ou les concepts scientifiques, je me concentrerai plutôt sur la façon de faire fonctionner les choses, vous donnerai un exemple de code pour que vous puissiez l'essayer vous-même, vous y habituer et vous amuser.

Vous êtes encouragé à ouvrir le manuel de référence de l'API sur un autre onglet et à vous y référer chaque fois que vous trouvez un nouvel objet, une fonction ou un paramètre sur le code fourni ici, une fois que vous l'avez construit pour la première fois, faites quelques changements par vous-même pour une meilleure compréhension.

De plus, c'est une bonne idée d'utiliser man et de consulter la documentation officielle de chacun des outils de construction, fichiers et termes présentés ici.

Qu'est-ce qu'OpenCV

OpenCV signifie Open Source Computer Vision Library, et son objectif principal est de créer une approche standardisée de la vision par ordinateur. Il fournit un ensemble de modules qui vous aident dans des domaines tels que l'algèbre linéaire, le traitement d'images, l'apprentissage automatique, l'abstraction matérielle, l'interface graphique de haut niveau, ainsi que l'interface avec OpenGL, OpenCL, CUDA, etc. Gardez également à l'esprit qu'il est distribué sous licence BSD, ce qui est assez permissif et bon à la fois pour la recherche et à des fins commerciales.

Les modules que nous allons utiliser dans nos programmes sont.

• Core - la base d'OpenCV
• HighGUI - Fournit une interface utilisateur graphique de haut niveau assez simple et utile
• améliorer - Fournit des capacités de traitement d'image

Exigences

Ce sont les exigences indiquées sur les documents OpenCV, certaines d'entre elles sont facultatives, mais c'est toujours une bonne idée de répondre à toutes les exigences lors de l'apprentissage de quoi que ce soit.

• GCC 4.4.x ou version ultérieure
• CMake 2.6 ou supérieur
• Git
• GTK+2.x ou supérieur, y compris les en-têtes (libgtk2.0-dev)
• pkg-config
• Python 2.6 ou version ultérieure et Numpy 1.5 ou version ultérieure avec packages de développement (python-dev, python-numpy)
• Packages de développement ffmpeg ou libav :libavcodec-dev, libavformat-dev, libswscale-dev
• [facultatif] libtbb2 libtbb-dev, libdc1394 2.x, libjpeg-dev, libpng-dev, libtiff-dev, libjasper-dev, libdc1394-22-dev

Comment installer

Dans cette première partie de l'article, je vais vous montrer comment préparer votre système, obtenir, construire et installer OpenCV et une configuration post-installation

Préparer

Commencez par mettre à jour votre base de données apt

apt-get update

Installez les éléments de la section des exigences avec apt-get.

apt-get install build-essential cmake git libgtk2.0-dev pkg-config libavcodec-dev libavformat-dev libswscale-dev python-dev python-numpy libtbb2 libtbb-dev libjpeg-dev libpng-dev libtiff-dev libjasper-dev libdc1394-22-dev

Obtenir OpenCV

Nous allons utiliser OpenCV 2.4.11, ouvrir une session de terminal et utiliser wget comme suit :

wget https://github.com/Itseez/opencv/archive/2.4.11.zip

Vous pouvez également cloner la dernière version plus tard, et jeter un œil ici, c'est un tutoriel de migration où vous pouvez apprendre à faire la transition entre les versions d'OpenCV.

git clone https://github.com/Itseez/opencv.git

Créer les sources

Entrez dans le répertoire du package

cd *2.4.11*

Créez un répertoire pour notre OpenCV build, et entrez dessus

mkdir build && cd build

Dans le répertoire de construction, utilisez cmake pour le préparer.

cmake ..

Maintenant que nous avons un Makefile, nous pouvons créer et installez

make && make install

Comment configurer

Testez si votre système peut trouver les chemins OpenCV, exécutez la commande suivante :

 pkg-config --cflags --libs opencv

Si cela vous donne un message d'erreur, votre variable d'environnement PKG_CONFIG_PATH peut ne pas pointer vers OpenCV et vous devez y ajouter le chemin. Essayez de relancer ceci et le test

export PKG_CONFIG_PATH="$PKG_CONFIG_PATH:/usr/local/lib/pkgconfig"

Vous pouvez ajouter la dernière commande sur un script de profil pour éviter d'avoir à l'exécuter à chaque fois, essayez .bashrc :

vi ~/.bashrc

Développer avec OpenCV

Nous sommes maintenant prêts à démarrer du code OpenCV, voici quelques exemples de programmes et une approche de base sur les moyens de les construire.

Première application - Fenêtre simple

Cette première application ouvre simplement une fenêtre à l'écran, ce n'est pas très utile, mais bon pour tester votre installation et apprendre à construire des applications OpenCV

main.cpp

//include high gui headers

#include "opencv2/highgui/highgui.hpp"

//we are using standard and OpenCV namespaces

using namespace cv;
using namespace std;

int main( int argc, const char** argv ){

//créer une fenêtre nommée laFenêtre

fenêtrenommée("laFenêtre", CV_WINDOW_AUTOSIZE);

//attendez que l'utilisateur appuie sur une touche

waitKey(0);

//détruit la fenêtre nommée theWindow

destroyWindow("theWindow");

renvoie 0 ;

}

Construction de terminaux

Créer un répertoire pour le projet

mkdir firstcv && cd firstcv

Créer le c++ fichier avec Vi

vi main.cpp

maintenant, construisez-le directement avec g++

g++ -o firstcv $(pkg-config --libs --cflags opencv) main.cpp

Faire

L'application firstcv est assez simple et il est facile de la construire directement, mais à mesure que le code devient complexe, vos commandes de construction deviennent rapidement cryptiques, le nettoyage et la maintenance générale deviennent un gâchis. Pour cette raison, nous utilisons make

Créez un fichier nommé Makefile avec le contenu suivant :

all:
g++ -o firstcv \
-I/usr/local/include/opencv  \
-L/usr/local/lib \
-lopencv_highgui \
-lopencv_core \
-lm \
main.cpp

clean:
rm firstcv

Il appellera essentiellement le compilateur avec un ensemble de paramètres préparé lorsque le tous est la cible et supprime l'exécutable lorsque la cible est propre , pour plus de détails sur Makefile, regardez ici

Un autre fait à propos de make est que si aucun identifiant de cible n'est donné, il utilisera la première cible, donc pour construire le code, vous avez juste besoin de make :

make

CMake

La dernière approche pour créer des applications, mais la création de Makefiles peut également devenir complexe lorsque vous construisez sur plusieurs systèmes. Vous pouvez ensuite générer votre build avec CMake, comme le fait le projet OpenCV lui-même, cela simplifie la gestion des builds et augmente la compatibilité entre les plates-formes.

Au lieu de travailler sur le Makefile, nous créons maintenant un fichier appelé CMakeLists.txt avec un contenu similaire à celui-ci :

cmake_minimum_required(VERSION 2.6)
project(firstcv)
include_directories("/usr/local/include")
find_package( OpenCV REQUIRED )
add_executable(firstcv main.cpp)
install(TARGETS firstcv RUNTIME DESTINATION bin)
target_link_libraries( firstcv ${OpenCV_LIBS} )

Il dit :

cmake_minimum_required  :la version minimale de CMake est 2.6

projet :nom de votre projet

include_directories :Chemin d'inclusion supplémentaire

find_package :recherchez le package OpenCV, comme nous l'avons fait avec pkg-config plus tôt

add_executable :les binaires résultants et ses fichiers source.

installer :Chemin d'installation

target_link_libraries :Objets partagés à lier, encore une fois cela fonctionne comme pkg-config

Créez ensuite un répertoire de construction et entrez dessus.

mkdir build && cd build

Préparez votre build avec cmake

cmake ..

Avec un Makefile en main, faites-le :

make

Exécutez simplement votre programme

./firstcv

KDevelop build

Bien que vous puissiez créer des systèmes entiers à partir du terminal de la console, vous pouvez faire beaucoup plus en utilisant des fonctionnalités telles que le formatage du code, la référence de code de mise en évidence de la syntaxe, le débogueur et autres en utilisant un IDE. KDevelop est génial, simple et je vais vous montrer comment créer vos projets basés sur son modèle d'application de terminal Cmake.

Cliquez sur le menu Projet ->Nouveau à partir d'un modèle , puis sélectionnez Standard à Catégorie,Terminal au type de projet et nommez-le.

Une fois le projet créé, changez le contenu du fichier main.cpp avec celui fourni précédemment

Dans le panneau des projets, double-cliquez sur le nom du projet, puis sur le fichier CMakeLists.txt et modifiez-le en fonction de la section CMake.

Construisez votre projet, cliquez sur construire ou appuyez sur [F8] clé et exécutez-le avec [F9] , lors de la première exécution, vous devrez définir les paramètres d'exécution comme suit

Vous êtes maintenant en mesure de créer du code OpenCV, pour les prochaines applications, il vous suffit de répéter la création du projet ou de remplacer la source du fichier main.cpp.

Application 2 - Afficher l'image

Cette application affiche simplement le contenu d'un fichier image sur la fenêtre

#include "opencv2/highgui/highgui.hpp"

using namespace cv;
using namespace std;

int main( int argc, const char** argv ){

//créer un objet Mat et y charger le contenu du fichier linoxide.png

Mat img =imread("linoxide.png", CV_LOAD_IMAGE_UNCHANGED);

//si l'img est vide, meurt avec le statut de sortie d'erreur

if (img.empty()){return -1;}

fenêtrenommée("laFenêtre", CV_WINDOW_AUTOSIZE);

//afficher l'img sur la fenêtre

imshow("theWindow", img);

waitKey(0);

destroyWindow("theWindow");

renvoie 0 ;

}

Voici le programme en cours :

Application 3 - Charger la vidéo

Cette fois, nous allons lire le contenu directement depuis notre appareil photo, il ne s'agit que de quelques changements sur le dernier code

#include "opencv2/opencv.hpp"

using namespace cv;
using namespace std;

int main( int argc, const char** argv ){

//Lancer la caméra

Limite de capture vidéo (0) ; Mat img;

fenêtrenommée("laFenêtre", CV_WINDOW_AUTOSIZE);

tandis que (vrai){

//si impossible de lire depuis la caméra, le programme meurt

if (!cap.read(img)) { return -1; }

imshow("laFenêtre", img );

if (waitKey(20) ==27) {return 0;}

}

}

Application 4 - Traitement d'images

Maintenant que vous pouvez charger vos images et avoir un flux de programme de base, améliorons cela, créons des contrôles, dessinons quelque chose ressemblant au logo de Linoxide, faisons quelques transformations sur les images et sauvegardons-les.

//we include High level GUI and Media I/O
#include "opencv2/highgui/highgui.hpp"

//Including Image processing capabilities
#include "opencv2/imgproc/imgproc.hpp"

//OpenCV core module is implicitly included

//we are using both standard and OpenCV namespaces
using namespace std;
using namespace cv;

int main(int argc, char **argv) {

//Lancer le périphérique de capture vidéo sur le cap VideoCapture cap(0);

//Si impossible d'ouvrir le périphérique de capture, le programme meurt if(!cap.isOpened()){return -1;}

//Voici notre cadre Mat frame;

//Nous afficherons ici nos cadres nomméWindow("display", CV_WINDOW_AUTOSIZE);

//Cette fenêtre contient des barres de suivi pour modifier le comportement du programme namedWindow("config", CV_WINDOW_AUTOSIZE);

//par défaut nous n'inverserons pas le frame bool invertimg =false;

//nous allons dessiner le croquis du logo Linoxide bool draw =true;

// crée un support pour notre mode de retournement de cadre int flipmode =0; // crée une barre de suivi pour changer le mode flip cvCreateTrackbar("Flip Mode:", "config", &flipmode, 3);

// détenteurs de valeurs de largeur et de hauteur pour le redimensionnement de l'image int screen_width =640; entier screen_height =480 ;

//créer des barres de suivi dans la fenêtre de configuration pour modifier les propriétés de taille cvCreateTrackbar("Width :", "config", &screen_width, 1024); cvCreateTrackbar("Hauteur :", "config", &screen_height, 768);

//créer un vecteur de paramètres de compression qui sera utilisé pour prendre un instantané vector compression_pars ; compression_pars.push_back(CV_IMWRITE_PNG_COMPRESSION); compression_pars.push_back(9);

tandis que (vrai){

if(!cap.read(frame)){return -1;} // impossible de lire le frame, le programme meurt

//si invertimg est vrai, inverse chacun des éléments de la matrice en réduisant sa valeur du maximum possible if(invertimg ==true){ frame =Scalar::all(255) - frame; }

//retourne le cadre en fonction des valeurs de la barre de suivi du mode retournement if(flipmode> 0){flip(frame,frame,1);} //retourne horizontalement if(flipmode> 1){flip(frame,frame,0);} //flip vertical, est maintenant retourné dans les deux sens if(flipmode> 2){flip(frame,frame,1);} //flip horizontal, maintenant seulement retourné verticalement

// redimensionne le cadre en fonction des valeurs sur les barres de suivi resize(frame,frame, Size(screen_width,screen_height) );

si (dessiner ==vrai){

//dessine un rectangle blanc à utiliser comme arrière-plan, la couleur est Scalar(B,G,R) rectangle(frame, Point(5,25), Point(140,70), Scalar(255,255,255), -1, 8, 0);

//rectangle jaune foncé, notez que la valeur alpha peut être utilisée rectangle(frame, Point(5,25), Point(54,55), Scalar(00,225,255,0), -1, 8, 0);

//rectangle bleu vif, l'épaisseur est négative, il sera donc complètement rempli rectangle(frame, Point(57,25), Point(140,55), Scalar(255,225,100), -1, 8, 0);

//rectangle noir, commence au point x5,y57, se termine à x140,y70 rectangle(frame, Point(5,57), Point(140,70), Scalar(0,0,0), -1, 8, 0 );

//écrire le texte sur le cadre, séparé par les caractéristiques de police et la position putText(frame, "L ", Point(10,50), FONT_HERSHEY_SIMPLEX, 1, Scalar(0,0,0),2,0); putText(frame, " IN ", Point(14,50), FONT_HERSHEY_SIMPLEX, 0.8, Scalar(0,0,0),2,0); putText(frame, " O ", Point(10,50), FONT_HERSHEY_SIMPLEX, 1, Scalar(255,255,255),2,0); putText(frame, " XIDE", Point(14,50), FONT_HERSHEY_SIMPLEX, 0.8, Scalar(255,255,255),2,0); putText(frame, "Linux Freedom Thoughts", Point(10,65), FONT_HERSHEY_PLAIN, 0.6, Scalar(255,255,255),0,0);

} // afficher notre cadre sur la fenêtre d'affichage imshow("display",frame);

switch(waitKey(10)){ case 27 ://[esc], terminer le programme avec succès return 0 ; case 'i' :// inverser l'image toggle if (invertimg ==false){invertimg =true;}else {invertimg =false ;} case 'd' :// dessiner Linoxide toggle if (draw ==false){draw =true;}else {draw =false;} case 's' ://prendre un instantané, enregistrer dans snapshot.png imwrite("snapshot.png", frame, compression_pars);

}

} //finir avec succès return 0 ;

}

Le voici

Conclusion

C'est tout pour l'instant, vous devriez être capable de construire des programmes basés sur la bibliothèque OpenCV. Les concepts présentés ici devraient vous permettre de comprendre les idées derrière la bibliothèque. Mais ce n'est que le début, vous pouvez creuser dans les tutoriels officiels, approfondir les références et les exemples d'OpenCV et jeter un œil à des choses plus avancées, comme la détection d'objets, la détection de visage, le suivi d'objets, la correspondance de modèles, l'apprentissage automatique, la cartographie 3D.

Merci d'avoir lu, j'espère que vous l'aimerez et que vous ferez de grandes choses avec OpenCV !