OpenCV - Kurzanleitung

OpenCV ist eine plattformübergreifende Bibliothek, mit der wir in Echtzeit entwickeln können computer vision applications. Es konzentriert sich hauptsächlich auf Bildverarbeitung, Videoaufnahme und -analyse, einschließlich Funktionen wie Gesichtserkennung und Objekterkennung.

Beginnen wir das Kapitel mit der Definition des Begriffs "Computer Vision".

Computer Vision

Computer Vision kann als eine Disziplin definiert werden, die erklärt, wie eine 3D-Szene anhand ihrer 2D-Bilder anhand der Eigenschaften der in der Szene vorhandenen Struktur rekonstruiert, unterbrochen und verstanden wird. Es befasst sich mit der Modellierung und Replikation des menschlichen Sehens mithilfe von Computersoftware und -hardware.

Computer Vision überschneidet sich erheblich mit den folgenden Feldern:

Image Processing - Es konzentriert sich auf die Bildmanipulation.
Pattern Recognition - Es werden verschiedene Techniken zur Klassifizierung von Mustern erläutert.
Photogrammetry - Es geht darum, genaue Messungen von Bildern zu erhalten.

Computer Vision gegen Bildverarbeitung

Image processingbefasst sich mit der Bild-zu-Bild-Transformation. Die Eingabe und Ausgabe der Bildverarbeitung sind beide Bilder.

Computer visionist die Konstruktion expliziter, aussagekräftiger Beschreibungen physischer Objekte aus ihrem Bild. Die Ausgabe von Computer Vision ist eine Beschreibung oder Interpretation von Strukturen in einer 3D-Szene.

Anwendungen von Computer Vision

Hier haben wir einige wichtige Bereiche aufgelistet, in denen Computer Vision stark genutzt wird.

Robotik-Anwendung

Lokalisierung - Bestimmen Sie den Roboterstandort automatisch
Navigation
Vermeidung von Hindernissen
Montage (Loch, Schweißen, Lackieren)
Manipulation (zB PUMA Robotermanipulator)
Human Robot Interaction (HRI) - Intelligente Robotik zur Interaktion mit und zum Dienst an Menschen

Medizin Anwendung

Klassifizierung und Erkennung (z. B. Klassifizierung von Läsionen oder Zellen und Erkennung von Tumoren)
2D / 3D-Segmentierung
3D-Rekonstruktion menschlicher Organe (MRT oder Ultraschall)
Vision-gesteuerte Robotik-Chirurgie

Industrielle Automatisierungsanwendung

Industrielle Inspektion (Fehlererkennung)
Assembly
Lesen von Barcode und Verpackungsetiketten
Objektsortierung
Dokumentenverständnis (zB OCR)

Sicherheitsanwendung

Biometrie (Iris, Fingerabdruck, Gesichtserkennung)
Überwachung - Erkennen bestimmter verdächtiger Aktivitäten oder Verhaltensweisen

Transportanwendung

Autonomes Fahrzeug
Sicherheit, z. B. Überwachung der Wachsamkeit des Fahrers

Funktionen der OpenCV-Bibliothek

Mit der OpenCV-Bibliothek können Sie -

Bilder lesen und schreiben
Videos aufnehmen und speichern
Bilder verarbeiten (filtern, transformieren)
Führen Sie eine Funktionserkennung durch
Erkennen Sie bestimmte Objekte wie Gesichter, Augen, Autos in den Videos oder Bildern.
Analysieren Sie das Video, dh schätzen Sie die Bewegung darin, subtrahieren Sie den Hintergrund und verfolgen Sie die darin enthaltenen Objekte.

OpenCV wurde ursprünglich in C ++ entwickelt. Darüber hinaus wurden Python- und Java-Bindungen bereitgestellt. OpenCV läuft auf verschiedenen Betriebssystemen wie Windows, Linux, OSx, FreeBSD, Net BSD, Open BSD usw.

In diesem Tutorial werden die Konzepte von OpenCV anhand von Beispielen mit Java-Bindungen erläutert.

OpenCV-Bibliotheksmodule

Im Folgenden sind die Hauptbibliotheksmodule der OpenCV-Bibliothek aufgeführt.

Kernfunktionalität

Dieses Modul behandelt die grundlegenden Datenstrukturen wie Skalar, Punkt, Bereich usw., die zum Erstellen von OpenCV-Anwendungen verwendet werden. Zusätzlich zu diesen enthält es auch das mehrdimensionale ArrayMat, mit dem die Bilder gespeichert werden. In der Java-Bibliothek von OpenCV ist dieses Modul als Paket mit dem Namen enthaltenorg.opencv.core.

Bildverarbeitung

Dieses Modul behandelt verschiedene Bildverarbeitungsvorgänge wie Bildfilterung, geometrische Bildtransformationen, Farbraumkonvertierung, Histogramme usw. In der Java-Bibliothek von OpenCV ist dieses Modul als Paket mit dem Namen enthalten org.opencv.imgproc.

Video

Dieses Modul behandelt die Videoanalysekonzepte wie Bewegungsschätzung, Hintergrundsubtraktion und Objektverfolgung. In der Java-Bibliothek von OpenCV ist dieses Modul als Paket mit dem Namen enthaltenorg.opencv.video.

Video-E / A.

In diesem Modul werden die Videoaufzeichnung und die Video-Codecs mithilfe der OpenCV-Bibliothek erläutert. In der Java-Bibliothek von OpenCV ist dieses Modul als Paket mit dem Namen enthaltenorg.opencv.videoio.

calib3d

Dieses Modul enthält Algorithmen für grundlegende Geometriealgorithmen mit mehreren Ansichten, Einzel- und Stereokamerakalibrierung, Objektposenschätzung, Stereokorrespondenz und Elemente der 3D-Rekonstruktion. In der Java-Bibliothek von OpenCV ist dieses Modul als Paket mit dem Namen enthaltenorg.opencv.calib3d.

features2d

Dieses Modul enthält die Konzepte der Merkmalserkennung und -beschreibung. In der Java-Bibliothek von OpenCV ist dieses Modul als Paket mit dem Namen enthaltenorg.opencv.features2d.

Objekt erkennen

Dieses Modul umfasst die Erkennung von Objekten und Instanzen der vordefinierten Klassen wie Gesichter, Augen, Tassen, Personen, Autos usw. In der Java-Bibliothek von OpenCV ist dieses Modul als Paket mit dem Namen enthalten org.opencv.objdetect.

Highgui

Dies ist eine benutzerfreundliche Oberfläche mit einfachen UI-Funktionen. In der Java-Bibliothek von OpenCV sind die Funktionen dieses Moduls in zwei verschiedenen Paketen enthalten, nämlichorg.opencv.imgcodecs und org.opencv.videoio.

Eine kurze Geschichte von OpenCV

OpenCV war ursprünglich eine Intel-Forschungsinitiative zur Beratung von CPU-intensiven Anwendungen. Es wurde offiziell im Jahr 1999 ins Leben gerufen.

Im Jahr 2006 wurde die erste Hauptversion, OpenCV 1.0, veröffentlicht.
Im Oktober 2009 wurde die zweite Hauptversion, OpenCV 2, veröffentlicht.
Im August 2012 wurde OpenCV von einer gemeinnützigen Organisation OpenCV.org übernommen.

In diesem Kapitel erfahren Sie, wie Sie OpenCV installieren und seine Umgebung in Ihrem System einrichten.

OpenCV installieren

Zunächst müssen Sie OpenCV auf Ihr System herunterladen. Befolgen Sie die unten angegebenen Schritte.

Step 1 - Öffnen Sie die Homepage von OpenCV indem Sie auf den folgenden Link klicken: http://opencv.org/ Beim Klicken sehen Sie die Homepage wie unten gezeigt.

Step 2 - Klicken Sie nun auf DownloadsLink im obigen Screenshot hervorgehoben. Wenn Sie auf klicken, werden Sie zur Downloadseite von OpenCV weitergeleitet.

Step 3 - Wenn Sie auf den markierten Link im obigen Screenshot klicken, wird eine Datei mit dem Namen angezeigt opencv-3.1.0.exewird heruntergeladen. Extrahieren Sie diese Datei, um einen Ordner zu generierenopencv in Ihrem System, wie im folgenden Screenshot gezeigt.

Step 4 - Öffnen Sie den Ordner OpenCV → build → java. Hier finden Sie die JAR-Datei von OpenCV mit dem Namenopencv-310.jar. Speichern Sie diese Datei zur weiteren Verwendung in einem separaten Ordner.

Eclipse-Installation

Nach dem Herunterladen der erforderlichen JAR-Dateien müssen Sie diese JAR-Dateien in Ihre Eclipse-Umgebung einbetten. Sie können dies tun, indem Sie den Erstellungspfad für diese JAR-Dateien festlegen und verwendenpom.xml.

Build-Pfad festlegen

Im Folgenden finden Sie die Schritte zum Einrichten von OpenCV in Eclipse:

Step 1- Stellen Sie sicher, dass Sie Eclipse auf Ihrem System installiert haben. Wenn nicht, laden Sie Eclipse herunter und installieren Sie es auf Ihrem System.

Step 2 - Öffnen Sie Eclipse, klicken Sie auf Datei, Neu und Öffnen Sie ein neues Projekt, wie im folgenden Screenshot gezeigt.

Step 3 - Bei Auswahl des Projekts erhalten Sie die New ProjectMagier. Wählen Sie in diesem Assistenten Java-Projekt aus und klicken Sie aufNext Schaltfläche, wie im folgenden Screenshot gezeigt.

Step 4 - Wenn Sie fortfahren, werden Sie an die weitergeleitet New Java Project wizard. Erstellen Sie ein neues Projekt und klicken Sie aufNext, wie im folgenden Screenshot gezeigt.

Step 5- Klicken Sie nach dem Erstellen eines neuen Projekts mit der rechten Maustaste darauf. WählenBuild Path und klicken Sie auf Configure Build Path… wie im folgenden Screenshot gezeigt.

Step 6 - Klicken Sie auf Build Path Option werden Sie an die weitergeleitet Java Build Path wizard. Drücke denAdd External JARs Schaltfläche, wie im folgenden Screenshot gezeigt.

Step 7 - Wählen Sie den Pfad aus, in dem Sie die Datei gespeichert haben opencv-310.jar.

Step 8 - Klicken Sie auf Open Klicken Sie im obigen Screenshot auf die Schaltfläche. Diese Dateien werden Ihrer Bibliothek hinzugefügt.

Step 9 - Beim Klicken OKWenn Sie die erforderlichen JAR-Dateien erfolgreich zum aktuellen Projekt hinzufügen, können Sie diese hinzugefügten Bibliotheken überprüfen, indem Sie die referenzierten Bibliotheken erweitern.

Festlegen des Pfads für native Bibliotheken

Zusätzlich zu den JAR-Dateien müssen Sie den Pfad für die nativen Bibliotheken (DLL-Dateien) von OpenCV festlegen.

Location of DLL files - Öffnen Sie den Installationsordner von OpenCV und gehen Sie zum Unterordner build → java. Hier finden Sie die beiden Ordnerx64 (64 Bit) und x86 (32 Bit), die die enthalten dll Dateien von OpenCV.

Öffnen Sie den entsprechenden Ordner, der für Ihr Betriebssystem geeignet ist, und sehen Sie den dll Datei, wie im folgenden Screenshot gezeigt.

Legen Sie nun auch den Pfad für diese Datei fest, indem Sie die folgenden Schritte ausführen:

Step 1- Öffnen Sie erneut das JavaBuildPath-Fenster. Hier können Sie die hinzugefügte JAR-Datei und dieJRE System Library.

Step 2 - Beim Erweitern erhalten Sie die Systembibliotheken und Native library location, wie im folgenden Screenshot hervorgehoben.

Step 3 - Doppelklicken Sie auf Native library location. Hier sehen Sie dieNative Library Folder Configuration window Wie nachfolgend dargestellt.

Klicken Sie hier auf die Schaltfläche External Folder… und wählen Sie den Ort des dll Datei in Ihrem System.

Um ein Bild aufzunehmen, verwenden wir Geräte wie Kameras und Scanner. Diese Geräte zeichnen numerische Werte des Bildes auf (Beispiel: Pixelwerte). OpenCV ist eine Bibliothek, die die digitalen Bilder verarbeitet. Daher müssen wir diese Bilder für die Verarbeitung speichern.

Das MatDie Klasse der OpenCV-Bibliothek wird zum Speichern der Werte eines Bildes verwendet. Es stellt ein n-dimensionales Array dar und wird zum Speichern von Bilddaten von Graustufen- oder Farbbildern, Voxelvolumina, Vektorfeldern, Punktwolken, Tensoren, Histogrammen usw. verwendet.

Diese Klasse besteht aus zwei Datenteilen: dem header und ein pointer

Header - Enthält Informationen wie Größe, Speichermethode und Adresse der Matrix (Größe konstant).
Pointer - Speichert die Pixelwerte des Bildes (Variiert weiter).

Die Mattenklasse

Die OpenCV-Java-Bibliothek stellt dieser Klasse denselben Namen zur Verfügung (Mat) innerhalb des Pakets org.opencv.core.

Konstruktoren

Die Mat-Klasse der OpenCV-Java-Bibliothek verfügt über verschiedene Konstruktoren, mit denen Sie das Mat-Objekt erstellen können.

S.No.	Konstruktoren und Beschreibung
1	Mat() Dies ist in den meisten Fällen der Standardkonstruktor ohne Parameter. Wir verwenden dies als Konstruktor, um eine leere Matrix zu erstellen und diese an andere OpenCV-Methoden zu übergeben.
2	Mat(int rows, int cols, int type) Dieser Konstruktor akzeptiert drei Parameter vom Typ Integer, die die Anzahl der Zeilen und Spalten in einem 2D-Array und den Typ des Arrays (der zum Speichern von Daten verwendet werden soll) darstellen.
3	Mat(int rows, int cols, int type, Scalar s) Dieser Konstruktor enthält unter Einbeziehung der Parameter des vorherigen zusätzlich ein Objekt der Klasse Scalar als Parameter.
4	Mat(Size size, int type) Dieser Konstruktor akzeptiert zwei Parameter, ein Objekt, das die Größe der Matrix darstellt, und eine Ganzzahl, die den Typ des Arrays darstellt, das zum Speichern der Daten verwendet wird.
5	Mat(Size size, int type, Scalar s) Dieser Konstruktor enthält unter Einbeziehung der Parameter des vorherigen zusätzlich ein Objekt der Klasse Scalar als Parameter.
6	Mat(long addr)
7	Mat(Mat m, Range rowRange) Dieser Konstruktor akzeptiert ein Objekt einer anderen Matrix und ein Objekt der Klasse Range, das den Bereich der Zeilen darstellt, die zum Erstellen einer neuen Matrix verwendet werden sollen.
8	Mat(Mat m, Range rowRange, Range colRange) Mit den Parametern des vorherigen akzeptiert dieser Konstruktor zusätzlich ein Objekt der Klasse. Bereich, der den Spaltenbereich darstellt.
9	Mat(Mat m, Rect roi) Dieser Konstruktor akzeptiert zwei Objekte, von denen eines eine andere Matrix und das andere die darstellt Region Of Iam interessantesten.

Note - -

Array-Typ. Verwenden Sie CV_8UC1, ..., CV_64FC4, um 1-4-Kanal-Matrizen zu erstellen, oder CV_8UC (n), ..., CV_64FC (n), um Mehrkanal-Matrizen (bis zu CV_CN_MAX-Kanälen) zu erstellen.
Der Typ der Matrizen wurde durch verschiedene Felder der Klasse dargestellt CvType welches zum Paket gehört org.opencv.core.

Methoden und Beschreibung

Im Folgenden sind einige der von der Mat-Klasse bereitgestellten Methoden aufgeführt.

S.No.	Methoden und Beschreibung
1	Mat col(int x) Diese Methode akzeptiert einen ganzzahligen Parameter, der den Index einer Spalte darstellt, und ruft diese Spalte ab und gibt sie zurück.
2	Mat row(int y) Diese Methode akzeptiert einen ganzzahligen Parameter, der den Index einer Zeile darstellt, und ruft diese Zeile ab und gibt sie zurück.
3	int cols() Diese Methode gibt die Anzahl der Spalten in der Matrix zurück.
4	int rows() Diese Methode gibt die Anzahl der Zeilen in der Matrix zurück.
5	Mat setTo(Mat value) Diese Methode akzeptiert ein Objekt der Mat Geben Sie ein und setzt die Array-Elemente auf den angegebenen Wert.
6	Mat setTo(Scalar s) Diese Methode akzeptiert ein Objekt der Scalar Geben Sie ein und setzt die Array-Elemente auf den angegebenen Wert.

Erstellen und Anzeigen der Matrix

In diesem Abschnitt werden wir unser erstes OpenCV-Beispiel diskutieren. Wir werden sehen, wie eine einfache OpenCV-Matrix erstellt und angezeigt wird.

Im Folgenden sind die Schritte aufgeführt, die zum Erstellen und Anzeigen einer Matrix in OpenCV ausgeführt werden müssen.

Schritt 1: Laden Sie die native OpenCV-Bibliothek

Während Sie Java-Code mit der OpenCV-Bibliothek schreiben, müssen Sie zunächst die native OpenCV-Bibliothek mit der laden loadLibrary(). Laden Sie die native OpenCV-Bibliothek wie unten gezeigt.

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

Schritt 2: Instanziieren Sie die Mat-Klasse

Instanziieren Sie die Mat-Klasse mit einer der zuvor in diesem Kapitel genannten Funktionen.

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

Schritt 3: Füllen Sie die Matrix mit den Methoden

Sie können bestimmte Zeilen / Spalten einer Matrix abrufen, indem Sie Indexwerte an die Methoden übergeben row()/col().

Und Sie können diese Werte mit einer der Varianten von festlegen setTo() Methoden.

//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

Mit dem folgenden Programmcode können Sie mithilfe der OpenCV-Bibliothek eine einfache Matrix in Java erstellen und anzeigen.

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()); 
   } 
}

Wenn Sie das obige Programm ausführen, erhalten Sie die folgende Ausgabe:

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]

Laden des Bildes mit der JavaSE-API

Das BufferedImage Klasse der java.awt.image.BufferedImage Paket wird verwendet, um ein Bild und die zu speichern ImageIO Klasse des Pakets import javax.imageio Bietet Methoden zum Lesen und Schreiben von Bildern.

Example

Mit dem folgenden Programmcode können Sie Bilder mithilfe der JavaSE-Bibliothek laden und speichern.

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");
   } 
}

Wenn Sie das obige Programm ausführen, erhalten Sie die folgende Ausgabe:

image Saved

Wenn Sie den angegebenen Pfad öffnen, können Sie das gespeicherte Bild wie folgt beobachten:

Das Imgcodecs Klasse des Pakets org.opencv.imgcodecsbietet Methoden zum Lesen und Schreiben von Bildern. Mit OpenCV können Sie ein Bild lesen und in einer Matrix speichern (bei Bedarf Transformationen in der Matrix durchführen). Später können Sie die verarbeitete Matrix in eine Datei schreiben.

Das read() Methode der ImgcodecsKlasse wird verwendet, um ein Bild mit OpenCV zu lesen. Es folgt die Syntax dieser Methode.

imread(filename)

Es akzeptiert ein Argument (filename), eine Variable vom Typ String, die den Pfad der zu lesenden Datei darstellt.

Im Folgenden sind die Schritte aufgeführt, die zum Lesen von Bildern in Java mithilfe der OpenCV-Bibliothek ausgeführt werden müssen.

Schritt 1: Laden Sie die native OpenCV-Bibliothek

Laden Sie die native OpenCV-Bibliothek mit load() Methode, wie unten gezeigt.

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

Schritt 2: Instanziieren Sie die Imgcodecs-Klasse

Instanziieren Sie die Imgcodecs Klasse.

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

Schritt 3: Lesen des Bildes

Lesen Sie das Bild mit der Methode imread(). Diese Methode akzeptiert ein Zeichenfolgenargument, das den Pfad des Bildes darstellt, und gibt das gelesene Bild als zurückMat Objekt.

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

Beispiel

Der folgende Programmcode zeigt, wie Sie können read an image mit OpenCV-Bibliothek.

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");     
   } 
}

Beim Ausführen des obigen Programms lädt OpenCV das angegebene Bild und zeigt die folgende Ausgabe an:

Image Loaded

Das write() Methode der ImgcodecsKlasse wird verwendet, um ein Bild mit OpenCV zu schreiben. Wiederholen Sie die ersten drei Schritte des vorherigen Beispiels, um ein Bild zu schreiben.

Um ein Bild zu schreiben, müssen Sie das aufrufen imwrite() Methode der Imgcodecs Klasse.

Es folgt die Syntax dieser Methode.

imwrite(filename, mat)

Diese Methode akzeptiert die folgenden Parameter:

filename - A. String Variable, die den Pfad darstellt, in dem die Datei gespeichert werden soll.
mat - A. Mat Objekt, das das zu schreibende Bild darstellt.

Beispiel

Das folgende Programm ist ein Beispiel für write an image Verwenden eines Java-Programms unter Verwendung einer OpenCV-Bibliothek.

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 ............"); 
   } 
}

Wenn Sie das obige Programm ausführen, erhalten Sie die folgende Ausgabe:

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

Wenn Sie den angegebenen Pfad öffnen, können Sie das gespeicherte Bild wie unten gezeigt beobachten.

In den vorherigen Kapiteln haben wir erläutert, wie Sie ein Bild mithilfe der OpenCV-Java-Bibliothek lesen und speichern. Darüber hinaus können wir die geladenen Bilder mithilfe von GUI-Bibliotheken wie AWT / Swings und JavaFX in einem separaten Fenster anzeigen.

Konvertieren der Matte in ein gepuffertes Bild

Um ein Bild zu lesen, verwenden wir die Methode imread(). Diese Methode gibt das gelesene Bild in Form von zurückMatrix. Um dieses Bild jedoch mit GUI-Bibliotheken (AWT / Swings und JavaFX) zu verwenden, sollte es als Objekt der Klasse konvertiert werdenBufferedImage des Pakets java.awt.image.BufferedImage.

Im Folgenden finden Sie die Schritte zum Konvertieren von a Mat Objekt von OpenCV zu BufferedImage Objekt.

Schritt 1: Codieren Sie die Mat in MatOfByte

Zunächst müssen Sie die Matrix in eine Bytematrix konvertieren. Sie können dies mit der Methode tunimencode() der Klasse Imgcodecs. Es folgt die Syntax dieser Methode.

imencode(ext, image, matOfByte);

Diese Methode akzeptiert die folgenden Parameter:

Ext - Ein String-Parameter, der das Bildformat angibt (.jpg, .png usw.)
image - Ein Mat-Objekt des Bildes
matOfByte - Ein leeres Objekt der Klasse MatOfByte

Codieren Sie das Bild mit dieser Methode wie unten gezeigt.

//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);

Schritt 2: Konvertieren Sie das MatOfByte-Objekt in ein Byte-Array

Konvertieren Sie die MatOfByte Objekt in ein Byte-Array mit der Methode toArray().

byte[] byteArray = matOfByte.toArray();

Schritt 3: Vorbereiten des InputStream-Objekts

Bereiten Sie das InputStream-Objekt vor, indem Sie das im vorherigen Schritt erstellte Byte-Array an den Konstruktor des übergeben ByteArrayInputStream Klasse.

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

Schritt 4: Vorbereiten des InputStream-Objekts

Übergeben Sie das im vorherigen Schritt erstellte Input Stream-Objekt an read() Methode der ImageIOKlasse. Dies gibt ein BufferedImage-Objekt zurück.

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

Anzeigen des Bildes mit AWT / Swings

Um ein Bild mit dem AWT / Swings-Rahmen anzuzeigen, lesen Sie zunächst ein Bild mit dem imread() Methode und konvertieren Sie es in BufferedImage Befolgen Sie die oben genannten Schritte.

Dann instanziieren Sie die JFrame Klasse und füge das gepufferte Bild hinzu, das im Inhaltsbereich des JFrames erstellt wurde, wie unten gezeigt -

//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

Der folgende Programmcode zeigt, wie Sie können read ein Bild und display es durch Swing-Fenster mit OpenCV-Bibliothek.

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");     
   } 
}

Wenn Sie das obige Programm ausführen, erhalten Sie die folgende Ausgabe:

Image Loaded

Darüber hinaus sehen Sie ein Fenster, in dem das geladene Bild wie folgt angezeigt wird:

Anzeigen von Bildern mit JavaFX

Um ein Bild mit JavaFX anzuzeigen, lesen Sie zunächst ein Bild mit imread() Methode und konvertieren Sie es in BufferedImage. Konvertieren Sie dann das BufferedImage in WritableImage, wie unten gezeigt.

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

Reich das weiter WritableImage Objekt an den Konstruktor der ImageView Klasse.

ImageView imageView = new ImageView(writableImage);

Example

Der folgende Programmcode zeigt, wie es geht read ein Bild und display es durch JavaFX-Fenster mit OpenCV-Bibliothek.

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); 
   } 
}

Wenn Sie das obige Programm ausführen, erhalten Sie die folgende Ausgabe:

Image Loaded

Darüber hinaus sehen Sie ein Fenster, in dem das geladene Bild wie folgt angezeigt wird:

OpenCV unterstützt verschiedene Arten von Bildern wie Farb-, Binär-, Graustufen- usw. imread() Methode und vordefinierte Felder der Imgcodecs Klasse können Sie ein bestimmtes Bild als einen anderen Typ lesen.

Der Flags-Parameter der imread () -Methode (IMREAD_XXX)

In den früheren Kapiteln haben wir die Syntax von gesehen imread() Methode der ImgcodecsKlasse. Es akzeptiert ein Zeichenfolgenargument, das die Position des zu lesenden Bildes darstellt.

imread(filename)

Das imread() Methode hat eine andere Syntax.

imread(filename, int flags)

Diese Syntax akzeptiert zwei Parameter -

filename - Es akzeptiert ein Argument (filename), eine Variable vom Typ String, die den Pfad der zu lesenden Datei darstellt.
flags- Ein ganzzahliger Wert, der einen vordefinierten Flag-Wert darstellt. Für jeden Wert wird das angegebene Bild als bestimmter Typ (Graustufenfarbe usw.) gelesen.

In der folgenden Tabelle sind verschiedene Felder aufgeführt, die in der Tabelle aufgeführt sind Imgproc Klasse als Werte für diesen Parameter.

S.No.	Felder und Beschreibung
1	IMREAD_COLOR Wenn das Flag auf diesen Wert gesetzt ist, wird das geladene Bild in ein 3-Kanal-BGR-Farbbild (Blau, Grün, Rot) konvertiert.
2	IMREAD_GRAYSCALE Wenn das Flag auf diesen Wert gesetzt ist, wird das geladene Bild in ein einkanaliges Graustufenbild konvertiert.
3	IMREAD_LOAD_GDAL Wenn das Flag auf diesen Wert gesetzt ist, können Sie das Bild mit dem laden gdal Treiber.
4	IMREAD_ANYCOLOR Wenn das Flag auf diesen Wert gesetzt ist, wird das Bild in einem beliebigen Farbformat gelesen.
5	IMREAD_REDUCED_COLOR_2 IMREAD_REDUCED_COLOR_4 IMREAD_REDUCED_COLOR_8 Wenn das Flag auf diesen Wert gesetzt wird, wird das Bild als Dreikanal BGR zu lesen, und die Größe des Bildes wird auf ½ reduziert wird , ¼ ^th oder ⅛ ^th der Originalgröße des Bildes in Bezug auf das Feld verwendet.
6	IMREAD_REDUCED_GRAYSCALE_2 IMREAD_REDUCED_GRAYSCALE_4 IMREAD_REDUCED_GRAYSCALE_8 Wenn das Flag auf diesen Wert gesetzt wird, wird das Bild als ein Einkanal-Graustufenbild zu lesen, und die Größe des Bildes wird auf ½ reduziert wird , ¼ ^th oder ⅛ ^th der Originalgröße des Bildes in Bezug auf das Feld verwendet .
7	IMREAD_UNCHANGED Wenn das Flag auf diesen Wert gesetzt ist, wird das geladene Bild so zurückgegeben, wie es ist.

Das folgende Programm zeigt, wie Sie ein farbiges Bild als Graustufen lesen und im JavaFX-Fenster anzeigen. Hier haben wir das Bild gelesen, indem wir die Flagge passiert habenIMREAD_GRAYSCALE zusammen mit der Zeichenfolge, die den Pfad eines farbigen Bildes enthält.

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); 
   } 
}

Bild eingeben

Angenommen, das Folgende ist das Eingabebild sample.jpg im obigen Programm angegeben.

Ausgabebild

Beim Ausführen des Programms erhalten Sie die folgende Ausgabe.

Das folgende Programm zeigt, wie Sie ein farbiges Bild als BGR-Bild lesen und im JavaFX-Fenster anzeigen. Hier haben wir das Bild gelesen, indem wir die Flagge passiert habenIMREAD_COLOR zur Methode imread() zusammen mit der Zeichenfolge, die den Pfad eines farbigen Bildes enthält.

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);
   } 
}

Bild eingeben

Angenommen, das Folgende ist das Eingabebild sample.jpg im obigen Programm angegeben.

Ausgabebild

Beim Ausführen des Programms erhalten Sie die folgende Ausgabe.

In den vorherigen Kapiteln haben wir erläutert, wie ein Eingabebild als verschiedene Typen (Binär, Graustufen, BGR usw.) gelesen wird. In diesem Kapitel erfahren Sie, wie Sie einen Bildtyp in einen anderen konvertieren.

Die benannte Klasse Imgproc des Pakets org.opencv.imgproc bietet Methoden zum Konvertieren eines Bildes von einer Farbe in eine andere.

Konvertieren farbiger Bilder in Graustufen

Eine Methode namens cvtColor()wird verwendet, um farbige Bilder in Graustufen umzuwandeln. Es folgt die Syntax dieser Methode.

cvtColor(Mat src, Mat dst, int code)

Diese Methode akzeptiert die folgenden Parameter:

src - Eine Matrix, die die Quelle darstellt.
dst - Eine Matrix, die das Ziel darstellt.
code - Ein ganzzahliger Code, der den Typ der Konvertierung darstellt, z. B. RGB in Graustufen.

Sie können farbige Bilder in Graustufen konvertieren, indem Sie den Code übergeben Imgproc.COLOR_RGB2GRAY zusammen mit den Quell- und Zielmatrizen als Parameter für die cvtColor() Methode.

Beispiel

Das folgende Programm zeigt, wie Sie ein farbiges Bild als Graustufenbild lesen und im JavaFX-Fenster anzeigen.

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);
   }
}

Bild eingeben

Angenommen, das Folgende ist das Eingabebild sample.jpg im obigen Programm angegeben.

Ausgabebild

Beim Ausführen des Programms erhalten Sie die folgende Ausgabe.

Eine Methode namens threshold()wird verwendet, um Graustufenbilder in Binärbilder umzuwandeln. Es folgt die Syntax dieser Methode.

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

Diese Methode akzeptiert die folgenden Parameter:

mat - A. Mat Objekt, das das Eingabebild darstellt.
dst - A. Mat Objekt, das das Ausgabebild darstellt.
thresh - Eine Ganzzahl, die den Schwellenwert darstellt.
maxval - Eine Ganzzahl, die den Maximalwert darstellt, der mit den Schwellenwerttypen THRESH_BINARY und THRESH_BINARY_INV verwendet werden soll.
type - Ein ganzzahliger Code, der den Typ der Konvertierung darstellt, z. B. RGB in Graustufen.

Sie können ein Graustufenbild in ein Binärbild konvertieren, indem Sie den Code übergeben Imgproc.THRESH_BINARY zusammen mit den Werten zu den übrigen Parametern.

Beispiel

Das folgende Programm zeigt, wie Sie ein farbiges Bild als Binärbild lesen und im JavaFX-Fenster anzeigen.

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);
   }
}

Bild eingeben

Angenommen, das Folgende ist das Eingabebild sample.jpg im obigen Programm angegeben.

Ausgabebild

Beim Ausführen des Programms erhalten Sie die folgende Ausgabe.

Sie können dieselbe im vorherigen Kapitel erwähnte Methode verwenden, um ein Graustufenbild in ein Binärbild zu konvertieren. Übergeben Sie einfach den Pfad für ein Graustufenbild als Eingabe für dieses Programm.

Beispiel

Das folgende Programm zeigt, wie Sie ein Graustufenbild als Binärbild lesen und im JavaFX-Fenster anzeigen.

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);
   }
}

Bild eingeben

Angenommen, das Folgende ist das Eingabebild sample.jpg im obigen Programm angegeben.

Ausgabebild

Beim Ausführen des Programms erhalten Sie die folgende Ausgabe.

Sie können verschiedene Formen wie Kreis, Rechteck, Linie, Ellipse, Polylinien, Konvexe, Polylinien, Polylinien auf einem Bild mit den jeweiligen Methoden des Zeichens zeichnen org.opencv.imgproc Paket.

Mit dieser Methode können Sie einen Kreis auf ein Bild zeichnen circle() des imgprocKlasse. Es folgt die Syntax dieser Methode:

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

Diese Methode akzeptiert die folgenden Parameter:

mat - A. Mat Objekt, das das Bild darstellt, auf das der Kreis gezeichnet werden soll.
point - A. Point Objekt, das den Mittelpunkt des Kreises darstellt.
radius - Eine Variable des Typs integer Darstellung des Radius des Kreises.
scalar - A. ScalarObjekt, das die Farbe des Kreises darstellt. (BGR)
thickness - Ein integerDarstellen der Dicke des Kreises; Standardmäßig ist der Wert für die Dicke 1.

Beispiel

Das folgende Programm zeigt, wie Sie einen Kreis auf ein Bild zeichnen und es mit dem JavaFX-Fenster anzeigen.

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);
   }
}

Wenn Sie das obige Programm ausführen, erhalten Sie die folgende Ausgabe:

Mit dieser Methode können Sie eine Linie auf einem Bild zeichnen line() des imgprocKlasse. Es folgt die Syntax dieser Methode.

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

Diese Methode akzeptiert die folgenden Parameter:

mat - A. Mat Objekt, das das Bild darstellt, auf dem die Linie gezeichnet werden soll.
pt1 and pt2 - Zwei Point Objekte, die die Punkte darstellen, zwischen denen die Linie gezeichnet werden soll.
scalar - A. ScalarObjekt, das die Farbe des Kreises darstellt. (BGR)
thickness- Eine Ganzzahl, die die Dicke der Linie darstellt; Standardmäßig ist der Wert für die Dicke 1.

Beispiel

Das folgende Programm zeigt, wie Sie eine Linie auf einem Bild zeichnen und im JavaFX-Fenster anzeigen.

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);
   }
}

Wenn Sie das obige Programm ausführen, erhalten Sie die folgende Ausgabe:

Mit dieser Methode können Sie ein Rechteck auf ein Bild zeichnen rectangle() des imgprocKlasse. Es folgt die Syntax dieser Methode:

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

Diese Methode akzeptiert die folgenden Parameter:

mat - A. Mat Objekt, das das Bild darstellt, auf das das Rechteck gezeichnet werden soll.
pt1 and pt2 - Zwei Point Objekte, die die Eckpunkte des zu zeichnenden Rechtecks darstellen.
scalar - A. ScalarObjekt, das die Farbe des Rechtecks darstellt. (BGR)
thickness- Eine Ganzzahl, die die Dicke des Rechtecks darstellt; Standardmäßig ist der Wert für die Dicke 1.

Beispiel

Das folgende Beispiel zeigt, wie Sie ein Rechteck auf ein Bild zeichnen und es mithilfe des JavaFX-Fensters anzeigen.

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);
   }
}

Wenn Sie das obige Programm ausführen, erhalten Sie die folgende Ausgabe:

Mit dieser Methode können Sie eine Ellipse auf ein Bild zeichnen rectangle() des imgprocKlasse. Es folgt die Syntax dieser Methode:

ellipse(img, box, color, thickness)

Diese Methode akzeptiert die folgenden Parameter:

mat - A. Mat Objekt, das das Bild darstellt, auf das das Rechteck gezeichnet werden soll.
box - Ein RotatedRect-Objekt (Die Ellipse ist in dieses Rechteck eingeschrieben gezeichnet.)
scalar - A. ScalarObjekt, das die Farbe des Rechtecks darstellt. (BGR)
thickness- Eine Ganzzahl, die die Dicke des Rechtecks darstellt; Standardmäßig ist der Wert für die Dicke 1.

Der Konstruktor der RotatedRect Klasse akzeptiert ein Objekt der Klasse Point, ein Objekt der Klasse Size und eine Variable vom Typ double, wie unten gezeigt.

RotatedRect(Point c, Size s, double a)

Beispiel

Das folgende Programm zeigt, wie Sie eine Ellipse auf ein Bild zeichnen und mithilfe des JavaFX-Fensters anzeigen.

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);
   }
}

Wenn Sie das obige Programm ausführen, erhalten Sie die folgende Ausgabe:

Mit dieser Methode können Sie Polylinien auf einem Bild zeichnen polylines() des imgprocKlasse. Es folgt die Syntax dieser Methode.

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

Diese Methode akzeptiert die folgenden Parameter:

mat - A. Mat Objekt, das das Bild darstellt, auf dem die Polylinien gezeichnet werden sollen.
pts - A. List Objekt, das die Objekte des Typs enthält MatOfPoint.
isClosed - Ein Parameter vom Typ Boolean, der angibt, ob die Polylinien geschlossen sind.
scalar - A. ScalarObjekt, das die Farbe der Polylinien darstellt. (BGR)
thickness- Eine Ganzzahl, die die Dicke der Polylinien darstellt; Standardmäßig ist der Wert für die Dicke 1.

Der Konstruktor der MatOfPoint Klasse akzeptiert Objekte der Klasse Point.

MatOfPoint(Point... a)

Beispiel

Das folgende Programm zeigt, wie Polylinien auf einem Bild gezeichnet und mithilfe des JavaFX-Fensters angezeigt werden.

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);
   }
}

Wenn Sie das obige Programm ausführen, erhalten Sie die folgende Ausgabe:

Mit dieser Methode können Sie konvexe Polylinien auf ein Bild zeichnen fillconvexPoly() des imgprocKlasse. Es folgt die Syntax dieser Methode.

fillConvexPoly(Mat img, MatOfPoint points, Scalar color)

Diese Methode akzeptiert die folgenden Parameter:

mat - A. Mat Objekt, das das Bild darstellt, auf dem die konvexen Polylinien gezeichnet werden sollen.
points - A. MatOfPoint Objekt, das Punkte darstellt, zwischen denen die konvexen Polylinien gezeichnet werden sollen.
scalar - A. ScalarObjekt, das die Farbe der konvexen Polylinien darstellt. (BGR)

Der Konstruktor der MatOfPoint Klasse akzeptiert Objekte der Klasse Point.

MatOfPoint(Point... a)

Beispiel

Das folgende Programm zeigt, wie Sie konvexe Polylinien auf einem Bild zeichnen und mithilfe des JavaFX-Fensters anzeigen.

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);
   }
}

Wenn Sie das obige Programm ausführen, erhalten Sie die folgende Ausgabe:

Mit dieser Methode können Sie eine Pfeillinie auf ein Bild zeichnen arrowedLine() des imgprocKlasse. Es folgt die Syntax dieser Methode:

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

Diese Methode akzeptiert die folgenden Parameter:

mat - A. Mat Objekt, das das Bild darstellt, auf dem die Pfeillinie gezeichnet werden soll.
pt1 and pt2 - Zwei Point Objekte, die die Punkte darstellen, zwischen denen die Pfeillinie gezeichnet werden soll.
scalar - A. ScalarObjekt, das die Farbe der Pfeillinie darstellt. (BGR)

Beispiel

Das folgende Programm zeigt, wie Sie eine Pfeillinie auf ein Bild zeichnen und es im JavaFX-Fenster anzeigen.

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);
   }
}

Wenn Sie das obige Programm ausführen, erhalten Sie die folgende Ausgabe:

Mit dieser Methode können Sie einem Bild Text hinzufügen arrowedLine() des imgprocKlasse. Es folgt die Syntax dieser Methode.

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

Diese Methode akzeptiert die folgenden Parameter:

mat - A. Mat Objekt, das das Bild darstellt, zu dem der Text hinzugefügt werden soll.
text - A. string Variable zur Darstellung des hinzuzufügenden Textes.
org - A. Point Objekt, das die Textzeichenfolge in der unteren linken Ecke im Bild darstellt.
fontFace - Eine Variable vom Typ Integer, die den Schrifttyp darstellt.
fontScale - Eine Variable vom Typ double, die den Skalierungsfaktor darstellt, der mit der schriftartenspezifischen Basisgröße multipliziert wird.
scalar - A. ScalarObjekt, das die Farbe des hinzuzufügenden Textes darstellt. (BGR)
thickness - Eine Ganzzahl, die standardmäßig die Dicke der Linie darstellt. Der Wert der Dicke ist 1.

Beispiel

Das folgende Programm zeigt, wie Sie einem Bild Text hinzufügen und ihn im JavaFX-Fenster anzeigen.

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);
   }
}

Wenn Sie das obige Programm ausführen, erhalten Sie die folgende Ausgabe:

Unschärfe (Glättung) ist die häufig verwendete Bildverarbeitungsoperation zur Reduzierung des Bildrauschens. Der Prozess entfernt hochfrequente Inhalte wie Kanten aus dem Bild und macht es glatt.

Im Allgemeinen wird die Unschärfe durch Falten (jedes Element des Bildes wird zu seinen lokalen Nachbarn hinzugefügt, gewichtet durch den Kernel) des Bildes durch einen Tiefpassfilterkern erreicht.

Unschärfe (Mittelwertbildung)

Während dieses Vorgangs wird das Bild mit einem Boxfilter (normalisiert) gefaltet. Bei diesem Vorgang wird das zentrale Element des Bildes durch den Durchschnitt aller Pixel im Kernelbereich ersetzt.

Sie können diesen Vorgang mit der Methode für ein Bild ausführen blur() des imgprocKlasse. Es folgt die Syntax dieser Methode:

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

Diese Methode akzeptiert die folgenden Parameter:

src - A. Mat Objekt, das die Quelle (Eingabebild) für diese Operation darstellt.
dst - A. Mat Objekt, das das Ziel (Ausgabebild) für diese Operation darstellt.
ksize - A. Size Objekt, das die Größe des Kernels darstellt.
anchor - Eine Variable vom Typ Integer, die den Ankerpunkt darstellt.
borderType - Eine Variable vom Typ Integer, die den Typ des Rahmens darstellt, der für die Ausgabe verwendet werden soll.

Beispiel

Das folgende Programm zeigt, wie die Mittelung (Unschärfe) für ein Bild ausgeführt wird.

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");
   }
}

Angenommen, das Folgende ist das Eingabebild sample.jpg im obigen Programm angegeben.

Ausgabe

Beim Ausführen des Programms erhalten Sie folgende Ausgabe:

Image Processed

Wenn Sie den angegebenen Pfad öffnen, können Sie das Ausgabebild wie folgt beobachten:

Bei der Gaußschen Unschärfeoperation wird das Bild mit einem Gaußschen Filter anstelle des Boxfilters gefaltet. Das Gaußsche Filter ist ein Tiefpassfilter, das die reduzierten Hochfrequenzkomponenten entfernt.

Sie können diesen Vorgang für ein Bild mit dem ausführen Gaussianblur() Methode der imgprocKlasse. Es folgt die Syntax dieser Methode:

GaussianBlur(src, dst, ksize, sigmaX)

Diese Methode akzeptiert die folgenden Parameter:

src - A. Mat Objekt, das die Quelle (Eingabebild) für diese Operation darstellt.
dst - A. Mat Objekt, das das Ziel (Ausgabebild) für diese Operation darstellt.
ksize - A. Size Objekt, das die Größe des Kernels darstellt.
sigmaX - Eine Variable vom Typ double, die die Standardabweichung des Gaußschen Kernels in X-Richtung darstellt.

Beispiel

Das folgende Programm zeigt, wie die Gaußsche Unschärfeoperation für ein Bild ausgeführt wird.

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");
   }
}

Angenommen, das Folgende ist das Eingabebild sample.jpg im obigen Programm angegeben.

Ausgabe

Beim Ausführen des Programms erhalten Sie folgende Ausgabe:

Image Processed

Wenn Sie den angegebenen Pfad öffnen, können Sie das Ausgabebild wie folgt beobachten:

Die Median-Unschärfe-Operation ähnelt den anderen Mittelungsmethoden. Hier wird das zentrale Element des Bildes durch den Median aller Pixel im Kernelbereich ersetzt. Diese Operation verarbeitet die Kanten, während das Rauschen entfernt wird.

Sie können diesen Vorgang für ein Bild mit dem ausführen medianBlur() Methode der imgprocKlasse. Es folgt die Syntax dieser Methode:

medianBlur(src, dst, ksize)

Diese Methode akzeptiert die folgenden Parameter:

src - A. Mat Objekt, das die Quelle (Eingabebild) für diese Operation darstellt.
dst - A. Mat Objekt, das das Ziel (Ausgabebild) für diese Operation darstellt.
ksize - A. Size Objekt, das die Größe des Kernels darstellt.

Beispiel

Das folgende Programm zeigt, wie die Median-Unschärfe-Operation für ein Bild ausgeführt wird.

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");
   }
}

Angenommen, das Folgende ist das Eingabebild sample.jpg im obigen Programm angegeben.

Ausgabe

Beim Ausführen des Programms erhalten Sie folgende Ausgabe:

Image Processed

Wenn Sie den angegebenen Pfad öffnen, können Sie das Ausgabebild wie folgt beobachten:

Mit der Bildfilterung können Sie verschiedene Effekte auf ein Bild anwenden. In diesem Kapitel und den folgenden drei Kapiteln werden verschiedene Filteroperationen wie bilateraler Filter, Boxfilter, SQR-Boxfilter und Filter2D erläutert.

Bilateraler Filter

Die Operation Bilateraler Filter wendet ein bilaterales Bild auf einen Filter an. Sie können diesen Vorgang für ein Bild mit dem ausführenmedianBlur() Methode der imgprocKlasse. Es folgt die Syntax dieser Methode.

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

Diese Methode akzeptiert die folgenden Parameter:

src - A. Mat Objekt, das die Quelle (Eingabebild) für diese Operation darstellt.
dst - A. Mat Objekt, das das Ziel (Ausgabebild) für diese Operation darstellt.
d - Eine Variable vom Typ Integer, die den Durchmesser der Pixelumgebung darstellt.
sigmaColor - Eine Variable vom Typ Integer, die das Filter-Sigma im Farbraum darstellt.
sigmaSpace - Eine Variable vom Typ Integer, die das Filter-Sigma im Koordinatenraum darstellt.
borderType - Ein ganzzahliges Objekt, das den Typ des verwendeten Rahmens darstellt.

Beispiel

Das folgende Programm zeigt, wie der bilaterale Filtervorgang für ein Bild ausgeführt wird.

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");
   }
}

Angenommen, das Folgende ist das Eingabebild filter_input.jpg im obigen Programm angegeben.

Ausgabe

Beim Ausführen des Programms erhalten Sie folgende Ausgabe:

Image Processed

Wenn Sie den angegebenen Pfad öffnen, können Sie das Ausgabebild wie folgt beobachten:

Die Box-Filter-Operation ähnelt der Mittelungsunschärfeoperation. Es wird ein bilaterales Bild auf einen Filter angewendet. Hier können Sie wählen, ob die Box normalisiert werden soll oder nicht.

Sie können diesen Vorgang für ein Bild mit dem ausführen boxFilter() Methode der imgprocKlasse. Es folgt die Syntax dieser Methode:

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

Diese Methode akzeptiert die folgenden Parameter:

src - A. Mat Objekt, das die Quelle (Eingabebild) für diese Operation darstellt.
dst - A. Mat Objekt, das das Ziel (Ausgabebild) für diese Operation darstellt.
ddepth - Eine Variable vom Typ Integer, die die Tiefe des Ausgabebildes darstellt.
ksize - A. Size Objekt, das die Größe des verwischenden Kernels darstellt.
anchor - Eine Variable vom Typ Integer, die den Ankerpunkt darstellt.
Normalize - Eine Variable vom Typ Boolean, die angibt, ob der Kernel normalisiert werden soll.
borderType - Ein ganzzahliges Objekt, das den Typ des verwendeten Rahmens darstellt.

Beispiel

Das folgende Programm zeigt, wie der Box-Filter-Vorgang für ein Bild ausgeführt wird.

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");
   }
}

Angenommen, das Folgende ist das Eingabebild filter_input.jpg im obigen Programm angegeben.

Ausgabe

Beim Ausführen des Programms erhalten Sie folgende Ausgabe:

Image Processed

Wenn Sie den angegebenen Pfad öffnen, können Sie das Ausgabebild wie folgt beobachten:

Sie können den SQRBox-Filtervorgang für ein Bild mithilfe von ausführen boxFilter() Methode der imgprocKlasse. Es folgt die Syntax dieser Methode:

sqrBoxFilter(src, dst, ddepth, ksize)

Diese Methode akzeptiert die folgenden Parameter:

src - A. Mat Objekt, das die Quelle (Eingabebild) für diese Operation darstellt.
dst - A. Mat Objekt, das das Ziel (Ausgabebild) für diese Operation darstellt.
ddepth - Eine Variable vom Typ Integer, die die Tiefe des Ausgabebildes darstellt.
ksize - A. Size Objekt, das die Größe des verwischenden Kernels darstellt.

Beispiel

Das folgende Programm zeigt, wie eine Sqrbox-Filteroperation für ein bestimmtes Bild ausgeführt wird.

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");
   } 
}

Angenommen, das Folgende ist das Eingabebild filter_input.jpg im obigen Programm angegeben.

Ausgabe

Beim Ausführen des Programms erhalten Sie folgende Ausgabe:

Image Processed

Wenn Sie den angegebenen Pfad öffnen, können Sie das Ausgabebild wie folgt beobachten:

Die Operation Filter2D faltet ein Bild mit dem Kernel zusammen. Sie können diesen Vorgang für ein Bild mit dem ausführenFilter2D() Methode der imgprocKlasse. Es folgt die Syntax dieser Methode:

filter2D(src, dst, ddepth, kernel)

Diese Methode akzeptiert die folgenden Parameter:

src - A. Mat Objekt, das die Quelle (Eingabebild) für diese Operation darstellt.
dst - A. Mat Objekt, das das Ziel (Ausgabebild) für diese Operation darstellt.
ddepth - Eine Variable vom Typ Integer, die die Tiefe des Ausgabebildes darstellt.
kernel - A. Mat Objekt, das den Faltungskern darstellt.

Beispiel

Das folgende Programm zeigt, wie die Filter2D-Operation für ein Image ausgeführt wird.

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");
   }
}

Angenommen, das Folgende ist das Eingabebild filter_input.jpg im obigen Programm angegeben.

Ausgabe

Beim Ausführen des Programms erhalten Sie folgende Ausgabe:

Image Processed

Wenn Sie den angegebenen Pfad öffnen, können Sie das Ausgabebild wie folgt beobachten:

Erosion und Dilatation sind die beiden Arten von morphologischen Operationen. Wie der Name schon sagt, sind morphologische Operationen die Menge von Operationen, die Bilder gemäß ihrer Form verarbeiten.

Basierend auf dem gegebenen Eingabebild wird ein "Strukturelement" entwickelt. Dies kann in einem der beiden Verfahren erfolgen. Diese zielen darauf ab, Rauschen zu beseitigen und die Unvollkommenheiten zu beseitigen, um das Bild klar zu machen.

Erweiterung

Diese Prozedur folgt der Faltung mit einem Kern einer bestimmten Form, wie beispielsweise einem Quadrat oder einem Kreis. Dieser Kernel hat einen Ankerpunkt, der sein Zentrum bezeichnet.

Dieser Kernel überlappt das Bild, um den maximalen Pixelwert zu berechnen. Nach der Berechnung wird das Bild in der Mitte durch einen Anker ersetzt. Mit diesem Verfahren vergrößern sich die Bereiche heller Bereiche und damit die Bildgröße.

Beispielsweise nimmt die Größe eines Objekts in weißem oder hellem Farbton zu, während die Größe eines Objekts in schwarzem oder dunklem Farbton abnimmt.

Sie können den Dilatationsvorgang für ein Bild mithilfe von ausführen dilate() Methode der imgprocKlasse. Es folgt die Syntax dieser Methode.

dilate(src, dst, kernel)

Diese Methode akzeptiert die folgenden Parameter:

src - A. Mat Objekt, das die Quelle (Eingabebild) für diese Operation darstellt.
dst - A. Mat Objekt, das das Ziel (Ausgabebild) für diese Operation darstellt.
kernel - A. Mat Objekt, das den Kernel darstellt.

Beispiel

Sie können die Kernelmatrix mit der vorbereiten getStructuringElement()Methode. Diese Methode akzeptiert eine Ganzzahl, die das darstelltmorph_rect Typ und ein Objekt des Typs Size.

Imgproc.getStructuringElement(int shape, Size ksize);

Das folgende Programm zeigt, wie die Dilatationsoperation an einem bestimmten Bild durchgeführt wird.

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");
   } 
}

Eingang

Angenommen, das Folgende ist das Eingabebild sample.jpg im obigen Programm angegeben.

Ausgabe

Beim Ausführen des Programms erhalten Sie folgende Ausgabe:

Image Processed

Wenn Sie den angegebenen Pfad öffnen, können Sie das Ausgabebild wie folgt beobachten:

Erosion ist ein ähnlicher Prozess wie Dilatation. Der hier berechnete Pixelwert ist jedoch eher minimal als maximal in der Dilatation. Das Bild wird unter dem Ankerpunkt durch diesen minimalen Pixelwert ersetzt.

Mit diesem Verfahren werden die Bereiche dunkler Bereiche größer und helle Bereiche kleiner. Beispielsweise nimmt die Größe eines Objekts im dunklen oder schwarzen Farbton zu, während sie im weißen oder hellen Farbton abnimmt.

Beispiel

Sie können diesen Vorgang für ein Bild mit dem ausführen erode() Methode der imgprocKlasse. Es folgt die Syntax dieser Methode:

erode(src, dst, kernel)

Diese Methode akzeptiert die folgenden Parameter:

src - A. Mat Objekt, das die Quelle (Eingabebild) für diese Operation darstellt.
dst - A. Mat Objekt, das das Ziel (Ausgabebild) für diese Operation darstellt.
kernel - A. Mat Objekt, das den Kernel darstellt.

Sie können die Kernelmatrix mit der vorbereiten getStructuringElement()Methode. Diese Methode akzeptiert eine Ganzzahl, die das darstelltmorph_rect Typ und ein Objekt des Typs Size.

Imgproc.getStructuringElement(int shape, Size ksize);

Das folgende Programm zeigt, wie die Erosionsoperation an einem bestimmten Bild durchgeführt wird.

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");
   }
}

Angenommen, das Folgende ist das Eingabebild sample.jpg im obigen Programm angegeben.

Ausgabe

Beim Ausführen des Programms erhalten Sie folgende Ausgabe:

Image Loaded

Wenn Sie den angegebenen Pfad öffnen, können Sie das Ausgabebild wie folgt beobachten:

In den früheren Kapiteln haben wir den Prozess von diskutiert erosion und dilation. Zusätzlich zu diesen beiden weist OpenCV mehr morphologische Transformationen auf. DasmorphologyEx() der Methode der Klasse Imgproc wird verwendet, um diese Operationen an einem bestimmten Bild auszuführen.

Es folgt die Syntax dieser Methode:

morphologyEx(src, dst, op, kernel)

Diese Methode akzeptiert die folgenden Parameter:

src - Ein Objekt der Klasse Mat Darstellen des Quellbildes (Eingabebildes).
dst - Objekt der Klasse Mat Darstellen des Zielbildes (Ausgabebildes).
op - Eine Ganzzahl, die den Typ der morphologischen Operation darstellt.
kernel - Eine Kernelmatrix.

Beispiel

Das folgende Programm zeigt, wie die morphologische Operation angewendet wird "top-hat" auf einem Bild mit OpenCV-Bibliothek.

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");
   } 
}

Angenommen, das Folgende ist das Eingabebild morph_input.jpg im obigen Programm angegeben.

Ausgabe

Beim Ausführen des Programms erhalten Sie folgende Ausgabe:

Image Processed

Wenn Sie den angegebenen Pfad öffnen, können Sie das Ausgabebild wie folgt beobachten:

Weitere Operationen

Neben der morphologischen Operation TOPHAT, in der vorherigen demonstriert exampleOpenCV bietet verschiedene andere Arten von Morphologien. Alle diese Typen werden durch vordefinierte statische Felder (feste Werte) von dargestelltImgproc Klasse.

Sie können den Typ der gewünschten Morphologie auswählen, indem Sie den entsprechenden vordefinierten Wert an den Parameter übergeben op des morphologyEx() Methode.

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

Es folgen die Werte, die die Art der morphologischen Operationen und ihre jeweiligen Ausgaben darstellen.

Bedienung und Beschreibung	Ausgabe
MORPH_BLACKHAT
MORPH_CLOSE
MORPH_CROSS
MORPH_DILATE
MORPH_ELLIPSE
MORPH_ERODE
MORPH_GRADIENT
MORPH_OPEN
MORPH_RECT
MORPH_TOPHAT

Pyramide ist eine Operation an einem Bild, bei der,

Ein Eingabebild wird anfänglich unter Verwendung eines bestimmten Glättungsfilters (z. B. Gauß, Laplace) geglättet, und dann wird das geglättete Bild unterabgetastet.
Dieser Vorgang wird mehrmals wiederholt.

Während des Pyramidenbetriebs wird die Glätte des Bildes erhöht und die Auflösung (Größe) verringert.

Pyramide nach oben

In Pyramid Up wird das Bild zunächst hochgesampelt und dann unscharf. Sie können die Pyramid Up-Operation für ein Bild mithilfe von ausführenpyrUP() Methode der imgprocKlasse. Es folgt die Syntax dieser Methode:

pyrUp(src, dst, dstsize, borderType)

Diese Methode akzeptiert die folgenden Parameter:

src - Ein Objekt der Klasse Mat Darstellen des Quellbildes (Eingabebildes).
mat - Ein Objekt der Klasse Mat Darstellen des Zielbildes (Ausgabebildes).
size - Ein Objekt der Klasse Size Darstellen der Größe, auf die das Bild vergrößert oder verkleinert werden soll.
borderType - Eine Variable vom Typ Integer, die den Typ des zu verwendenden Rahmens darstellt.

Beispiel

Das folgende Programm zeigt, wie der Pyramid Up-Vorgang für ein Bild ausgeführt wird.

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");
   }
}

Angenommen, das Folgende ist das Eingabebild pyramid_input.jpg im obigen Programm angegeben.

Ausgabe

Beim Ausführen des Programms erhalten Sie folgende Ausgabe:

Image Processed

Wenn Sie den angegebenen Pfad öffnen, können Sie das Ausgabebild wie folgt beobachten:

Pyramide nach unten

In Pyramid Down wird das Bild zunächst unscharf und dann abgetastet. Sie können die Pyramid Down-Operation für ein Bild mithilfe von ausführenpyrDown() Methode der imgprocKlasse. Es folgt die Syntax dieser Methode:

pyrDown(src, dst, dstsize, borderType)

Diese Methode akzeptiert die folgenden Parameter:

src - Ein Objekt der Klasse Mat Darstellen des Quellbildes (Eingabebildes).
mat - Ein Objekt der Klasse Mat Darstellen des Zielbildes (Ausgabebildes).
size - Ein Objekt der Klasse Size Darstellen der Größe, auf die das Bild vergrößert oder verkleinert werden soll.
borderType - Eine Variable vom Typ Integer, die den Typ des zu verwendenden Rahmens darstellt.

Beispiel

Das folgende Programm zeigt, wie die Pyramid Down-Operation für ein Bild ausgeführt wird.

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");
   } 
}

Angenommen, das Folgende ist das Eingabebild pyramid_input.jpg im obigen Programm angegeben.

Ausgabe

Beim Ausführen des Programms erhalten Sie folgende Ausgabe:

Image Processed

Wenn Sie den angegebenen Pfad öffnen, können Sie das Ausgabebild wie folgt beobachten:

Mittlere Verschiebungsfilterung

Bei der Operation der mittleren Verschiebungspyramide wird ein erster Schritt der mittleren Verschiebungssegmentierung eines Bildes ausgeführt.

Sie können die Filterung der mittleren Verschiebung der Pyramide für ein Bild mithilfe von ausführen pyrDown() Methode der imgprocKlasse. Es folgt die Syntax dieser Methode.

pyrMeanShiftFiltering(src, dst, sp, sr)

Diese Methode akzeptiert die folgenden Parameter:

src - Ein Objekt der Klasse Mat Darstellen des Quellbildes (Eingabebildes).
mat - Ein Objekt der Klasse Mat Darstellen des Zielbildes (Ausgabebildes).
sp - Eine Variable vom Typ double, die den räumlichen Fensterradius darstellt.
sr - Eine Variable vom Typ double, die den Radius des Farbfensters darstellt.

Beispiel

Das folgende Programm zeigt, wie eine Filterung der mittleren Verschiebung für ein bestimmtes Bild ausgeführt wird.

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");
   } 
}

Angenommen, das Folgende ist das Eingabebild pyramid_input.jpg im obigen Programm angegeben.

Ausgabe

Beim Ausführen des Programms erhalten Sie folgende Ausgabe:

Image Processed

Wenn Sie den angegebenen Pfad öffnen, können Sie das Ausgabebild wie folgt beobachten:

Thresholding ist eine Methode zur Bildsegmentierung. Im Allgemeinen werden damit Binärbilder erstellt. Es gibt zwei Arten von Schwellenwerten, nämlich einfache Schwellenwerte und adaptive Schwellenwerte.

Einfache Schwelle

Bei einer einfachen Schwellenwertoperation wird den Pixeln, deren Werte größer als der angegebene Schwellenwert sind, ein Standardwert zugewiesen.

Mit dieser Methode können Sie eine einfache Schwellenwertoperation für ein Bild ausführen threshold() des Imgproc classIm Folgenden finden Sie die Syntax dieser Methode.

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

Diese Methode akzeptiert die folgenden Parameter:

src - Ein Objekt der Klasse Mat Darstellen des Quellbildes (Eingabebildes).
dst - Ein Objekt der Klasse Mat Darstellen des Zielbildes (Ausgabebildes).
thresh - Eine Variable vom Doppeltyp, die den Schwellenwert darstellt.
maxval - Eine Variable vom Doppeltyp, die den Wert darstellt, der angegeben werden soll, wenn der Pixelwert größer als der Schwellenwert ist.
type - Eine Variable vom Typ Integer, die den Typ des zu verwendenden Schwellenwerts darstellt.

Beispiel

Das folgende Programm zeigt, wie eine einfache Schwellenwertoperation für ein Image in OpenCV ausgeführt wird.

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");
   }
}

Angenommen, das Folgende ist das Eingabebild thresh_input.jpg im obigen Programm angegeben.

Ausgabe

Beim Ausführen des Programms erhalten Sie folgende Ausgabe:

Image Processed

Wenn Sie den angegebenen Pfad öffnen, können Sie das Ausgabebild wie folgt beobachten:

Andere Arten der einfachen Schwellenwertbildung

Zusätzlich zu THRESH_BINARYDie im vorherigen Beispiel demonstrierte Operation OpenCV bietet verschiedene andere Arten von Schwellenwertoperationen. Alle diese Typen werden durch vordefinierte statische Felder (feste Werte) von dargestelltImgproc Klasse.

Sie können den Typ der gewünschten Schwellenwertoperation auswählen, indem Sie den entsprechenden vordefinierten Wert an den genannten Parameter übergeben type des threshold() Methode.

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

Im Folgenden sind die Werte aufgeführt, die verschiedene Arten von Schwellenwertoperationen und ihre jeweiligen Ausgaben darstellen.

Bedienung und Beschreibung	Ausgabe
THRESH_BINARY
THRESH_BINARY_INV
THRESH_TRUNC
THRESH_TOZERO
THRESH_TOZERO_INV

Im simple thresholdingDer Schwellenwert ist global, dh er ist für alle Pixel im Bild gleich. Adaptive thresholding ist die Methode, bei der der Schwellenwert für kleinere Regionen berechnet wird und daher unterschiedliche Schwellenwerte für verschiedene Regionen vorliegen.

In OpenCV können Sie mit der Methode eine adaptive Schwellenwertoperation für ein Bild ausführen adaptiveThreshold() des ImgprocKlasse. Es folgt die Syntax dieser Methode.

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

Diese Methode akzeptiert die folgenden Parameter:

src - Ein Objekt der Klasse Mat Darstellen des Quellbildes (Eingabebildes).
dst - Ein Objekt der Klasse Mat Darstellen des Zielbildes (Ausgabebildes).
maxValue - Eine Variable vom Doppeltyp, die den Wert darstellt, der angegeben werden soll, wenn der Pixelwert größer als der Schwellenwert ist.
adaptiveMethod- Eine Ganzzahlvariable des Typs, der die zu verwendende adaptive Methode darstellt. Dies ist einer der beiden folgenden Werte
- ADAPTIVE_THRESH_MEAN_C - Der Schwellenwert ist der Mittelwert der Nachbarschaftsfläche.
- ADAPTIVE_THRESH_GAUSSIAN_C - Der Schwellenwert ist die gewichtete Summe der Nachbarschaftswerte, wobei Gewichte ein Gaußsches Fenster sind.
thresholdType - Eine Variable vom Typ Integer, die den Typ des zu verwendenden Schwellenwerts darstellt.
blockSize - Eine Variable vom Typ Integer, die die Größe der Pixelumgebung darstellt, die zur Berechnung des Schwellenwerts verwendet wird.
C - Eine Variable vom Doppeltyp, die die in beiden Methoden verwendete Konstante darstellt (vom Mittelwert oder gewichteten Mittelwert abgezogen).

Beispiel

Das folgende Programm zeigt, wie eine adaptive Schwellenwertoperation für ein Image in OpenCV ausgeführt wird. Hier wählen wir die adaptive Typschwellebinary und ADAPTIVE_THRESH_MEAN_C für Schwellenwertmethode.

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");
   } 
}

Angenommen, das Folgende ist das Eingabebild thresh_input.jpg im obigen Programm angegeben.

Ausgabe

Beim Ausführen des Programms erhalten Sie folgende Ausgabe:

Image Processed

Wenn Sie den angegebenen Pfad öffnen, können Sie das Ausgabebild wie folgt beobachten:

Andere Arten der adaptiven Schwellenwertbildung

Zusätzlich zu ADAPTIVE_THRESH_MEAN_C als adaptive Methode und THRESH_BINARY Als Schwellenwerttyp, wie im vorherigen Beispiel gezeigt, können wir weitere Kombinationen dieser beiden Werte auswählen.

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

Es folgen die Werte, die verschiedene Wertekombinationen für die Parameter darstellen adaptiveMethod und thresholdType und ihre jeweiligen Ausgänge.

adaptiveMethod / Schwellwerttyp	ADAPTIVE_THRESH_MEAN_C	ADAPTIVE_THRESH_GAUSSIAN_C:
THRESH_BINARY
THRESH_BINARY_INV

In diesem Kapitel erfahren Sie, wie Sie Kröten an ein Bild binden.

Die copyMakeBorder () -Methode

Mit der Methode können Sie einem Bild verschiedene Rahmen hinzufügen copyMakeBorder() der Klasse namens Core, die zum Paket gehört org.opencv.core. Das Folgende ist die Syntax dieser Methode.

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

Diese Methode akzeptiert die folgenden Parameter:

src - Ein Objekt der Klasse Mat Darstellen des Quellbildes (Eingabebildes).
dst - Ein Objekt der Klasse Mat Darstellen des Zielbildes (Ausgabebildes).
top - Eine Ganzzahlvariable vom Typ Ganzzahl, die die Länge des Rahmens oben im Bild darstellt.
bottom - Eine Ganzzahlvariable vom Typ Ganzzahl, die die Länge des Rahmens am unteren Rand des Bildes darstellt.
left - Eine Ganzzahlvariable vom Typ Ganzzahl, die die Länge des Rahmens links im Bild darstellt.
right - Eine Ganzzahlvariable vom Typ Ganzzahl, die die Länge des Rahmens rechts im Bild darstellt.
borderType - Eine Variable vom Typ Integer, die den Typ des zu verwendenden Rahmens darstellt.

Beispiel

Das folgende Programm zeigt anhand eines Beispiels, wie einem bestimmten Bild ein Rahmen hinzugefügt wird.

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");
   }
}

Angenommen, das Folgende ist das Eingabebild thresh_input.jpg im obigen Programm angegeben.

Ausgabe

Beim Ausführen des Programms erhalten Sie folgende Ausgabe:

Image Processed

Wenn Sie den angegebenen Pfad öffnen, können Sie das Ausgabebild wie folgt beobachten:

Andere Arten von Grenzen

Neben dem Randtyp BORDER_CONSTANTWie im vorherigen Beispiel gezeigt, bietet OpenCV verschiedene andere Arten von Grenzen. Alle diese Typen werden durch vordefinierte statische Felder (feste Werte) der Core-Klasse dargestellt.

Sie können den Typ der gewünschten Schwellenwertoperation auswählen, indem Sie den entsprechenden vordefinierten Wert an den genannten Parameter übergeben borderType des copyMakeBorder() Methode.

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

Im Folgenden sind die Werte aufgeführt, die verschiedene Arten von Grenzoperationen und ihre jeweiligen Ausgaben darstellen.

Bedienung und Beschreibung	Ausgabe
BORDER_CONSTANT
BORDER_ISOLATED
BORDER_DEFAULT
BORDER_REFLECT
BORDER_REFLECT_101
BORDER_REFLECT101
BORDER_REPLICATE
BORDER_WRAP

Verwendung der sobel operationkönnen Sie die Kanten eines Bildes sowohl in horizontaler als auch in vertikaler Richtung erkennen. Mit der Methode können Sie eine Sobel-Operation auf ein Bild anwendensobel(). Es folgt die Syntax dieser Methode:

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

Diese Methode akzeptiert die folgenden Parameter:

src - Ein Objekt der Klasse Mat Darstellen des Quellbildes (Eingabebildes).
dst - Ein Objekt der Klasse Mat Darstellen des Zielbildes (Ausgabebildes).
ddepth - Eine ganzzahlige Variable, die die Tiefe des Bildes darstellt (-1)
dx- Eine ganzzahlige Variable, die die x-Ableitung darstellt. (0 oder 1)
dy- Eine ganzzahlige Variable, die die y-Ableitung darstellt. (0 oder 1)

Beispiel

Das folgende Programm zeigt, wie eine Sobel-Operation für ein bestimmtes Bild ausgeführt wird.

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");
   }
}

Angenommen, das Folgende ist das Eingabebild sobel_input.jpg im obigen Programm angegeben.

Ausgabe

Beim Ausführen des Programms erhalten Sie folgende Ausgabe:

Image Processed

Wenn Sie den angegebenen Pfad öffnen, können Sie das Ausgabebild wie folgt beobachten:

Sobel-Varianten

Wenn Sie unterschiedliche Werte an die letzten Parameter (dx und dy) (zwischen 0 und 1) übergeben, erhalten Sie unterschiedliche Ausgaben -

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

In der folgenden Tabelle sind verschiedene Werte für die Variablen aufgeführt dx und dy der Methode Sobel() und ihre jeweiligen Ausgänge.

X-Derivat	Y-Ableitung	Ausgabe
0	1
1	0
1	1

Scharr wird auch verwendet, um die zweiten Ableitungen eines Bildes in horizontaler und vertikaler Richtung zu erfassen. Mit der Methode können Sie eine Scharr-Operation für ein Bild ausführenscharr(). Es folgt die Syntax dieser Methode:

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

Diese Methode akzeptiert die folgenden Parameter:

src - Ein Objekt der Klasse Mat Darstellen des Quellbildes (Eingabebildes).
dst - Ein Objekt der Klasse Mat Darstellen des Zielbildes (Ausgabebildes).
ddepth - Eine ganzzahlige Variable, die die Tiefe des Bildes darstellt (-1)
dx- Eine ganzzahlige Variable, die die x-Ableitung darstellt. (0 oder 1)
dy- Eine ganzzahlige Variable, die die y-Ableitung darstellt. (0 oder 1)

Beispiel

Das folgende Programm zeigt, wie Sie scharr auf ein bestimmtes Bild anwenden.

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");
   }
}

Angenommen, das Folgende ist das Eingabebild scharr_input.jpg im obigen Programm angegeben.

Ausgabe

Bei der Ausführung erhalten Sie die folgende Ausgabe:

Image Processed

Wenn Sie den angegebenen Pfad öffnen, können Sie das Ausgabebild wie folgt beobachten:

Mehr scharr Derivate

Wenn Sie unterschiedliche Werte an die letzten Parameter (dx und dy) (zwischen 0 und 1) übergeben, erhalten Sie unterschiedliche Ausgaben -

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

Es folgt eine Tabelle mit verschiedenen Werten für die Variablen dx und dy der Methode scharr() und ihre jeweiligen Ausgänge.

X-Derivat	Y-Ableitung	Ausgabe
0	1
1	0

Der Laplace-Operator ist auch ein Ableitungsoperator, mit dem Kanten in einem Bild gefunden werden. Es ist eine abgeleitete Maske zweiter Ordnung. In dieser Maske haben wir zwei weitere Klassifikationen: eine ist der positive Laplace-Operator und die andere ist der negative Laplace-Operator.

Im Gegensatz zu anderen Operatoren hat Laplacian keine Kanten in eine bestimmte Richtung entfernt, sondern Kanten in der folgenden Klassifizierung.

Einwärtskanten
Außenkanten

Sie können durchführen Laplacian Transform Operation an einem Bild mit der Laplacian() Methode der imgproc Die folgende Klasse ist die Syntax dieser Methode.

Laplacian(src, dst, ddepth)

Diese Methode akzeptiert die folgenden Parameter:

src - A. Mat Objekt, das die Quelle (Eingabebild) für diese Operation darstellt.
dst - A. Mat Objekt, das das Ziel (Ausgabebild) für diese Operation darstellt.
ddepth - Eine Variable vom Typ Integer, die die Tiefe des Zielbilds darstellt.

Beispiel

Das folgende Programm zeigt, wie eine Laplace-Transformationsoperation für ein bestimmtes Bild ausgeführt wird.

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");
   }
}

Angenommen, das Folgende ist das Eingabebild laplacian_input.jpg im obigen Programm angegeben.

Ausgabe

Beim Ausführen des Programms erhalten Sie folgende Ausgabe:

Image Processed

Wenn Sie den angegebenen Pfad öffnen, können Sie das Ausgabebild wie folgt beobachten:

Das distance transformDer Operator nimmt im Allgemeinen Binärbilder als Eingaben. Bei dieser Operation werden die Graustufenintensitäten der Punkte innerhalb der Vordergrundbereiche geändert, um ihre jeweiligen Abstände vom nächsten 0-Wert (Grenze) zu entfernen.

Mit der Methode können Sie die Entfernungstransformation in OpenCV anwenden distanceTransform(). Es folgt die Syntax dieser Methode.

distanceTransform(src, dst, distanceType, maskSize)

Diese Methode akzeptiert die folgenden Parameter:

src - Ein Objekt der Klasse Mat Darstellen des Quellbildes (Eingabebildes).
dst - Ein Objekt der Klasse Mat Darstellen des Zielbildes (Ausgabebildes).
distanceType - Eine Variable vom Typ Integer, die den Typ der anzuwendenden Entfernungstransformation darstellt.
maskSize - Eine Variable vom Typ Integer, die die zu verwendende Maskengröße darstellt.

Beispiel

Das folgende Programm zeigt, wie eine Entfernungstransformationsoperation für ein bestimmtes Bild ausgeführt wird.

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");
   }
}

Angenommen, das Folgende ist das Eingabebild input.jpg im obigen Programm angegeben.

Ausgabe

Beim Ausführen des Programms erhalten Sie folgende Ausgabe:

Image Processed

Wenn Sie den angegebenen Pfad öffnen, können Sie das Ausgabebild wie folgt beobachten:

Arten von Entfernungstransformationsoperationen

Neben der Distanzbetriebsart DIST_CIm vorherigen Beispiel demonstriert, bietet OpenCV verschiedene andere Arten von Entfernungstransformationsoperationen. Alle diese Typen werden durch vordefinierte statische Felder (feste Werte) der Imgproc-Klasse dargestellt.

Sie können den Typ der gewünschten Entfernungstransformationsoperation auswählen, indem Sie den entsprechenden vordefinierten Wert an den genannten Parameter übergeben distanceType des distanceTransform() Methode.

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

Im Folgenden sind die Werte aufgeführt, die verschiedene Arten von darstellen distanceTransform Operationen und ihre jeweiligen Ausgänge.

Bedienung und Beschreibung	Ausgabe
DIST_C
DIST_L1
DIST_L2
DIST_LABEL_PIXEL
DIST_MASK_3

In diesem Kapitel erfahren Sie, wie Sie mit OpenCV Bilder mit der Systemkamera aufnehmen. DasVideoCapture Klasse der org.opencv.videoioDas Paket enthält Klassen und Methoden zum Aufnehmen von Videos mit der Kamera. Lassen Sie uns Schritt für Schritt lernen, wie man Frames erfasst -

Schritt 1: Laden Sie die native OpenCV-Bibliothek

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

Schritt 2: Instanziieren Sie die Videoaufnahmeklasse

Instanziieren Sie die Mat-Klasse mit einer der zuvor in diesem Lernprogramm genannten Funktionen.

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

Schritt 3: Lesen Sie die Frames

Sie können die Bilder von der Kamera mit der lesen read() Methode der VideoCaptureKlasse. Diese Methode akzeptiert ein Objekt der KlasseMat um den gelesenen Frame zu speichern.

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

Beispiel

Das folgende Programm zeigt, wie Sie ein Bild mit der Kamera aufnehmen und mit dem JavaFX-Fenster anzeigen. Außerdem wird der aufgenommene Frame gespeichert.

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);
   }
}

Ausgabe

Beim Ausführen des Programms erhalten Sie die folgende Ausgabe.

Wenn Sie den angegebenen Pfad öffnen, können Sie denselben Frame beobachten, der als JPG-Datei gespeichert ist.

Das VideoCapture Klasse der org.opencv.videoioDas Paket enthält Klassen und Methoden zum Aufnehmen von Videos mit der Systemkamera. Lassen Sie uns Schritt für Schritt gehen und lernen, wie es geht.

Schritt 1: Laden Sie die native OpenCV-Bibliothek

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

Schritt 2: Instanziieren Sie die CascadeClassifier-Klasse

Das CascadeClassifier Klasse des Pakets org.opencv.objdetectwird zum Laden der Klassifikatordatei verwendet. Instanziieren Sie diese Klasse, indem Sie diexml Datei lbpcascade_frontalface.xml Wie nachfolgend dargestellt.

// Instantiating the CascadeClassifier 
String xmlFile = "E:/OpenCV/facedetect/lbpcascade_frontalface.xml"; 
CascadeClassifier classifier = new CascadeClassifier(xmlFile);

Schritt 3: Erkennen Sie die Gesichter

Sie können die Gesichter im Bild mithilfe der Methode erkennen detectMultiScale() der genannten Klasse CascadeClassifier. Diese Methode akzeptiert ein Objekt der KlasseMat Halten des Eingabebildes und eines Objekts der Klasse MatOfRect um die erkannten Gesichter zu speichern.

// Detecting the face in the snap 
MatOfRect faceDetections = new MatOfRect(); 
classifier.detectMultiScale(src, faceDetections);

Beispiel

Das folgende Programm zeigt, wie Gesichter in einem Bild erkannt werden.

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");
   }
}

Angenommen, das Folgende ist das Eingabebild facedetection_input.jpg im obigen Programm angegeben.

Ausgabe

Beim Ausführen des Programms erhalten Sie folgende Ausgabe:

Detected 3 faces 
Image Processed

Wenn Sie den angegebenen Pfad öffnen, können Sie das Ausgabebild wie folgt beobachten:

Das folgende Programm zeigt, wie Gesichter mit einer Systemkamera erkannt und mit dem JavaFX-Fenster angezeigt werden.

Beispiel

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);
   }
}

Ausgabe

Beim Ausführen des Programms erhalten Sie die folgende Ausgabe.

Wenn Sie den angegebenen Pfad öffnen, wird derselbe Snapshot angezeigt, der als gespeichert wurde jpg Bild.

Sie können durchführen affine translation auf einem Bild mit dem warpAffine()Methode der imgproc-Klasse. Es folgt die Syntax dieser Methode:

Imgproc.warpAffine(src, dst, tranformMatrix, size);

Diese Methode akzeptiert die folgenden Parameter:

src - A. Mat Objekt, das die Quelle (Eingabebild) für diese Operation darstellt.
dst - A. Mat Objekt, das das Ziel (Ausgabebild) für diese Operation darstellt.
tranformMatrix - A. Mat Objekt, das die Transformationsmatrix darstellt.
size - Eine Variable vom Typ Integer, die die Größe des Ausgabebilds darstellt.

Beispiel

Das folgende Programm zeigt, wie eine affine Operation auf ein bestimmtes Bild angewendet wird.

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");
   }
}

Angenommen, das Folgende ist das Eingabebild transform_input.jpg im obigen Programm angegeben.

Ausgabe

Bei der Ausführung erhalten Sie die folgende Ausgabe:

Image Processed

Wenn Sie den angegebenen Pfad öffnen, können Sie das Ausgabebild wie folgt beobachten:

Sie können perform rotation Operation an einem Bild mit der warpAffine() Methode der imgprocKlasse. Es folgt die Syntax dieser Methode:

Imgproc.warpAffine(src, dst, rotationMatrix, size);

Diese Methode akzeptiert die folgenden Parameter:

src - A. Mat Objekt, das die Quelle (Eingabebild) für diese Operation darstellt.
dst - A. Mat Objekt, das das Ziel (Ausgabebild) für diese Operation darstellt.
rotationMatrix - A. Mat Objekt, das die Rotationsmatrix darstellt.
size - Eine Variable vom Typ Integer, die die Größe des Ausgabebilds darstellt.

Beispiel

Das folgende Programm zeigt, wie ein Bild gedreht wird.

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");
   }
}

Angenommen, das Folgende ist das Eingabebild transform_input.jpg im obigen Programm angegeben.

Ausgabe

Beim Ausführen des Programms erhalten Sie folgende Ausgabe:

Image Processed

Wenn Sie den angegebenen Pfad öffnen, können Sie das Ausgabebild wie folgt beobachten:

Sie können durchführen scaling auf einem Bild mit dem resize() Methode der imgprocKlasse. Es folgt die Syntax dieser Methode.

resize(Mat src, Mat dst, Size dsize, double fx, double fy, int interpolation)

Diese Methode akzeptiert die folgenden Parameter:

src - A. Mat Objekt, das die Quelle (Eingabebild) für diese Operation darstellt.
dst - A. Mat Objekt, das das Ziel (Ausgabebild) für diese Operation darstellt.
dsize - A. Size Objekt, das die Größe des Ausgabebildes darstellt.
fx - Eine Variable vom Typ double, die den Skalierungsfaktor entlang der horizontalen Achse darstellt.
fy - Eine Variable vom Typ double, die den Skalierungsfaktor entlang der vertikalen Achse darstellt.
Interpolation - Eine ganzzahlige Variable, die die Interpolationsmethode darstellt.

Beispiel

Das folgende Programm zeigt, wie Sie sich bewerben scale transformation zu einem Bild.

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");
   }
}

Angenommen, das Folgende ist das Eingabebild transform_input.jpg im obigen Programm angegeben (Größe - Breite: 300px und Höhe: 300px).

Ausgabe

Beim Ausführen des Programms erhalten Sie folgende Ausgabe:

Image Processed

Wenn Sie den angegebenen Pfad öffnen, können Sie das Ausgabebild wie folgt beobachten (Größe - Breite: 600 Pixel und Höhe: 600 Pixel) -

In OpenCV können Sie mit der Methode verschiedene Farbkarten auf ein Bild anwenden applyColorMap() der Klasse Imgproc. Es folgt die Syntax dieser Methode:

applyColorMap(Mat src, Mat dst, int colormap)

Es akzeptiert drei Parameter -

src - Ein Objekt der Klasse Mat Darstellen des Quellbildes (Eingabebildes).
dst - Ein Objekt der Klasse Mat Darstellen des Zielbildes (Ausgabebildes).
colormap - Eine Variable vom Typ Integer, die den Typ der anzuwendenden Farbkarte darstellt.

Beispiel

Das folgende Programm zeigt, wie Sie sich bewerben color map zu einem Bild.

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");
   }
}

Angenommen, das Folgende ist das Eingabebild color_input.jpg im obigen Programm angegeben.

Ausgabe

Wenn Sie das obige Programm ausführen, erhalten Sie die folgende Ausgabe:

Image Processed

Wenn Sie den angegebenen Pfad öffnen, können Sie das Ausgabebild wie folgt beobachten:

Weitere Operationen

Zusätzlich zu COLORMAP_HOTIm vorherigen Beispiel wurde gezeigt, dass OpenCV verschiedene andere Arten von Farbkarten bietet. Alle diese Typen werden durch vordefinierte statische Felder (feste Werte) der Imgproc-Klasse dargestellt.

Sie können den Typ der gewünschten Farbkarte auswählen, indem Sie den entsprechenden vordefinierten Wert an den genannten Parameter übergeben colormap des applyColorMap() Methode.

Imgproc.applyColorMap(src, dst, Imgproc.COLORMAP_HOT);

Im Folgenden sind die Werte aufgeführt, die verschiedene Arten von Farbkarten und ihre jeweiligen Ausgaben darstellen.

Bedienung und Beschreibung	Ausgabe
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

Canny Edge Detection wird verwendet, um die Kanten in einem Bild zu erkennen. Es akzeptiert ein Graustufenbild als Eingabe und verwendet einen mehrstufigen Algorithmus.

Sie können diesen Vorgang für ein Bild mit dem ausführen Canny() Methode der imgproc Die folgende Klasse ist die Syntax dieser Methode.

Canny(image, edges, threshold1, threshold2)

Diese Methode akzeptiert die folgenden Parameter:

image - A. Mat Objekt, das die Quelle (Eingabebild) für diese Operation darstellt.
edges - A. Mat Objekt, das das Ziel (Kanten) für diese Operation darstellt.
threshold1 - Eine Variable vom Typ double, die den ersten Schwellenwert für das Hystereseverfahren darstellt.
threshold2 - Eine Variable vom Typ double, die den zweiten Schwellenwert für das Hystereseverfahren darstellt.

Beispiel

Das folgende Programm zeigt anhand eines Beispiels, wie ein Canny Edge Detection-Vorgang für ein bestimmtes Bild ausgeführt wird.

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");
   } 
}

Angenommen, das Folgende ist das Eingabebild canny_input.jpg im obigen Programm angegeben.

Ausgabe

Wenn Sie das obige Programm ausführen, erhalten Sie die folgende Ausgabe:

Image Processed

Wenn Sie den angegebenen Pfad öffnen, können Sie das Ausgabebild wie folgt beobachten:

Sie können die Form eines bestimmten Bildes erkennen, indem Sie die Hough Transform technique mit der Methode HoughLines() des ImgprocKlasse. Es folgt die Syntax dieser Methode.

HoughLines(image, lines, rho, theta, threshold)

Diese Methode akzeptiert die folgenden Parameter:

image - Ein Objekt der Klasse Mat Darstellen des Quellbildes (Eingabebildes).
lines - Ein Objekt der Klasse Mat das speichert den Vektor, der die Parameter (r, Φ) der Linien speichert.
rho - Eine Variable vom Typ double, die die Auflösung des Parameters r in Pixel darstellt.
theta - Eine Variable vom Typ double, die die Auflösung des Parameters Φ im Bogenmaß darstellt.
threshold - Eine Variable vom Typ Integer, die die minimale Anzahl von Schnittpunkten darstellt, um eine Linie zu „erkennen“.

Beispiel

Das folgende Programm zeigt, wie Hough-Linien in einem bestimmten Bild erkannt werden.

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");
   }
}

Angenommen, das Folgende ist das Eingabebild hough_input.jpg im obigen Programm angegeben.

Ausgabe

Beim Ausführen des Programms erhalten Sie folgende Ausgabe:

143 
1 
Image Processed

Wenn Sie den angegebenen Pfad öffnen, können Sie das Ausgabebild wie folgt beobachten:

Das histogrameines Bildes zeigt die Häufigkeit der Intensitätswerte der Pixel. In einem Bildhistogramm zeigt die X-Achse die Graustufenintensitäten und die Y-Achse die Häufigkeit dieser Intensitäten.

Histogram equalizationverbessert den Kontrast eines Bildes, um den Intensitätsbereich auszudehnen. Mit der Methode können Sie das Histogramm eines bestimmten Bildes angleichenequalizeHist() des ImgprocKlasse. Es folgt die Syntax dieser Methode.

equalizeHist(src, dst)

Diese Methode akzeptiert die folgenden Parameter:

src - Ein Objekt der Klasse Mat Darstellen des Quellbildes (Eingabebildes).
dst - Ein Objekt der Klasse MatDarstellung der Ausgabe. (Bild erhalten nach dem Ausgleich des Histogramms)

Beispiel

Das folgende Programm zeigt, wie das Histogramm eines bestimmten Bildes ausgeglichen wird.

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");
   }
}

Angenommen, das Folgende ist das Eingabebild histo_input.jpg im obigen Programm angegeben.