OpenCV - Guide rapide

OpenCV est une bibliothèque multiplateforme à l'aide de laquelle nous pouvons développer en temps réel computer vision applications. Il se concentre principalement sur le traitement d'image, la capture vidéo et l'analyse, y compris des fonctionnalités telles que la détection de visage et la détection d'objets.

Commençons le chapitre en définissant le terme «Computer Vision».

Vision par ordinateur

La vision par ordinateur peut être définie comme une discipline qui explique comment reconstruire, interrompre et comprendre une scène 3D à partir de ses images 2D, en termes de propriétés de la structure présente dans la scène. Il traite de la modélisation et de la reproduction de la vision humaine à l'aide de logiciels et de matériel informatique.

La vision par ordinateur chevauche considérablement les domaines suivants -

Image Processing - Il se concentre sur la manipulation d'images.
Pattern Recognition - Il explique diverses techniques pour classer les modèles.
Photogrammetry - Il s'agit d'obtenir des mesures précises à partir d'images.

Vision par ordinateur vs traitement d'image

Image processingtraite de la transformation d'image en image. L'entrée et la sortie du traitement d'image sont toutes deux des images.

Computer visionest la construction de descriptions explicites et significatives d'objets physiques à partir de leur image. Le résultat de la vision par ordinateur est une description ou une interprétation de structures dans une scène 3D.

Applications de la vision par ordinateur

Nous avons répertorié ici certains des principaux domaines dans lesquels la vision par ordinateur est largement utilisée.

Application robotique

Localisation - Déterminez automatiquement l'emplacement du robot
Navigation
Évitement des obstacles
Assemblage (peg-in-hole, soudure, peinture)
Manipulation (par exemple, manipulateur de robot PUMA)
Human Robot Interaction (HRI) - Robotique intelligente pour interagir et servir les gens

Application de médecine

Classification et détection (par exemple, classification des lésions ou des cellules et détection des tumeurs)
Segmentation 2D / 3D
Reconstruction d'organes humains en 3D (IRM ou échographie)
Chirurgie robotique guidée par la vision

Application d'automatisation industrielle

Inspection industrielle (détection de défauts)
Assembly
Lecture de codes-barres et d'étiquettes d'emballage
Tri d'objets
Compréhension des documents (par exemple OCR)

Application de sécurité

Biométrie (iris, empreinte digitale, reconnaissance faciale)
Surveillance - Détection de certaines activités ou comportements suspects

Application de transport

Véhicule autonome
Sécurité, p. Ex. Surveillance de la vigilance du conducteur

Caractéristiques de la bibliothèque OpenCV

En utilisant la bibliothèque OpenCV, vous pouvez -

Lire et écrire des images
Capturez et enregistrez des vidéos
Images de processus (filtrer, transformer)
Effectuer la détection des fonctionnalités
Détectez des objets spécifiques tels que des visages, des yeux, des voitures, dans les vidéos ou les images.
Analysez la vidéo, c'est-à-dire estimez le mouvement qu'elle contient, soustrayez l'arrière-plan et suivez les objets qu'elle contient.

OpenCV a été initialement développé en C ++. En plus de cela, des liaisons Python et Java ont été fournies. OpenCV fonctionne sur divers systèmes d'exploitation tels que Windows, Linux, OSx, FreeBSD, Net BSD, Open BSD, etc.

Ce tutoriel explique les concepts d'OpenCV avec des exemples utilisant des liaisons Java.

Modules de bibliothèque OpenCV

Voici les principaux modules de bibliothèque de la bibliothèque OpenCV.

Fonctionnalité de base

Ce module couvre les structures de données de base telles que Scalar, Point, Range, etc., qui sont utilisées pour créer des applications OpenCV. En plus de ceux-ci, il comprend également le tableau multidimensionnelMat, qui est utilisé pour stocker les images. Dans la bibliothèque Java d'OpenCV, ce module est inclus sous forme de package avec le nomorg.opencv.core.

Traitement d'image

Ce module couvre diverses opérations de traitement d'images telles que le filtrage d'images, les transformations géométriques d'images, la conversion d'espace colorimétrique, les histogrammes, etc. Dans la bibliothèque Java d'OpenCV, ce module est inclus sous forme de package avec le nom org.opencv.imgproc.

Vidéo

Ce module couvre les concepts d'analyse vidéo tels que l'estimation de mouvement, la soustraction d'arrière-plan et le suivi d'objets. Dans la bibliothèque Java d'OpenCV, ce module est inclus sous forme de package avec le nomorg.opencv.video.

E / S vidéo

Ce module explique la capture vidéo et les codecs vidéo à l'aide de la bibliothèque OpenCV. Dans la bibliothèque Java d'OpenCV, ce module est inclus sous forme de package avec le nomorg.opencv.videoio.

calib3d

Ce module comprend des algorithmes concernant les algorithmes de géométrie de base à vues multiples, l'étalonnage de caméra simple et stéréo, l'estimation de la pose de l'objet, la correspondance stéréo et les éléments de reconstruction 3D. Dans la bibliothèque Java d'OpenCV, ce module est inclus sous forme de package avec le nomorg.opencv.calib3d.

caractéristiques2d

Ce module comprend les concepts de détection et de description des fonctionnalités. Dans la bibliothèque Java d'OpenCV, ce module est inclus sous forme de package avec le nomorg.opencv.features2d.

Objdetect

Ce module inclut la détection d'objets et d'instances des classes prédéfinies telles que les visages, les yeux, les mugs, les personnes, les voitures, etc. Dans la bibliothèque Java d'OpenCV, ce module est inclus sous forme de package avec le nom org.opencv.objdetect.

Highgui

Il s'agit d'une interface facile à utiliser avec des capacités d'interface utilisateur simples. Dans la bibliothèque Java d'OpenCV, les fonctionnalités de ce module sont incluses dans deux packages différents à savoir,org.opencv.imgcodecs et org.opencv.videoio.

Une brève histoire d'OpenCV

OpenCV était initialement une initiative de recherche d'Intel visant à conseiller les applications gourmandes en CPU. Il a été officiellement lancé en 1999.

En 2006, sa première version majeure, OpenCV 1.0, est sortie.
En octobre 2009, la deuxième version majeure, OpenCV 2, est sortie.
En août 2012, OpenCV a été repris par une organisation à but non lucratif OpenCV.org.

Dans ce chapitre, vous apprendrez à installer OpenCV et à configurer son environnement dans votre système.

Installer OpenCV

Tout d'abord, vous devez télécharger OpenCV sur votre système. Suivez les étapes ci-dessous.

Step 1 - Ouvrez la page d'accueil de OpenCV en cliquant sur le lien suivant: http://opencv.org/ En cliquant, vous verrez sa page d'accueil comme indiqué ci-dessous.

Step 2 - Maintenant, cliquez sur le Downloadslien mis en évidence dans la capture d'écran ci-dessus. En cliquant, vous serez dirigé vers la page de téléchargement d'OpenCV.

Step 3 - En cliquant sur le lien en surbrillance dans la capture d'écran ci-dessus, un fichier nommé opencv-3.1.0.exesera téléchargé. Extrayez ce fichier pour générer un dossieropencv dans votre système, comme illustré dans la capture d'écran suivante.

Step 4 - Ouvrez le dossier OpenCV → build → java. Vous trouverez ici le fichier jar d'OpenCV nomméopencv-310.jar. Enregistrez ce fichier dans un dossier séparé pour une utilisation ultérieure.

Installation d'Eclipse

Après avoir téléchargé les fichiers JAR requis, vous devez intégrer ces fichiers JAR à votre environnement Eclipse. Vous pouvez le faire en définissant le chemin de génération sur ces fichiers JAR et en utilisantpom.xml.

Définition du chemin de construction

Voici les étapes pour configurer OpenCV dans Eclipse -

Step 1- Assurez-vous que vous avez installé Eclipse dans votre système. Sinon, téléchargez et installez Eclipse dans votre système.

Step 2 - Ouvrez Eclipse, cliquez sur Fichier, Nouveau et ouvrez un nouveau projet comme indiqué dans la capture d'écran suivante.

Step 3 - En sélectionnant le projet, vous obtiendrez le New Projectsorcier. Dans cet assistant, sélectionnez le projet Java et continuez en cliquant sur leNext bouton, comme indiqué dans la capture d'écran suivante.

Step 4 - En continuant, vous serez dirigé vers le New Java Project wizard. Créez un nouveau projet et cliquez surNext, comme illustré dans la capture d'écran suivante.

Step 5- Après avoir créé un nouveau projet, faites un clic droit dessus. SélectionnerBuild Path et cliquez Configure Build Path… comme indiqué dans la capture d'écran suivante.

Step 6 - En cliquant sur le Build Path option, vous serez dirigé vers le Java Build Path wizard. Clique leAdd External JARs bouton, comme indiqué dans la capture d'écran suivante.

Step 7 - Sélectionnez le chemin où vous avez enregistré le fichier opencv-310.jar.

Step 8 - En cliquant sur le Open dans la capture d'écran ci-dessus, ces fichiers seront ajoutés à votre bibliothèque.

Step 9 - En cliquant OK, vous ajouterez avec succès les fichiers JAR requis au projet actuel et vous pourrez vérifier ces bibliothèques ajoutées en développant les bibliothèques référencées.

Définition du chemin d'accès aux bibliothèques natives

En plus des fichiers JAR, vous devez définir le chemin des bibliothèques natives (fichiers DLL) d'OpenCV.

Location of DLL files - Ouvrez le dossier d'installation de OpenCV et allez dans le sous-dossier build → java. Ici vous trouverez les deux dossiersx64 (64 bits) et x86 (32 bits) qui contiennent le dll fichiers d'OpenCV.

Ouvrez le dossier correspondant adapté à votre système d'exploitation, puis vous pouvez voir le dll fichier, comme indiqué dans la capture d'écran suivante.

Maintenant, définissez également le chemin de ce fichier en suivant les étapes ci-dessous -

Step 1- Une fois de plus, ouvrez la fenêtre JavaBuildPath. Ici, vous pouvez observer le fichier JAR ajouté et leJRE System Library.

Step 2 - En le développant, vous obtiendrez les bibliothèques système et Native library location, comme mis en évidence dans la capture d'écran suivante.

Step 3 - Double-cliquez sur le Native library location. Ici, vous pouvez voir leNative Library Folder Configuration window comme indiqué ci-dessous.

Ici, cliquez sur le bouton External Folder… et sélectionnez l'emplacement du dll fichier dans votre système.

Pour capturer une image, nous utilisons des appareils tels que des appareils photo et des scanners. Ces appareils enregistrent les valeurs numériques de l'image (Ex: valeurs de pixels). OpenCV est une bibliothèque qui traite les images numériques, nous devons donc stocker ces images pour le traitement.

le MatLa classe de la bibliothèque OpenCV est utilisée pour stocker les valeurs d'une image. Il représente un tableau à n dimensions et est utilisé pour stocker des données d'image d'images en niveaux de gris ou en couleurs, des volumes de voxel, des champs vectoriels, des nuages de points, des tenseurs, des histogrammes, etc.

Cette classe comprend deux parties de données: le header et un pointer

Header - Contient des informations telles que la taille, la méthode utilisée pour le stockage et l'adresse de la matrice (taille constante).
Pointer - Stocke les valeurs de pixel de l'image (continue à varier).

La classe Mat

La bibliothèque Java OpenCV fournit cette classe avec le même nom (Mat) dans le colis org.opencv.core.

Constructeurs

La classe Mat de la bibliothèque Java OpenCV a divers constructeurs, à l'aide desquels vous pouvez construire l'objet Mat.

S.Non	Constructeurs et description
1	Mat() Il s'agit du constructeur par défaut sans paramètres dans la plupart des cas. Nous utilisons ceci pour le constructeur pour créer une matrice vide et la passer à d'autres méthodes OpenCV.
2	Mat(int rows, int cols, int type) Ce constructeur accepte trois paramètres de type entier représentant le nombre de lignes et de colonnes dans un tableau 2D et le type du tableau (qui doit être utilisé pour stocker les données).
3	Mat(int rows, int cols, int type, Scalar s) En incluant les paramètres du précédent, ce constructeur accepte en plus un objet de la classe Scalar comme paramètre.
4	Mat(Size size, int type) Ce constructeur accepte deux paramètres, un objet représentant la taille de la matrice et un entier représentant le type du tableau utilisé pour stocker les données.
5	Mat(Size size, int type, Scalar s) En incluant les paramètres du précédent, ce constructeur accepte en plus un objet de la classe Scalar comme paramètre.
6	Mat(long addr)
sept	Mat(Mat m, Range rowRange) Ce constructeur accepte un objet d'une autre matrice et un objet de la classe Range représentant la plage des lignes à prendre pour créer une nouvelle matrice.
8	Mat(Mat m, Range rowRange, Range colRange) En incluant les paramètres du précédent, ce constructeur accepte en plus un objet de la classe. Plage représentant la plage de colonnes.
9	Mat(Mat m, Rect roi) Ce constructeur accepte deux objets, l'un représentant une autre matrice et l'autre représentant le Region OF Iintérêt.

Note -

Type de tableau. Utilisez CV_8UC1, ..., CV_64FC4 pour créer des matrices de 1 à 4 canaux, ou CV_8UC (n), ..., CV_64FC (n) pour créer des matrices multicanaux (jusqu'aux canaux CV_CN_MAX).
Le type des matrices était représenté par différents champs de la classe CvType qui appartient au package org.opencv.core.

Méthodes et description

Voici quelques-unes des méthodes fournies par la classe Mat.

S.Non	Méthodes et description
1	Mat col(int x) Cette méthode accepte un paramètre entier représentant l'index d'une colonne et récupère et retourne cette colonne.
2	Mat row(int y) Cette méthode accepte un paramètre entier représentant l'index d'une ligne et récupère et retourne cette ligne.
3	int cols() Cette méthode renvoie le nombre de colonnes dans la matrice.
4	int rows() Cette méthode renvoie le nombre de lignes dans la matrice.
5	Mat setTo(Mat value) Cette méthode accepte un objet du Mat type et définit les éléments du tableau sur la valeur spécifiée.
6	Mat setTo(Scalar s) Cette méthode accepte un objet du Scalar type et définit les éléments du tableau sur la valeur spécifiée.

Création et affichage de la matrice

Dans cette section, nous allons discuter de notre premier exemple OpenCV. Nous verrons comment créer et afficher une matrice OpenCV simple.

Vous trouverez ci-dessous les étapes à suivre pour créer et afficher une matrice dans OpenCV.

Étape 1: Chargez la bibliothèque native OpenCV

Lors de l'écriture de code Java à l'aide de la bibliothèque OpenCV, la première étape à faire est de charger la bibliothèque native d'OpenCV à l'aide du loadLibrary(). Chargez la bibliothèque native OpenCV comme indiqué ci-dessous.

//Loading the core library 
System.loadLibrary(Core.NATIVE_LIBRARY_NAME);

Étape 2: instancier la classe Mat

Instanciez la classe Mat en utilisant l'une des fonctions mentionnées précédemment dans ce chapitre.

//Creating a matrix 
Mat matrix = new Mat(5, 5, CvType.CV_8UC1, new Scalar(0));

Étape 3: Remplissez la matrice en utilisant les méthodes

Vous pouvez récupérer des lignes / colonnes particulières d'une matrice en passant des valeurs d'index aux méthodes row()/col().

Et, vous pouvez définir des valeurs à ces derniers en utilisant l'une des variantes du setTo() méthodes.

//Retrieving the row with index 0 
Mat row0 = matrix.row(0); 
     
//setting values of all elements in the row with index 0 
row0.setTo(new Scalar(1)); 
     
//Retrieving the row with index 3 
Mat col3 = matrix.col(3);  
     
//setting values of all elements in the row with index 3 
col3.setTo(new Scalar(3));

Example

Vous pouvez utiliser le code de programme suivant pour créer et afficher une matrice simple en Java à l'aide de la bibliothèque OpenCV.

import org.opencv.core.Core; 
import org.opencv.core.Mat;  
import org.opencv.core.CvType;  
import org.opencv.core.Scalar;   

class DisplayingMatrix { 
   public static void main(String[] args) {     
      //Loading the core library 
      System.loadLibrary(Core.NATIVE_LIBRARY_NAME);     

      //Creating a matrix 
      Mat matrix = new Mat(5, 5, CvType.CV_8UC1, new Scalar(0));  

      //Retrieving the row with index 0 
      Mat row0 = matrix.row(0);

      //setting values of all elements in the row with index 0 
      row0.setTo(new Scalar(1)); 

      //Retrieving the row with index 3 
      Mat col3 = matrix.col(3);  

      //setting values of all elements in the row with index 3 
      col3.setTo(new Scalar(3)); 

      //Printing the matrix 
      System.out.println("OpenCV Mat data:\n" + matrix.dump()); 
   } 
}

Lors de l'exécution du programme ci-dessus, vous obtiendrez la sortie suivante -

OpenCV Mat data: 
[  1,   1,   1,   3,   1; 
   0,   0,   0,   3,   0; 
   0,   0,   0,   3,   0; 
   0,   0,   0,   3,   0; 
   0,   0,   0,   3,   0]

Chargement d'une image à l'aide de l'API JavaSE

le BufferedImage classe de la java.awt.image.BufferedImage package est utilisé pour stocker une image et le ImageIO classe du package import javax.imageio fournit des méthodes pour lire et écrire des images.

Example

Vous pouvez utiliser le code de programme suivant pour charger et enregistrer des images à l'aide de la bibliothèque JavaSE.

import java.awt.image.BufferedImage; 
import java.io.File; 
import java.io.IOException; 
import javax.imageio.ImageIO;
  
public class LoadingImage_JSE_library {
   public static void main( String[] args ) throws IOException {
      //Input File 
      File input = new File("C:/EXAMPLES/OpenCV/sample.jpg");
          
      //Reading the image 
      BufferedImage image = ImageIO.read(input);
      
      //Saving the image with a different name
      File ouptut = new File("C:/OpenCV/sample.jpg");
      ImageIO.write(image, "jpg", ouptut);
         
      System.out.println("image Saved");
   } 
}

Lors de l'exécution du programme ci-dessus, vous obtiendrez la sortie suivante -

image Saved

Si vous ouvrez le chemin spécifié, vous pouvez observer l'image enregistrée comme suit -

le Imgcodecs classe du package org.opencv.imgcodecsfournit des méthodes pour lire et écrire des images. En utilisant OpenCV, vous pouvez lire une image et la stocker dans une matrice (effectuer des transformations sur la matrice si nécessaire). Plus tard, vous pouvez écrire la matrice traitée dans un fichier.

le read() méthode de la ImgcodecsLa classe est utilisée pour lire une image en utilisant OpenCV. Voici la syntaxe de cette méthode.

imread(filename)

Il accepte un argument (filename), une variable de type String représentant le chemin du fichier à lire.

Vous trouverez ci-dessous les étapes à suivre pour lire des images en Java à l'aide de la bibliothèque OpenCV.

Étape 1: Chargez la bibliothèque native OpenCV

Chargez la bibliothèque native OpenCV à l'aide du load() méthode, comme indiqué ci-dessous.

//Loading the core library 
System.loadLibrary(Core.NATIVE_LIBRARY_NAME);

Étape 2: instancier la classe Imgcodecs

Instancier le Imgcodecs classe.

//Instantiating the Imgcodecs class 
Imgcodecs imageCodecs = new Imgcodecs();

Étape 3: lecture de l'image

Lisez l'image en utilisant la méthode imread(). Cette méthode accepte un argument de chaîne représentant le chemin de l'image et renvoie l'image lue commeMat objet.

//Reading the Image from the file  
Mat matrix = imageCodecs.imread(Path of the image);

Exemple

Le code de programme suivant montre comment vous pouvez read an image en utilisant la bibliothèque OpenCV.

import org.opencv.core.Core; 
import org.opencv.core.Mat;  
import org.opencv.imgcodecs.Imgcodecs;
 
public class ReadingImages {
   public static void main(String args[]) { 
      //Loading the OpenCV core library  
      System.loadLibrary( Core.NATIVE_LIBRARY_NAME ); 
     
      //Instantiating the Imagecodecs class 
      Imgcodecs imageCodecs = new Imgcodecs(); 
     
      //Reading the Image from the file  
      String file ="C:/EXAMPLES/OpenCV/sample.jpg"; 
      Mat matrix = imageCodecs.imread(file); 
     
      System.out.println("Image Loaded");     
   } 
}

Lors de l'exécution du programme ci-dessus, OpenCV charge l'image spécifiée et affiche la sortie suivante -

Image Loaded

le write() méthode de la ImgcodecsLa classe est utilisée pour écrire une image en utilisant OpenCV. Pour écrire une image, répétez les trois premières étapes de l'exemple précédent.

Pour écrire une image, vous devez appeler le imwrite() méthode de la Imgcodecs classe.

Voici la syntaxe de cette méthode.

imwrite(filename, mat)

Cette méthode accepte les paramètres suivants -

filename - Un String variable représentant le chemin où enregistrer le fichier.
mat - Un Mat objet représentant l'image à écrire.

Exemple

Le programme suivant est un exemple pour write an image en utilisant le programme Java en utilisant la bibliothèque OpenCV.

import org.opencv.core.Core; 
import org.opencv.core.Mat; 
import org.opencv.imgcodecs.Imgcodecs;
 
public class WritingImages {  
   public static void main(String args[]) { 
      //Loading the OpenCV core library  
      System.loadLibrary(Core.NATIVE_LIBRARY_NAME); 
      
      //Instantiating the imagecodecs class 
      Imgcodecs imageCodecs = new Imgcodecs(); 

      //Reading the Image from the file and storing it in to a Matrix object 
      String file ="C:/EXAMPLES/OpenCV/sample.jpg";   
      Mat matrix = imageCodecs.imread(file); 

      System.out.println("Image Loaded ..........");
      String file2 = "C:/EXAMPLES/OpenCV/sample_resaved.jpg"; 

      //Writing the image 
      imageCodecs.imwrite(file2, matrix); 
      System.out.println("Image Saved ............"); 
   } 
}

Lors de l'exécution du programme ci-dessus, vous obtiendrez la sortie suivante -

Image Loaded .......... 
Image Saved ...........

Si vous ouvrez le chemin spécifié, vous pouvez observer l'image enregistrée comme indiqué ci-dessous -

Dans les chapitres précédents, nous avons expliqué comment lire et enregistrer une image à l'aide de la bibliothèque Java OpenCV. En plus de cela, nous pouvons également afficher les images chargées dans une fenêtre séparée en utilisant des bibliothèques d'interface graphique telles que AWT / Swings et JavaFX.

Conversion d'un tapis en image tamponnée

Pour lire une image, nous utilisons la méthode imread(). Cette méthode renvoie l'image lue sous la forme deMatrix. Mais, pour utiliser cette image avec des bibliothèques GUI (AWT / Swings et JavaFX), elle doit être convertie en objet de la classeBufferedImage du forfait java.awt.image.BufferedImage.

Voici les étapes pour convertir un Mat objet d'OpenCV à BufferedImage objet.

Étape 1: encodez le Mat en MatOfByte

Tout d'abord, vous devez convertir la matrice en matrice d'octet. Vous pouvez le faire en utilisant la méthodeimencode() de la classe Imgcodecs. Voici la syntaxe de cette méthode.

imencode(ext, image, matOfByte);

Cette méthode accepte les paramètres suivants -

Ext - Un paramètre String spécifiant le format de l'image (.jpg, .png, etc.)
image - Un objet Mat de l'image
matOfByte - Un objet vide de la classe MatOfByte

Encodez l'image en utilisant cette méthode comme indiqué ci-dessous.

//Reading the image 
Mat image = Imgcodecs.imread(file);

//instantiating an empty MatOfByte class 
MatOfByte matOfByte = new MatOfByte();

//Converting the Mat object to MatOfByte 
Imgcodecs.imencode(".jpg", image, matOfByte);

Étape 2: Convertissez l'objet MatOfByte en tableau d'octets

Convertissez le MatOfByte objet dans un tableau d'octets à l'aide de la méthode toArray().

byte[] byteArray = matOfByte.toArray();

Étape 3: préparation de l'objet InputStream

Préparez l'objet InputStream en passant le tableau d'octets créé à l'étape précédente au constructeur du ByteArrayInputStream classe.

//Preparing the InputStream object 
InputStream in = new ByteArrayInputStream(byteArray);

Étape 4: préparation de l'objet InputStream

Passez l'objet Input Stream créé à l'étape précédente au read() méthode de la ImageIOclasse. Cela renverra un objet BufferedImage.

//Preparing the BufferedImage 
BufferedImage bufImage = ImageIO.read(in);

Affichage de l'image à l'aide d'AWT / Swings

Pour afficher une image à l'aide du cadre AWT / Swings, tout d'abord, lisez une image à l'aide du imread() méthode et convertissez-la en BufferedImage en suivant les étapes mentionnées ci-dessus.

Ensuite, instanciez le JFrame et ajoutez l'image mise en mémoire tampon créée au ContentPane du JFrame, comme indiqué ci-dessous -

//Instantiate JFrame 
JFrame frame = new JFrame();
 
//Set Content to the JFrame 
frame.getContentPane().add(new JLabel(new ImageIcon(bufImage))); 
frame.pack(); 
frame.setVisible(true);

Example

Le code de programme suivant montre comment vous pouvez read une image et display à travers la fenêtre pivotante en utilisant la bibliothèque OpenCV.

import java.awt.image.BufferedImage;

import java.io.ByteArrayInputStream;
import java.io.InputStream;

import javax.imageio.ImageIO;
import javax.swing.ImageIcon;
import javax.swing.JFrame;
import javax.swing.JLabel;

import org.opencv.core.Core;
import org.opencv.core.Mat;
import org.opencv.core.MatOfByte;
import org.opencv.imgcodecs.Imgcodecs;

public class DisplayingImagesUsingSwings {
   public static void main(String args[]) throws Exception { 
      //Loading the OpenCV core library  
      System.loadLibrary( Core.NATIVE_LIBRARY_NAME ); 
    
      //Reading the Image from the file and storing it in to a Matrix object 
      String file = "C:/EXAMPLES/OpenCV/sample.jpg"; 
      Mat image = Imgcodecs.imread(file); 
    
      //Encoding the image 
      MatOfByte matOfByte = new MatOfByte();       
      Imgcodecs.imencode(".jpg", image, matOfByte); 

      //Storing the encoded Mat in a byte array 
      byte[] byteArray = matOfByte.toArray(); 

      //Preparing the Buffered Image 
      InputStream in = new ByteArrayInputStream(byteArray); 
      BufferedImage bufImage = ImageIO.read(in); 

      //Instantiate JFrame 
      JFrame frame = new JFrame(); 

      //Set Content to the JFrame 
      frame.getContentPane().add(new JLabel(new ImageIcon(bufImage))); 
      frame.pack(); 
      frame.setVisible(true);
      
      System.out.println("Image Loaded");     
   } 
}

Lors de l'exécution du programme ci-dessus, vous obtiendrez la sortie suivante -

Image Loaded

En plus de cela, vous pouvez voir une fenêtre affichant l'image chargée, comme suit -

Affichage de l'image à l'aide de JavaFX

Pour afficher une image à l'aide de JavaFX, tout d'abord, lisez une image à l'aide du imread() méthode et convertissez-la en BufferedImage. Ensuite, convertissez BufferedImage en WritableImage, comme illustré ci-dessous.

WritableImage writableImage = SwingFXUtils.toFXImage(bufImage, null);

Passe ça WritableImage objet au constructeur du ImageView classe.

ImageView imageView = new ImageView(writableImage);

Example

Le code de programme suivant montre comment read une image et display via la fenêtre JavaFX en utilisant la bibliothèque OpenCV.

import java.awt.image.BufferedImage;

import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;

import javafx.application.Application;
import javafx.embed.swing.SwingFXUtils;
import javafx.scene.Group;
import javafx.scene.Scene;
import javafx.scene.image.ImageView;
import javafx.scene.image.WritableImage;
import javafx.stage.Stage;

import javax.imageio.ImageIO;

import org.opencv.core.Core;
import org.opencv.core.Mat;
import org.opencv.core.MatOfByte;
import org.opencv.imgcodecs.Imgcodecs;

public class DisplayingImagesJavaFX extends Application {
   @Override 
   public void start(Stage stage) throws IOException {   
      WritableImage writableImage = loadImage(); 
  
      //Setting the image view 
      ImageView imageView = new ImageView(writableImage); 
        
      //Setting the position of the image 
      imageView.setX(50); 
      imageView.setY(25); 
        
      //setting the fit height and width of the image view 
      imageView.setFitHeight(400); 
      imageView.setFitWidth(500);
      
      //Setting the preserve ratio of the image view
      imageView.setPreserveRatio(true);
      
      //Creating a Group object  
      Group root = new Group(imageView);
      
      //Creating a scene object
      Scene scene = new Scene(root, 600, 400);
      
      //Setting title to the Stage 
      stage.setTitle("Loading an image");
      
      //Adding scene to the stage
      stage.setScene(scene);

      //Displaying the contents of the stage
      stage.show();
   } 
   public WritableImage loadImage() throws IOException {
      //Loading the OpenCV core library  
      System.loadLibrary( Core.NATIVE_LIBRARY_NAME );
      
      //Reading the Image from the file and storing it in to a Matrix object
      String file ="C:/EXAMPLES/OpenCV/sample.jpg";
      Mat image = Imgcodecs.imread(file);
      
      //Encoding the image
      MatOfByte matOfByte = new MatOfByte();
      Imgcodecs.imencode(".jpg", image, matOfByte);

      //Storing the encoded Mat in a byte array
      byte[] byteArray = matOfByte.toArray();
      
      //Displaying the image
      InputStream in = new ByteArrayInputStream(byteArray); 
      BufferedImage bufImage = ImageIO.read(in);

      System.out.println("Image Loaded");
      WritableImage writableImage = SwingFXUtils.toFXImage(bufImage, null);
      return writableImage; 
   }
   public static void main(String args[]) {
      launch(args); 
   } 
}

Lors de l'exécution du programme ci-dessus, vous obtiendrez la sortie suivante -

Image Loaded

En plus de cela, vous pouvez voir une fenêtre affichant l'image chargée, comme suit -

OpenCV prend en charge différents types d'images telles que les images colorées, binaires, en niveaux de gris, etc. imread() méthode et champs prédéfinis du Imgcodecs class, vous pouvez lire une image donnée sous un autre type.

Le paramètre flags de la méthode imread () (IMREAD_XXX)

Dans les chapitres précédents, nous avons vu la syntaxe de imread() méthode de la Imgcodecsclasse. Il accepte un argument de chaîne représentant l'emplacement de l'image à lire.

imread(filename)

le imread() La méthode a une autre syntaxe.

imread(filename, int flags)

Cette syntaxe accepte deux paramètres -

filename - Il accepte un argument (filename), une variable de type String représentant le chemin du fichier à lire.
flags- Une valeur entière représentant une valeur d'indicateur prédéfinie. Pour chaque valeur, cela lit l'image donnée comme un type spécifique (couleur d'échelle de gris, etc.)

Le tableau suivant répertorie les différents champs fournis dans le Imgproc class comme valeurs pour ce paramètre.

S.Non	Champs et description
1	IMREAD_COLOR Si l'indicateur est défini sur cette valeur, l'image chargée sera convertie en une image couleur BGR (bleu vert rouge) à 3 canaux.
2	IMREAD_GRAYSCALE Si l'indicateur est défini sur cette valeur, l'image chargée sera convertie en une image en niveaux de gris monocouche.
3	IMREAD_LOAD_GDAL Si l'indicateur est défini sur cette valeur, vous pouvez charger l'image à l'aide du gdal chauffeur.
4	IMREAD_ANYCOLOR Si l'indicateur est défini sur cette valeur, l'image est lue dans n'importe quel format de couleur possible.
5	IMREAD_REDUCED_COLOR_2 IMREAD_REDUCED_COLOR_4 IMREAD_REDUCED_COLOR_8 Si le drapeau est mis à cette valeur, l'image est lue comme BGR à trois canaux, et la taille de l'image est réduite à 1/2, 1/4 ^ème ou size ^ème de la taille d'origine de l'image par rapport au champ utilisé.
6	IMREAD_REDUCED_GRAYSCALE_2 IMREAD_REDUCED_GRAYSCALE_4 IMREAD_REDUCED_GRAYSCALE_8 Si l'indicateur est défini sur cette valeur, l'image est lue comme une image en niveaux de gris monocanal, et la taille de l'image est réduite à ½, ¼ ^ème ou ⅛ ^ème de la taille d'origine de l'image par rapport au champ utilisé .
sept	IMREAD_UNCHANGED Si l'indicateur est défini sur cette valeur, l'image chargée est renvoyée telle quelle.

Le programme suivant montre comment lire une image colorée en niveaux de gris et l'afficher à l'aide de la fenêtre JavaFX. Ici, nous avons lu l'image en passant le drapeauIMREAD_GRAYSCALE avec la chaîne contenant le chemin d'une image colorée.

import java.awt.image.BufferedImage;

import org.opencv.core.Core;
import org.opencv.core.Mat;
import org.opencv.imgcodecs.Imgcodecs;

import javafx.application.Application;
import javafx.embed.swing.SwingFXUtils;
import javafx.scene.Group;
import javafx.scene.Scene;
import javafx.scene.image.ImageView;
import javafx.scene.image.WritableImage;
import javafx.stage.Stage;

public class ReadingAsGrayscale extends Application {
   @Override
   public void start(Stage stage) throws Exception {
      WritableImage writableImage = loadAndConvert();

      // Setting the image view
      ImageView imageView = new ImageView(writableImage);

      // Setting the position of the image
      imageView.setX(10);
      imageView.setY(10);

      // setting the fit height and width of the image view
      imageView.setFitHeight(400);
      imageView.setFitWidth(600);
      
      // Setting the preserve ratio of the image view
      imageView.setPreserveRatio(true);
      
      // Creating a Group object  
      Group root = new Group(imageView);
      
      // Creating a scene object
      Scene scene = new Scene(root, 600, 400);
      
      // Setting title to the Stage
      stage.setTitle("Reading image as grayscale");
      
      // Adding scene to the stage
      stage.setScene(scene);
      
      // Displaying the contents of the stage
      stage.show();
   } 
   public WritableImage loadAndConvert() throws Exception {
      // Loading the OpenCV core library
      System.loadLibrary( Core.NATIVE_LIBRARY_NAME );

      // Instantiating the imagecodecs class
      Imgcodecs imageCodecs = new Imgcodecs();

      String input = "C:/EXAMPLES/OpenCV/sample.jpg";

      // Reading the image
      Mat src = imageCodecs.imread(input, Imgcodecs.IMREAD_GRAYSCALE);
       
      byte[] data1 = new byte[src.rows() * src.cols() * (int)(src.elemSize())];
      src.get(0, 0, data1);
      
      // Creating the buffered image
      BufferedImage bufImage = new BufferedImage(src.cols(),src.rows(), 
         BufferedImage.TYPE_BYTE_GRAY);
      
      // Setting the data elements to the image
      bufImage.getRaster().setDataElements(0, 0, src.cols(), src.rows(), data1);
              
      // Creating a WritableImage
      WritableImage writableImage = SwingFXUtils.toFXImage(bufImage, null);
      System.out.println("Image Read");
      return writableImage;
   } 
   public static void main(String args[]) throws Exception { 
      launch(args); 
   } 
}

Image d'entrée

Supposons que ce qui suit est l'image d'entrée sample.jpg spécifié dans le programme ci-dessus.

Image de sortie

Lors de l'exécution du programme, vous obtiendrez la sortie suivante.

Le programme suivant montre comment lire une image colorée en tant qu'image de type BGR et l'afficher à l'aide de la fenêtre JavaFX. Ici, nous avons lu l'image en passant le drapeauIMREAD_COLOR à la méthode imread() avec la chaîne contenant le chemin d'une image colorée.

import java.awt.image.BufferedImage;

import org.opencv.core.Core;
import org.opencv.core.Mat;
import org.opencv.imgcodecs.Imgcodecs;

import javafx.application.Application;
import javafx.embed.swing.SwingFXUtils;
import javafx.scene.Group;
import javafx.scene.Scene;
import javafx.scene.image.ImageView;
import javafx.scene.image.WritableImage;
import javafx.stage.Stage;

public class ReadingAsColored extends Application {
   @Override 
   public void start(Stage stage) throws Exception {
      WritableImage writableImage = loadAndConvert();
       
      // Setting the image view
      ImageView imageView = new ImageView(writableImage);

      // Setting the position of the image
      imageView.setX(10);
      imageView.setY(10);

      // setting the fit height and width of the image view
      imageView.setFitHeight(400);
      imageView.setFitWidth(600);
      
      // Setting the preserve ratio of the image view
      imageView.setPreserveRatio(true);
      
      // Creating a Group object
      Group root = new Group(imageView);

      // Creating a scene object
      Scene scene = new Scene(root, 600, 400);
     
      // Setting title to the Stage
      stage.setTitle("Reading as colored image");

      // Adding scene to the stage
      stage.setScene(scene);
      
      // Displaying the contents of the stage
      stage.show();
   } 
   public WritableImage loadAndConvert() throws Exception {     
      // Loading the OpenCV core library
      System.loadLibrary( Core.NATIVE_LIBRARY_NAME );
       
      String input = "C:/EXAMPLES/OpenCV/sample.jpg";
       
      Mat dst = new Mat();

      // Reading the image
      Mat src = Imgcodecs.imread(input, Imgcodecs.IMREAD_COLOR);

      byte[] data1 = new byte[src.rows() * src.cols() * (int)(src.elemSize())]; 
      src.get(0, 0, data1);
      
      // Creating the buffered image
      BufferedImage bufImage = new BufferedImage(src.cols(),src.rows(), 
         BufferedImage.TYPE_3BYTE_BGR);

      // Setting the data elements to the image 
      bufImage.getRaster().setDataElements(0, 0, src.cols(), src.rows(), data1);

      // Creating a WritableImage
      WritableImage writableImage = SwingFXUtils.toFXImage(bufImage, null);

      System.out.println("Image read");
      return writableImage;
   } 
   public static void main(String args[]) throws Exception {
      launch(args);
   } 
}

Image d'entrée

Supposons que ce qui suit est l'image d'entrée sample.jpg spécifié dans le programme ci-dessus.

Image de sortie

Lors de l'exécution du programme, vous obtiendrez la sortie suivante.

Dans les chapitres précédents, nous avons expliqué comment lire une image d'entrée sous différents types (binaire, niveaux de gris, BGR, etc.). Dans ce chapitre, nous allons apprendre à convertir un type d'image en un autre.

La classe nommée Imgproc du forfait org.opencv.imgproc fournit des méthodes pour convertir une image d'une couleur à une autre.

Conversion d'images colorées en niveaux de gris

Une méthode nommée cvtColor()est utilisé pour convertir les images colorées en niveaux de gris. Voici la syntaxe de cette méthode.

cvtColor(Mat src, Mat dst, int code)

Cette méthode accepte les paramètres suivants -

src - Une matrice représentant la source.
dst - Une matrice représentant la destination.
code - Un code entier représentant le type de conversion, par exemple RVB en niveaux de gris.

Vous pouvez convertir des images colorées en échelle de gris en passant le code Imgproc.COLOR_RGB2GRAY avec les matrices source et destination en tant que paramètre du cvtColor() méthode.

Exemple

Le programme suivant montre comment lire une image colorée en tant qu'image en niveaux de gris et l'afficher à l'aide de la fenêtre JavaFX.

import java.awt.image.BufferedImage;
  
import org.opencv.core.Core;
import org.opencv.core.Mat;
import org.opencv.imgcodecs.Imgcodecs;
import org.opencv.imgproc.Imgproc;

import javafx.application.Application;
import javafx.embed.swing.SwingFXUtils;
import javafx.scene.Group;
import javafx.scene.Scene;
import javafx.scene.image.ImageView;
import javafx.scene.image.WritableImage;

import javafx.stage.Stage;

public class ColorToGrayscale extends Application {
   @Override
   public void start(Stage stage) throws Exception {
      WritableImage writableImage = loadAndConvert();
       
      // Setting the image view
      ImageView imageView = new ImageView(writableImage);

      // Setting the position of the image
      imageView.setX(10);
      imageView.setY(10);

      // setting the fit height and width of the image view
      imageView.setFitHeight(400);
      imageView.setFitWidth(600);

      // Setting the preserve ratio of the image view
      imageView.setPreserveRatio(true);

      // Creating a Group object
      Group root = new Group(imageView);

      // Creating a scene object
      Scene scene = new Scene(root, 600, 400);

      // Setting title to the Stage
      stage.setTitle("Colored to grayscale image");

      // Adding scene to the stage
      stage.setScene(scene);

      // Displaying the contents of the stage
      stage.show();
   } 
   public WritableImage loadAndConvert() throws Exception {
      //Loading the OpenCV core library
      System.loadLibrary( Core.NATIVE_LIBRARY_NAME );

      String input = "C:/EXAMPLES/OpenCV/sample.jpg";

      //Reading the image
      Mat src = Imgcodecs.imread(input);

      //Creating the empty destination matrix
      Mat dst = new Mat();

      //Converting the image to gray sacle and saving it in the dst matrix
      Imgproc.cvtColor(src, dst, Imgproc.COLOR_RGB2GRAY);
      
      //Extracting data from the transformed image (dst)
      byte[] data1 = new byte[dst.rows() * dst.cols() * (int)(dst.elemSize())];
      dst.get(0, 0, data1);

      //Creating Buffered image using the data
      BufferedImage bufImage = new BufferedImage(dst.cols(),dst.rows(), 
         BufferedImage.TYPE_BYTE_GRAY);

      //Setting the data elements to the image
      bufImage.getRaster().setDataElements(0, 0, dst.cols(), dst.rows(), data1);

      //Creating a WritableImage
      WritableImage writableImage = SwingFXUtils.toFXImage(bufImage, null);
      System.out.println("Converted to Grayscale");
      return writableImage;
   }
   public static void main(String args[]) throws Exception {
      launch(args);
   }
}

Image d'entrée

Supposons que ce qui suit est l'image d'entrée sample.jpg spécifié dans le programme ci-dessus.

Image de sortie

Lors de l'exécution du programme, vous obtiendrez la sortie suivante.

Une méthode appelée threshold()est utilisé pour convertir des images en niveaux de gris en image binaire. Voici la syntaxe de cette méthode.

threshold(Mat src, Mat dst, double thresh, double maxval, int type)

Cette méthode accepte les paramètres suivants -

mat - Un Mat objet représentant l'image d'entrée.
dst - Un Mat objet représentant l'image de sortie.
thresh - Un entier représentant la valeur seuil.
maxval - Un entier représentant la valeur maximale à utiliser avec les types de seuillage THRESH_BINARY et THRESH_BINARY_INV.
type - Un code entier représentant le type de conversion, par exemple RVB en niveaux de gris.

Vous pouvez convertir une image en niveaux de gris en image binaire en passant le code Imgproc.THRESH_BINARY ainsi que les valeurs des paramètres restants.

Exemple

Le programme suivant montre comment lire une image colorée en tant qu'image binaire et l'afficher à l'aide de la fenêtre JavaFX.

import java.awt.image.BufferedImage;

import org.opencv.core.Core;
import org.opencv.core.Mat;
import org.opencv.imgcodecs.Imgcodecs;
import org.opencv.imgproc.Imgproc;

import javafx.application.Application;
import javafx.embed.swing.SwingFXUtils;
import javafx.scene.Group;
import javafx.scene.Scene;
import javafx.scene.image.ImageView;
import javafx.scene.image.WritableImage;
import javafx.stage.Stage;

public class ColorToBinary extends Application {
   @Override
   public void start(Stage stage) throws Exception {
      WritableImage writableImage = loadAndConvert();

      // Setting the image view
      ImageView imageView = new ImageView(writableImage);

      // Setting the position of the image
      imageView.setX(10);
      imageView.setY(10);

      // setting the fit height and width of the image view
      imageView.setFitHeight(400);
      imageView.setFitWidth(600);

      // Setting the preserve ratio of the image view
      imageView.setPreserveRatio(true);
      
      // Creating a Group object
      Group root = new Group(imageView);

      // Creating a scene object
      Scene scene = new Scene(root, 600, 400);
      
      // Setting title to the Stage
      stage.setTitle("Loading an image");

      // Adding scene to the stage
      stage.setScene(scene);

      // Displaying the contents of the stage
      stage.show();
   }
   public WritableImage loadAndConvert() throws Exception {
      // Loading the OpenCV core library
      System.loadLibrary( Core.NATIVE_LIBRARY_NAME );

      // Instantiating the Imgcodecs class
      Imgcodecs imageCodecs = new Imgcodecs();
        
      // File input = new File("C:/EXAMPLES/OpenCV/sample.jpg");
      String input = "C:/EXAMPLES/OpenCV/sample.jpg";

      // Reading the image
      Mat src = imageCodecs.imread(input);

      // Creating the destination matrix
      Mat dst = new Mat();

      // Converting to binary image...
      Imgproc.threshold(src, dst, 200, 500, Imgproc.THRESH_BINARY);

      // Extracting data from the transformed image (dst)
      byte[] data1 = new byte[dst.rows() * dst.cols() * (int)(dst.elemSize())];
      dst.get(0, 0, data1);

      // Creating Buffered image using the data
      BufferedImage bufImage = new BufferedImage(dst.cols(),dst.rows(), 
         BufferedImage.TYPE_BYTE_GRAY);

      // Setting the data elements to the image
      bufImage.getRaster().setDataElements(0, 0, dst.cols(), dst.rows(), data1);

      // Creating a Writable image
      WritableImage writableImage = SwingFXUtils.toFXImage(bufImage, null);

      System.out.println("Converted to binary");
      return writableImage;
   }  
   public static void main(String args[]) throws Exception {
      launch(args);
   }
}

Image d'entrée

Supposons que ce qui suit est l'image d'entrée sample.jpg spécifié dans le programme ci-dessus.

Image de sortie

Lors de l'exécution du programme, vous obtiendrez la sortie suivante.

Vous pouvez utiliser la même méthode que celle mentionnée dans le chapitre précédent pour convertir une image en niveaux de gris en image binaire. Passez simplement le chemin d'une image en niveaux de gris en entrée de ce programme.

Exemple

Le programme suivant montre comment lire une image en niveaux de gris en tant qu'image binaire et l'afficher à l'aide de la fenêtre JavaFX.

import java.awt.image.BufferedImage;

import org.opencv.core.Core;
import org.opencv.core.Mat;
import org.opencv.imgcodecs.Imgcodecs;
import org.opencv.imgproc.Imgproc;

import javafx.application.Application;
import javafx.embed.swing.SwingFXUtils;
import javafx.scene.Group;
import javafx.scene.Scene;
import javafx.scene.image.ImageView;
import javafx.scene.image.WritableImage;
import javafx.stage.Stage;

public class GrayScaleToBinary extends Application {
   @Override
   public void start(Stage stage) throws Exception {
      WritableImage writableImage = loadAndConvert();
       
      // Setting the image view
      ImageView imageView = new ImageView(writableImage);

      // Setting the position of the image
      imageView.setX(10);
      imageView.setY(10);
      
      // Setting the fit height and width of the image view
      imageView.setFitHeight(400);
      imageView.setFitWidth(600);

      // Setting the preserve ratio of the image view
      imageView.setPreserveRatio(true);

      // Creating a Group object
      Group root = new Group(imageView);

      // Creating a scene object
      Scene scene = new Scene(root, 600, 400);

      // Setting title to the Stage
      stage.setTitle("Grayscale to binary image");

      // Adding scene to the stage
      stage.setScene(scene);

      // Displaying the contents of the stage
      stage.show();
   }
   public WritableImage loadAndConvert() throws Exception {
      // Loading the OpenCV core library
      System.loadLibrary( Core.NATIVE_LIBRARY_NAME );

      // Instantiating the imagecodecs class
      Imgcodecs imageCodecs = new Imgcodecs();

      String input = "E:/OpenCV/chap7/grayscale.jpg";

      // Reading the image
      Mat src = imageCodecs.imread(input);

      // Creating the destination matrix
      Mat dst = new Mat();

      // Converting to binary image...
      Imgproc.threshold(src, dst, 200, 500, Imgproc.THRESH_BINARY);

      // Extracting data from the transformed image (dst)
      byte[] data1 = new byte[dst.rows() * dst.cols() * (int)(dst.elemSize())];
      dst.get(0, 0, data1);

      // Creating Buffered image using the data
      BufferedImage bufImage = new BufferedImage(dst.cols(),dst.rows(), 
         BufferedImage.TYPE_BYTE_BINARY);

      // Setting the data elements to the image
      bufImage.getRaster().setDataElements(0, 0, dst.cols(), dst.rows(), data1);

      // Creating a Writable image
      WritableImage writableImage = SwingFXUtils.toFXImage(bufImage, null);

      System.out.println("Converted to binary");
      return writableImage;
   }
   public static void main(String args[]) throws Exception {
      launch(args);
   }
}

Image d'entrée

Supposons que ce qui suit est l'image d'entrée sample.jpg spécifié dans le programme ci-dessus.

Image de sortie

Lors de l'exécution du programme, vous obtiendrez la sortie suivante.

Vous pouvez dessiner diverses formes telles que Cercle, Rectangle, Ligne, Ellipse, Polylignes, Convexe, Polylignes, Polylignes sur une image en utilisant les méthodes respectives du org.opencv.imgproc paquet.

Vous pouvez dessiner un cercle sur une image en utilisant la méthode circle() du imgprocclasse. Voici la syntaxe de cette méthode -

circle(img, center, radius, color, thickness)

Cette méthode accepte les paramètres suivants -

mat - Un Mat objet représentant l'image sur laquelle le cercle doit être dessiné.
point - Un Point objet représentant le centre du cercle.
radius - Une variable du type integer représentant le rayon du cercle.
scalar - Un Scalarobjet représentant la couleur du cercle. (BGR)
thickness - Un integerreprésentant l'épaisseur du cercle; par défaut, la valeur de l'épaisseur est 1.

Exemple

Le programme suivant montre comment dessiner un cercle sur une image et l'afficher à l'aide de la fenêtre JavaFX.

import java.awt.image.BufferedImage;

import java.io.ByteArrayInputStream;
import java.io.InputStream;
import javax.imageio.ImageIO;

import javafx.application.Application;
import javafx.embed.swing.SwingFXUtils;
import javafx.scene.Group;
import javafx.scene.Scene;
import javafx.scene.image.ImageView;
import javafx.scene.image.WritableImage;
import javafx.stage.Stage;

import org.opencv.core.Core;
import org.opencv.core.Mat;
import org.opencv.core.MatOfByte;
import org.opencv.core.Point;
import org.opencv.core.Scalar;
import org.opencv.imgcodecs.Imgcodecs;
import org.opencv.imgproc.Imgproc;

public class DrawingCircle extends Application {
   Mat matrix = null;
   
   @Override
   public void start(Stage stage) throws Exception {
      // Capturing the snapshot from the camera
      DrawingCircle obj = new DrawingCircle();
      WritableImage writableImage = obj.LoadImage();

      // Setting the image view
      ImageView imageView = new ImageView(writableImage);

      // setting the fit height and width of the image view
      imageView.setFitHeight(600);
      imageView.setFitWidth(600);

      // Setting the preserve ratio of the image view
      imageView.setPreserveRatio(true);

      // Creating a Group object
      Group root = new Group(imageView);

      // Creating a scene object
      Scene scene = new Scene(root, 600, 400);

      // Setting title to the Stage
      stage.setTitle("Drawing Circle on the image");
      
      // Adding scene to the stage
      stage.setScene(scene);

      // Displaying the contents of the stage
      stage.show();
   }      
   public WritableImage LoadImage() throws Exception {
      // Loading the OpenCV core library
      System.loadLibrary( Core.NATIVE_LIBRARY_NAME );

      // Reading the Image from the file and storing it in to a Matrix object
      String file ="E:/OpenCV/chap8/input.jpg";
      Mat matrix = Imgcodecs.imread(file);

      //Drawing a Circle Imgproc.circle ( matrix, //Matrix obj of the image new Point(230, 160), //Center of the circle 100, //Radius new Scalar(0, 0, 255), //Scalar object for color 10 //Thickness of the circle );
      
      // Encoding the image
      MatOfByte matOfByte = new MatOfByte();
      Imgcodecs.imencode(".jpg", matrix, matOfByte);

      // Storing the encoded Mat in a byte array
      byte[] byteArray = matOfByte.toArray();

      // Displaying the image
      InputStream in = new ByteArrayInputStream(byteArray);
      BufferedImage bufImage = ImageIO.read(in);
      this.matrix = matrix;
      
      // Creating the Writable Image
      WritableImage writableImage = SwingFXUtils.toFXImage(bufImage, null);

      return writableImage;
   }
   public static void main(String args[]) {
      launch(args);
   }
}

Lors de l'exécution du programme ci-dessus, vous obtiendrez la sortie suivante -

Vous pouvez dessiner une ligne sur une image en utilisant la méthode line() du imgprocclasse. Voici la syntaxe de cette méthode.

line(img, pt1, pt2, color, thickness)

Cette méthode accepte les paramètres suivants -

mat - Un Mat objet représentant l'image sur laquelle la ligne doit être dessinée.
pt1 and pt2 - Deux Point objets représentant les points entre lesquels la ligne doit être dessinée.
scalar - Un Scalarobjet représentant la couleur du cercle. (BGR)
thickness- Un entier représentant l'épaisseur de la ligne; par défaut, la valeur de l'épaisseur est 1.

Exemple

Le programme suivant montre comment dessiner une ligne sur une image et l'afficher à l'aide de la fenêtre JavaFX.

import java.awt.image.BufferedImage;

import java.io.ByteArrayInputStream;
import java.io.InputStream;
import javax.imageio.ImageIO;

import javafx.application.Application;
import javafx.embed.swing.SwingFXUtils;
import javafx.scene.Group;
import javafx.scene.Scene;
import javafx.scene.image.ImageView;
import javafx.scene.image.WritableImage;
import javafx.stage.Stage;

import org.opencv.core.Core;
import org.opencv.core.Mat;
import org.opencv.core.MatOfByte;
import org.opencv.core.Point;
import org.opencv.core.Scalar;
import org.opencv.imgcodecs.Imgcodecs;
import org.opencv.imgproc.Imgproc;

public class DrawingLine extends Application {
   Mat matrix = null;

   @Override
   public void start(Stage stage) throws Exception {
   
      // Capturing the snapshot from the camera
      DrawingLine obj = new DrawingLine();
      WritableImage writableImage = obj.LoadImage();

      // Setting the image view
      ImageView imageView = new ImageView(writableImage);

      // setting the fit height and width of the image view
      imageView.setFitHeight(600);
      imageView.setFitWidth(600);

      // Setting the preserve ratio of the image view
      imageView.setPreserveRatio(true);

      // Creating a Group object  
      Group root = new Group(imageView);

      // Creating a scene object
      Scene scene = new Scene(root, 600, 400);

      // Setting title to the Stage
      stage.setTitle("Drawing a line on the image");

      // Adding scene to the stage
      stage.setScene(scene);

      // Displaying the contents of the stage
      stage.show();
   }
   public WritableImage LoadImage() throws Exception {
      // Loading the OpenCV core library
      System.loadLibrary( Core.NATIVE_LIBRARY_NAME );

      // Reading the Image from the file and storing it in to a Matrix object
      String file ="E:/OpenCV/chap8/input.jpg";
      Mat matrix = Imgcodecs.imread(file);

      // Drawing a line Imgproc.line ( matrix, //Matrix obj of the image new Point(10, 200), //p1 new Point(300, 200), //p2 new Scalar(0, 0, 255), //Scalar object for color 5 //Thickness of the line );
      // Encoding the image
      MatOfByte matOfByte = new MatOfByte();
      Imgcodecs.imencode(".jpg", matrix, matOfByte);

      // Storing the encoded Mat in a byte array
      byte[] byteArray = matOfByte.toArray();

      // Displaying the image
      InputStream in = new ByteArrayInputStream(byteArray);
      BufferedImage bufImage = ImageIO.read(in);

      this.matrix = matrix;

      // Creating the Writable Image
      WritableImage writableImage = SwingFXUtils.toFXImage(bufImage, null);
      return writableImage;
   }
   public static void main(String args[]) {
      launch(args);
   }
}

Lors de l'exécution du programme ci-dessus, vous obtiendrez la sortie suivante -

Vous pouvez dessiner un rectangle sur une image en utilisant la méthode rectangle() du imgprocclasse. Voici la syntaxe de cette méthode -

rectangle(img, pt1, pt2, color, thickness)

Cette méthode accepte les paramètres suivants -

mat - Un Mat objet représentant l'image sur laquelle le rectangle doit être dessiné.
pt1 and pt2 - Deux Point objets représentant les sommets du rectangle à dessiner.
scalar - Un Scalarobjet représentant la couleur du rectangle. (BGR)
thickness- Un entier représentant l'épaisseur du rectangle; par défaut, la valeur de l'épaisseur est 1.

Exemple

L'exemple suivant montre comment dessiner un rectangle sur une image et l'afficher à l'aide de la fenêtre JavaFX.

import java.awt.image.BufferedImage;

import java.io.ByteArrayInputStream;
import java.io.InputStream;
import javax.imageio.ImageIO;

import javafx.application.Application;
import javafx.embed.swing.SwingFXUtils;
import javafx.scene.Group;
import javafx.scene.Scene;
import javafx.scene.image.ImageView;
import javafx.scene.image.WritableImage;
import javafx.stage.Stage;

import org.opencv.core.Core;
import org.opencv.core.Mat;
import org.opencv.core.MatOfByte;
import org.opencv.core.Point;
import org.opencv.core.Scalar;
import org.opencv.imgcodecs.Imgcodecs;
import org.opencv.imgproc.Imgproc;

public class DrawingRectangle extends Application {
   Mat matrix = null;

   @Override
   public void start(Stage stage) throws Exception {
      // Capturing the snapshot from the camera
      DrawingRectangle obj = new DrawingRectangle();
      WritableImage writableImage = obj.LoadImage();

      // Setting the image view
      ImageView imageView = new ImageView(writableImage);

      // setting the fit height and width of the image view
      imageView.setFitHeight(600);
      imageView.setFitWidth(600);

      // Setting the preserve ratio of the image view
      imageView.setPreserveRatio(true);

      // Creating a Group object
      Group root = new Group(imageView);

      // Creating a scene object
      Scene scene = new Scene(root, 600, 400);

      // Setting title to the Stage
      stage.setTitle("Drawing Rectangle on the image");

      // Adding scene to the stage
      stage.setScene(scene);

      // Displaying the contents of the stage
      stage.show();
   }
   public WritableImage LoadImage() throws Exception {
      // Loading the OpenCV core library
      System.loadLibrary( Core.NATIVE_LIBRARY_NAME );

      // Reading the Image from the file and storing it in to a Matrix object
      String file ="E:/OpenCV/chap8/input.jpg";
      Mat matrix = Imgcodecs.imread(file);

      // Drawing a Rectangle Imgproc.rectangle ( matrix, //Matrix obj of the image new Point(130, 50), //p1 new Point(300, 280), //p2 new Scalar(0, 0, 255), //Scalar object for color 5 //Thickness of the line );
      
      // Encoding the image
      MatOfByte matOfByte = new MatOfByte();
      Imgcodecs.imencode(".jpg", matrix, matOfByte);

      // Storing the encoded Mat in a byte array
      byte[] byteArray = matOfByte.toArray();

      // Displaying the image
      InputStream in = new ByteArrayInputStream(byteArray);
      BufferedImage bufImage = ImageIO.read(in);

      this.matrix = matrix;

      // Creating the Writable Image
      WritableImage writableImage = SwingFXUtils.toFXImage(bufImage, null);
      return writableImage;
   }
   public static void main(String args[]) {
      launch(args);
   }
}

Lors de l'exécution du programme ci-dessus, vous obtiendrez la sortie suivante -

Vous pouvez dessiner une ellipse sur une image en utilisant la méthode rectangle() du imgprocclasse. Voici la syntaxe de cette méthode -

ellipse(img, box, color, thickness)

Cette méthode accepte les paramètres suivants -

mat - Un Mat objet représentant l'image sur laquelle le Rectangle doit être dessiné.
box - Un objet RotatedRect (l'ellipse est dessinée inscrite dans ce rectangle.)
scalar - Un Scalarobjet représentant la couleur du rectangle. (BGR)
thickness- Un entier représentant l'épaisseur du rectangle; par défaut, la valeur de l'épaisseur est 1.

Le constructeur du RotatedRect class accepte un objet de la classe Point, un objet de la classe Size et une variable de type double, comme illustré ci-dessous.

RotatedRect(Point c, Size s, double a)

Exemple

Le programme suivant montre comment dessiner une ellipse sur une image et l'afficher à l'aide de la fenêtre JavaFX.

import java.awt.image.BufferedImage;

import java.io.ByteArrayInputStream;
import java.io.InputStream;
import javax.imageio.ImageIO;

import javafx.application.Application;
import javafx.embed.swing.SwingFXUtils;
import javafx.scene.Group;
import javafx.scene.Scene;
import javafx.scene.image.ImageView;
import javafx.scene.image.WritableImage;
import javafx.stage.Stage;

import org.opencv.core.Core;
import org.opencv.core.Mat;
import org.opencv.core.MatOfByte;
import org.opencv.core.Point;
import org.opencv.core.RotatedRect;
import org.opencv.core.Scalar;
import org.opencv.core.Size;
import org.opencv.imgcodecs.Imgcodecs;
import org.opencv.imgproc.Imgproc;

public class DrawingEllipse extends Application {
   Mat matrix = null;

   @Override
   public void start(Stage stage) throws Exception {
      // Capturing the snapshot from the camera
      DrawingEllipse obj = new DrawingEllipse();
      WritableImage writableImage = obj.LoadImage();

      // Setting the image view
      ImageView imageView = new ImageView(writableImage);

      // setting the fit height and width of the image view
      imageView.setFitHeight(600);
      imageView.setFitWidth(600);

      // Setting the preserve ratio of the image view
      imageView.setPreserveRatio(true);

      // Creating a Group object
      Group root = new Group(imageView);

      // Creating a scene object
      Scene scene = new Scene(root, 600, 400);

      // Setting title to the Stage
      stage.setTitle("Drawing Ellipse on the image");

      // Adding scene to the stage
      stage.setScene(scene);

      // Displaying the contents of the stage
      stage.show();
   }
   public WritableImage LoadImage() throws Exception {
      // Loading the OpenCV core library
      System.loadLibrary( Core.NATIVE_LIBRARY_NAME );

      // Reading the Image from the file and storing it in to a Matrix object
      String file ="E:/OpenCV/chap8/input.jpg";
      Mat matrix = Imgcodecs.imread(file);

      // Drawing an Ellipse Imgproc.ellipse ( matrix, //Matrix obj of the image new RotatedRect ( // RotatedRect(Point c, Size s, double a) new Point(200, 150), new Size(260, 180), 180 ), new Scalar(0, 0, 255), //Scalar object for color 10 //Thickness of the line );
      
      // Encoding the image
      MatOfByte matOfByte = new MatOfByte();
      Imgcodecs.imencode(".jpg", matrix, matOfByte);

      // Storing the encoded Mat in a byte array
      byte[] byteArray = matOfByte.toArray();

      // Displaying the image
      InputStream in = new ByteArrayInputStream(byteArray);
      BufferedImage bufImage = ImageIO.read(in);

      this.matrix = matrix;
      
      // Creating the Writable Image
      WritableImage writableImage = SwingFXUtils.toFXImage(bufImage, null);

      return writableImage;
   }
   public static void main(String args[]) {
      launch(args);
   }
}

Lors de l'exécution du programme ci-dessus, vous obtiendrez la sortie suivante -

Vous pouvez dessiner des polylignes sur une image en utilisant la méthode polylines() du imgprocclasse. Voici la syntaxe de cette méthode.

polylines(img, pts, isClosed, color, thickness)

Cette méthode accepte les paramètres suivants -

mat - Un Mat objet représentant l'image sur laquelle les polylignes doivent être dessinées.
pts - Un List objet contenant les objets du type MatOfPoint.
isClosed - Un paramètre de type booléen spécifiant le temps que les polylignes sont fermées.
scalar - Un Scalarobjet représentant la couleur des polylignes. (BGR)
thickness- Un entier représentant l'épaisseur des polylignes; par défaut, la valeur de l'épaisseur est 1.

Le constructeur du MatOfPoint la classe accepte les objets de la classe Point.

MatOfPoint(Point... a)

Exemple

Le programme suivant montre comment dessiner des polylignes sur une image et l'afficher à l'aide de la fenêtre JavaFX.

import java.awt.image.BufferedImage;

import java.io.ByteArrayInputStream;
import java.io.InputStream;

import java.util.ArrayList;
import java.util.List;
import javax.imageio.ImageIO;

import javafx.application.Application;
import javafx.embed.swing.SwingFXUtils;
import javafx.scene.Group;
import javafx.scene.Scene;
import javafx.scene.image.ImageView;
import javafx.scene.image.WritableImage;
import javafx.stage.Stage;

import org.opencv.core.Core;
import org.opencv.core.Mat;
import org.opencv.core.MatOfByte;
import org.opencv.core.MatOfPoint;
import org.opencv.core.Point;
import org.opencv.core.Scalar;
import org.opencv.imgcodecs.Imgcodecs;
import org.opencv.imgproc.Imgproc;

public class DrawingPolyLines extends Application {
   Mat matrix = null;

   @Override
   public void start(Stage stage) throws Exception {
      // Capturing the snapshot from the camera
      DrawingPolyLines obj = new DrawingPolyLines();
      WritableImage writableImage = obj.LoadImage();

      // Setting the image view
      ImageView imageView = new ImageView(writableImage);

      // setting the fit height and width of the image view
      imageView.setFitHeight(600);
      imageView.setFitWidth(600);

      // Setting the preserve ratio of the image view
      imageView.setPreserveRatio(true);

      // Creating a Group object
      Group root = new Group(imageView);

      // Creating a scene object
      Scene scene = new Scene(root, 600, 400);

      // Setting title to the Stage
      stage.setTitle("Drawing Polylines on the image");

      // Adding scene to the stage
      stage.setScene(scene);

      // Displaying the contents of the stage
      stage.show();
   }      
   public WritableImage LoadImage() throws Exception {
      // Loading the OpenCV core library
      System.loadLibrary( Core.NATIVE_LIBRARY_NAME );

      // Reading the Image from the file and storing it in to a Matrix object
      String file ="E:/OpenCV/chap8/input.jpg";
      Mat matrix = Imgcodecs.imread(file);

      List<MatOfPoint> list = new ArrayList();
      list.add(
         new MatOfPoint (
            new Point(75, 100), new Point(350, 100),
            new Point(75, 150), new Point(350, 150),
            new Point(75, 200), new Point(350, 200),
            new Point(75, 250), new Point(350, 250)
         )
      );
      // Drawing polylines Imgproc.polylines ( matrix, // Matrix obj of the image list, // java.util.List<MatOfPoint> pts false, // isClosed new Scalar(0, 0, 255), // Scalar object for color 2 // Thickness of the line );
      // Encoding the image
      MatOfByte matOfByte = new MatOfByte();
      Imgcodecs.imencode(".jpg", matrix, matOfByte);

      // Storing the encoded Mat in a byte array
      byte[] byteArray = matOfByte.toArray();

      // Displaying the image
      InputStream in = new ByteArrayInputStream(byteArray);
      BufferedImage bufImage = ImageIO.read(in);

      this.matrix = matrix;

      // Creating the Writable Image
      WritableImage writableImage = SwingFXUtils.toFXImage(bufImage, null);
      return writableImage;
   }
   public static void main(String args[]) {
      launch(args);
   }
}

Lors de l'exécution du programme ci-dessus, vous obtiendrez la sortie suivante -

Vous pouvez dessiner des polylignes convexes sur une image en utilisant la méthode fillconvexPoly() du imgprocclasse. Voici la syntaxe de cette méthode.

fillConvexPoly(Mat img, MatOfPoint points, Scalar color)

Cette méthode accepte les paramètres suivants -

mat - Un Mat objet représentant l'image sur laquelle les polylignes convexes doivent être dessinées.
points - Un MatOfPoint objet représentant les points entre lesquels les polylignes convexes doivent être dessinées.
scalar - Un Scalarobjet représentant la couleur des polylignes convexes. (BGR)

Le constructeur du MatOfPoint la classe accepte les objets de la classe Point.

MatOfPoint(Point... a)

Exemple

Le programme suivant montre comment dessiner des polylignes convexes sur une image et l'afficher à l'aide de la fenêtre JavaFX.

import java.awt.image.BufferedImage;

import java.io.ByteArrayInputStream;
import java.io.InputStream;
import javax.imageio.ImageIO;

import javafx.application.Application;
import javafx.embed.swing.SwingFXUtils;
import javafx.scene.Group;
import javafx.scene.Scene;
import javafx.scene.image.ImageView;
import javafx.scene.image.WritableImage;
import javafx.stage.Stage;

import org.opencv.core.Core;
import org.opencv.core.Mat;
import org.opencv.core.MatOfByte;
import org.opencv.core.MatOfPoint;
import org.opencv.core.Point;
import org.opencv.core.Scalar;
import org.opencv.imgcodecs.Imgcodecs;
import org.opencv.imgproc.Imgproc;

public class FillConvexPoly extends Application {
   Mat matrix = null;

   @Override
   public void start(Stage stage) throws Exception {
      // Capturing the snapshot from the camera
      FillConvexPoly obj = new FillConvexPoly();
      WritableImage writableImage = obj.LoadImage();

      // Setting the image view
      ImageView imageView = new ImageView(writableImage);

      // setting the fit height and width of the image view
      imageView.setFitHeight(600);
      imageView.setFitWidth(600);

      //Setting the preserve ratio of the image view
      imageView.setPreserveRatio(true);

      // Creating a Group object
      Group root = new Group(imageView);

      // Creating a scene object
      Scene scene = new Scene(root, 600, 400);

      // Setting title to the Stage
      stage.setTitle("Drawing convex Polylines (fill) on the image");

      // Adding scene to the stage
      stage.setScene(scene);

      // Displaying the contents of the stage
      stage.show();
   }
   public WritableImage LoadImage() throws Exception {
      // Loading the OpenCV core library
      System.loadLibrary( Core.NATIVE_LIBRARY_NAME );

      // Reading the Image from the file and storing it in to a Matrix object
      String file ="E:/OpenCV/chap8/input.jpg";
      Mat matrix = Imgcodecs.imread(file);

      MatOfPoint matOfPoint = new MatOfPoint (
         new Point(75, 100), new Point(350, 100),
         new Point(75, 150), new Point(350, 150),
         new Point(75, 200), new Point(350, 200),
         new Point(75, 250), new Point(350, 250)
      ); 
      // Drawing polylines Imgproc.fillConvexPoly ( matrix, // Matrix obj of the image matOfPoint, // java.util.List<MatOfPoint> pts new Scalar(0, 0, 255) // Scalar object for color );
      // Encoding the image
      MatOfByte matOfByte = new MatOfByte();
      Imgcodecs.imencode(".jpg", matrix, matOfByte);

      // Storing the encoded Mat in a byte array
      byte[] byteArray = matOfByte.toArray();

      // Displaying the image
      InputStream in = new ByteArrayInputStream(byteArray);
      BufferedImage bufImage = ImageIO.read(in);
      this.matrix = matrix;
            
      // Creating the Writable Image
      WritableImage writableImage = SwingFXUtils.toFXImage(bufImage, null);
      return writableImage;
   } 
   public static void main(String args[]) {
      launch(args);
   }
}

Lors de l'exécution du programme ci-dessus, vous obtiendrez la sortie suivante -

Vous pouvez dessiner une ligne fléchée sur une image en utilisant la méthode arrowedLine() du imgprocclasse. Voici la syntaxe de cette méthode -

arrowedLine(Mat img, Point pt1, Point pt2, Scalar color)

Cette méthode accepte les paramètres suivants -

mat - Un Mat objet représentant l'image sur laquelle la ligne fléchée doit être dessinée.
pt1 and pt2 - Deux Point objets représentant les points entre lesquels la ligne fléchée doit être dessinée.
scalar - Un Scalarobjet représentant la couleur de la ligne fléchée. (BGR)

Exemple

Le programme suivant montre comment dessiner une ligne fléchée sur une image et l'afficher à l'aide de la fenêtre JavaFX.

import java.awt.image.BufferedImage;

import java.io.ByteArrayInputStream;
import java.io.InputStream;
import javax.imageio.ImageIO;

import javafx.application.Application;
import javafx.embed.swing.SwingFXUtils;
import javafx.scene.Group;
import javafx.scene.Scene;
import javafx.scene.image.ImageView;
import javafx.scene.image.WritableImage;
import javafx.stage.Stage;

import org.opencv.core.Core;
import org.opencv.core.Mat;
import org.opencv.core.MatOfByte;
import org.opencv.core.Point;
import org.opencv.core.Scalar;
import org.opencv.imgcodecs.Imgcodecs;
import org.opencv.imgproc.Imgproc;

public class DrawingArrowedLine extends Application {
   Mat matrix = null;

   @Override
   public void start(Stage stage) throws Exception {
      // Capturing the snapshot from the camera
      DrawingArrowedLine obj = new DrawingArrowedLine();
      WritableImage writableImage = obj.LoadImage();

      // Setting the image view
      ImageView imageView = new ImageView(writableImage);

      // setting the fit height and width of the image view
      imageView.setFitHeight(600);
      imageView.setFitWidth(600);

      // Setting the preserve ratio of the image view
      imageView.setPreserveRatio(true);

      // Creating a Group object
      Group root = new Group(imageView);

      // Creating a scene object
      Scene scene = new Scene(root, 600, 400);

      // Setting title to the Stage
      stage.setTitle("Drawing a line on the image");

      // Adding scene to the stage
      stage.setScene(scene);

      // Displaying the contents of the stage
      stage.show();
   }
   public WritableImage LoadImage() throws Exception {
      // Loading the OpenCV core library
      System.loadLibrary( Core.NATIVE_LIBRARY_NAME );

      // Reading the Image from the file and storing it in to a Matrix object
      String file ="C:/EXAMPLES/OpenCV/Aish.jpg";
      Mat matrix = Imgcodecs.imread(file);

      //Drawing a line Imgproc.arrowedLine( matrix, // Matrix obj of the image new Point(10, 200), // p1 new Point(590, 200), // p2 new Scalar(0, 100, 255) // Scalar object for color );

      // arrowedLine(Mat img, Point pt1, Point pt2, Scalar color)
      // Encoding the image
      MatOfByte matOfByte = new MatOfByte();
      Imgcodecs.imencode(".jpg", matrix, matOfByte);

      // Storing the encoded Mat in a byte array
      byte[] byteArray = matOfByte.toArray();

      // Displaying the image
      InputStream in = new ByteArrayInputStream(byteArray);
      BufferedImage bufImage = ImageIO.read(in);
      this.matrix = matrix;

      // Creating the Writable Image
      WritableImage writableImage = SwingFXUtils.toFXImage(bufImage, null);

      return writableImage;
   }
   public static void main(String args[]) {
      launch(args);
   }
}

Lors de l'exécution du programme ci-dessus, vous obtiendrez la sortie suivante -

Vous pouvez ajouter du texte à une image en utilisant la méthode arrowedLine() du imgprocclasse. Voici la syntaxe de cette méthode.

putText(img, text, org, fontFace, fontScale, Scalar color, int thickness)

Cette méthode accepte les paramètres suivants -

mat - Un Mat objet représentant l'image à laquelle le texte doit être ajouté.
text - Un string variable représentant le texte à ajouter.
org - Un Point objet représentant la chaîne de texte du coin inférieur gauche de l'image.
fontFace - Une variable de type entier représentant le type de police.
fontScale - Une variable de type double représentant le facteur d'échelle qui est multiplié par la taille de base spécifique à la police.
scalar - Un Scalarobjet représentant la couleur du texte à ajouter. (BGR)
thickness - Un entier représentant l'épaisseur de la ligne par défaut, la valeur de l'épaisseur est 1.

Exemple

Le programme suivant montre comment ajouter du texte à une image et l'afficher à l'aide de la fenêtre JavaFX.

import java.awt.image.BufferedImage;

import java.io.ByteArrayInputStream;
import java.io.InputStream;
import javax.imageio.ImageIO;

import javafx.application.Application;
import javafx.embed.swing.SwingFXUtils;
import javafx.scene.Group;
import javafx.scene.Scene;
import javafx.scene.image.ImageView;
import javafx.scene.image.WritableImage;
import javafx.stage.Stage;

import org.opencv.core.Core;
import org.opencv.core.Mat;
import org.opencv.core.MatOfByte;
import org.opencv.core.Point;
import org.opencv.core.Scalar;
import org.opencv.imgcodecs.Imgcodecs;
import org.opencv.imgproc.Imgproc;

public class AddingTextToImage extends Application {
   Mat matrix = null;

   @Override
   public void start(Stage stage) throws Exception {
      // Capturing the snapshot from the camera
      AddingTextToImage obj = new AddingTextToImage();
      WritableImage writableImage = obj.LoadImage();

      // Setting the image view
      ImageView imageView = new ImageView(writableImage);

      // setting the fit height and width of the image view
      imageView.setFitHeight(600);
      imageView.setFitWidth(600);

      // Setting the preserve ratio of the image view
      imageView.setPreserveRatio(true);

      // Creating a Group object
      Group root = new Group(imageView);

      // Creating a scene object
      Scene scene = new Scene(root, 600, 400);

      // Setting title to the Stage
      stage.setTitle("Adding text to an image");

      // Adding scene to the stage
      stage.setScene(scene);

      // Displaying the contents of the stage
      stage.show();
   }
   public WritableImage LoadImage() throws Exception {
      // Loading the OpenCV core library
      System.loadLibrary( Core.NATIVE_LIBRARY_NAME );

      // Reading the Image from the file and storing it in to a Matrix object
      String file ="E:/OpenCV/chap8/input.jpg";
      Mat matrix = Imgcodecs.imread(file);

      // Adding Text Imgproc.putText ( matrix, // Matrix obj of the image "Ravivarma's Painting", // Text to be added new Point(10, 50), // point Core.FONT_HERSHEY_SIMPLEX , // front face 1, // front scale new Scalar(0, 0, 0), // Scalar object for color 4 // Thickness );
      
      // Encoding the image
      MatOfByte matOfByte = new MatOfByte();
      Imgcodecs.imencode(".jpg", matrix, matOfByte);

      // Storing the encoded Mat in a byte array
      byte[] byteArray = matOfByte.toArray();

      // Displaying the image
      InputStream in = new ByteArrayInputStream(byteArray);
      BufferedImage bufImage = ImageIO.read(in);
      this.matrix = matrix;

      //Creating the Writable Image
      WritableImage writableImage = SwingFXUtils.toFXImage(bufImage, null);
      return writableImage;
   }
   public static void main(String args[]) {
      launch(args);
   }
}

Lors de l'exécution du programme ci-dessus, vous obtiendrez la sortie suivante -

Le flou (lissage) est l'opération de traitement d'image couramment utilisée pour réduire le bruit de l'image. Le processus supprime le contenu haute fréquence, comme les bords, de l'image et la rend lisse.

En général, le flou est obtenu en convoluant (chaque élément de l'image est ajouté à ses voisins locaux, pondérés par le noyau) l'image à travers un noyau de filtre passe-bas.

Flou (moyenne)

Lors de cette opération, l'image est convoluée avec un filtre boîte (normalisé). Dans ce processus, l'élément central de l'image est remplacé par la moyenne de tous les pixels de la zone du noyau.

Vous pouvez effectuer cette opération sur une image en utilisant la méthode blur() du imgprocclasse. Voici la syntaxe de cette méthode -

blur(src, dst, ksize, anchor, borderType)

Cette méthode accepte les paramètres suivants -

src - Un Mat objet représentant la source (image d'entrée) de cette opération.
dst - Un Mat objet représentant la destination (image de sortie) de cette opération.
ksize - Un Size objet représentant la taille du noyau.
anchor - Une variable de type entier représentant le point d'ancrage.
borderType - Une variable de type entier représentant le type de bordure à utiliser pour la sortie.

Exemple

Le programme suivant montre comment effectuer l'opération de moyennage (flou) sur une image.

import org.opencv.core.Core;
import org.opencv.core.Mat;
import org.opencv.core.Point;
import org.opencv.core.Size;
import org.opencv.imgcodecs.Imgcodecs;
import org.opencv.imgproc.Imgproc;

public class BlurTest {
   public static void main(String args[]) {
      // Loading the OpenCV core library
      System.loadLibrary( Core.NATIVE_LIBRARY_NAME );

      // Reading the Image from the file and storing it in to a Matrix object
      String file ="C:/EXAMPLES/OpenCV/sample.jpg";
      Mat src = Imgcodecs.imread(file);

      // Creating an empty matrix to store the result
      Mat dst = new Mat();

      // Creating the Size and Point objects
      Size size = new Size(45, 45);
      Point point = new Point(20, 30);

      // Applying Blur effect on the Image
      Imgproc.blur(src, dst, size, point, Core.BORDER_DEFAULT);

      // blur(Mat src, Mat dst, Size ksize, Point anchor, int borderType)
      // Writing the image
      Imgcodecs.imwrite("E:/OpenCV/chap9/blur.jpg", dst);
      System.out.println("Image processed");
   }
}

Supposons que ce qui suit est l'image d'entrée sample.jpg spécifié dans le programme ci-dessus.

Production

Lors de l'exécution du programme, vous obtiendrez la sortie suivante -

Image Processed

Si vous ouvrez le chemin spécifié, vous pouvez observer l'image de sortie comme suit -

Dans l'opération Flou gaussien, l'image est convoluée avec un filtre gaussien au lieu du filtre boîte. Le filtre gaussien est un filtre passe-bas qui supprime les composantes haute fréquence qui sont réduites.

Vous pouvez effectuer cette opération sur une image à l'aide du Gaussianblur() méthode de la imgprocclasse. Voici la syntaxe de cette méthode -

GaussianBlur(src, dst, ksize, sigmaX)

Cette méthode accepte les paramètres suivants -

src - Un Mat objet représentant la source (image d'entrée) de cette opération.
dst - Un Mat objet représentant la destination (image de sortie) de cette opération.
ksize - Un Size objet représentant la taille du noyau.
sigmaX - Une variable de type double représentant l'écart type du noyau gaussien dans la direction X.

Exemple

Le programme suivant montre comment effectuer l'opération de flou gaussien sur une image.

import org.opencv.core.Core;
import org.opencv.core.Mat;
import org.opencv.core.Size;
import org.opencv.imgcodecs.Imgcodecs;
import org.opencv.imgproc.Imgproc;

public class GaussianTest {
   public static void main(String args[]) {
      // Loading the OpenCV core library
      System.loadLibrary(Core.NATIVE_LIBRARY_NAME);

      // Reading the Image from the file and storing it in to a Matrix object
      String file ="C:/EXAMPLES/OpenCV/sample.jpg";
      Mat src = Imgcodecs.imread(file);

      // Creating an empty matrix to store the result
      Mat dst = new Mat();
    
      // Applying GaussianBlur on the Image
      Imgproc.GaussianBlur(src, dst, new Size(45, 45), 0);

      // Writing the image
      Imgcodecs.imwrite("E:/OpenCV/chap9/Gaussian.jpg", dst);
      System.out.println("Image Processed");
   }
}

Supposons que ce qui suit est l'image d'entrée sample.jpg spécifié dans le programme ci-dessus.

Production

Lors de l'exécution du programme, vous obtiendrez la sortie suivante -

Image Processed

Si vous ouvrez le chemin spécifié, vous pouvez observer l'image de sortie comme suit -

L'opération Flou médian est similaire aux autres méthodes de calcul de la moyenne. Ici, l'élément central de l'image est remplacé par la médiane de tous les pixels de la zone du noyau. Cette opération traite les bords tout en supprimant le bruit.

Vous pouvez effectuer cette opération sur une image à l'aide du medianBlur() méthode de la imgprocclasse. Voici la syntaxe de cette méthode -

medianBlur(src, dst, ksize)

Cette méthode accepte les paramètres suivants -

src - Un Mat objet représentant la source (image d'entrée) de cette opération.
dst - Un Mat objet représentant la destination (image de sortie) de cette opération.
ksize - Un Size objet représentant la taille du noyau.

Exemple

Le programme suivant montre comment effectuer l'opération de flou médian sur une image.

import org.opencv.core.Core;
import org.opencv.core.Mat;
import org.opencv.imgcodecs.Imgcodecs;
import org.opencv.imgproc.Imgproc;

public class MedianBlurTest {
   public static void main(String args[]) {
      // Loading the OpenCV core library
      System.loadLibrary( Core.NATIVE_LIBRARY_NAME );

      // Reading the Image from the file and storing it in to a Matrix object
      String file ="C:/EXAMPLES/OpenCV/sample.jpg";
      Mat src = Imgcodecs.imread(file);

      // Creating an empty matrix to store the result
      Mat dst = new Mat();

      // Applying MedianBlur on the Image
      Imgproc.medianBlur(src, dst, 15);

      // Writing the image
      Imgcodecs.imwrite("E:/OpenCV/chap9/median.jpg", dst);

      System.out.println("Image Processed");
   }
}

Supposons que ce qui suit est l'image d'entrée sample.jpg spécifié dans le programme ci-dessus.

Production

Lors de l'exécution du programme, vous obtiendrez la sortie suivante -

Image Processed

Si vous ouvrez le chemin spécifié, vous pouvez observer l'image de sortie comme suit -

Le filtrage d'image vous permet d'appliquer divers effets à une image. Dans ce chapitre et les trois chapitres suivants, nous allons discuter de diverses opérations de filtrage telles que Bilateral Filter, Box Filter, SQR Box Filter et Filter2D.

Filtre bilatéral

L'opération Filtre bilatéral applique une image bilatérale à un filtre. Vous pouvez effectuer cette opération sur une image à l'aide dumedianBlur() méthode de la imgprocclasse. Voici la syntaxe de cette méthode.

bilateralFilter(src, dst, d, sigmaColor, sigmaSpace, borderType)

Cette méthode accepte les paramètres suivants -

src - Un Mat objet représentant la source (image d'entrée) de cette opération.
dst - Un Mat objet représentant la destination (image de sortie) de cette opération.
d - Une variable de type entier représentant le diamètre du voisinage des pixels.
sigmaColor - Une variable de type entier représentant le sigma du filtre dans l'espace colorimétrique.
sigmaSpace - Une variable de type entier représentant le sigma du filtre dans l'espace de coordonnées.
borderType - Un objet entier représentant le type de bordure utilisée.

Exemple

Le programme suivant montre comment effectuer l'opération de filtre bilatéral sur une image.

import org.opencv.core.Core;
import org.opencv.core.Mat;
import org.opencv.imgcodecs.Imgcodecs;
import org.opencv.imgproc.Imgproc;

public class BilateralFilter {
   public static void main(String args[]) {
      // Loading the OpenCV core library
      System.loadLibrary( Core.NATIVE_LIBRARY_NAME );

      // Reading the Image from the file and storing it in to a Matrix object
      String file ="E:/OpenCV/chap11/filter_input.jpg";
      Mat src = Imgcodecs.imread(file);

      // Creating an empty matrix to store the result
      Mat dst = new Mat();

      // Applying Bilateral filter on the Image
      Imgproc.bilateralFilter(src, dst, 15, 80, 80, Core.BORDER_DEFAULT);

      // Writing the image
      Imgcodecs.imwrite("E:/OpenCV/chap11/bilateralfilter.jpg", dst);

      System.out.println("Image Processed");
   }
}

Supposons que ce qui suit est l'image d'entrée filter_input.jpg spécifié dans le programme ci-dessus.

Production

Lors de l'exécution du programme, vous obtiendrez la sortie suivante -

Image Processed

Si vous ouvrez le chemin spécifié, vous pouvez observer l'image de sortie comme suit -

L'opération de filtre de boîte est similaire à l'opération de flou de moyennage; il applique une image bilatérale à un filtre. Ici, vous pouvez choisir si la boîte doit être normalisée ou non.

Vous pouvez effectuer cette opération sur une image à l'aide du boxFilter() méthode de la imgprocclasse. Voici la syntaxe de cette méthode -

boxFilter(src, dst, ddepth, ksize, anchor, normalize, borderType)

Cette méthode accepte les paramètres suivants -

src - Un Mat objet représentant la source (image d'entrée) de cette opération.
dst - Un Mat objet représentant la destination (image de sortie) de cette opération.
ddepth - Une variable de type entier représentant la profondeur de l'image de sortie.
ksize - Un Size objet représentant la taille du noyau de flou.
anchor - Une variable de type entier représentant le point d'ancrage.
Normalize - Une variable de type booléen spécifiant le temps que le noyau doit être normalisé.
borderType - Un objet entier représentant le type de bordure utilisée.

Exemple

Le programme suivant montre comment effectuer l'opération Box Filter sur une image.

import org.opencv.core.Core;
import org.opencv.core.Mat;
import org.opencv.core.Point;
import org.opencv.core.Size;
import org.opencv.imgcodecs.Imgcodecs;
import org.opencv.imgproc.Imgproc;

public class BoxFilterTest {
   public static void main( String[] args ) {
      // Loading the OpenCV core library
      System.loadLibrary( Core.NATIVE_LIBRARY_NAME );

      // Reading the Image from the file and storing it in to a Matrix object
      String file = "E:/OpenCV/chap11/filter_input.jpg";
      Mat src = Imgcodecs.imread(file);

      // Creating an empty matrix to store the result
      Mat dst = new Mat();

      // Creating the objects for Size and Point
      Size size = new Size(45, 45);
      Point point = Point(-1, -1);

      // Applying Box Filter effect on the Image
      Imgproc.boxFilter(src, dst, 50, size, point, true, Core.BORDER_DEFAULT);

      // Writing the image
      Imgcodecs.imwrite("E:/OpenCV/chap11/boxfilterjpg", dst);

      System.out.println("Image Processed");
   }
}

Supposons que ce qui suit est l'image d'entrée filter_input.jpg spécifié dans le programme ci-dessus.

Production

Lors de l'exécution du programme, vous obtiendrez la sortie suivante -

Image Processed

Si vous ouvrez le chemin spécifié, vous pouvez observer l'image de sortie comme suit -

Vous pouvez effectuer l'opération de filtre SQRBox sur une image à l'aide du boxFilter() méthode de la imgprocclasse. Voici la syntaxe de cette méthode -

sqrBoxFilter(src, dst, ddepth, ksize)

Cette méthode accepte les paramètres suivants -

src - Un Mat objet représentant la source (image d'entrée) de cette opération.
dst - Un Mat objet représentant la destination (image de sortie) de cette opération.
ddepth - Une variable de type entier représentant la profondeur de l'image de sortie.
ksize - Un Size objet représentant la taille du noyau de flou.

Exemple

Le programme suivant montre comment effectuer une opération de filtre Sqrbox sur une image donnée.

import org.opencv.core.Core;
import org.opencv.core.Mat;
import org.opencv.core.Size;
import org.opencv.imgcodecs.Imgcodecs;
import org.opencv.imgproc.Imgproc;

public class SqrBoxFilterTest {
   public static void main( String[] args ) {
      // Loading the OpenCV core library
      System.loadLibrary( Core.NATIVE_LIBRARY_NAME );

      // Reading the Image from the file and storing it in to a Matrix object
      String file ="E:/OpenCV/chap11/filter_input.jpg";
      Mat src = Imgcodecs.imread(file);

      // Creating an empty matrix to store the result
      Mat dst = new Mat();

      // Applying Box Filter effect on the Image
      Imgproc.sqrBoxFilter(src, dst, -1, new Size(1, 1));
     
      // Writing the image
      Imgcodecs.imwrite("E:/OpenCV/chap11/sqrboxfilter.jpg", dst);

      System.out.println("Image Processed");
   } 
}

Supposons que ce qui suit est l'image d'entrée filter_input.jpg spécifié dans le programme ci-dessus.

Production

Lors de l'exécution du programme, vous obtiendrez la sortie suivante -

Image Processed

Si vous ouvrez le chemin spécifié, vous pouvez observer l'image de sortie comme suit -

L'opération Filter2D convolve une image avec le noyau. Vous pouvez effectuer cette opération sur une image à l'aide duFilter2D() méthode de la imgprocclasse. Voici la syntaxe de cette méthode -

filter2D(src, dst, ddepth, kernel)

Cette méthode accepte les paramètres suivants -

src - Un Mat objet représentant la source (image d'entrée) de cette opération.
dst - Un Mat objet représentant la destination (image de sortie) de cette opération.
ddepth - Une variable de type entier représentant la profondeur de l'image de sortie.
kernel - Un Mat objet représentant le noyau de convolution.

Exemple

Le programme suivant montre comment effectuer l'opération Filter2D sur une image.

import org.opencv.core.Core;
import org.opencv.core.CvType;
import org.opencv.core.Mat;
import org.opencv.imgcodecs.Imgcodecs;
import org.opencv.imgproc.Imgproc;

public class Filter2D {
   public static void main( String[] args ) {
      //Loading the OpenCV core library  
      System.loadLibrary( Core.NATIVE_LIBRARY_NAME );

      //Reading the Image from the file and storing it in to a Matrix object
      String file ="E:/OpenCV/chap11/filter_input.jpg";
      Mat src = Imgcodecs.imread(file);

      //Creating an empty matrix to store the result
      Mat dst = new Mat();

      // Creating kernel matrix
      Mat kernel = Mat.ones(2,2, CvType.CV_32F);
      
      for(int i = 0; i<kernel.rows(); i++) {
         for(int j = 0; j<kernel.cols(); j++) {
            double[] m = kernel.get(i, j);

            for(int k = 1; k<m.length; k++) {
               m[k] = m[k]/(2 * 2);
            }
            kernel.put(i,j, m);
         }
      }
      Imgproc.filter2D(src, dst, -1, kernel);
      Imgcodecs.imwrite("E:/OpenCV/chap11/filter2d.jpg", dst);
      System.out.println("Image Processed");
   }
}

Supposons que ce qui suit est l'image d'entrée filter_input.jpg spécifié dans le programme ci-dessus.

Production

Lors de l'exécution du programme, vous obtiendrez la sortie suivante -

Image Processed

Si vous ouvrez le chemin spécifié, vous pouvez observer l'image de sortie comme suit -

L'érosion et la dilatation sont les deux types d'opérations morphologiques. Comme son nom l'indique, les opérations morphologiques sont l'ensemble des opérations qui traitent les images en fonction de leurs formes.

Sur la base de l'image d'entrée donnée, un "élément structurel" est développé. Cela peut être fait dans l'une des deux procédures. Celles-ci visent à éliminer le bruit et à corriger les imperfections, pour rendre l'image claire.

Dilatation

Cette procédure suit la convolution avec un noyau d'une forme spécifique telle qu'un carré ou un cercle. Ce noyau a un point d'ancrage, qui désigne son centre.

Ce noyau est superposé sur l'image pour calculer la valeur maximale des pixels. Après le calcul, l'image est remplacée par l'ancre au centre. Avec cette procédure, la taille des zones des régions lumineuses augmente et donc la taille de l'image augmente.

Par exemple, la taille d'un objet dans une teinte blanche ou une teinte claire augmente, tandis que la taille d'un objet dans une teinte noire ou une teinte foncée diminue.

Vous pouvez effectuer l'opération de dilatation sur une image à l'aide du dilate() méthode de la imgprocclasse. Voici la syntaxe de cette méthode.

dilate(src, dst, kernel)

Cette méthode accepte les paramètres suivants -

src - Un Mat objet représentant la source (image d'entrée) de cette opération.
dst - Un Mat objet représentant la destination (image de sortie) de cette opération.
kernel - Un Mat objet représentant le noyau.

Exemple

Vous pouvez préparer la matrice du noyau en utilisant le getStructuringElement()méthode. Cette méthode accepte un entier représentant lemorph_rect type et un objet du type Size.

Imgproc.getStructuringElement(int shape, Size ksize);

Le programme suivant montre comment effectuer l'opération de dilatation sur une image donnée.

import org.opencv.core.Core;
import org.opencv.core.Mat;
import org.opencv.core.Size;
import org.opencv.imgcodecs.Imgcodecs;
import org.opencv.imgproc.Imgproc;

public class DilateTest {
   public static void main( String[] args ) {
      // Loading the OpenCV core library
      System.loadLibrary( Core.NATIVE_LIBRARY_NAME );

      // Reading the Image from the file and storing it in to a Matrix object
      String file ="C:/EXAMPLES/OpenCV/sample.jpg";
      Mat src = Imgcodecs.imread(file);

      // Creating an empty matrix to store the result
      Mat dst = new Mat();

      // Preparing the kernel matrix object 
      Mat kernel = Imgproc.getStructuringElement(Imgproc.MORPH_RECT, 
         new  Size((2*2) + 1, (2*2)+1));

      // Applying dilate on the Image
      Imgproc.dilate(src, dst, kernel);

      // Writing the image
      Imgcodecs.imwrite("E:/OpenCV/chap10/Dilation.jpg", dst);

      System.out.println("Image Processed");
   } 
}

Contribution

Supposons que ce qui suit est l'image d'entrée sample.jpg spécifié dans le programme ci-dessus.

Production

Lors de l'exécution du programme, vous obtiendrez la sortie suivante -

Image Processed

Si vous ouvrez le chemin spécifié, vous pouvez observer l'image de sortie comme suit -

L'érosion est un processus assez similaire à la dilatation. Mais la valeur de pixel calculée ici est minimale plutôt que maximale en dilatation. L'image est remplacée sous le point d'ancrage par cette valeur de pixel minimale.

Avec cette procédure, les zones des régions sombres grossissent et les régions claires se réduisent. Par exemple, la taille d'un objet dans une teinte sombre ou une teinte noire augmente, alors qu'elle diminue dans une teinte blanche ou une teinte claire.

Exemple

Vous pouvez effectuer cette opération sur une image à l'aide du erode() méthode de la imgprocclasse. Voici la syntaxe de cette méthode -

erode(src, dst, kernel)

Cette méthode accepte les paramètres suivants -

src - Un Mat objet représentant la source (image d'entrée) de cette opération.
dst - Un Mat objet représentant la destination (image de sortie) de cette opération.
kernel - Un Mat objet représentant le noyau.

Vous pouvez préparer la matrice du noyau en utilisant le getStructuringElement()méthode. Cette méthode accepte un entier représentant lemorph_rect type et un objet du type Size.

Imgproc.getStructuringElement(int shape, Size ksize);

Le programme suivant montre comment effectuer l'opération d'érosion sur une image donnée.

import org.opencv.core.Core;
import org.opencv.core.Mat;
import org.opencv.core.Size;
import org.opencv.imgcodecs.Imgcodecs;
import org.opencv.imgproc.Imgproc;

public class ErodeTest {
   public static void main( String[] args ) {
      // Loading the OpenCV core library
      System.loadLibrary( Core.NATIVE_LIBRARY_NAME );

      // Reading the Image from the file and storing it in to a Matrix object
      String file ="C:/EXAMPLES/OpenCV/sample.jpg";
      Mat src = Imgcodecs.imread(file);

      // Creating an empty matrix to store the result
      Mat dst = new Mat();

      // Preparing the kernel matrix object
      Mat kernel = Imgproc.getStructuringElement(Imgproc.MORPH_RECT, 
         new  Size((2*2) + 1, (2*2)+1));

      // Applying erode on the Image
      Imgproc.erode(src, dst, kernel);

      // Writing the image
      Imgcodecs.imwrite("E:/OpenCV/chap10/Erosion.jpg", dst);

      System.out.println("Image processed");
   }
}

Supposons que ce qui suit est l'image d'entrée sample.jpg spécifié dans le programme ci-dessus.

Production

Lors de l'exécution du programme, vous obtiendrez la sortie suivante -

Image Loaded

Si vous ouvrez le chemin spécifié, vous pouvez observer l'image de sortie comme suit -

Dans les chapitres précédents, nous avons discuté du processus de erosion et dilation. En plus de ces deux, OpenCV a plus de transformations morphologiques. lemorphologyEx() de la méthode de la classe Imgproc est utilisé pour effectuer ces opérations sur une image donnée.

Voici la syntaxe de cette méthode -

morphologyEx(src, dst, op, kernel)

Cette méthode accepte les paramètres suivants -

src - Un objet de la classe Mat représentant l'image source (entrée).
dst - objet de la classe Mat représentant l'image de destination (sortie).
op - Un entier représentant le type de l'opération morphologique.
kernel - Une matrice de noyau.

Exemple

Le programme suivant montre comment appliquer l'opération morphologique "top-hat" sur une image utilisant la bibliothèque OpenCV.

import org.opencv.core.Core;
import org.opencv.core.CvType;
import org.opencv.core.Mat;
import org.opencv.imgcodecs.Imgcodecs;
import org.opencv.imgproc.Imgproc;

public class MorphologyExTest {
   public static void main(String args[]) {
      // Loading the OpenCV core library
      System.loadLibrary( Core.NATIVE_LIBRARY_NAME );

      // Reading the Image from the file and storing it in to a Matrix object
      String file ="E:/OpenCV/chap12/morph_input.jpg";
      Mat src = Imgcodecs.imread(file);

      // Creating an empty matrix to store the result
      Mat dst = new Mat();

      // Creating kernel matrix
      Mat kernel = Mat.ones(5,5, CvType.CV_32F);

      // Applying Blur effect on the Image 
      Imgproc.morphologyEx(src, dst, Imgproc.MORPH_TOPHAT, kernel);

      // Writing the image
      Imgcodecs.imwrite("E:/OpenCV/chap12/morph_tophat.jpg", dst);

      System.out.println("Image Processed");
   } 
}

Supposons que ce qui suit est l'image d'entrée morph_input.jpg spécifié dans le programme ci-dessus.

Production

Lors de l'exécution du programme, vous obtiendrez la sortie suivante -

Image Processed

Si vous ouvrez le chemin spécifié, vous pouvez observer l'image de sortie comme suit -

Plus d'opérations

En plus de l'opération morphologique TOPHAT, démontré dans le précédent example, OpenCV répond à divers autres types de morphologies. Tous ces types sont représentés par des champs statiques prédéfinis (valeurs fixes) deImgproc classe.

Vous pouvez choisir le type de morphologie dont vous avez besoin en passant leur valeur prédéfinie respective au paramètre op du morphologyEx() méthode.

// Applying Blur effect on the Image
Imgproc.morphologyEx(src, dst, Imgproc.MORPH_TOPHAT, kernel);

Voici les valeurs représentant le type d'opérations morphologiques et leurs résultats respectifs.

Fonctionnement et description	Production
MORPH_BLACKHAT
MORPH_CLOSE
MORPH_CROSS
MORPH_DILATE
MORPH_ELLIPSE
MORPH_ERODE
MORPH_GRADIENT
MORPH_OPEN
MORPH_RECT
MORPH_TOPHAT

Pyramide est une opération sur une image où,

Une image d'entrée est d'abord lissée à l'aide d'un filtre de lissage particulier (ex: gaussien, laplacien), puis l'image lissée est sous-échantillonnée.
Ce processus est répété plusieurs fois.

Pendant l'opération pyramidale, la fluidité de l'image est augmentée et la résolution (taille) est diminuée.

Pyramide vers le haut

Dans Pyramid Up, l'image est d'abord suréchantillonnée, puis floue. Vous pouvez effectuer une opération Pyramid Up sur une image à l'aide depyrUP() méthode de la imgprocclasse. Voici la syntaxe de cette méthode -

pyrUp(src, dst, dstsize, borderType)

Cette méthode accepte les paramètres suivants -

src - Un objet de la classe Mat représentant l'image source (entrée).
mat - Un objet de la classe Mat représentant l'image de destination (sortie).
size - Un objet de la classe Size représentant la taille à laquelle l'image doit être augmentée ou diminuée.
borderType - Une variable de type entier représentant le type de bordure à utiliser.

Exemple

Le programme suivant montre comment effectuer l'opération Pyramid Up sur une image.

import org.opencv.core.Core;
import org.opencv.core.Mat;
import org.opencv.core.Size;
import org.opencv.imgcodecs.Imgcodecs;
import org.opencv.imgproc.Imgproc;

public class PyramidUp {
   public static void main( String[] args ) {
      // Loading the OpenCV core library
      System.loadLibrary( Core.NATIVE_LIBRARY_NAME );

      // Reading the Image from the file and storing it in to a Matrix object
      String file ="E:/OpenCV/chap13/pyramid_input.jpg";
      Mat src = Imgcodecs.imread(file);

      // Creating an empty matrix to store the result
      Mat dst = new Mat();

      // Applying pyrUp on the Image
      Imgproc.pyrUp(src, dst, new Size(src.cols()*2,  src.rows()*2), Core.BORDER_DEFAULT);

      // Writing the image
      Imgcodecs.imwrite("E:/OpenCV/chap13/pyrUp_output.jpg", dst);

      System.out.println("Image Processed");
   }
}

Supposons que ce qui suit est l'image d'entrée pyramid_input.jpg spécifié dans le programme ci-dessus.

Production

Lors de l'exécution du programme, vous obtiendrez la sortie suivante -

Image Processed

Si vous ouvrez le chemin spécifié, vous pouvez observer l'image de sortie comme suit -

Pyramide vers le bas

Dans Pyramid Down, l'image est d'abord floue, puis sous-échantillonnée. Vous pouvez effectuer une opération Pyramid Down sur une image à l'aide depyrDown() méthode de la imgprocclasse. Voici la syntaxe de cette méthode -

pyrDown(src, dst, dstsize, borderType)

Cette méthode accepte les paramètres suivants -

src - Un objet de la classe Mat représentant l'image source (entrée).
mat - Un objet de la classe Mat représentant l'image de destination (sortie).
size - Un objet de la classe Size représentant la taille à laquelle l'image doit être augmentée ou diminuée.
borderType - Une variable de type entier représentant le type de bordure à utiliser.

Exemple

Le programme suivant montre comment effectuer l'opération Pyramid Down sur une image.

import org.opencv.core.Core;
import org.opencv.core.Mat;
import org.opencv.core.Size;
import org.opencv.imgcodecs.Imgcodecs;
import org.opencv.imgproc.Imgproc;

public class PyramidDown {
   public static void main( String[] args ) {
      // Loading the OpenCV core library
      System.loadLibrary( Core.NATIVE_LIBRARY_NAME );

      // Reading the Image from the file and storing it in to a Matrix object
      String file ="E:/OpenCV/chap13/pyramid_input.jpg";
      Mat src = Imgcodecs.imread(file);

      // Creating an empty matrix to store the result
      Mat dst = new Mat();

      // Applying pyrDown on the Image
      Imgproc.pyrDown(src, dst, new Size(src.cols()/2,  src.rows()/2),
         Core.BORDER_DEFAULT);

      // Writing the image
      Imgcodecs.imwrite("E:/OpenCV/chap13/pyrDown_output.jpg", dst);

      System.out.println("Image Processed");
   } 
}

Supposons que ce qui suit est l'image d'entrée pyramid_input.jpg spécifié dans le programme ci-dessus.

Production

Lors de l'exécution du programme, vous obtiendrez la sortie suivante -

Image Processed

Si vous ouvrez le chemin spécifié, vous pouvez observer l'image de sortie comme suit -

Filtrage par décalage moyen

Dans l'opération pyramidale à décalage moyen, une étape initiale de segmentation par décalage moyen d'une image est effectuée.

Vous pouvez effectuer une opération de filtrage pyramidal Mean Shift sur une image à l'aide de pyrDown() méthode de la imgprocclasse. Voici la syntaxe de cette méthode.

pyrMeanShiftFiltering(src, dst, sp, sr)

Cette méthode accepte les paramètres suivants -

src - Un objet de la classe Mat représentant l'image source (entrée).
mat - Un objet de la classe Mat représentant l'image de destination (sortie).
sp - Une variable de type double représentant le rayon de la fenêtre spatiale.
sr - Une variable de type double représentant le rayon de la fenêtre de couleur.

Exemple

Le programme suivant montre comment effectuer une opération de filtrage par décalage moyen sur une image donnée.

import org.opencv.core.Core;
import org.opencv.core.Mat;
import org.opencv.imgcodecs.Imgcodecs;
import org.opencv.imgproc.Imgproc;

public class PyramidMeanShift {
   public static void main( String[] args ) {
      // Loading the OpenCV core library
      System.loadLibrary( Core.NATIVE_LIBRARY_NAME );

      // Reading the Image from the file and storing it in to a Matrix object
      String file ="E:/OpenCV/chap13/pyramid_input.jpg";
      Mat src = Imgcodecs.imread(file);

      // Creating an empty matrix to store the result
      Mat dst = new Mat();

      // Applying meanShifting on the Image
      Imgproc.pyrMeanShiftFiltering(src, dst, 200, 300);

      // Writing the image
      Imgcodecs.imwrite("E:/OpenCV/chap13/meanShift_output.jpg", dst);
      
      System.out.println("Image Processed");
   } 
}

Supposons que ce qui suit est l'image d'entrée pyramid_input.jpg spécifié dans le programme ci-dessus.

Production

Lors de l'exécution du programme, vous obtiendrez la sortie suivante -

Image Processed

Si vous ouvrez le chemin spécifié, vous pouvez observer l'image de sortie comme suit -

Le seuillage est une méthode de segmentation d'image, en général, il est utilisé pour créer des images binaires. Le seuillage est de deux types, à savoir le seuillage simple et le seuillage adaptatif.

Seuils simples

Dans une opération de seuillage simple, les pixels dont les valeurs sont supérieures à la valeur de seuil spécifiée se voient attribuer une valeur standard.

Vous pouvez effectuer une opération de seuil simple sur une image en utilisant la méthode threshold() du Imgproc class, Voici la syntaxe de cette méthode.

threshold(src, dst, thresh, maxval, type)

Cette méthode accepte les paramètres suivants -

src - Un objet de la classe Mat représentant l'image source (entrée).
dst - Un objet de la classe Mat représentant l'image de destination (sortie).
thresh - Une variable de type double représentant la valeur seuil.
maxval - Une variable de type double représentant la valeur à donner si la valeur du pixel est supérieure à la valeur seuil.
type - Une variable de type entier représentant le type de seuil à utiliser.

Exemple

Le programme suivant montre comment effectuer une opération de seuillage simple sur une image dans OpenCV.

import org.opencv.core.Core;
import org.opencv.core.Mat;
import org.opencv.imgcodecs.Imgcodecs;
import org.opencv.imgproc.Imgproc;

public class Thresh {
   public static void main(String args[]) {
      // Loading the OpenCV core library
      System.loadLibrary( Core.NATIVE_LIBRARY_NAME );

      // Reading the Image from the file and storing it in to a Matrix object
      String file ="E:/OpenCV/chap14/thresh_input.jpg";
      Mat src = Imgcodecs.imread(file);

      // Creating an empty matrix to store the result
      Mat dst = new Mat();
      Imgproc.threshold(src, dst, 50, 255, Imgproc.THRESH_BINARY);

      // Writing the image
      Imgcodecs.imwrite("E:/OpenCV/chap14/thresh_trunc.jpg", dst);

      System.out.println("Image Processed");
   }
}

Supposons que ce qui suit est l'image d'entrée thresh_input.jpg spécifié dans le programme ci-dessus.

Production

Lors de l'exécution du programme, vous obtiendrez la sortie suivante -

Image Processed

Si vous ouvrez le chemin spécifié, vous pouvez observer l'image de sortie comme suit -

Autres types de seuillage simple

En plus de THRESH_BINARYopération démontrée dans l'exemple précédent, OpenCV répond à divers autres types d'opérations de seuil. Tous ces types sont représentés par des champs statiques prédéfinis (valeurs fixes) deImgproc classe.

Vous pouvez choisir le type d'opération de seuil dont vous avez besoin, en passant sa valeur prédéfinie respective au paramètre nommé type du threshold() méthode.

Imgproc.threshold(src, dst, 50, 255, Imgproc.THRESH_BINARY);

Voici les valeurs représentant divers types d'opérations de seuil et leurs sorties respectives.

Fonctionnement et description	Production
THRESH_BINARY
THRESH_BINARY_INV
THRESH_TRUNC
THRESH_TOZERO
THRESH_TOZERO_INV

Dans simple thresholding, la valeur seuil est globale, c'est-à-dire qu'elle est la même pour tous les pixels de l'image. Adaptive thresholding est la méthode dans laquelle la valeur de seuil est calculée pour des régions plus petites et, par conséquent, il y aura différentes valeurs de seuil pour différentes régions.

Dans OpenCV, vous pouvez effectuer une opération de seuil adaptatif sur une image à l'aide de la méthode adaptiveThreshold() du Imgprocclasse. Voici la syntaxe de cette méthode.

adaptiveThreshold(src, dst, maxValue, adaptiveMethod, thresholdType, blockSize, C)

Cette méthode accepte les paramètres suivants -

src - Un objet de la classe Mat représentant l'image source (entrée).
dst - Un objet de la classe Mat représentant l'image de destination (sortie).
maxValue - Une variable de type double représentant la valeur à donner si la valeur du pixel est supérieure à la valeur seuil.
adaptiveMethod- Une variable de type entier représentant la méthode adaptative à utiliser. Ce sera l'une des deux valeurs suivantes
- ADAPTIVE_THRESH_MEAN_C - la valeur seuil est la moyenne de la zone de voisinage.
- ADAPTIVE_THRESH_GAUSSIAN_C - la valeur seuil est la somme pondérée des valeurs de voisinage où les poids sont une fenêtre gaussienne.
thresholdType - Une variable de type entier représentant le type de seuil à utiliser.
blockSize - Une variable de type entier représentant la taille du pixel voisinage utilisée pour calculer la valeur seuil.
C - Une variable de type double représentant la constante utilisée dans les deux méthodes (soustraite de la moyenne ou moyenne pondérée).

Exemple

Le programme suivant montre comment effectuer une opération de seuil adaptatif sur une image dans OpenCV. Ici, nous choisissons un seuil adaptatif de typebinary et ADAPTIVE_THRESH_MEAN_C pour la méthode du seuil.

import org.opencv.core.Core;
import org.opencv.core.Mat;
import org.opencv.imgcodecs.Imgcodecs;
import org.opencv.imgproc.Imgproc;

public class AdaptiveThresh {
   public static void main(String args[]) throws Exception {
      // Loading the OpenCV core library
      System.loadLibrary( Core.NATIVE_LIBRARY_NAME );

      // Reading the Image from the file and storing it in to a Matrix object
      String file ="E:/OpenCV/chap14/thresh_input.jpg";
      
      // Reading the image
      Mat src = Imgcodecs.imread(file,0);

      // Creating an empty matrix to store the result
      Mat dst = new Mat();

      Imgproc.adaptiveThreshold(src, dst, 125, Imgproc.ADAPTIVE_THRESH_MEAN_C,
         Imgproc.THRESH_BINARY, 11, 12);

      // Writing the image
      Imgcodecs.imwrite("E:/OpenCV/chap14/Adaptivemean_thresh_binary.jpg", dst);

      System.out.println("Image Processed");
   } 
}

Supposons que ce qui suit est l'image d'entrée thresh_input.jpg spécifié dans le programme ci-dessus.

Production

Lors de l'exécution du programme, vous obtiendrez la sortie suivante -

Image Processed

Si vous ouvrez le chemin spécifié, vous pouvez observer l'image de sortie comme suit -

Autres types de seuils adaptatifs

En plus de ADAPTIVE_THRESH_MEAN_C comme méthode adaptative et THRESH_BINARY comme type de seuil comme démontré dans l'exemple précédent, nous pouvons choisir plus de combinaisons de ces deux valeurs.

Imgproc.adaptiveThreshold(src, dst, 125, Imgproc.ADAPTIVE_THRESH_MEAN_C, Imgproc.THRESH_BINARY, 11, 12);

Voici les valeurs représentant diverses combinaisons de valeurs pour les paramètres adaptiveMethod et thresholdType et leurs résultats respectifs.

adaptiveMethod / thresholdType	ADAPTIVE_THRESH_MEAN_C	ADAPTIVE_THRESH_GAUSSIAN_C:
THRESH_BINARY
THRESH_BINARY_INV

Ce chapitre vous apprend à créer des bordures de crapaud sur une image.

La méthode copyMakeBorder ()

Vous pouvez ajouter diverses bordures à une image en utilisant la méthode copyMakeBorder() de la classe nommée Core, qui appartient au package org.opencv.core. Voici la syntaxe de cette méthode.

copyMakeBorder(src, dst, top, bottom, left, right, borderType)

Cette méthode accepte les paramètres suivants -

src - Un objet de la classe Mat représentant l'image source (entrée).
dst - Un objet de la classe Mat représentant l'image de destination (sortie).
top - Une variable d'entier de type entier représentant la longueur de la bordure en haut de l'image.
bottom - Une variable d'entier de type entier représentant la longueur de la bordure en bas de l'image.
left - Une variable d'entier de type entier représentant la longueur de la bordure à gauche de l'image.
right - Une variable d'entier de type entier représentant la longueur de la bordure à droite de l'image.
borderType - Une variable de type entier représentant le type de bordure à utiliser.

Exemple

Le programme suivant est un exemple montrant comment ajouter une bordure à une image donnée.

import org.opencv.core.Core;
import org.opencv.core.Mat;
import org.opencv.imgcodecs.Imgcodecs;

public class AddingBorder {
   public static void main( String[] args ) {
      // Loading the OpenCV core library
      System.loadLibrary( Core.NATIVE_LIBRARY_NAME );
     
      // Reading the Image from the file and storing it in to a Matrix object
      String file ="E:/OpenCV/chap15/input.jpg";
      Mat src = Imgcodecs.imread(file);

      // Creating an empty matrix to store the result
      Mat dst = new Mat();
   
      Core.copyMakeBorder(src, dst, 20, 20, 20, 20, Core.BORDER_CONSTANT);
      Imgcodecs.imwrite("E:/OpenCV/chap15/border_constant.jpg", dst);

      System.out.println("Image Processed");
   }
}

Supposons que ce qui suit est l'image d'entrée thresh_input.jpg spécifié dans le programme ci-dessus.

Production

Lors de l'exécution du programme, vous obtiendrez la sortie suivante -

Image Processed

Si vous ouvrez le chemin spécifié, vous pouvez observer l'image de sortie comme suit -

Autres types de frontières

En plus du type de bordure, BORDER_CONSTANTdémontré dans l'exemple précédent, OpenCV répond à divers autres types de bordures. Tous ces types sont représentés par des champs statiques prédéfinis (valeurs fixes) de la classe Core.

Vous pouvez choisir le type d'opération de seuil dont vous avez besoin, en passant sa valeur prédéfinie respective au paramètre nommé borderType du copyMakeBorder() méthode.

Core.copyMakeBorder(src, dst, 20, 20, 20, 20, Core.BORDER_CONSTANT);

Voici les valeurs représentant divers types d'opérations aux frontières et leurs résultats respectifs.

Fonctionnement et description	Production
BORDER_CONSTANT
BORDER_ISOLATED
BORDER_DEFAULT
BORDER_REFLECT
BORDER_REFLECT_101
BORDER_REFLECT101
BORDER_REPLICATE
BORDER_WRAP

En utilisant le sobel operation, vous pouvez détecter les bords d'une image dans les directions horizontale et verticale. Vous pouvez appliquer l'opération Sobel sur une image en utilisant la méthodesobel(). Voici la syntaxe de cette méthode -

Sobel(src, dst, ddepth, dx, dy)

Cette méthode accepte les paramètres suivants -

src - Un objet de la classe Mat représentant l'image source (entrée).
dst - Un objet de la classe Mat représentant l'image de destination (sortie).
ddepth - Une variable entière représentant la profondeur de l'image (-1)
dx- Une variable entière représentant la dérivée x. (0 ou 1)
dy- Une variable entière représentant la dérivée y. (0 ou 1)

Exemple

Le programme suivant montre comment effectuer une opération Sobel sur une image donnée.

import org.opencv.core.Core;
import org.opencv.core.Mat;

import org.opencv.imgcodecs.Imgcodecs;
import org.opencv.imgproc.Imgproc;

public class SobelTest {
   public static void main(String args[]) {
      // Loading the OpenCV core library
      System.loadLibrary(Core.NATIVE_LIBRARY_NAME);

      // Reading the Image from the file and storing it in to a Matrix object
      String file ="E:/OpenCV/chap16/sobel_input.jpg";
      Mat src = Imgcodecs.imread(file);

      // Creating an empty matrix to store the result
      Mat dst = new Mat();

      // Applying sobel on the Image
      Imgproc.Sobel(src, dst, -1, 1, 1);

      // Writing the image
      Imgcodecs.imwrite("E:/OpenCV/chap16/sobel_output.jpg", dst);

      System.out.println("Image processed");
   }
}

Supposons que ce qui suit est l'image d'entrée sobel_input.jpg spécifié dans le programme ci-dessus.

Production

Lors de l'exécution du programme, vous obtiendrez la sortie suivante -

Image Processed

Si vous ouvrez le chemin spécifié, vous pouvez observer l'image de sortie comme suit -

Variantes sobel

En passant différentes valeurs au dernier aux paramètres (dx et dy) (entre 0 et 1), vous obtiendrez différentes sorties -

// Applying sobel on the Image
Imgproc.Sobel(src, dst, -1, 1, 1);

Le tableau suivant répertorie différentes valeurs pour les variables dx et dy de la méthode Sobel() et leurs résultats respectifs.

Dérivé X	Dérivé Y	Production
0	1
1	0
1	1

Scharr est également utilisé pour détecter les secondes dérivées d'une image dans les directions horizontale et verticale. Vous pouvez effectuer une opération scharr sur une image en utilisant la méthodescharr(). Voici la syntaxe de cette méthode -

Scharr(src, dst, ddepth, dx, dy)

Cette méthode accepte les paramètres suivants -

src - Un objet de la classe Mat représentant l'image source (entrée).
dst - Un objet de la classe Mat représentant l'image de destination (sortie).
ddepth - Une variable entière représentant la profondeur de l'image (-1)
dx- Une variable entière représentant la dérivée x. (0 ou 1)
dy- Une variable entière représentant la dérivée y. (0 ou 1)

Exemple

Le programme suivant montre comment appliquer scharr à une image donnée.

import org.opencv.core.Core;
import org.opencv.core.Mat;

import org.opencv.imgcodecs.Imgcodecs;
import org.opencv.imgproc.Imgproc;

public class ScharrTest {

   public static void main( String[] args ) {

      // Loading the OpenCV core library
      System.loadLibrary( Core.NATIVE_LIBRARY_NAME );

      // Reading the Image from the file and storing it in to a Matrix object
      String file ="E:/OpenCV/chap16/sobel_input.jpg";
      Mat src = Imgcodecs.imread(file);

      // Creating an empty matrix to store the result
      Mat dst = new Mat();

      // Applying Box Filter effect on the Image
      Imgproc.Scharr(src, dst, Imgproc.CV_SCHARR, 0, 1);

      // Writing the image
      Imgcodecs.imwrite("E:/OpenCV/chap16/scharr_output.jpg", dst);

      System.out.println("Image processed");
   }
}

Supposons que ce qui suit est l'image d'entrée scharr_input.jpg spécifié dans le programme ci-dessus.

Production

En l'exécutant, vous obtiendrez la sortie suivante -

Image Processed

Si vous ouvrez le chemin spécifié, vous pouvez observer l'image de sortie comme suit -

Plus de dérivés scharr

En passant différentes valeurs au dernier aux paramètres (dx et dy) (entre 0 et 1), vous obtiendrez différentes sorties -

// Applying scharr on the Image
Imgproc.Scharr(src, dst, -1, 1, 1);

Voici un tableau répertoriant différentes valeurs pour les variables dx et dy de la méthode scharr() et leurs résultats respectifs.

Dérivé X	Dérivé Y	Production
0	1
1	0

L'opérateur laplacien est également un opérateur dérivé utilisé pour trouver les bords d'une image. C'est un masque dérivé du second ordre. Dans ce masque, nous avons deux autres classifications, l'une est l'opérateur laplacien positif et l'autre est l'opérateur laplacien négatif.

Contrairement à d'autres opérateurs, Laplacian n'a pas retiré les arêtes dans une direction particulière, mais il a supprimé les arêtes dans la classification suivante.

Bords intérieurs
Bords extérieurs

Vous pouvez effectuer Laplacian Transform opération sur une image à l'aide du Laplacian() méthode de la imgproc class, voici la syntaxe de cette méthode.

Laplacian(src, dst, ddepth)

Cette méthode accepte les paramètres suivants -

src - Un Mat objet représentant la source (image d'entrée) de cette opération.
dst - Un Mat objet représentant la destination (image de sortie) de cette opération.
ddepth - Une variable de type entier représentant la profondeur de l'image de destination.

Exemple

Le programme suivant montre comment effectuer une opération de transformation de Laplace sur une image donnée.

import org.opencv.core.Core;
import org.opencv.core.Mat;
import org.opencv.imgcodecs.Imgcodecs;
import org.opencv.imgproc.Imgproc;

public class LaplacianTest {
   public static void main(String args[]) {
      // Loading the OpenCV core library
      System.loadLibrary(Core.NATIVE_LIBRARY_NAME);

      //Reading the Image from the file and storing it in to a Matrix object
      String file ="E:/OpenCV/chap18/laplacian_input.jpg";
      Mat src = Imgcodecs.imread(file);

      // Creating an empty matrix to store the result
      Mat dst = new Mat();

      // Applying GaussianBlur on the Image
      Imgproc.Laplacian(src, dst, 10);

      // Writing the image
      Imgcodecs.imwrite("E:/OpenCV/chap18/laplacian.jpg", dst);

      System.out.println("Image Processed");
   }
}

Supposons que ce qui suit est l'image d'entrée laplacian_input.jpg spécifié dans le programme ci-dessus.

Production

Lors de l'exécution du programme, vous obtiendrez la sortie suivante -

Image Processed

Si vous ouvrez le chemin spécifié, vous pouvez observer l'image de sortie comme suit -

le distance transformL'opérateur prend généralement des images binaires comme entrées. Dans cette opération, les intensités de niveau de gris des points à l'intérieur des régions de premier plan sont modifiées pour éloigner leurs distances respectives de la valeur 0 la plus proche (limite).

Vous pouvez appliquer la transformation de distance dans OpenCV en utilisant la méthode distanceTransform(). Voici la syntaxe de cette méthode.

distanceTransform(src, dst, distanceType, maskSize)

Cette méthode accepte les paramètres suivants -

src - Un objet de la classe Mat représentant l'image source (entrée).
dst - Un objet de la classe Mat représentant l'image de destination (sortie).
distanceType - Une variable de type entier représentant le type de transformation de distance à appliquer.
maskSize - Une variable de type entier représentant la taille du masque à utiliser.

Exemple

Le programme suivant montre comment effectuer une opération de transformation de distance sur une image donnée.

import org.opencv.core.Core;
import org.opencv.core.Mat;
import org.opencv.imgcodecs.Imgcodecs;
import org.opencv.imgproc.Imgproc;

public class DistanceTransform {
   public static void main(String args[]) {
      // Loading the OpenCV core library
      System.loadLibrary( Core.NATIVE_LIBRARY_NAME );

      // Reading the Image from the file and storing it in to a Matrix object
      String file ="E:/OpenCV/chap19/input.jpg";
      Mat src = Imgcodecs.imread(file,0);

      // Creating an empty matrix to store the results
      Mat dst = new Mat();
      Mat binary = new Mat();

      // Converting the grayscale image to binary image
      Imgproc.threshold(src, binary, 100, 255, Imgproc.THRESH_BINARY);

      // Applying distance transform
      Imgproc.distanceTransform(mat, dst, Imgproc.DIST_C, 3);

      // Writing the image
      Imgcodecs.imwrite("E:/OpenCV/chap19/distnceTransform.jpg", dst);

      System.out.println("Image Processed");
   }
}

Supposons que ce qui suit est l'image d'entrée input.jpg spécifié dans le programme ci-dessus.

Production

Lors de l'exécution du programme, vous obtiendrez la sortie suivante -

Image Processed

Si vous ouvrez le chemin spécifié, vous pouvez observer l'image de sortie comme suit -

Types d'opérations de transformation de distance

En plus du type d'opération à distance DIST_Cdémontré dans l'exemple précédent, OpenCV prend en charge divers autres types d'opérations de transformation de distance. Tous ces types sont représentés par des champs statiques prédéfinis (valeurs fixes) de la classe Imgproc.

Vous pouvez choisir le type d'opération de transformation de distance dont vous avez besoin, en passant sa valeur prédéfinie respective au paramètre nommé distanceType du distanceTransform() méthode.

// Applying distance transform 
Imgproc.distanceTransform(mat, dst, Imgproc.DIST_C, 3);

Voici les valeurs représentant différents types de distanceTransform opérations et leurs résultats respectifs.

Fonctionnement et description	Production
DIST_C
DIST_L1
DIST_L2
DIST_LABEL_PIXEL
DIST_MASK_3

Dans ce chapitre, nous allons apprendre à utiliser OpenCV pour capturer des images à l'aide de la caméra système. leVideoCapture classe de la org.opencv.videoioLe package contient des classes et des méthodes pour capturer des vidéos à l'aide de la caméra. Allons-y étape par étape et apprenons à capturer des images -

Étape 1: Chargez la bibliothèque native OpenCV

// Loading the core library 
System.loadLibrary(Core.NATIVE_LIBRARY_NAME);

Étape 2: instancier la classe de capture vidéo

Instanciez la classe Mat à l'aide de l'une des fonctions mentionnées précédemment dans ce didacticiel.

// Instantiating the VideoCapture class (camera:: 0) 
VideoCapture capture = new VideoCapture(0);

Étape 3: Lisez les cadres

Vous pouvez lire les images de l'appareil photo à l'aide du read() méthode de la VideoCaptureclasse. Cette méthode accepte un objet de la classeMat pour stocker la trame lue.

// Reading the next video frame from the camera 
Mat matrix = new Mat(); 
capture.read(matrix);

Exemple

Le programme suivant montre comment capturer une image à l'aide de l'appareil photo et l'afficher à l'aide de la fenêtre JavaFX. Il enregistre également l'image capturée.

import java.awt.image.BufferedImage;
import java.awt.image.DataBufferByte;
import java.awt.image.WritableRaster;

import java.io.FileNotFoundException;
import java.io.IOException;

import javafx.application.Application;
import javafx.embed.swing.SwingFXUtils;
import javafx.scene.Group;
import javafx.scene.Scene;
import javafx.scene.image.ImageView;
import javafx.scene.image.WritableImage;
import javafx.stage.Stage;

import org.opencv.core.Core;
import org.opencv.core.Mat;
import org.opencv.imgcodecs.Imgcodecs;
import org.opencv.videoio.VideoCapture;

public class CameraSnapshotJavaFX extends Application {
   Mat matrix = null;

   @Override
   public void start(Stage stage) throws FileNotFoundException, IOException {
      // Capturing the snapshot from the camera
      CameraSnapshotJavaFX obj = new CameraSnapshotJavaFX();
      WritableImage writableImage = obj.capureSnapShot();

      // Saving the image
      obj.saveImage();

      // Setting the image view
      ImageView imageView = new ImageView(writableImage);

      // setting the fit height and width of the image view
      imageView.setFitHeight(400);
      imageView.setFitWidth(600);

      // Setting the preserve ratio of the image view
      imageView.setPreserveRatio(true);

      // Creating a Group object
      Group root = new Group(imageView);

      // Creating a scene object
      Scene scene = new Scene(root, 600, 400);

      // Setting title to the Stage
      stage.setTitle("Capturing an image");

      // Adding scene to the stage
      stage.setScene(scene);

      // Displaying the contents of the stage
      stage.show();
   }
   public WritableImage capureSnapShot() {
      WritableImage WritableImage = null;

      // Loading the OpenCV core library
      System.loadLibrary( Core.NATIVE_LIBRARY_NAME );

      // Instantiating the VideoCapture class (camera:: 0)
      VideoCapture capture = new VideoCapture(0);

      // Reading the next video frame from the camera
      Mat matrix = new Mat();
      capture.read(matrix);

      // If camera is opened
      if( capture.isOpened()) {
         // If there is next video frame
         if (capture.read(matrix)) {
            // Creating BuffredImage from the matrix
            BufferedImage image = new BufferedImage(matrix.width(), 
               matrix.height(), BufferedImage.TYPE_3BYTE_BGR);
            
            WritableRaster raster = image.getRaster();
            DataBufferByte dataBuffer = (DataBufferByte) raster.getDataBuffer();
            byte[] data = dataBuffer.getData();
            matrix.get(0, 0, data);
            this.matrix = matrix;
            
            // Creating the Writable Image
            WritableImage = SwingFXUtils.toFXImage(image, null);
         }
      }
      return WritableImage;
   }
   public void saveImage() {
      // Saving the Image
      String file = "E:/OpenCV/chap22/sanpshot.jpg";

      // Instantiating the imgcodecs class
      Imgcodecs imageCodecs = new Imgcodecs();

      // Saving it again 
      imageCodecs.imwrite(file, matrix);
   }
   public static void main(String args[]) {
      launch(args);
   }
}

Production

Lors de l'exécution du programme, vous obtiendrez la sortie suivante.

Si vous ouvrez le chemin spécifié, vous pouvez observer le même cadre qui est enregistré en tant que fichier jpg.

le VideoCapture classe de la org.opencv.videoioLe package contient des classes et des méthodes pour capturer de la vidéo à l'aide de la caméra système. Allons-y étape par étape et apprenons à le faire.

Étape 1: Chargez la bibliothèque native OpenCV

// Loading the core library 
System.loadLibrary(Core.NATIVE_LIBRARY_NAME);

Étape 2: instancier la classe CascadeClassifier

le CascadeClassifier classe du package org.opencv.objdetectest utilisé pour charger le fichier classificateur. Instanciez cette classe en passant lexml fichier lbpcascade_frontalface.xml comme indiqué ci-dessous.

// Instantiating the CascadeClassifier 
String xmlFile = "E:/OpenCV/facedetect/lbpcascade_frontalface.xml"; 
CascadeClassifier classifier = new CascadeClassifier(xmlFile);

Étape 3: Détectez les visages

Vous pouvez détecter les visages sur l'image en utilisant la méthode detectMultiScale() de la classe nommée CascadeClassifier. Cette méthode accepte un objet de la classeMat contenant l'image d'entrée et un objet de la classe MatOfRect pour stocker les visages détectés.

// Detecting the face in the snap 
MatOfRect faceDetections = new MatOfRect(); 
classifier.detectMultiScale(src, faceDetections);

Exemple

Le programme suivant montre comment détecter les visages dans une image.

import org.opencv.core.Core;
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;
  
public class FaceDetectionImage {
   public static void main (String[] args) {
      // Loading the OpenCV core library
      System.loadLibrary( Core.NATIVE_LIBRARY_NAME );

      // Reading the Image from the file and storing it in to a Matrix object
      String file ="E:/OpenCV/chap23/facedetection_input.jpg";
      Mat src = Imgcodecs.imread(file);

      // Instantiating the CascadeClassifier
      String xmlFile = "E:/OpenCV/facedetect/lbpcascade_frontalface.xml";
      CascadeClassifier classifier = new CascadeClassifier(xmlFile);

      // Detecting the face in the snap
      MatOfRect faceDetections = new MatOfRect();
      classifier.detectMultiScale(src, faceDetections);
      System.out.println(String.format("Detected %s faces", 
         faceDetections.toArray().length));

      // Drawing boxes for (Rect rect : faceDetections.toArray()) { Imgproc.rectangle( src, // where to draw the box new Point(rect.x, rect.y), // bottom left new Point(rect.x + rect.width, rect.y + rect.height), // top right new Scalar(0, 0, 255), 3 // RGB colour );
      }

      // Writing the image
      Imgcodecs.imwrite("E:/OpenCV/chap23/facedetect_output1.jpg", src);

      System.out.println("Image Processed");
   }
}

Supposons que ce qui suit est l'image d'entrée facedetection_input.jpg spécifié dans le programme ci-dessus.

Production

Lors de l'exécution du programme, vous obtiendrez la sortie suivante -

Detected 3 faces 
Image Processed

Si vous ouvrez le chemin spécifié, vous pouvez observer l'image de sortie comme suit -

Le programme suivant montre comment détecter les visages à l'aide de la caméra système et l'afficher à l'aide de la fenêtre JavaFX.

Exemple

import java.awt.image.BufferedImage;
import java.awt.image.DataBufferByte;
import java.awt.image.WritableRaster;

import java.io.FileNotFoundException;
import java.io.IOException;

import javafx.application.Application;
import javafx.embed.swing.SwingFXUtils;
import javafx.scene.Group;
import javafx.scene.Scene;
import javafx.scene.image.ImageView;
import javafx.scene.image.WritableImage;
import javafx.stage.Stage;

import org.opencv.core.Core;
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;

public class faceDetectionJavaFXX extends Application {
   Mat matrix = null;

   @Override
   public void start(Stage stage) throws FileNotFoundException, IOException {
      // Capturing the snapshot from the camera
      faceDetectionJavaFXX obj = new faceDetectionJavaFXX();
      WritableImage writableImage = obj.capureFrame();

      // Saving the image
      obj.saveImage();

      // Setting the image view
      ImageView imageView = new ImageView(writableImage);

      // setting the fit height and width of the image view
      imageView.setFitHeight(400);
      imageView.setFitWidth(600);

      // Setting the preserve ratio of the image view
      imageView.setPreserveRatio(true);

      // Creating a Group object
      Group root = new Group(imageView);

      // Creating a scene object
      Scene scene = new Scene(root, 600, 400);

      // Setting title to the Stage
      stage.setTitle("Capturing an image");

      // Adding scene to the stage
      stage.setScene(scene);

      // Displaying the contents of the stage
      stage.show();
   }
   public WritableImage capureFrame() {
      WritableImage writableImage = null;

      // Loading the OpenCV core library
      System.loadLibrary( Core.NATIVE_LIBRARY_NAME );

      // Instantiating the VideoCapture class (camera:: 0)
      VideoCapture capture = new VideoCapture(0);

      // Reading the next video frame from the camera
      Mat matrix = new Mat();
      capture.read(matrix);

      // If camera is opened
      if(!capture.isOpened()) {
         System.out.println("camera not detected");
      } else
         System.out.println("Camera detected ");
           
      // If there is next video frame
      if (capture.read(matrix)) {
         /////// Detecting the face in the snap /////
         String file = "E:/OpenCV/facedetect/lbpcascade_frontalface.xml";
         CascadeClassifier classifier = new CascadeClassifier(file);

         MatOfRect faceDetections = new MatOfRect();
         classifier.detectMultiScale(matrix, faceDetections);
         System.out.println(String.format("Detected %s faces",
            faceDetections.toArray().length));

         // Drawing boxes for (Rect rect : faceDetections.toArray()) { Imgproc.rectangle( matrix, //where to draw the box new Point(rect.x, rect.y), //bottom left new Point(rect.x + rect.width, rect.y + rect.height), //top right new Scalar(0, 0, 255) //RGB colour );
         }
         // Creating BuffredImage from the matrix
         BufferedImage image = new BufferedImage(matrix.width(), matrix.height(),
            BufferedImage.TYPE_3BYTE_BGR);
         
         WritableRaster raster = image.getRaster();
         DataBufferByte dataBuffer = (DataBufferByte) raster.getDataBuffer();
         byte[] data = dataBuffer.getData();
         matrix.get(0, 0, data);

         this.matrix = matrix;
           
         // Creating the Writable Image
         writableImage = SwingFXUtils.toFXImage(image, null);
      }
      return writableImage;
   }
   public void saveImage() {
      // Saving the Image
      String file = "E:/OpenCV/chap23/facedetected.jpg";

      // Instantiating the imagecodecs class
      Imgcodecs imageCodecs = new Imgcodecs();

      // Saving it again
      imageCodecs.imwrite(file, matrix);
   }
   public static void main(String args[]) {
      launch(args);
   }
}

Production

Lors de l'exécution du programme, vous obtiendrez la sortie suivante.

Si vous ouvrez le chemin spécifié, vous pouvez voir le même instantané enregistré en tant que jpg image.

Vous pouvez effectuer affine translation sur une image en utilisant le warpAffine()méthode de la classe imgproc. Voici la syntaxe de cette méthode -

Imgproc.warpAffine(src, dst, tranformMatrix, size);

Cette méthode accepte les paramètres suivants -

src - Un Mat objet représentant la source (image d'entrée) de cette opération.
dst - Un Mat objet représentant la destination (image de sortie) de cette opération.
tranformMatrix - Un Mat objet représentant la matrice de transformation.
size - Une variable de type entier représentant la taille de l'image de sortie.

Exemple

Le programme suivant montre comment appliquer une opération affine sur une image donnée.

import org.opencv.core.Core;
import org.opencv.core.Mat;
import org.opencv.core.MatOfPoint2f;
import org.opencv.core.Point;
import org.opencv.core.Size;
import org.opencv.imgcodecs.Imgcodecs;
import org.opencv.imgproc.Imgproc;

public class AffineTranslation {
   public static void main(String args[]) {
      // Loading the OpenCV core library
      System.loadLibrary( Core.NATIVE_LIBRARY_NAME );

      // Reading the Image from the file and storing it in to a Matrix object
      String file ="E:/OpenCV/chap24/transform_input.jpg";
      Mat src = Imgcodecs.imread(file);

      //Creating an empty matrix to store the result
      Mat dst = new Mat();

      Point p1 = new Point( 0,0 );
      Point p2 = new Point( src.cols() - 1, 0 );
      Point p3 = new Point( 0, src.rows() - 1 );
      Point p4 = new Point( src.cols()*0.0, src.rows()*0.33 );
      Point p5 = new Point( src.cols()*0.85, src.rows()*0.25 );
      Point p6 = new Point( src.cols()*0.15, src.rows()*0.7 );
      
      MatOfPoint2f ma1 = new MatOfPoint2f(p1,p2,p3);
      MatOfPoint2f ma2 = new MatOfPoint2f(p4,p5,p6);

      // Creating the transformation matrix
      Mat tranformMatrix = Imgproc.getAffineTransform(ma1,ma2);

      // Creating object of the class Size
      Size size = new Size(src.cols(), src.cols());

      // Applying Wrap Affine
      Imgproc.warpAffine(src, dst, tranformMatrix, size);

      // Writing the image
      Imgcodecs.imwrite("E:/OpenCV/chap24/Affinetranslate.jpg", dst);

      System.out.println("Image Processed");
   }
}

Supposons que ce qui suit est l'image d'entrée transform_input.jpg spécifié dans le programme ci-dessus.

Production

En l'exécutant, vous obtiendrez la sortie suivante -

Image Processed

Si vous ouvrez le chemin spécifié, vous pouvez observer l'image de sortie comme suit -

Vous pouvez perform rotation opération sur une image à l'aide du warpAffine() méthode de la imgprocclasse. Voici la syntaxe de cette méthode -

Imgproc.warpAffine(src, dst, rotationMatrix, size);

Cette méthode accepte les paramètres suivants -

src - Un Mat objet représentant la source (image d'entrée) de cette opération.
dst - Un Mat objet représentant la destination (image de sortie) de cette opération.
rotationMatrix - Un Mat objet représentant la matrice de rotation.
size - Une variable de type entier représentant la taille de l'image de sortie.

Exemple

Le programme suivant montre comment faire pivoter une image.

import org.opencv.core.Core;
import org.opencv.core.Mat;
import org.opencv.core.Point;
import org.opencv.core.Size;

import org.opencv.imgcodecs.Imgcodecs;
import org.opencv.imgproc.Imgproc;

public class Rotation {
   public static void main(String args[]) {
      // Loading the OpenCV core library
      System.loadLibrary( Core.NATIVE_LIBRARY_NAME );

      // Reading the Image from the file and storing it in to a Matrix object
      String file ="E:/OpenCV/chap24/transform_input.jpg";
      Mat src = Imgcodecs.imread(file);

      // Creating an empty matrix to store the result
      Mat dst = new Mat();

      // Creating a Point object
      Point point = new Point(300, 200)

      // Creating the transformation matrix M
      Mat rotationMatrix = Imgproc.getRotationMatrix2D(point, 30, 1);

      // Creating the object of the class Size
      Size size = new Size(src.cols(), src.cols());

      // Rotating the given image
      Imgproc.warpAffine(src, dst, rotationMatrix, size);

      // Writing the image
      Imgcodecs.imwrite("E:/OpenCV/chap24/rotate_output.jpg", dst);

      System.out.println("Image Processed");
   }
}

Supposons que ce qui suit est l'image d'entrée transform_input.jpg spécifié dans le programme ci-dessus.

Production

Lors de l'exécution du programme, vous obtiendrez la sortie suivante -

Image Processed

Si vous ouvrez le chemin spécifié, vous pouvez observer l'image de sortie comme suit -

Vous pouvez effectuer scaling sur une image en utilisant le resize() méthode de la imgprocclasse. Voici la syntaxe de cette méthode.

resize(Mat src, Mat dst, Size dsize, double fx, double fy, int interpolation)

Cette méthode accepte les paramètres suivants -

src - Un Mat objet représentant la source (image d'entrée) de cette opération.
dst - Un Mat objet représentant la destination (image de sortie) de cette opération.
dsize - Un Size objet représentant la taille de l'image de sortie.
fx - Une variable de type double représentant le facteur d'échelle le long de l'axe horizontal.
fy - Une variable de type double représentant le facteur d'échelle le long de l'axe vertical.
Interpolation - Une variable entière représentant la méthode d'interpolation.

Exemple

Le programme suivant montre comment postuler scale transformation à une image.

import org.opencv.core.Core;
import org.opencv.core.Mat;
import org.opencv.core.Size;

import org.opencv.imgcodecs.Imgcodecs;
import org.opencv.imgproc.Imgproc;

public class Scaling {
   public static void main(String args[]) {
      // Loading the OpenCV core library
      System.loadLibrary( Core.NATIVE_LIBRARY_NAME );

      // Reading the Image from the file and storing it in to a Matrix object
      String file ="E:/OpenCV/chap24/transform_input.jpg";
      Mat src = Imgcodecs.imread(file);

      // Creating an empty matrix to store the result
      Mat dst = new Mat();

      // Creating the Size object
      Size size = new Size(src.rows()*2, src.rows()*2);

      // Scaling the Image
      Imgproc.resize(src, dst, size, 0, 0, Imgproc.INTER_AREA);

      // Writing the image
      Imgcodecs.imwrite("E:/OpenCV/chap24/scale_output.jpg", dst);

      System.out.println("Image Processed");
   }
}

Supposons que ce qui suit est l'image d'entrée transform_input.jpg spécifié dans le programme ci-dessus (taille - Largeur: 300px et hauteur: 300px).

Production

Lors de l'exécution du programme, vous obtiendrez la sortie suivante -

Image Processed

Si vous ouvrez le chemin spécifié, vous pouvez observer l'image de sortie comme suit (taille - Largeur: 600px et hauteur: 600px) -

Dans OpenCV, vous pouvez appliquer différentes cartes de couleurs à une image en utilisant la méthode applyColorMap() de la classe Imgproc. Voici la syntaxe de cette méthode -

applyColorMap(Mat src, Mat dst, int colormap)

Il accepte trois paramètres -

src - Un objet de la classe Mat représentant l'image source (entrée).
dst - Un objet de la classe Mat représentant l'image de destination (sortie).
colormap - Une variable de type entier représentant le type de la palette de couleurs à appliquer.

Exemple

Le programme suivant montre comment postuler color map à une image.

import org.opencv.core.Core;
import org.opencv.core.Mat;

import org.opencv.imgcodecs.Imgcodecs;
import org.opencv.imgproc.Imgproc;

public class ColorMapTest {
   public static void main(String args[]) {
      // Loading the OpenCV core library
      System.loadLibrary(Core.NATIVE_LIBRARY_NAME);

      // Reading the Image from the file and storing it in to a Matrix object
      String file ="E:/OpenCV/chap25/color_input.jpg";
      Mat src = Imgcodecs.imread(file);

      // Creating an empty matrix to store the result
      Mat dst = new Mat();

      // Applying color map to an image
      Imgproc.applyColorMap(src, dst, Imgproc.COLORMAP_HOT);

      // Writing the image
      Imgcodecs.imwrite("E:/OpenCV/chap25/colormap_hot.jpg", dst);
      System.out.println("Image processed");
   }
}

Supposons que ce qui suit est l'image d'entrée color_input.jpg spécifié dans le programme ci-dessus.

Production

Lors de l'exécution du programme ci-dessus, vous obtiendrez la sortie suivante -

Image Processed

Si vous ouvrez le chemin spécifié, vous pouvez observer l'image de sortie comme suit -

Plus d'opérations

En plus de COLORMAP_HOTdémontré dans l'exemple précédent, OpenCV répond à divers autres types de cartes de couleurs. Tous ces types sont représentés par des champs statiques prédéfinis (valeurs fixes) de la classe Imgproc.

Vous pouvez choisir le type de palette de couleurs dont vous avez besoin, en passant sa valeur prédéfinie respective au paramètre nommé colormap du applyColorMap() méthode.

Imgproc.applyColorMap(src, dst, Imgproc.COLORMAP_HOT);

Voici les valeurs représentant différents types de cartes de couleurs et leurs sorties respectives.

Fonctionnement et description	Production
COLORMAP_AUTUMN
COLORMAP_BONE
COLORMAP_COOL
COLORMAP_HOT
COLORMAP_HSV
COLORMAP_JET
COLORMAP_OCEAN
COLORMAP_PARULA
COLORMAP_PINK
COLORMAP_RAINBOW
COLORMAP_SPRING
COLORMAP_SUMMER
COLORMAP_WINTER

La détection Canny Edge est utilisée pour détecter les bords d'une image. Il accepte une image en échelle de gris comme entrée et utilise un algorithme à plusieurs étages.

Vous pouvez effectuer cette opération sur une image à l'aide du Canny() méthode de la imgproc class, voici la syntaxe de cette méthode.

Canny(image, edges, threshold1, threshold2)

Cette méthode accepte les paramètres suivants -

image - Un Mat objet représentant la source (image d'entrée) de cette opération.
edges - Un Mat objet représentant la destination (arêtes) de cette opération.
threshold1 - Une variable de type double représentant le premier seuil de la procédure d'hystérésis.
threshold2 - Une variable de type double représentant le deuxième seuil de la procédure d'hystérésis.

Exemple

Le programme suivant est un exemple montrant comment effectuer une opération de détection de Canny Edge sur une image donnée.

import org.opencv.core.Core;
import org.opencv.core.Mat;

import org.opencv.imgcodecs.Imgcodecs;
import org.opencv.imgproc.Imgproc;

public class CannyEdgeDetection {
   public static void main(String args[]) throws Exception {
      // Loading the OpenCV core library
      System.loadLibrary(Core.NATIVE_LIBRARY_NAME);

      // Reading the Image from the file and storing it in to a Matrix object
      String file = "E:/OpenCV/chap17/canny_input.jpg";

      // Reading the image
      Mat src = Imgcodecs.imread(file);

      // Creating an empty matrix to store the result
      Mat gray = new Mat();

      // Converting the image from color to Gray
      Imgproc.cvtColor(src, gray, Imgproc.COLOR_BGR2GRAY);
      Mat edges = new Mat();

      // Detecting the edges
      Imgproc.Canny(gray, edges, 60, 60*3);

      // Writing the image
      Imgcodecs.imwrite("E:/OpenCV/chap17/canny_output.jpg", edges);
      System.out.println("Image Loaded");
   } 
}

Supposons que ce qui suit est l'image d'entrée canny_input.jpg spécifié dans le programme ci-dessus.

Production

Lors de l'exécution du programme ci-dessus, vous obtiendrez la sortie suivante -

Image Processed

Si vous ouvrez le chemin spécifié, vous pouvez observer l'image de sortie comme suit -

Vous pouvez détecter la forme d'une image donnée en appliquant le Hough Transform technique en utilisant la méthode HoughLines() du Imgprocclasse. Voici la syntaxe de cette méthode.

HoughLines(image, lines, rho, theta, threshold)

Cette méthode accepte les paramètres suivants -

image - Un objet de la classe Mat représentant l'image source (entrée).
lines - Un objet de la classe Mat qui stocke le vecteur qui stocke les paramètres (r, Φ) des lignes.
rho - Une variable de type double représentant la résolution du paramètre r en pixels.
theta - Une variable de type double représentant la résolution du paramètre Φ en radians.
threshold - Une variable de type entier représentant le nombre minimum d'intersections pour «détecter» une ligne.

Exemple

Le programme suivant montre comment détecter les lignes Hough dans une image donnée.

import org.opencv.core.Core;
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;

public class HoughlinesTest {
   public static void main(String args[]) throws Exception {
      // Loading the OpenCV core library
      System.loadLibrary( Core.NATIVE_LIBRARY_NAME );

      // Reading the Image from the file and storing it in to a Matrix object
      String file = "E:/OpenCV/chap21/hough_input.jpg";

      // Reading the image
      Mat src = Imgcodecs.imread(file,0);

      // Detecting edges of it
      Mat canny = new Mat();
      Imgproc.Canny(src, canny, 50, 200, 3, false);

      // Changing the color of the canny
      Mat cannyColor = new Mat();
      Imgproc.cvtColor(canny, cannyColor, Imgproc.COLOR_GRAY2BGR);

      // Detecting the hough lines from (canny)
      Mat lines = new Mat();
      Imgproc.HoughLines(canny, lines, 1, Math.PI/180, 100);

      System.out.println(lines.rows());
      System.out.println(lines.cols());

      // Drawing lines on the image
      double[] data;
      double rho, theta;
      Point pt1 = new Point();
      Point pt2 = new Point();
      double a, b;
      double x0, y0;
      
      for (int i = 0; i < lines.cols(); i++) {
         data = lines.get(0, i);
         rho = data[0];
         theta = data[1];
         
         a = Math.cos(theta);
         b = Math.sin(theta);
         x0 = a*rho;
         y0 = b*rho;
         
         pt1.x = Math.round(x0 + 1000*(-b));
         pt1.y = Math.round(y0 + 1000*(a));
         pt2.x = Math.round(x0 - 1000*(-b));
         pt2.y = Math.round(y0 - 1000 *(a));
         Imgproc.line(cannyColor, pt1, pt2, new Scalar(0, 0, 255), 6);
      }
      // Writing the image
      Imgcodecs.imwrite("E:/OpenCV/chap21/hough_output.jpg", cannyColor);
          
      System.out.println("Image Processed");
   }
}

Supposons que ce qui suit est l'image d'entrée hough_input.jpg spécifié dans le programme ci-dessus.

Production

Lors de l'exécution du programme, vous obtiendrez la sortie suivante -

143 
1 
Image Processed

Si vous ouvrez le chemin spécifié, vous pouvez observer l'image de sortie comme suit -

le histogramd'une image montre la fréquence des valeurs d'intensité des pixels. Dans un histogramme d'image, l'axe X montre les intensités du niveau de gris et l'axe Y montre la fréquence de ces intensités.

Histogram equalizationaméliore le contraste d'une image, afin d'étendre la plage d'intensité. Vous pouvez égaliser l'histogramme d'une image donnée en utilisant la méthodeequalizeHist() du Imgprocclasse. Voici la syntaxe de cette méthode.

equalizeHist(src, dst)

Cette méthode accepte les paramètres suivants -

src - Un objet de la classe Mat représentant l'image source (entrée).
dst - Un objet de la classe Matreprésentant la sortie. (Image obtenue après égalisation de l'histogramme)

Exemple

Le programme suivant montre comment égaliser l'histogramme d'une image donnée.

import java.util.ArrayList;
import java.util.List;

import org.opencv.core.Core;
import org.opencv.core.Mat;
import org.opencv.core.Size;
import org.opencv.imgcodecs.Imgcodecs;
import org.opencv.imgproc.Imgproc;

public class HistoTest {
   public static void main (String[] args) {
      // Loading the OpenCV core library
      System.loadLibrary( Core.NATIVE_LIBRARY_NAME );

      // Reading the Image from the file and storing it in to a Matrix object
      String file ="E:/OpenCV/chap20/histo_input.jpg";

      // Load the image
      Mat img = Imgcodecs.imread(file);

      // Creating an empty matrix
      Mat equ = new Mat();
      img.copyTo(equ);

      // Applying blur
      Imgproc.blur(equ, equ, new Size(3, 3));

      // Applying color
      Imgproc.cvtColor(equ, equ, Imgproc.COLOR_BGR2YCrCb);
      List<Mat> channels = new ArrayList<Mat>();

      // Splitting the channels
      Core.split(equ, channels);

      // Equalizing the histogram of the image
      Imgproc.equalizeHist(channels.get(0), channels.get(0));
      Core.merge(channels, equ);
      Imgproc.cvtColor(equ, equ, Imgproc.COLOR_YCrCb2BGR);

      Mat gray = new Mat();
      Imgproc.cvtColor(equ, gray, Imgproc.COLOR_BGR2GRAY);
      Mat grayOrig = new Mat();
      Imgproc.cvtColor(img, grayOrig, Imgproc.COLOR_BGR2GRAY);

      Imgcodecs.imwrite("E:/OpenCV/chap20/histo_output.jpg", equ);
      System.out.println("Image Processed");
   }
}

Supposons que ce qui suit est l'image d'entrée histo_input.jpg spécifié dans le programme ci-dessus.

Production

Lors de l'exécution du programme, vous obtiendrez la sortie suivante -

Image Processed

Si vous ouvrez le chemin spécifié, vous pouvez observer l'image de sortie comme suit -

↰ Previous page Next page ↱