Opencv FR
Opencv FR
Opencv FR
#opencv
Table des matières
À propos 1
Remarques 2
Versions 2
OpenCV 3 2
OpenCV 2 2
Examples 3
Préparez-vous à la construction 4
Construire et installer 5
Test d'installation 5
Java 6
C ++ 7
Python 8
Remarques 16
Examples 16
Examples 23
Examples 25
Chargement de vidéos 25
Capture en direct 26
Enregistrement de vidéos 26
Examples 29
Python 29
Code 29
Résultat 29
Java 30
C ++ 31
Chapitre 6: Construire et compiler opencv 3.1.0-dev pour Python2 sous Windows en utilisant 34
Remarques 34
Examples 43
Syntaxe 45
Paramètres 45
Remarques 45
g (i, j) = .f (i, j) + 45
Examples 46
Examples 48
Introduction 49
Examples 49
Examples 52
RÉSULTAT 52
Examples 54
Syntaxe 56
Paramètres 56
Examples 56
Algorithme Canny 56
Canny Algorithm - C ++ 57
Examples 60
Examples 61
Initialisation asynchrone 61
OpenCV Manager 62
Initialisation statique 62
Introduction 65
Examples 65
Examples 68
Modification de la couleur de l’image dans OpenCV - kmeans (). Pour analyser tous les pixe 69
Introduction 70
Examples 70
Type de données 70
Tapis 70
Vec 71
Syntaxe 73
Paramètres 73
Remarques 73
Examples 73
Seuillage 74
Filtrage Bilatéral 75
Syntaxe 77
Paramètres 77
Examples 78
Obtenir une image statique, détecter les éléments et afficher les résultats. 78
Examples 84
Crédits 86
À propos
You can share this PDF with anyone you feel could benefit from it, downloaded the latest version
from: opencv
It is an unofficial and free opencv ebook created for educational purposes. All the content is
extracted from Stack Overflow Documentation, which is written by many hardworking individuals at
Stack Overflow. It is neither affiliated with Stack Overflow nor official opencv.
The content is released under Creative Commons BY-SA, and the list of contributors to each
chapter are provided in the credits section at the end of this book. Images may be copyright of
their respective owners unless otherwise specified. All trademarks and registered trademarks are
the property of their respective company owners.
Use the content presented in this book at your own risk; it is not guaranteed to be correct nor
accurate, please send your feedback and corrections to [email protected]
https://riptutorial.com/fr/home 1
Chapitre 1: Commencer avec opencv
Remarques
Cette section fournit une vue d'ensemble de ce qu'est une ouverture, et pourquoi un développeur
peut vouloir l'utiliser.
Il devrait également mentionner tous les grands sujets à l’intérieur du forum, et les relier aux sujets
connexes. La documentation de opencv étant nouvelle, vous devrez peut-être créer des versions
initiales de ces rubriques connexes.
Versions
OpenCV 3
Version Date de sortie
3.2 2016-12-23
3.1 2015-12-18
3.0 2015-06-03
OpenCV 2
Version Date de sortie
2.4.13 2016-05-19
2.4.12 2015-07-30
2.4.11 2015-02-25
2.4.10 2014-10-01
2.4.9 2014-04-14
2.3.1 2011-08-17
https://riptutorial.com/fr/home 2
Version Date de sortie
2.3.0 2011-07-04
2.2.0 2010-12-05
2.1.0 2010-04-06
2.0.0 2009-10-01
1.0.0 2006-10-19
Examples
Charger et afficher une image avec OpenCV
Avec cet exemple, nous verrons comment charger une image couleur à partir du disque et
l'afficher à l'aide des fonctions intégrées d'OpenCV. Pour ce faire, nous pouvons utiliser les
liaisons C / C ++, Python ou Java.
En C ++:
#include <opencv2/core.hpp>
#include <opencv2/highgui.hpp>
#include <iostream>
// Finally, we display our image and ask the program to wait for a key to be pressed
imshow("My first OpenCV window", image);
waitKey(0);
return 0;
}
En Python:
import sys
import cv2
https://riptutorial.com/fr/home 3
# We load the image from disk
img = cv2.imread("image.jpg", cv2.CV_LOAD_IMAGE_COLOR)
# We display our image and ask the program to wait until a key is pressed
cv2.imshow("My first OpenCV window", img)
cv2.waitKey(0)
En Java:
import org.opencv.core.Core;
import org.opencv.core.Mat;
import org.opencv.core.CvType;
import org.opencv.highgui.Highgui;
public class Sample{
public static void main (String[] args) {
//Read image from file first param:file location ,second param:color space
Mat img = imread("image.jpg",CV_LOAD_IMAGE_COLOR);
HighGui n'a aucune fenêtre nommée ni équivalent dans opencv java. Utilisez swing ou swt pour
afficher l'image.
Ceci est un guide étape par étape pour installer OpenCV 3 sur un système Linux basé sur Debian
à partir de la source. Les étapes doivent rester les mêmes pour les autres distributions, il suffit de
remplacer les commandes du gestionnaire de packages pertinentes lors de l'installation des
packages pour la génération.
Remarque: Si vous n'avez pas envie de perdre du temps à créer des éléments ou à ne pas aimer
le terminal, vous pouvez très probablement installer OpenCV à partir de l'interface graphique du
gestionnaire de paquets Synaptic. Cependant, ces bibliothèques sont souvent obsolètes.
Préparez-vous à la construction
https://riptutorial.com/fr/home 4
Emettez les commandes suivantes dans votre terminal pour installer les packages requis:
Emettez la commande suivante pour obtenir le code source OpenCV et préparer la génération:
mkdir ~/src
cd ~/src
git clone https://github.com/opencv/opencv.git
cd opencv
mkdir build && cd build
Construire et installer
Nous incluons les exemples dans la construction, mais n'hésitez pas à les laisser de côté.
N'hésitez pas non plus à définir d'autres drapeaux et à personnaliser votre build comme vous le
souhaitez.
cmake -D CMAKE_BUILD_TYPE=RELEASE \
-D CMAKE_INSTALL_PREFIX=/usr/local \
-D INSTALL_PYTHON_EXAMPLES=ON \
-D INSTALL_C_EXAMPLES=ON ..
make -j$(nproc)
Si aucune erreur n'a été produite, nous pouvons continuer à installer OpenCV sur le système:
Maintenant, OpenCV devrait être disponible pour votre système. Vous pouvez utiliser les lignes
suivantes pour savoir où OpenCV a été installé et quelles bibliothèques ont été installées:
Test d'installation
Nous construisons d’abord les exemples C ++:
https://riptutorial.com/fr/home 5
cd ~/src/opencv/samples
cmake .
make
./cpp/cpp-example-edge
python
>> import cv2
>> print cv2.__version__
Si ces commandes importent OpenCV et impriment la version correcte sans se plaindre, alors les
liaisons Python sont correctement installées.
import org.opencv.core.Core;
import org.opencv.core.Mat;
import org.opencv.imgcodecs.Imgcodecs;
Affichez un flux vidéo en direct provenant d'une webcam à l'aide de la classe VideoCapture
d'OpenCV avec Java, C / C ++ et Python.
Java
https://riptutorial.com/fr/home 6
import org.opencv.core.Core;
import org.opencv.core.Mat;
import org.opencv.videoio.VideoCapture;
C ++
#include "opencv2/opencv.hpp"
#include "iostream"
https://riptutorial.com/fr/home 7
return 0;
}
Python
import numpy as np
import cv2
while(True):
# Capture frame-by-frame
ret, frame = cap.read()
Nous installons OpenCV 3.1.0 sous Windows et commençons. Il existe deux manières d’installer
OpenCV sur Windows. L'une consiste à télécharger le programme d'installation et à l'exécuter.
L'autre consiste à construire à partir des sources.
C'est le moyen le plus simple d'installer OpenCV et de commencer. OpenCV fournit des fichiers
binaires de pré-compilation à installer sur Windows ici . Une fois le téléchargement terminé,
extrayez-le et installez-le sur le chemin choisi.
ProTip: Assurez-vous que votre chemin OpenCV n'inclut aucun espace. Donc, c'est mieux si vous
l'installez simplement dans le répertoire racine C: \ ou D: \
Le problème avec la méthode ci-dessus est que vous ne pouvez pas utiliser les modules
opencv_contrib. En outre, il ne vient pas avec tous les outils et bibliothèques tiers. Donc, si vous
voulez utiliser tout cela, suivez simplement.
Je vous expliquerai le minimum pour installer OpenCV depuis la source. Pour plus avancé,
référez-vous ici .
• Installez CMake .
• Clone source OpenCV de https://github.com/Itseez/opencv.git dans un répertoire qui n'a pas
d'espaces. Appelons-le "OpenCVdir".
https://riptutorial.com/fr/home 8
• Maintenant, ouvrez l'interface graphique de CMake et ajoutez votre répertoire source
(OpenCVdir) au menu Sources et créez le répertoire dans le menu de génération. Conseil:
S'il n'y a pas de répertoire de compilation, créez-en un dans votre dossier opencv.
• Cliquez sur Configurer et sélectionnez votre version du compilateur Visual Studio. J'ai eu
Visual Studio 2013 Professional 32 bits, j'ai donc choisi le compilateur Visual Studio 12.
https://riptutorial.com/fr/home 9
Conseil: vous pouvez télécharger Visual Studio 2013 Professional à partir d'ici. Il est livré avec 30
jours d'essai + 90 jours de prolongation après s'être connecté.
• Appuyez sur Terminer et CMake chargera tous les paquets automatiquement. Vous pouvez
ajouter ou supprimer des packages. Appuyez à nouveau sur Configure.
• Si vous voulez construire avec des modules opencv_contrib supplémentaires, vous devez
les télécharger ici . Ensuite, extrayez-les et ajoutez le répertoire opencv_contrib / modules à
votre CMake comme indiqué ci-dessous.
https://riptutorial.com/fr/home 10
• Maintenant, appuyez à nouveau sur Configurer, puis appuyez sur Générer.
• Fermer CMake. Allez dans le dossier your_opencv \ build et ouvrez le fichier nommé
'OpenCV.sln'. - Il va ouvrir Visual Studio. Maintenant, lancez-le dans les deux Debug
mode et libération
mode.
• Maintenant, dans l'explorateur de solutions en haut à droite de Visual Studio, sélectionnez le
projet INSTALL et construisez-le.
https://riptutorial.com/fr/home 11
Hourra!! Profitez de votre OpenCV.
https://riptutorial.com/fr/home 12
• Maintenant, cliquez sur Variables d'environnement >> Chemin >> Modifier.
https://riptutorial.com/fr/home 13
• Ici, ajoutez le dossier bin situé dans votre dossier OpenCVdir / build / install / x86 / vc ** / bin
à cette variable. Veillez à ne pas remplacer les valeurs de chemin existantes.
• Après cela, vous devez redémarrer votre système pour que les variables d'environnement
changent et que vous êtes maintenant prêt.
OpenCV (Open Source Computer Vision Library) est une bibliothèque de logiciels et de logiciels
d'apprentissage automatique. Il a été conçu pour divers objectifs tels que l'apprentissage
automatique, la vision par ordinateur, l'algorithme, les opérations mathématiques, la capture
vidéo, le traitement d'images, etc. , android, ios). En outre, il a enveloppé dans divers langages de
programmation renommés. Dans le cadre du contrat de licence, les entreprises peuvent accéder
au code et le modifier.
La bibliothèque contient plus de 2500 algorithmes optimisés, qui ont une excellente précision en
termes de performances et de vitesse. Ces algorithmes peuvent être utilisés pour détecter et
reconnaître des visages, identifier des objets, classer des actions humaines dans des vidéos,
suivre des mouvements de caméra, suivre des objets en mouvement, extraire des modèles 3D
d'objets, produire des nuages de points 3D à partir de caméras stéréo image d'une scène entière,
trouver des images similaires à partir d'une base de données d'images, supprimer les yeux rouges
https://riptutorial.com/fr/home 14
des images prises, suivre les mouvements oculaires, reconnaître les décors et établir des
marqueurs pour la superposer à la réalité augmentée. , les développeurs et les chercheurs, le
nombre est plus de 47 000 et le nombre estimé de téléchargements dépasse 7 millions. La
bibliothèque est largement constituée de sociétés professionnelles, de groupes de recherche et
d’autres groupes.
De nombreuses entreprises bien établies telles que Google, Yahoo, Microsoft, Intel, IBM, Sony,
Honda et Toyota qui emploient la bibliothèque, ainsi que de nombreuses startups telles que
Applied Minds, VideoSurf et Zeitera, utilisent largement OpenCV. Les utilisations déployées
d'OpenCV s'étendent de l'assemblage d'images StreetView, à la détection d'intrusions dans la
vidéo de surveillance en Israël, à la surveillance des équipements miniers en Chine, à la détection
des accidents de noyade en Europe et à l'art interactif. L'Espagne et New York vérifient les pistes
en Turquie et inspectent les étiquettes des produits dans les usines du monde entier pour détecter
rapidement les visages au Japon. Il possède des interfaces C ++, C, Python, Java et MATLAB et
supporte Windows, Linux, Android et Mac OS. OpenCV s'appuie principalement sur les
applications de vision en temps réel et tire parti des instructions MMX et SSE lorsqu'elles sont
disponibles. Des interfaces complètes CUDA et OpenCL sont en cours de développement. Il
existe plus de 500 algorithmes et environ 10 fois plus de fonctions qui composent ou supportent
ces algorithmes. OpenCV est écrit nativement en C ++ et possède une interface basée sur des
modèles qui fonctionne de manière transparente avec les conteneurs STL.
https://riptutorial.com/fr/home 15
Chapitre 2: Accès aux pixels
Remarques
Veillez à bien connaître le type de cv::Mat vous parlez. Par exemple, si vous avez un cv::Mat de
type CV_8UC3 , mais que vous y accédez avec image.at<uchar>(r,c) aucune erreur ne se produira,
mais votre programme aura un comportement inattendu.
Examples
Accédez à des valeurs de pixel individuelles avec cv :: Mat :: at ()
Pour accéder aux valeurs de pixels dans un objet OpenCV cv::Mat , vous devez d'abord connaître
le type de votre matrice.
Pour accéder aux pixels individuels, le moyen le plus sûr, mais pas le plus efficace, consiste à
utiliser la méthode cv::Mat::at<T>(r,c) où r est la ligne de la matrice et c la colonne . L'argument
du modèle dépend du type de la matrice.
Disons que vous avez une cv::Mat image . Selon son type, la méthode d'accès et le type de
couleur de pixel seront différents.
Notez qu'OpenCV représente les images dans l'ordre des lignes principales , comme par
exemple Matlab ou la convention en Algèbre. Ainsi, si vos coordonnées de pixel sont (x,y) , vous
accéderez au pixel en utilisant image.at<..>(y,x) .
Alternativement, at<> également prendre en charge l'accès via un seul argument cv::Point .
Dans ce cas, l'accès se fait en colonne majeure :
image.at<..>(cv::Point(x,y));
https://riptutorial.com/fr/home 16
Consultez la documentation OpenCV pour plus de détails sur cette méthode.
Si l'efficacité est importante, un moyen rapide d'itérer sur des pixels dans un objet cv::Mat consiste
à utiliser sa méthode ptr<T>(int r) pour obtenir un pointeur sur le début de la ligne r (index basé
sur 0).
Cet objet ptr peut alors être utilisé pour accéder à la valeur de pixel sur la ligne r et la colonne c
en appelant ptr[c] .
Pour illustrer cela, voici un exemple où nous chargeons une image à partir du disque et inversons
ses canaux bleu et rouge, fonctionnant pixel par pixel:
#include <opencv2/core.hpp>
#include <opencv2/imgproc.hpp>
#include <opencv2/highgui.hpp>
if(!image.data) {
std::cout << "Error: the image wasn't correctly loaded." << std::endl;
return -1;
}
return 0;
}
https://riptutorial.com/fr/home 17
// Assumptions: Opecv is installed configured in the visual studio project
// Opencv version: OpenCV 3.1
#include "stdafx.h"
#include<opencv2/core/core.hpp>
#include<opencv2/highgui/highgui.hpp>
#include<opencv2/imgproc/imgproc.hpp>
#include<string>
#include<iostream>
int main()
{
cv::Mat output ;
imgGrayscale.copyTo(output); // Just to make sure the Mat objects are of the same size.
if (channels == 1)
{
for (int x = 0; x<imgGrayscale.rows; x++) {
for (int y = 0; y<imgGrayscale.cols; y++) {
// Accesssing values of each pixel
if (imgGrayscale.at<uchar>(x, y) >= threshhold) {
// Setting the pixel values to 255 if it's above the threshold
output.at<uchar>(x, y) = 254;
}
else if (imgGrayscale.at<uchar>(x, y) < threshhold) {
// Setting the pixel values to 255 if it's below the threshold
output.at<uchar>(x, y) = 0;
}
else {
// Just in case
printf("The value at (%d, %d) are not right. Value: %d\n", x, y,
imgGrayscale.at<uchar>(x, y));
}
}
https://riptutorial.com/fr/home 18
}
}
else if (channels == 3)
{
// This is only for gray scale images
printf("\tThe image has 3 channels. The function does not support images with 3
channels.\n");
}
return 0;
}
Ce n'est pas la meilleure façon de parcourir les pixels. cependant, c'est mieux que cv :: Mat :: at
<T>.
Supposons que vous ayez une image couleur dans votre dossier et que vous souhaitiez itérer
chaque pixel de cette image et effacer les canaux vert et rouge (notez que ceci est un exemple,
vous pouvez le faire de manière plus optimisée);
#include <opencv2/core/core.hpp>
#include <opencv2/highgui/highgui.hpp>
// Create a container
cv::Mat im;
//Create a vector
cv::Vec3b *vec;
https://riptutorial.com/fr/home 19
// Create a new window
cv::namedWindow("Resulting Image");
return 0;
}
cmake_minimum_required(VERSION 2.8)
project(Main)
find_package(OpenCV REQUIRED)
add_executable(Main main.cpp)
target_link_libraries(Main ${OpenCV_LIBS})
L'image originale:
L'image traitée:
https://riptutorial.com/fr/home 20
Notez que nous ne touchons que le canal bleu.
L'accès individuel aux pixels dans la structure OpenCV Mat peut être réalisé de plusieurs
manières. Pour comprendre comment accéder, il est préférable d'apprendre d'abord les types de
données.
typedef Vec<type, channels> Vec< channels>< one char for the type>
où type est l'un des uchar, short, int, float, double et les caractères de chaque type sont
respectivement b, s, i, f, d .
Considérez Mat mat(R,C,T) où R est #rows, C est #cols et T est le type. Voici quelques exemples
d’accès à la coordonnée (i, j) de mat :
https://riptutorial.com/fr/home 21
2D:
3D:
Notez qu'il est très important d'entrer un type correct dans <...> , sinon vous pouvez avoir une
erreur d'exécution ou des résultats indésirables.
https://riptutorial.com/fr/home 22
Chapitre 3: Afficher l'image OpenCV
Examples
Lecture de base et affichage d'une image
import cv2
#display image data in a new window with title 'I am an image display window'
cv2.imshow('I am an image display window',img)
Pour contrôler la taille de la fenêtre d'affichage à l'écran, ajoutez les commandes suivantes avant
la commande cv2.imshow:
import cv2
import numpy as np
import urllib
stream=urllib.urlopen('http://96.10.1.168/mjpg/video.mjpg')
bytes=''
while True:
bytes+=stream.read(1024)
a = bytes.find('\xff\xd8') # JPEG start
b = bytes.find('\xff\xd9') # JPEG end
if a!=-1 and b!=-1:
jpg = bytes[a:b+2] # actual image
bytes= bytes[b+2:] # other informations
https://riptutorial.com/fr/home 23
# decode to colored image ( another option is cv2.IMREAD_GRAYSCALE )
img = cv2.imdecode(np.fromstring(jpg, dtype=np.uint8),cv2.IMREAD_COLOR)
cv2.imshow('Window name',img) # display image while receiving data
if cv2.waitKey(1) ==27: # if user hit esc
exit(0) # exit program
Chaque JPEG commence par 0xff 0xd8 et se termine par 0xff 0xd9 . Entre ceux-ci se trouve l'image
réelle. Informations détaillées dans cette réponse SO
import org.opencv.core.Core;
import org.opencv.core.Mat;
import org.opencv.imgcodecs.Imgcodecs;
Si vous voulez voir des images, vous ne pouvez pas utiliser imshow car OpenCV-java n'a pas
cette méthode non plus. Au lieu de cela, vous pouvez écrire la méthode suivante.
Vous pouvez voir l'objet de résultat dans Jframe, Jlabel (icône jlabel), etc.
https://riptutorial.com/fr/home 24
Chapitre 4: Chargement et enregistrement de
différents formats de supports
Examples
Chargement des images
#include <highgui.h>
//...
...
Chargement de vidéos
Montrer comment utiliser cv::VideoCapture . Voici l'exemple du chargement de la vidéo à partir d'un
fichier:
#include "opencv2/highgui/highgui.hpp"
#include "opencv2/imgproc/imgproc.hpp"
#include "opencv2/core/core.hpp"
#include <iostream>
int main()
{
//Open video
if (!videoSource.open(VIDEO_PATH))
{
std::cout<<"Video not found at "<<VIDEO_PATH<<std::endl;
return 1; // Exit if fail
}
videoSource.set(CV_CAP_PROP_CONVERT_RGB, 1);
while(true)
{
videoSource >> frame;
if(frame.empty())
break;
https://riptutorial.com/fr/home 25
//Resize frame
cv::resize(frame, frame, cv::Size(320, 320 / cameraAspectRatio));
imshow("frame", frame);
waitKey(20);
}
waitKey(0);
return 0;
}
Capture en direct
Montrer comment utiliser cv::VideoCapture avec par exemple une webcam. Capturer les images de
la webcam et l'afficher. Voici le code exemple:
#include <iostream>
#include "opencv2/highgui/highgui.hpp"
#include "opencv2/imgproc/imgproc.hpp"
#include "opencv2/core/core.hpp"
int main()
{
if(!videoSource.open(0)) //if more cameras available use 1,2,...
return 1;
while(true)
{
videoSource >> frame;
if(frame.empty())
break;
imshow("Webcam", frame); //or any kinf of precessing
if(waitKey(1)==27)
break;//stop capturing is ESC pressed
}
return 0;
}
Enregistrement de vidéos
#include "opencv2/highgui/highgui.hpp"
#include <iostream>
https://riptutorial.com/fr/home 26
if (!cap.isOpened()) // if not success, exit program
{
cout << "ERROR: Cannot open the video file" << endl;
return -1;
}
cout << "Frame Size = " << dWidth << "x" << dHeight << endl;
while (1)
{
Mat frame;
if (waitKey(10) == 27) //wait for 'esc' key press for 30ms. If 'esc' key is pressed, break
loop
{
cout << "esc key is pressed by user" << endl;
break;
}
}
return 0;
En fait, l'exemple de Live Capture est utile pour capturer des images. Je l'utilise donc pour
capturer des images et les enregistrer dans un dossier.
https://riptutorial.com/fr/home 27
#include <fstream>
#include <string>
#include <opencv2/highgui/highgui.hpp>
#include <opencv2/core/core.hpp>
#include <opencv2/imgproc/imgproc.hpp>
int main()
{
std::stringstream file; // to write the file name
cv::imwrite(file.str(), frame);
return 0;
}
https://riptutorial.com/fr/home 28
Chapitre 5: Classificateurs en cascade
Examples
Utilisation de classificateurs en cascade pour détecter le visage
Python
Code
import numpy as np
import cv2
face_cascade = cv2.CascadeClassifier('haarcascade_frontalface_default.xml')
eye_cascade = cv2.CascadeClassifier('haarcascade_eye.xml')
Résultat
https://riptutorial.com/fr/home 29
Classificateurs en cascade pour détecter le visage avec Java
Java
Code
import org.opencv.core.Mat;
import org.opencv.core.MatOfRect;
import org.opencv.core.Point;
import org.opencv.core.Rect;
import org.opencv.core.Scalar;
import org.opencv.highgui.Highgui;
import org.opencv.highgui.VideoCapture;
import org.opencv.objdetect.CascadeClassifier;
System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
//Create object
CascadeClassifier faceDetector = new
CascadeClassifier(FaceDetector.class.getResource("haarcascade_frontalface_default.xml").getPath());
//Read image
Mat image = Highgui.imread("sourceimage.jpg");
/*
//Or read from webcam
https://riptutorial.com/fr/home 30
MatOfRect faceDetections = new MatOfRect();
//Result list
faceDetector.detectMultiScale(image, faceDetections);
//write result
Highgui.imwrite("result.png", image);
System.out.println("Succesfull");
}
Résultat
C ++
#include "opencv2/objdetect/objdetect.hpp"
#include "opencv2/highgui/highgui.hpp"
#include "opencv2/imgproc/imgproc.hpp"
#include <iostream>
#include <stdio.h>
// Function Headers
void detectAndDisplay(Mat frame);
// Global variables
string face_cascade_name = "./data/haarcascade_frontalface_alt2.xml";
CascadeClassifier face_cascade;
// Function main
https://riptutorial.com/fr/home 31
int main(void)
{
// Load the cascade
if (!face_cascade.load(face_cascade_name)){
printf("--(!)Error on cascade loading\n");
return (-1);
}
// Function detectAndDisplay
void detectAndDisplay(Mat frame)
{
std::vector<Rect> faces;
Mat frame_gray;
// Detect faces
face_cascade.detectMultiScale(frame_gray, faces, 1.1, 2, 0 | CASCADE_SCALE_IMAGE, Size(30,
30));
for (int ic = 0; ic < faces.size(); ic++) // Iterate through all current elements
(detected faces)
{
Point pt1(faces[ic].x, faces[ic].y); // Display detected faces on main window - live
stream from camera
Point pt2((faces[ic].x + faces[ic].height), (faces[ic].y + faces[ic].width));
rectangle(frame, pt1, pt2, Scalar(0, 255, 0), 2, 8, 0);
}
imshow("original", frame);
}
https://riptutorial.com/fr/home 32
https://riptutorial.com/fr/opencv/topic/6562/classificateurs-en-cascade
https://riptutorial.com/fr/home 33
Chapitre 6: Construire et compiler opencv
3.1.0-dev pour Python2 sous Windows en
utilisant CMake et Visual Studio
Remarques
Construire et compiler opencv 3.1.0-dev pour obtenir un accès pour les modules non libres peut
être un casse-tête pour certaines personnes, en particulier sur les machines Windows.
Contrairement à Ubuntu, la configuration d’opencv pour Windows prend un certain temps et
nécessite deux dépendances de pf pour être installées avant de générer et de compiler.
Les programmes que vous devez télécharger et installer avant d'aller plus loin dans n'importe
quelle étape sont les suivants:
Si vous souhaitez télécharger Python pour Win32, vous devez également télécharger
CMake pour Win32 même si vous utilisez un ordinateur 64 bits.
Après avoir installé toutes les dépendances ci-dessus, redémarrez votre PC et vous serez prêt à
passer à l'étape suivante.
Étape 2:
Si vous n'êtes pas le type de personne qui préfère lire, vous pouvez regarder ce tutoriel . Le
tutoriel vous emmène d'ici à la fin de cette documentation.
Vous devrez obtenir opencv et opencv_contrib à partir de github . Vous pouvez trouver les
deux à:
1. opencv
2. opencv_contrib
Créez un répertoire nommé opencv-3.1.0 dans lequel vous allez créer deux autres répertoires,
l'un pour la construction et l'autre pour les sources . Vous allez mettre les deux fichiers zip
téléchargés dans le fichier source après l'extraction.
https://riptutorial.com/fr/home 34
Par exemple, votre répertoire opencv-3.1.0 se trouve dans le lecteur C, vous aurez donc trois
chemins:
1. C:\opencv-3.1.0
2. C:\opencv-3.1.0\build
3. C:\opencv-3.1.0\sources
1. C:\opencv-3.1.0\sources\opencv
2. C:\opencv-3.1.0\sources\opencv_contrib
Maintenant c'est fait avec la préparation. Permet de faire des choses utiles.
Étape 3:
Exécutez CMake en tant qu'administrateur. Une fenêtre comme celle-ci apparaîtra et vous devrez
fournir deux répertoires, l’un pour les sources et l’autre pour l’endroit où les fichiers seront
compilés. L'image ci-dessous peut vous aider mieux que les mots.
https://riptutorial.com/fr/home 35
Ensuite, cliquez sur configurer et vous serez promu pour fournir les générateurs; c'est-à-dire des
compilateurs; pour opencv. Vous devez fournir le cl.exe situé dans Microsoft Visual Studio 2013.
Cliquez sur spécifiez les générateurs natifs et une fenêtre pop-up apparaîtra comme suit:
Les chemins seront quelque chose comme ceci: C:/Program Files (x86)/Microsoft Visual Studio
12.0/VC/bin/cl.exe . Indiquez votre chemin pour les champs C et C ++. Cliquez sur Terminer et
attendez que la configuration soit terminée. Vous devriez obtenir zéro erreur si vous suiviez
correctement toutes les étapes précédentes.
https://riptutorial.com/fr/home 36
Une fois la configuration de CMake terminée, vous verrez apparaître de nouveaux éléments dans
la fenêtre CMake qui sont mis en évidence en rouge. Ce sera quelque chose comme:
https://riptutorial.com/fr/home 37
Vérifiez les builds dont vous avez besoin en cliquant sur la petite case carrée. Recherchez la ligne
OPENCV_EXTRA_MODULES_PATH et indiquez le répertoire de modules dans opencv_contrib dans le
répertoire des sources.
https://riptutorial.com/fr/home 38
Une fois que vous avez terminé tout ce dont vous avez besoin et que le chemin des modules
supplémentaires est activé, appuyez à nouveau sur configure pour mettre à jour. Les lignes
précédemment surlignées ne seront plus mises en surbrillance et les nouveaux champs seront
surlignés en rouge à la place.
Cochez également les cases pour tout ce que vous devez construire.
À la fin de cette étape, cliquez sur Générer et vous aurez terminé avec CMake et vous pourrez le
fermer. S'il n'y a pas d'erreurs, vous obtiendrez un message à la fin du volet inférieur indiquant
Génération terminée .
https://riptutorial.com/fr/home 39
Étape 4:
Vous ne traitez que OpenCV.sln fichier OpenCV.sln et ne faites rien avec les fichiers restants. Ouvrez
ce fichier avec la version utilisée lors de la compilation dans le CMake à l'étape précédente. Ce
doit être Visual Microsoft 2013 .
https://riptutorial.com/fr/home 40
Lorsque vous ouvrez le fichier .sln, soyez patient car il faut un certain temps pour tout préparer à
la construction. Lorsque Prêt est stable (ne change pas), vous pouvez commencer à construire
vos cibles. Commencez à construire comme numéroté dans l'image ci-dessous. Assurez-vous
également que la Solution Configuration la Solution Configuration est Release pas Debug .
https://riptutorial.com/fr/home 41
Étape 5:
Lorsque la construction est terminée, vous devrez copier et coller quelques fichiers du répertoire
de construction dans le répertoire Python27 .
Vérification:
https://riptutorial.com/fr/home 42
Ouvrez IDLE et dans le type de shell Python:
Examples
Lecture de l'image et conversion en niveaux de gris
import cv2
import numpy as np
img = cv2.imread('<your_image>')
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
cv2.imshow('image', img)
https://riptutorial.com/fr/home 43
cv2.imshow('gray', gray)
cv2.waitKey(0)
cv2.destroyAllWindows()
Lire Construire et compiler opencv 3.1.0-dev pour Python2 sous Windows en utilisant CMake et
Visual Studio en ligne: https://riptutorial.com/fr/opencv/topic/6100/construire-et-compiler-opencv-3-
1-0-dev-pour-python2-sous-windows-en-utilisant-cmake-et-visual-studio
https://riptutorial.com/fr/home 44
Chapitre 7: Contraste et luminosité en C ++
Syntaxe
• void cv :: Mat :: convertTo (OutputArray m, int rtype, double alpha = 1, double beta = 0)
const
Paramètres
Paramètre Détails
matrice de sortie; s'il n'a pas une taille ou un type correct avant l'opération, il est
m
réaffecté
facteur d'échelle facultatif. Cela change le contraste d'une image. Les valeurs
alpha
inférieures à 1 diminuent le contraste et au dessus on augmente le contraste
delta facultatif ajouté aux valeurs mises à l'échelle. Les valeurs positives
bêta
augmentent la luminosité et les valeurs négatives les diminuent
Remarques
Contraste :
Le contraste est la différence de luminance ou de couleur qui permet de distinguer un objet (ou sa
représentation dans une image ou un affichage). Plus la différence entre un pixel et ses voisins
est élevée, plus le contraste est élevé dans cette zone.
Luminosité :
En d'autres termes, la luminosité est la perception provoquée par la luminance d'une cible
visuelle. En termes de pixels, plus la valeur d'un pixel est élevée, plus le pixel est lumineux.
i et j indiquent que le pixel est situé dans la i-ème ligne et la j-ième colonne.
https://riptutorial.com/fr/home 45
Les paramètres α > 0 et β sont souvent appelés paramètres de gain et de biais; On dit parfois que
ces paramètres contrôlent respectivement le contraste et la luminosité .
Opencv a une fonction appelée convertTo () qui peut appliquer ces deux opérations.
Sources:
http://docs.opencv.org/trunk/d3/d63/classcv_1_1Mat.html#adf88c60c5b4980e05bb556080916978b
http://opencv-srf.blogspot.ca/2013/07/change-contrast-of-image-or-video .html http://opencv-
srf.blogspot.ca/2013/07/change-brightness.html
Examples
Réglage de la luminosité et du contraste d'une image en c ++
if (img.empty())
{
cout << "Image cannot be loaded..!!" << endl;
return -1;
}
Mat img_higher_contrast;
img.convertTo(img_higher_contrast, -1, 2, 0); //increase the contrast (double)
Mat img_lower_contrast;
img.convertTo(img_lower_contrast, -1, 0.5, 0); //decrease the contrast (halve)
Mat img_higher_brightness;
img.convertTo(img_higher_brightness, -1, 1, 20); //increase the brightness by 20 for each
pixel
Mat img_lower_brightness;
img.convertTo(img_lower_brightness, -1, 1, -20); //decrease the brightness by 20 for each
pixel
//create windows
namedWindow("Original Image", CV_WINDOW_AUTOSIZE);
namedWindow("High Contrast", CV_WINDOW_AUTOSIZE);
namedWindow("Low Contrast", CV_WINDOW_AUTOSIZE);
namedWindow("High Brightness", CV_WINDOW_AUTOSIZE);
namedWindow("Low Brightness", CV_WINDOW_AUTOSIZE);
//show the image
https://riptutorial.com/fr/home 46
imshow("Original Image", img);
imshow("High Contrast", img_higher_contrast);
imshow("Low Contrast", img_lower_contrast);
imshow("High Brightness", img_higher_brightness);
imshow("Low Brightness", img_lower_brightness);
Sortie du programme:
https://riptutorial.com/fr/home 47
Chapitre 8: Créer une vidéo
Introduction
Chaque fois que vous travaillez avec des flux vidéo, vous pouvez éventuellement enregistrer votre
résultat de traitement d'image sous la forme d'un nouveau fichier vidéo. Pour des sorties vidéo
simples, vous pouvez utiliser la classe VideoWriter intégrée à OpenCV, conçue pour cela. Il est
utile d’examiner certains concepts avant de les utiliser. Ces concepts sont codec, c'est-à-dire
décodeur et FourCC (code à quatre caractères).
Examples
Créer une vidéo avec OpenCV (Java)
VideoWriter videoWriter;
videoWriter = new VideoWriter(outputFile, VideoWriter.fourcc('x', '2','6','4'),
fps, frameSize, isRGB);
//We have stated that we will use x264 as codec with FourCC
//For writing, we add the following method and it will write the image we give as parameter in
this call.
public void Write(Mat frame) {
if(videoWriter.isOpened()==false){
videoWriter.release();
throw new IllegalArgumentException("Video Writer Exception: VideoWriter not
opened,"
+ "check parameters.");
}
//Write video
videoWriter.write(frame);
}
//With Video Capture for example, we can read images from the camera and write the same video
https://riptutorial.com/fr/home 48
Chapitre 9: Dessin de formes (ligne, cercle,
..., etc.) en C ++
Introduction
Dans OpenCV, on peut dessiner de nombreuses formes telles que point, ligne, cercle, ..., etc. Il
existe une option pour remplir une forme. Le code suivant est explicite et montre comment les
formes sont dessinées.
Examples
Exemple de formes de dessin
#include <opencv2/core/core.hpp>
#include <opencv2/highgui/highgui.hpp>
#include <opencv2/imgproc.hpp> // drawing shapes
#include <iostream>
// filled circle
cv::Point centerCircle2(400,100);
cv::Scalar colorCircle2(0,100,0);
https://riptutorial.com/fr/home 49
//####################( Draw Rectangle )#######################
// unfilled
cv::Point p3(400,400), p4(450,450);
cv::Scalar colorRectangle1(0,0,255);
int thicknessRectangle1 = 3;
// filled
cv::Point p5(100,400), p6(150,450);
cv::Scalar colorRectangle2(255,0,255);
cv::waitKey(0);
return 0;
}
La sortie est
https://riptutorial.com/fr/home 50
OpenCV 3.2 Mac avec compilateur g ++
https://riptutorial.com/fr/home 51
Chapitre 10: Détection d'objets
Examples
Correspondance de modèle avec Java
import org.opencv.core.Core;
import org.opencv.core.Core.MinMaxLocResult;
import org.opencv.core.Mat;
import org.opencv.core.Point;
import org.opencv.core.Scalar;
import org.opencv.imgcodecs.Imgcodecs;
import org.opencv.imgproc.Imgproc;
System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
Mat source=null;
Mat template=null;
String filePath="C:\\Users\\mesutpiskin\\Desktop\\Object Detection\\Template
Matching\\Sample Image\\";
//Load image file
source=Imgcodecs.imread(filePath+"kapadokya.jpg");
template=Imgcodecs.imread(filePath+"balon.jpg");
Imgcodecs.imwrite(filePath+"sonuc.jpg", source);
System.out.println("Complated.");
}
RÉSULTAT
https://riptutorial.com/fr/home 52
Lire Détection d'objets en ligne: https://riptutorial.com/fr/opencv/topic/6735/detection-d-objets
https://riptutorial.com/fr/home 53
Chapitre 11: Détection de blob
Examples
Détection circulaire de blob
Cet exemple montre comment trouver des gouttes circulaires dans une image en niveaux de gris.
L'évaluation de la circularité d'un blob se fait à l'aide de l'aire et du périmètre (longueur de l'arc) du
contour. Le point central est évalué à l'aide des moments du contour.
#include "opencv/cv.h"
#include "opencv/highgui.h"
#include "opencv/cxcore.h"
if(contours.size() <= 0)
{
printf("no contours found");
return 0;
}
// filter the contours
vector<vector<Point>> filteredBlobs;
Mat centers = Mat::zeros(0,2,CV_64FC1);
for(int i = 0; i < contours.size(); i++)
{
// calculate circularity
double area = contourArea(contours[i]);
double arclength = arcLength(contours[i], true);
double circularity = 4 * CV_PI * area / (arclength * arclength);
if(circularity > 0.8)
{
filteredBlobs.push_back(contours[i]);
//calculate center
Moments mu = moments(contours[i], false);
Mat centerpoint = Mat(1,2,CV_64FC1);
centerpoint.at<double>(i,0) = mu.m10 / mu.m00; // x-coordinate
centerpoint.at<double>(i,1) = mu.m01 / mu.m00; // y-coordinate
centers.push_back(centerpoint);
}
https://riptutorial.com/fr/home 54
}
if(filteredBlobs.size() <= 0)
{
printf("no circular blobs found");
return 0;
}
drawContours(resultImg, filteredBlobs, -1, Scalar(0,0,255), CV_FILLED, 8);
imshow("Blobs",resultImg);
waitKey(0);
return 0;
}
https://riptutorial.com/fr/home 55
Chapitre 12: Détection de bord
Syntaxe
• bords = cv2. Canny (image, seuil1, seuil2 [, bords [, apertureSize [, L2gradient]]])
• void Canny (image InputArray, bords OutputArray, double threshold1, double threshold2, int
apertureSize = 3, bool L2gradient = false
Paramètres
Paramètre Détails
Examples
Algorithme Canny
L'algorithme de Canny est un détecteur de bord plus récent conçu comme un problème de
traitement du signal. Dans OpenCV, il génère une image binaire marquant les arêtes détectées.
Python:
import cv2
import sys
https://riptutorial.com/fr/home 56
# Display the output in a window
cv2.imshow('output', edges)
cv2.waitKey()
Canny Algorithm - C ++
Vous trouverez ci-dessous une utilisation de l'algorithme canny en c ++. Notez que l'image est
d'abord convertie en image en niveaux de gris, puis que le filtre gaussien est utilisé pour réduire le
bruit dans l'image. Ensuite, l'algorithme de Canny est utilisé pour la détection des contours.
#include "stdafx.h"
#include<opencv2/highgui/highgui.hpp>
#include<opencv2/imgproc/imgproc.hpp>
#include<string>
#include<iostream>
int main()
{
https://riptutorial.com/fr/home 57
200); // high threshold
// Declare windows
// Note: you can use CV_WINDOW_NORMAL which allows resizing the window
// or CV_WINDOW_AUTOSIZE for a fixed size window matching the resolution of the image
// CV_WINDOW_AUTOSIZE is the default
cv::namedWindow("imgOriginal", CV_WINDOW_AUTOSIZE);
cv::namedWindow("imgCanny", CV_WINDOW_AUTOSIZE);
//Show windows
cv::imshow("imgOriginal", imgOriginal);
cv::imshow("imgCanny", imgCanny);
Calcul automatique des seuils bas et haut pour l'opération Canny en ouverture
import cv2
def canny_webcam():
"Live capture frames from webcam and show the canny edge image of the captured frames."
cap = cv2.VideoCapture(0)
while True:
ret, frame = cap.read() # ret gets a boolean value. True if reading is successful (I
think). frame is an
# uint8 numpy.ndarray
canny_webcam()
"""
CannyTrackbar function allows for a better understanding of
the mechanisms behind Canny Edge detection algorithm and rapid
prototyping. The example includes basic use case.
https://riptutorial.com/fr/home 58
2 of the trackbars allow for tuning of the Canny function and
the other 2 help with understanding how basic filtering affects it.
"""
import cv2
def empty_function(*args):
pass
def CannyTrackbar(img):
win_name = "CannyTrackbars"
cv2.namedWindow(win_name)
cv2.resizeWindow(win_name, 500,100)
while True:
cth1_pos = cv2.getTrackbarPos("canny_th1", win_name)
cth2_pos = cv2.getTrackbarPos("canny_th2", win_name)
bsize_pos = cv2.getTrackbarPos("blur_size", win_name)
bamp_pos = cv2.getTrackbarPos("blur_amp", win_name)
cv2.destroyAllWindows()
return canny
img = cv2.imread("image.jpg")
canny = CannyTrackbar(img)
cv2.imwrite("result.jpg", canny)
https://riptutorial.com/fr/home 59
Chapitre 13: Fonctions de dessin en Java
Examples
Dessine un rectangle sur l'image
https://riptutorial.com/fr/home 60
Chapitre 14: Initialisation OpenCV sous
Android
Examples
Initialisation asynchrone
@Override
public void onResume() {
super.onResume();
OpenCVLoader.initAsync(OpenCVLoader.OPENCV_VERSION_3_1_0, this, mLoaderCallback);
}
...
}
https://riptutorial.com/fr/home 61
Dans ce cas, notre application fonctionne avec OpenCV Manager de manière asynchrone.
OnManagerConnected rappel OnManagerConnected sera appelé dans le thread d'interface utilisateur
lorsque l'initialisation sera terminée.
Veuillez noter qu'il est interdit d'utiliser des appels OpenCV ou de charger des libs
natives dépendantes d'OpenCV avant d'appeler ce rappel. Chargez vos propres
bibliothèques natives qui dépendent d'OpenCV après l'initialisation réussie d'OpenCV.
Par défaut BaseLoaderCallback mise en œuvre gâterie contexte d'application comme Activity et
demande Activity.finish() méthode de sortie en cas d'échec d'initialisation. Pour remplacer ce
comportement, vous devez remplacer la méthode finish() de la classe BaseLoaderCallback et
implémenter votre propre méthode de finalisation.
OpenCV Manager
OpenCV Manager est un service Android destiné à gérer les fichiers binaires de bibliothèque
OpenCV sur les périphériques des utilisateurs finaux. Il permet de partager les bibliothèques
dynamiques OpenCV entre les applications sur le même périphérique.
• Moins d’utilisation de la mémoire (environ 40 Mo). Toutes les applications utilisent les
mêmes fichiers binaires du service et ne conservent pas les bibliothèques natives à
l'intérieur.
• Optimisations spécifiques au matériel pour toutes les plates-formes prises en charge.
• Source de bibliothèque OpenCV fiable. Tous les packages avec OpenCV sont publiés sur le
marché Google Play.
• Mises à jour régulières et corrections de bugs.
Le seul inconvénient est que l'utilisateur est invité à télécharger et à appliquer une application
supplémentaire, ce qui réduit légèrement l'expérience utilisateur.
Initialisation statique
Selon cette approche, tous les fichiers binaires OpenCV sont inclus dans votre package
https://riptutorial.com/fr/home 62
d'application. Il est conçu principalement à des fins de développement et de débogage. Cette
approche est déconseillée pour le code de production, l'initialisation asynchrone est
recommandée.
Si votre projet d'application ne comporte pas de partie JNI, copiez simplement les librairies natives
OpenCV correspondantes d' OpenCV-3.1.0-android-sdk/sdk/native/libs dans le répertoire de votre
projet dans le dossier app/src/main/jniLibs .
Dans le cas du projet d'application avec une partie JNI, au lieu de copier manuellement des
bibliothèques, vous devez modifier votre fichier Android.mk : ajoutez les deux lignes de code
suivantes après "include $(CLEAR_VARS)" et avant "include path_to_OpenCV-3.1.0-android-
sdk/sdk/native/jni/OpenCV.mk" :
OPENCV_CAMERA_MODULES:=on
OPENCV_INSTALL_MODULES:=on
include $(CLEAR_VARS)
# OpenCV
OPENCV_CAMERA_MODULES:=on
OPENCV_INSTALL_MODULES:=on
include ../../sdk/native/jni/OpenCV.mk
Après cela, les bibliothèques OpenCV seront copiées dans le dossier jniLibs de votre application
lors de la construction de JNI.
La dernière étape de l'activation d'OpenCV dans votre application est le code d'initialisation Java
avant d'appeler l'API OpenCV. Cela peut être fait, par exemple, dans la section statique de la
classe Activité:
static {
if (!OpenCVLoader.initDebug()) {
// Handle initialization error
}
}
Si votre application inclut d'autres bibliothèques natives dépendantes d'OpenCV, vous devez les
charger après l'initialisation d'OpenCV:
static {
if (!OpenCVLoader.initDebug()) {
// Handle initialization error
} else {
System.loadLibrary("my_jni_lib1");
System.loadLibrary("my_jni_lib2");
}
}
https://riptutorial.com/fr/home 63
souhaitez publier votre approche d'utilisation de l'application avec l'initialisation
asynchrone.
https://riptutorial.com/fr/home 64
Chapitre 15: Installation OpenCV
Introduction
Installation d'OpenCV sous Linux, Mac OS et Windows
Examples
Installation d'OpenCV sur Ubuntu
Lien source
sudo su
2-Installation de Dependenices:
https://riptutorial.com/fr/home 65
sudo apt-get install libtbb-dev libeigen3-dev
8 – Installation Java:
Installation en 9 python:
wget https://github.com/opencv/opencv/archive/3.2.0.zip
unzip 3.2.0.zip
rm 3.2.0.zip
13-Build OPENCV:
mv opencv-3.2.0 opencv
cd opencv
mkdir build
cd build
make -j4
https://riptutorial.com/fr/home 66
sudo sh -c 'echo "/usr/local/lib" > /etc/ld.so.conf.d/opencv.conf'
sudo ldconfig
https://riptutorial.com/fr/home 67
Chapitre 16: Modification du contenu de
l'image
Examples
Définir l'image entière sur une couleur unie
Étant donné une taille de cv::Mat img non vide, nous pouvons la remplir de plusieurs manières:
img = cv::Scalar(blueVal,greenVal,redVal);
img.setTo(cv::Scalar(blueVal,greenVal,redVal));
Utilisation:
cvSet(img, CV_RGB(redVal,greenVal,blueVal));
Dans OpenCV, les images peuvent être RVB / BGR, HSV, niveaux de gris, noir et blanc, etc. Il est
essentiel de connaître le type de données avant de traiter les images.
Les types de données d'image sont principalement CV_8UC3 (matrice de uchar à 3 canaux) et
CV_8U (matrice de uchar à 1 canal), mais la conversion à d'autres types tels que CV_32FC3,
CV_64F est également possible. (voir types de données )
Considérez que l'image est une image RVB qui est lue par la fonction de imread .
gray.at<uchar>(i,j) = X;
Notez que, dans OpenCV, les images en noir et blanc sont stockées en tant que type CV_8U avec
les valeurs 0 et 255. Par conséquent, la modification des images BW est identique à celle des
images grises.
https://riptutorial.com/fr/home 68
Modification de la couleur de l’image dans OpenCV - kmeans (). Pour analyser
tous les pixels d'une image et remplacer les valeurs de pixels par des
couleurs génériques.
#include opencv2/opencv.hpp> #include vector> using namespace std; using namespace cv; int
main() { Mat3b img = imread("test.jpg"); imshow("Original", img); // Cluster int K = 8; int n =
img.rows * img.cols; Mat data = img.reshape(1, n); data.convertTo(data, CV_32F); Mat labels;
Mat1f colors; kmeans(data, K, labels, cv::TermCriteria(), 1, cv::KMEANS_PP_CENTERS, colors); for
(int i = 0; i < n; ++i) { data.at<float>(i, 0) = colors(labels.at<int>(i), 0); data.at<float>(i,
1) = colors(labels.at<int>(i), 1); data.at<float>(i, 2) = colors(labels.at<int>(i), 2); } Mat
reduced = data.reshape(3, img.rows); reduced.convertTo(reduced, CV_8U); imshow("Reduced",
reduced); waitKey(0); return 0;
imshow("Original", img);
// Cluster
int K = 8;
int n = img.rows * img.cols;
Mat data = img.reshape(1, n);
data.convertTo(data, CV_32F);
Mat labels;
Mat1f colors;
kmeans(data, K, labels, cv::TermCriteria(), 1, cv::KMEANS_PP_CENTERS, colors);
imshow("Reduced", reduced);
waitKey(0);
return 0;
https://riptutorial.com/fr/home 69
Chapitre 17: Structures de base
Introduction
Cette rubrique couvre les structures de base dans OpenCV. Les structures qui seront abordées
dans cette rubrique sont DataType , Point , Vec , Size , Rect , Scalar , Ptr et Mat .
Examples
Type de données
Les types primitifs dans OpenCV sont unsigned char, bool, signed char, unsigned short, signed
short, int, float, double . Tout type de données dans OpenCV est défini comme CV_<bit-
depth>{U|S|F}C(<number_of_channels>) où U: unsigned , S:signed et F:floating point .
Par exemple, CV_32FC2 est une CV_32FC2 32 bits, à virgule flottante et 2 canaux. et la définition de
base, les types de canal sont
#define CV_8U 0
#define CV_8S 1
#define CV_16U 2
#define CV_16S 3
#define CV_32S 4
#define CV_32F 5
#define CV_64F 6
#define CV_USRTYPE1 7
Les autres types avec un canal plus élevé sont produits à partir de ceux-ci par la définition
suivante:
Tapis
Mat (Matrix) est un tableau à n dimensions qui peut être utilisé pour stocker différents types de
données, telles que des images RVB, HSV ou en niveaux de gris, des vecteurs avec des valeurs
réelles ou complexes, d'autres matrices, etc.
Un Mat contient les informations suivantes: width , height , type , channels , data , flags , datastart ,
dataend , etc.
Il existe plusieurs façons de créer une variable Mat. Considérez que je veux créer une matrice
avec 100 lignes, 200 colonnes, tapez CV_32FC3:
https://riptutorial.com/fr/home 70
int R = 100, C = 200;
Mat m1; m1.create(R,C,CV_32FC3);//creates empty matrix
Mat m2(cv::Size(R, C), CV_32FC3); // creates a matrix with R rows, C columns with data type T
where R and C are integers,
Mat m3(R,C,CV_32FC3); // same as m2
Tapis d'initialisation:
Mat m1 = Mat::zeros(R,C,CV_32FC3); // This initialized to zeros, you can use one, eye or
cv::randn etc.
Mat m2(R,C,CV_32FC3);
for (int i = 0; i < m2.rows; i++)
for (int j = 0; j < m2.cols; j++)
for (int k = 0; k < m2.channels(); k++)
m2.at<Vec3f>(i,j)[k] = 0;
//Note that, because m2 is a float type and has 3 channels, we used Vec3f, for more info see
Vec
Vec
Vec (Vector) est une classe de modèle pour les valeurs numériques. Contrairement au c++ vector ,
il stocke généralement des vecteurs courts (quelques éléments seulement).
typedef Vec<type, channels> Vec< channels>< one char for the type>;
où type est l'un des uchar, short, int, float, double et les caractères de chaque type sont
respectivement b, s, i, f, d .
Par exemple, Vec3b indique un vecteur char non signé de 3 canaux. Chaque index d'une image
RVB est dans ce format.
v1 = v2 + v3
v1 = v2 - v3
v1 = v2 * scale
v1 = scale * v2
v1 = -v2
v1 += v2 and other augmenting operations
v1 == v2, v1 != v2
https://riptutorial.com/fr/home 71
Lire Structures de base en ligne: https://riptutorial.com/fr/opencv/topic/9099/structures-de-base
https://riptutorial.com/fr/home 72
Chapitre 18: Traitement d'image
Syntaxe
1. Syntaxe du flou gaussien C ++: GaussianBlur vide (InputArray src, OutputArray dst, Taille
ksize, double sigmaX, double sigmaY = 0, int borderType = BORDER_DEFAULT)
Paramètres
Paramètres
du flou Détails
gaussien
Image d'entrée, l'image peut avoir n'importe quel nombre de canaux, qui
src sont traités indépendamment, mais la profondeur doit être CV_8U , CV_16U ,
CV_16S , CV_32F ou CV_64F .
Écart type du noyau gaussien dans la direction Y Si sigmaY est à zéro, il est
défini pour être égal à sigmaX , si les deux sigmas sont des zéros, ils sont
calculés à partir de ksize.width et de ksize.height . Pour contrôler
sigmaY
complètement le résultat indépendamment des modifications futures
possibles de toute cette sémantique, il est recommandé de spécifier tous
les ksize , sigmaX et sigmaY .
Remarques
Je ne pense pas qu'il soit logique de mettre la syntaxe et les paramètres spécifiques au flou
gaussien dans ce lieu, car le sujet est tellement vaste qu'il devrait inclure de nombreux autres
exemples.
Examples
Lissage d'images avec flou gaussien en C ++
https://riptutorial.com/fr/home 73
Le lissage, également appelé flou , est l’une des opérations les plus couramment utilisées dans le
traitement d’images.
L'utilisation la plus courante de l'opération de lissage consiste à réduire le bruit dans l'image pour
un traitement ultérieur.
Nous allons examiner l'un des filtres les plus couramment utilisés pour brouiller une image, le
filtre gaussien utilisant la fonction de bibliothèque OpenCV GaussianBlur() . Ce filtre est conçu
spécifiquement pour supprimer le bruit haute fréquence des images.
#include <opencv2/opencv.hpp>
#include <iostream>
return 0;
}
Pour la définition mathématique détaillée et d'autres types de filtres, vous pouvez vérifier la
documentation d'origine .
Seuillage
En Python:
https://riptutorial.com/fr/home 74
import cv2
image_path= 'd:/contour.png'
img = cv2.imread(image_path)
Filtrage Bilatéral
Dans les applications de traitement d'image, les filtres bilatéraux constituent un type particulier de
filtres non linéaires .
https://riptutorial.com/fr/home 75
informations précieuses sur la scène et nous ne voulons pas les perdre. Le filtre bilatéral connaît
la structure de la scène et a tendance à agir comme un filtre de flou classique lorsqu'il se trouve
sur une zone sans arêtes. cependant, quand il voit un bord, il change de comportement; de sorte
que le flou ne fonctionne pas sur tous les bords, mais fonctionne le long des bords, ce qui signifie
qu'ils sont des filtres préservant les bords.
#include <opencv2/opencv.hpp>
#include <iostream>
https://riptutorial.com/fr/home 76
Chapitre 19: Utilisation de classificateurs en
cascade en Java
Syntaxe
• CascadeClassifier cascade = new CascadeClassifier ("cascade.xml"); // Crée un
classificateur en cascade à partir de cascade.xml
• Mat image = Imgcodecs.imread ("image.png"); // Convertit image.png en un objet Mat
(Matrix)
• Détections MatOfRect = new MatOfRect (); // Crée un fichier MatOfRect (Matrix of
Rectangles) vide, utilisé comme sortie pour nos classes de détection
• detections.toArray (); // Retourne un tableau d'objets Rect pouvant être itéré sur
• Imgproc.rectangle (image, nouveau point (rect.x, rect.y), nouveau point (rect.x + rect.width,
rect.y + rect.height), nouveau scalaire (0, 255, 0)); // Dessine un rectangle à contour vert
depuis les emplacements x et y du premier point vers l'emplacement x et y du second point
sur l'objet Mat "image". "rect" est un objet Rect, généralement fourni par detections.toArray
(). Utilise la classe de points OpenCV.
• Imgcodecs.imwrite ("output.png", image); // Ecrit l'objet Mat modifié "image" dans le fichier
"output.png"
• CascadeClassifier.detectMultiScale (image, détections); // Détecte tout objet dans l'objet Mat
"image" et affiche les détections dans l'objet MatOfRect "détections"
• CascadeClassifier.detectMultiScale (image, détections, scaleFactor , minNeighbors , flags
, minSize , maxSize ); // Effectue une détection avec des paramètres supplémentaires. Voir
les détails ci-dessous.
• Imgproc.ellipse (image, centre, axes , 0, 0, 360, nouveau Scalar (255, 0, 255), épaisseur ,
lineType , 0); // Dessine une ellipse sur l'image au center du point. Utilise la classe de points
OpenCV.
Paramètres
Paramètre Détails
facteur Combien la taille de l'image est réduite à chaque échelle d'image. Par
d'échelle défaut = 1.1
Drapeaux hérités Dans la plupart des cas, cela devrait être mis à 0 . Par
drapeaux
défaut = 0
La taille minimale d'un rectangle candidat peut être. Cela utilise la classe de
minSize Size OpenCV. Peut être utilisé pour réduire le temps de détection et
l'utilisation du processeur, ainsi que pour réduire les faux positifs.
https://riptutorial.com/fr/home 77
Paramètre Détails
les axes Utilise la classe de taille OpenCV. Définit la largeur et la hauteur de l'ellipse.
Examples
Obtenir une image statique, détecter les éléments et afficher les résultats.
import org.opencv.core.Mat;
import org.opencv.core.MatOfRect;
import org.opencv.core.Point;
import org.opencv.core.Rect;
import org.opencv.core.Scalar;
import org.opencv.imgcodecs.Imgcodecs;
import org.opencv.imgproc.Imgproc;
import org.opencv.objdetect.CascadeClassifier;
}
}
https://riptutorial.com/fr/home 78
Le Rect[] renvoyé par diceDetections.toArray() peut être itéré sur. Chaque Rect à l'intérieur du
tableau aura quatre propriétés principales: x , y , width et height . x et y définissent la position
supérieure gauche du rectangle et width et height renvoie un int de la largeur et de la hauteur du
rectangle. Ceci est utilisé pour dessiner des rectangles sur des images. Les paramètres requis
minimaux de la fonction Imgproc.rectangle sont les suivants:
Les deux Point sont utilisés pour les positions du coin supérieur gauche et du coin inférieur droit.
Ces positions sont à la fois absolues sur l'image fournie comme premier paramètre et non sur
l'autre. Vous devez donc ajouter la position x ou y du rectangle en plus de la width ou de la height
pour définir correctement le point de end .
Notez que la classe Point utilisée dans ces paramètres n'est pas la classe Point la bibliothèque
standard de Java. Vous devez importer la classe de Point OpenCV à la place!
Cet exemple présente la classe VideoCapture , où nous l'utilisons pour prendre une image à partir
d'une webcam et l'enregistrer sur une image.
import org.opencv.core.Mat;
import org.opencv.core.MatOfRect;
import org.opencv.core.Point;
import org.opencv.core.Rect;
import org.opencv.core.Scalar;
import org.opencv.imgcodecs.Imgcodecs;
import org.opencv.imgproc.Imgproc;
import org.opencv.objdetect.CascadeClassifier;
import org.opencv.videoio.VideoCapture;
https://riptutorial.com/fr/home 79
// Save the visualized detection.
Imgcodecs.imwrite(output, image);
}
}
Cet exemple de Daniel Baggio a été tiré directement de cette réponse StackExchange , mais a été
republié pour la visibilité.
Cette classe prend un objet Mat et renvoie l'objet BufferedImage utilisé par les bibliothèques
javax.swing . Cela peut être utilisé par un objet Graphics pour dessiner l'image.
return null;
}
Cet exemple utilise Dice et les points noirs sur les dés (les pips) comme objet. Comme l'exemple
est assez long, expliquer d'abord certains concepts clés est essentiel pour comprendre l'exemple.
Comprendre le premier exemple, "Obtention d’une image statique, détection des éléments et
sortie des résultats". est essentiel pour comprendre cet exemple, en particulier comment OpenCV
dessine des rectangles.
https://riptutorial.com/fr/home 80
Nous utiliserons la méthode de sous-application, où nous utiliserons une zone détectée comme
base pour appliquer davantage de détections. Ceci n'est possible que si un objet se trouve
toujours dans un autre objet que nous pouvons détecter, comme nos pips sur nos dés. Cette
méthode présente plusieurs avantages:
• Au lieu de scanner l'image entière, il suffit de scanner la zone dans laquelle nous savons
que l'objet se trouvera.
• Supprime toute possibilité de faux positifs en dehors de la zone de détection.
Nous faisons cela en appliquant d'abord un balayage classificateur en cascade sur l'image entière
pour nous donner un objet MatOfRect contenant nos grands objets (dés, dans ce cas). Nous
parcourons ensuite le tableau Rect[] donné par la fonction toArray() de l'objet MatOfRect . Cet objet
Rect est utilisé pour créer un objet Mat temporaire qui est "recadré" aux propriétés de l'objet Rect (
x, y, width, height ) à partir de l'image d'origine, où nous pouvons alors effectuer des détections
sur l'objet Mat temporaire. En d'autres termes, nous demandons au classificateur de ne faire que
des détections sur les parties de dés de l'image, et nous spécifions la position de chaque dé en
utilisant les objets Rect obtenus en effectuant une détection sur l'image entière.
Cependant, les objets Rect (pips) ont leurs propriétés par rapport à leurs dés, et non à l'image elle-
même. Pour résoudre ce problème, lorsque nous voulons dessiner des rectangles à l'image réelle
montrant l'emplacement des pépins, nous ajoutons à la fois dice.x et dice.y au Point départ.
import org.opencv.core.Mat;
import org.opencv.core.MatOfRect;
import org.opencv.core.Point;
import org.opencv.core.Rect;
import org.opencv.core.Scalar;
import org.opencv.core.Size;
import org.opencv.imgcodecs.Imgcodecs;
import org.opencv.imgproc.Imgproc;
import org.opencv.objdetect.CascadeClassifier;
import org.opencv.videoio.VideoCapture;
https://riptutorial.com/fr/home 81
private CascadeClassifier diceCascade =
new CascadeClassifier("res/newMethod/diceCascade.xml");
private CascadeClassifier pipCascade =
new CascadeClassifier("res/newMethod/pipCascade6.xml");
private VideoCapture vc = new VideoCapture();
private Mat image;
// Gets the number of detected pips and draws a cricle around the ROI
for (int y = 0; y < pipDetections.toArray().length; y++) {
// Provides the relative position of the pips to the dice ROI
Rect pipRect = pipDetections.toArray()[y];
return image;
}
}
La fonction getNextImage() renvoie un objet Mat , qui, associé aux autres exemples publiés, peut
https://riptutorial.com/fr/home 82
être appelé en permanence et peut être converti en BufferImage pour fournir un flux de diffusion
affichant les détections.
https://riptutorial.com/fr/home 83
Chapitre 20: Utiliser VideoCapture avec
OpenCV Python
Examples
Lecture d'images d'une vidéo pré-capturée
import numpy as np
import cv2
frameStack=[]
numFrames=10
for fr in range(numFrames):
cap.set(cv2.CAP_PROP_POS_FRAMES,fr) #specifies which frame to read next
frame=cap.read() #read the frame
#gray = cv2.cvtColor(frame[1], cv2.COLOR_BGR2GRAY) #convert to gray scale
frameStack.append(frame[1]) #add current frame to our frame Stack
Il n'y a pas de solution dans Java, vous devez écrire une méthode pour cela. Cette méthode est
un Mat2bufferedImage. Prend l'objet mat comme paramètre et renvoie l'image.
https://riptutorial.com/fr/home 84
JLabel vidpanel = new JLabel();
jframe.setContentPane(vidpanel);
jframe.setVisible(true);
while (true) {
if (camera.read(frame)) {
}
}
}
https://riptutorial.com/fr/home 85
Crédits
S.
Chapitres Contributeurs
No
Afficher l'image
3 Aleksandar, Elizabeth, jlarsch, mesutpiskin, smttsp
OpenCV
Chargement et
enregistrement de Adi Shavit, cagatayodabasi, Jav_Rock, Lakshya Kejriwal, MD.
4
différents formats de Nazmul Kibria
supports
Classificateurs en
5 Arijit, MD. Nazmul Kibria, mesutpiskin
cascade
Construire et
compiler opencv
3.1.0-dev pour
6 Python2 sous Tes3awy
Windows en utilisant
CMake et Visual
Studio
Contraste et
7 Ehsan Ab, MD. Nazmul Kibria
luminosité en C ++
Dessin de formes
9 (ligne, cercle, ..., CroCo
etc.) en C ++
https://riptutorial.com/fr/home 86
en Java
Initialisation OpenCV
14 David Miguel
sous Android
Modification du
16 Adi Shavit, DivyaMaheswaran, smttsp
contenu de l'image
Utilisation de
19 classificateurs en Edward Shen
cascade en Java
Utiliser VideoCapture
20 avec OpenCV jlarsch, mesutpiskin
Python
https://riptutorial.com/fr/home 87