OpenCV - Guida rapida

OpenCV è una libreria multipiattaforma utilizzando la quale possiamo sviluppare in tempo reale computer vision applications. Si concentra principalmente sull'elaborazione delle immagini, l'acquisizione e l'analisi di video, comprese funzionalità come il rilevamento del volto e il rilevamento di oggetti.

Iniziamo il capitolo definendo il termine "Computer Vision".

Visione computerizzata

La Computer Vision può essere definita come una disciplina che spiega come ricostruire, interrompere e comprendere una scena 3D dalle sue immagini 2D, in termini di proprietà della struttura presente nella scena. Si occupa di modellare e replicare la visione umana utilizzando software e hardware per computer.

La visione artificiale si sovrappone in modo significativo ai seguenti campi:

• Image Processing - Si concentra sulla manipolazione delle immagini.

• Pattern Recognition - Spiega varie tecniche per classificare i modelli.

• Photogrammetry - Si occupa di ottenere misurazioni accurate dalle immagini.

Computer Vision vs elaborazione delle immagini

Image processingsi occupa della trasformazione da immagine a immagine. L'input e l'output dell'elaborazione delle immagini sono entrambi immagini.

Computer visionè la costruzione di descrizioni esplicite e significative di oggetti fisici a partire dalla loro immagine. Il risultato della visione artificiale è una descrizione o un'interpretazione delle strutture nella scena 3D.

Applicazioni della visione artificiale

Qui abbiamo elencato alcuni dei principali domini in cui è ampiamente utilizzato Visione artificiale.

Applicazione di robotica

• Localizzazione: determina automaticamente la posizione del robot

• Navigation

• Evitamento degli ostacoli

• Assemblaggio (piolo, saldatura, verniciatura)

• Manipolazione (es. Manipolatore robotico PUMA)

• Human Robot Interaction (HRI): robotica intelligente per interagire e servire le persone

Applicazione della medicina

• Classificazione e rilevamento (ad es. Classificazione di lesioni o cellule e rilevamento di tumori)
• Segmentazione 2D / 3D
• Ricostruzione 3D di organi umani (MRI o ultrasuoni)
• Chirurgia robotica guidata dalla vista

Applicazione di automazione industriale

• Ispezione industriale (rilevamento di difetti)
• Assembly
• Lettura del codice a barre e dell'etichetta della confezione
• Ordinamento degli oggetti
• Comprensione dei documenti (ad es. OCR)

Applicazione di sicurezza

• Biometria (iride, impronte digitali, riconoscimento facciale)

• Sorveglianza: rilevamento di determinate attività o comportamenti sospetti

Applicazione di trasporto

• Veicolo autonomo
• Sicurezza, ad es. Monitoraggio della vigilanza del conducente

Caratteristiche della libreria OpenCV

Utilizzando la libreria OpenCV, puoi:

• Leggere e scrivere immagini

• Cattura e salva video

• Elabora immagini (filtra, trasforma)

• Eseguire il rilevamento delle funzionalità

• Rileva oggetti specifici come volti, occhi, automobili, nei video o nelle immagini.

• Analizza il video, vale a dire stimare il movimento in esso, sottrarre lo sfondo e tracciare gli oggetti in esso.

OpenCV è stato originariamente sviluppato in C ++. Inoltre, sono stati forniti collegamenti Python e Java. OpenCV funziona su vari sistemi operativi come Windows, Linux, OSx, FreeBSD, Net BSD, Open BSD, ecc.

Questo tutorial spiega i concetti di OpenCV con esempi che utilizzano i collegamenti Java.

Moduli libreria OpenCV

Di seguito sono riportati i principali moduli della libreria della libreria OpenCV.

Funzionalità di base

Questo modulo copre le strutture dati di base come Scalare, Punto, Intervallo, ecc., Che vengono utilizzate per creare applicazioni OpenCV. Oltre a questi, include anche l'array multidimensionaleMat, che viene utilizzato per memorizzare le immagini. Nella libreria Java di OpenCV, questo modulo è incluso come pacchetto con il nomeorg.opencv.core.

Elaborazione delle immagini

Questo modulo copre varie operazioni di elaborazione delle immagini come il filtraggio delle immagini, le trasformazioni geometriche delle immagini, la conversione dello spazio colore, gli istogrammi, ecc. Nella libreria Java di OpenCV, questo modulo è incluso come pacchetto con il nome org.opencv.imgproc.

video

Questo modulo copre i concetti di analisi video come la stima del movimento, la sottrazione dello sfondo e il tracciamento degli oggetti. Nella libreria Java di OpenCV, questo modulo è incluso come pacchetto con il nomeorg.opencv.video.

Video I / O

Questo modulo spiega l'acquisizione di video e i codec video utilizzando la libreria OpenCV. Nella libreria Java di OpenCV, questo modulo è incluso come pacchetto con il nomeorg.opencv.videoio.

calib3d

Questo modulo include algoritmi riguardanti algoritmi di geometria a vista multipla di base, calibrazione di telecamere singole e stereo, stima della posa degli oggetti, corrispondenza stereo ed elementi di ricostruzione 3D. Nella libreria Java di OpenCV, questo modulo è incluso come pacchetto con il nomeorg.opencv.calib3d.

features2d

Questo modulo include i concetti di rilevamento e descrizione delle funzionalità. Nella libreria Java di OpenCV, questo modulo è incluso come pacchetto con il nomeorg.opencv.features2d.

Objdetect

Questo modulo include il rilevamento di oggetti e istanze delle classi predefinite come volti, occhi, tazze, persone, automobili, ecc. Nella libreria Java di OpenCV, questo modulo è incluso come pacchetto con il nome org.opencv.objdetect.

Highgui

Questa è un'interfaccia facile da usare con semplici funzionalità dell'interfaccia utente. Nella libreria Java di OpenCV, le funzionalità di questo modulo sono incluse in due diversi pacchetti e cioè,org.opencv.imgcodecs e org.opencv.videoio.

Una breve storia di OpenCV

OpenCV era inizialmente un'iniziativa di ricerca Intel per consigliare applicazioni ad alta intensità di CPU. È stato lanciato ufficialmente nel 1999.

• Nel 2006 è stata rilasciata la sua prima versione principale, OpenCV 1.0.
• Nell'ottobre 2009 è stata rilasciata la seconda versione principale, OpenCV 2.
• Nell'agosto 2012, OpenCV è stata acquisita da un'organizzazione senza scopo di lucro OpenCV.org.

In questo capitolo imparerai come installare OpenCV e configurare il suo ambiente nel tuo sistema.

Installazione di OpenCV

Prima di tutto, devi scaricare OpenCV sul tuo sistema. Segui i passaggi indicati di seguito.

Step 1 - Apri la home page di OpenCV facendo clic sul seguente collegamento: http://opencv.org/ Facendo clic, vedrai la sua homepage come mostrato di seguito.

Step 2 - Ora, fai clic su Downloadscollegamento evidenziato nello screenshot qui sopra. Facendo clic, verrai indirizzato alla pagina dei download di OpenCV.

Step 3 - Facendo clic sul collegamento evidenziato nello screenshot sopra, un file denominato opencv-3.1.0.exeverrà scaricato. Estrai questo file per generare una cartellaopencv nel tuo sistema, come mostrato nello screenshot seguente.

Step 4 - Apri la cartella OpenCV → build → java. Qui troverai il file jar di OpenCV denominatoopencv-310.jar. Salvare questo file in una cartella separata per un ulteriore utilizzo.

Installazione di Eclipse

Dopo aver scaricato i file JAR richiesti, è necessario incorporare questi file JAR nel proprio ambiente Eclipse. È possibile farlo impostando il percorso di compilazione per questi file JAR e utilizzandopom.xml.

Impostazione del percorso di costruzione

Di seguito sono riportati i passaggi per configurare OpenCV in Eclipse:

Step 1- Assicurati di aver installato Eclipse nel tuo sistema. In caso contrario, scarica e installa Eclipse nel tuo sistema.

Step 2 - Apri Eclipse, fai clic su File, Nuovo e Apri un nuovo progetto come mostrato nella seguente schermata.

Step 3 - Selezionando il progetto, otterrai il file New Projectprocedura guidata. In questa procedura guidata, seleziona il progetto Java e procedi facendo clic suNext pulsante, come mostrato nello screenshot seguente.

Step 4 - Andando avanti, verrai indirizzato al New Java Project wizard. Crea un nuovo progetto e fai clicNext, come mostrato nello screenshot seguente.

Step 5- Dopo aver creato un nuovo progetto, fai clic destro su di esso. SelezionareBuild Path e fare clic Configure Build Path… come mostrato nello screenshot seguente.

Step 6 - Facendo clic su Build Path opzione, verrai indirizzato al file Java Build Path wizard. Clicca ilAdd External JARs pulsante, come mostrato nello screenshot seguente.

Step 7 - Seleziona il percorso in cui hai salvato il file opencv-310.jar.

Step 8 - Facendo clic su Open nello screenshot qui sopra, quei file verranno aggiunti alla tua libreria.

Step 9 - Facendo clic OK, aggiungerai correttamente i file JAR richiesti al progetto corrente e potrai verificare queste librerie aggiunte espandendo le Librerie referenziate.

Impostazione del percorso per le librerie native

Oltre ai file JAR, è necessario impostare il percorso per le librerie native (file DLL) di OpenCV.

Location of DLL files - Apri la cartella di installazione di OpenCV e vai alla sottocartella build → java. Qui troverai le due cartellex64 (64 bit) e x86 (32 bit) che contengono l'estensione dll file di OpenCV.

Apri la rispettiva cartella adatta al tuo sistema operativo, quindi puoi vedere il file dll file, come mostrato nello screenshot seguente.

Ora, imposta anche il percorso per questo file seguendo i passaggi indicati di seguito:

Step 1- Ancora una volta, apri la finestra JavaBuildPath. Qui puoi osservare il file JAR aggiunto e il fileJRE System Library.

Step 2 - Espandendolo, otterrai le librerie di sistema e Native library location, come evidenziato nello screenshot seguente.

Step 3 - Fare doppio clic sul file Native library location. Qui puoi vedere il fileNative Library Folder Configuration window come mostrato di seguito.

Qui, fai clic sul pulsante External Folder… e seleziona la posizione del file dll file nel tuo sistema.

Per catturare un'immagine, utilizziamo dispositivi come fotocamere e scanner. Questi dispositivi registrano i valori numerici dell'immagine (Es: valori dei pixel). OpenCV è una libreria che elabora le immagini digitali, quindi abbiamo bisogno di memorizzare queste immagini per l'elaborazione.

Il Matla classe della libreria OpenCV viene utilizzata per memorizzare i valori di un'immagine. Rappresenta un array n-dimensionale e viene utilizzato per memorizzare dati immagine di immagini in scala di grigi oa colori, volumi voxel, campi vettoriali, nuvole di punti, tensori, istogrammi, ecc.

Questa classe comprende due parti di dati: il header e a pointer

• Header - Contiene informazioni come le dimensioni, il metodo utilizzato per la memorizzazione e l'indirizzo della matrice (dimensione costante).

• Pointer - Memorizza i valori dei pixel dell'immagine (continua a variare).

La classe Mat

La libreria Java OpenCV fornisce questa classe con lo stesso nome (Mat) all'interno della confezione org.opencv.core.

Costruttori

La classe Mat della libreria Java OpenCV ha vari costruttori, utilizzando i quali è possibile costruire l'oggetto Mat.

S.No	Costruttori e descrizione
1	Mat() Questo è il costruttore predefinito senza parametri nella maggior parte dei casi. Lo usiamo per il costruttore per creare una matrice vuota e passarlo ad altri metodi OpenCV.
2	Mat(int rows, int cols, int type) Questo costruttore accetta tre parametri di tipo intero che rappresentano il numero di righe e colonne in un array 2D e il tipo di array (che deve essere utilizzato per memorizzare i dati).
3	Mat(int rows, int cols, int type, Scalar s) Includendo i parametri del precedente, questo costruttore accetta anche un oggetto della classe Scalar come parametro.
4	Mat(Size size, int type) Questo costruttore accetta due parametri, un oggetto che rappresenta la dimensione della matrice e un numero intero che rappresenta il tipo di array utilizzato per memorizzare i dati.
5	Mat(Size size, int type, Scalar s) Includendo i parametri del precedente, questo costruttore accetta anche un oggetto della classe Scalar come parametro.
6	Mat(long addr)
7	Mat(Mat m, Range rowRange) Questo costruttore accetta un oggetto di un'altra matrice e un oggetto della classe Range che rappresenta l'intervallo delle righe da prendere per creare una nuova matrice.
8	Mat(Mat m, Range rowRange, Range colRange) Includendo i parametri del precedente, questo costruttore accetta anche un oggetto della classe. Intervallo che rappresenta l'intervallo di colonne.
9	Mat(Mat m, Rect roi) Questo costruttore accetta due oggetti, uno che rappresenta un'altra matrice e l'altro che rappresenta il file Region Of Iinteresse.

Note -

• Tipo di array. Utilizzare CV_8UC1, ..., CV_64FC4 per creare matrici di canali 1-4 o CV_8UC (n), ..., CV_64FC (n) per creare matrici multicanale (fino a canali CV_CN_MAX).

• Il tipo delle matrici era rappresentato da vari campi della classe CvType che appartiene al pacchetto org.opencv.core.

Metodi e descrizione

Di seguito sono riportati alcuni dei metodi forniti dalla classe Mat.

S.No	Metodi e descrizione
1	Mat col(int x) Questo metodo accetta un parametro intero che rappresenta l'indice di una colonna e recupera e restituisce quella colonna.
2	Mat row(int y) Questo metodo accetta un parametro intero che rappresenta l'indice di una riga e recupera e restituisce quella riga.
3	int cols() Questo metodo restituisce il numero di colonne nella matrice.
4	int rows() Questo metodo restituisce il numero di righe nella matrice.
5	Mat setTo(Mat value) Questo metodo accetta un oggetto di Mat type e imposta gli elementi dell'array sul valore specificato.
6	Mat setTo(Scalar s) Questo metodo accetta un oggetto di Scalar type e imposta gli elementi dell'array sul valore specificato.

Creazione e visualizzazione della matrice

In questa sezione, discuteremo il nostro primo esempio di OpenCV. Vedremo come creare e visualizzare una semplice matrice OpenCV.

Di seguito sono riportati i passaggi da seguire per creare e visualizzare una matrice in OpenCV.

Passaggio 1: carica la libreria nativa di OpenCV

Durante la scrittura del codice Java utilizzando la libreria OpenCV, il primo passo che devi fare è caricare la libreria nativa di OpenCV utilizzando il loadLibrary(). Carica la libreria nativa di OpenCV come mostrato di seguito.

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

Passaggio 2: creare un'istanza della classe Mat

Istanziare la classe Mat utilizzando una delle funzioni menzionate in questo capitolo in precedenza.

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

Passaggio 3: riempire la matrice utilizzando i metodi

È possibile recuperare particolari righe / colonne di una matrice passando i valori di indice ai metodi row()/col().

Inoltre, puoi impostare i valori su questi utilizzando una qualsiasi delle varianti di setTo() metodi.

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

È possibile utilizzare il seguente codice di programma per creare e visualizzare una semplice matrice in Java utilizzando la libreria OpenCV.

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

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

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

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

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

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

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

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

Eseguendo il programma sopra, otterrai il seguente output:

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]

Caricamento dell'immagine utilizzando l'API JavaSE

Il BufferedImage classe di java.awt.image.BufferedImage pacchetto viene utilizzato per memorizzare un'immagine e il file ImageIO classe del pacchetto import javax.imageio fornisce metodi per leggere e scrivere immagini.

Example

È possibile utilizzare il seguente codice di programma per caricare e salvare le immagini utilizzando la libreria JavaSE.

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

Eseguendo il programma sopra, otterrai il seguente output:

image Saved

Se apri il percorso specificato, puoi osservare l'immagine salvata come segue:

Il Imgcodecs classe del pacchetto org.opencv.imgcodecsfornisce metodi per leggere e scrivere immagini. Usando OpenCV, puoi leggere un'immagine e memorizzarla in una matrice (eseguire trasformazioni sulla matrice se necessario). Successivamente, è possibile scrivere la matrice elaborata su un file.

Il read() metodo del Imgcodecsclass viene utilizzata per leggere un'immagine utilizzando OpenCV. Di seguito è riportata la sintassi di questo metodo.

imread(filename)

Accetta un argomento (filename), una variabile di tipo String che rappresenta il percorso del file che deve essere letto.

Di seguito sono riportati i passaggi da seguire per leggere le immagini in Java utilizzando la libreria OpenCV.

Passaggio 1: carica la libreria nativa di OpenCV

Carica la libreria nativa di OpenCV utilizzando il file load() metodo, come mostrato di seguito.

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

Passaggio 2: creare un'istanza della classe Imgcodecs

Istanziare il file Imgcodecs classe.

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

Passaggio 3: lettura dell'immagine

Leggi l'immagine usando il metodo imread(). Questo metodo accetta un argomento stringa che rappresenta il percorso dell'immagine e restituisce l'immagine letta comeMat oggetto.

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

Esempio

Il codice del programma seguente mostra come puoi farlo read an image utilizzando la libreria OpenCV.

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

All'esecuzione del programma sopra, OpenCV carica l'immagine specificata e visualizza il seguente output:

Image Loaded

Il write() metodo del Imgcodecsclass è usata per scrivere un'immagine usando OpenCV. Per scrivere un'immagine, ripetere i primi tre passaggi dell'esempio precedente.

Per scrivere un'immagine, è necessario richiamare il file imwrite() metodo del Imgcodecs classe.

Di seguito è riportata la sintassi di questo metodo.

imwrite(filename, mat)

Questo metodo accetta i seguenti parametri:

• filename - A String variabile che rappresenta il percorso in cui salvare il file.

• mat - A Mat oggetto che rappresenta l'immagine da scrivere.

Esempio

Il seguente programma è un esempio per write an image utilizzando il programma Java utilizzando la libreria OpenCV.

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

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

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

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

Eseguendo il programma sopra, otterrai il seguente output:

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

Se apri il percorso specificato, puoi osservare l'immagine salvata come mostrato di seguito -

Nei capitoli precedenti, abbiamo discusso come leggere e salvare un'immagine utilizzando la libreria Java OpenCV. Oltre a ciò, possiamo anche visualizzare le immagini caricate in una finestra separata utilizzando le librerie GUI come AWT / Swings e JavaFX.

Conversione di mat in immagine tamponata

Per leggere un'immagine usiamo il metodo imread(). Questo metodo restituisce l'immagine letta sotto forma diMatrix. Ma, per utilizzare questa immagine con le librerie GUI (AWT / Swings e JavaFX), dovrebbe essere convertita come oggetto della classeBufferedImage del pacchetto java.awt.image.BufferedImage.

Di seguito sono riportati i passaggi per convertire un file Mat oggetto di OpenCV a BufferedImage oggetto.

Passaggio 1: codifica Mat in MatOfByte

Prima di tutto, devi convertire la matrice in matrice di byte. Puoi farlo usando il metodoimencode() della classe Imgcodecs. Di seguito è riportata la sintassi di questo metodo.

imencode(ext, image, matOfByte);

Questo metodo accetta i seguenti parametri:

• Ext - Un parametro String che specifica il formato dell'immagine (.jpg, .png, ecc.)

• image - Un oggetto Mat dell'immagine

• matOfByte - Un oggetto vuoto della classe MatOfByte

Codifica l'immagine utilizzando questo metodo come mostrato di seguito.

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

Passaggio 2: converti l'oggetto MatOfByte in un array di byte

Converti il ​​file MatOfByte oggetto in una matrice di byte utilizzando il metodo toArray().

byte[] byteArray = matOfByte.toArray();

Passaggio 3: preparazione dell'oggetto InputStream

Preparare l'oggetto InputStream passando la matrice di byte creata nel passaggio precedente al costruttore di ByteArrayInputStream classe.

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

Passaggio 4: preparazione dell'oggetto InputStream

Passare l'oggetto Input Stream creato nel passaggio precedente al file read() metodo del ImageIOclasse. Ciò restituirà un oggetto BufferedImage.

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

Visualizzazione dell'immagine utilizzando AWT / Swings

Per visualizzare un'immagine utilizzando la cornice AWT / Swings, prima di tutto leggere un'immagine utilizzando il imread() metodo e convertirlo in BufferedImage seguendo i passaggi sopra indicati.

Quindi, istanzia il file JFrame class e aggiungi l'immagine bufferizzata creata al ContentPane di JFrame, come mostrato di seguito -

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

Il codice del programma seguente mostra come puoi farlo read un'immagine e display attraverso la finestra oscillante utilizzando la libreria OpenCV.

import java.awt.image.BufferedImage;

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

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

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

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

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

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

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

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

Eseguendo il programma sopra, otterrai il seguente output:

Image Loaded

Oltre a ciò, puoi vedere una finestra che mostra l'immagine caricata, come segue:

Visualizzazione dell'immagine utilizzando JavaFX

Per visualizzare un'immagine utilizzando JavaFX, prima di tutto, leggi un'immagine utilizzando il imread() metodo e convertirlo in BufferedImage. Quindi, converti BufferedImage in WritableImage, come mostrato di seguito.

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

Passa questo WritableImage oggetto al costruttore del file ImageView classe.

ImageView imageView = new ImageView(writableImage);

Example

Il codice di programma seguente mostra come read un'immagine e display attraverso la finestra JavaFX utilizzando la libreria OpenCV.

import java.awt.image.BufferedImage;

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

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

import javax.imageio.ImageIO;

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

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

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

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

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

Eseguendo il programma sopra, otterrai il seguente output:

Image Loaded

Oltre a ciò, puoi vedere una finestra che mostra l'immagine caricata, come segue:

OpenCV supporta vari tipi di immagini come colorate, binarie, in scala di grigi, ecc. Utilizzando l'estensione imread() metodo e campi predefiniti del file Imgcodecs class, puoi leggere una data immagine come un altro tipo.

Il parametro flags del metodo imread () (IMREAD_XXX)

Nei capitoli precedenti abbiamo visto la sintassi di imread() metodo del Imgcodecsclasse. Accetta un argomento stringa che rappresenta la posizione dell'immagine che deve essere letta.

imread(filename)

Il imread() ha un'altra sintassi.

imread(filename, int flags)

Questa sintassi accetta due parametri:

• filename - Accetta un argomento (filename), una variabile di tipo String che rappresenta il percorso del file che deve essere letto.

• flags- Un valore intero che rappresenta un valore di flag predefinito. Per ogni valore, questo legge l'immagine data come un tipo specifico (colore della scala di grigi ecc.)

Di seguito è riportata la tabella che elenca i vari campi forniti nel file Imgproc class come valori per questo parametro.

S.No	Campi e descrizione
1	IMREAD_COLOR Se il flag è impostato su questo valore, l'immagine caricata verrà convertita in un'immagine a colori BGR (blu verde rosso) a 3 canali.
2	IMREAD_GRAYSCALE Se il flag è impostato su questo valore, l'immagine caricata verrà convertita in un'immagine in scala di grigi a canale singolo.
3	IMREAD_LOAD_GDAL Se il flag è impostato su questo valore, è possibile caricare l'immagine utilizzando il gdal conducente.
4	IMREAD_ANYCOLOR Se il flag è impostato su questo valore, l'immagine viene letta in qualsiasi formato di colore possibile.
5	IMREAD_REDUCED_COLOR_2 IMREAD_REDUCED_COLOR_4 IMREAD_REDUCED_COLOR_8 Se il flag è impostato a questo valore, l'immagine viene letta come tre canali BGR, e la dimensione dell'immagine è ridotto a ½, ¼ th o ⅛ th delle dimensioni originali dell'immagine rispetto al campo utilizzato.
6	IMREAD_REDUCED_GRAYSCALE_2 IMREAD_REDUCED_GRAYSCALE_4 IMREAD_REDUCED_GRAYSCALE_8 Se il flag è impostato a questo valore, l'immagine viene letta come scala di grigi un singolo canale, e la dimensione dell'immagine è ridotto a ½, ¼ th o ⅛ th delle dimensioni originali dell'immagine rispetto al campo utilizzati .
7	IMREAD_UNCHANGED Se il flag è impostato su questo valore, l'immagine caricata viene restituita così com'è.

Il seguente programma mostra come leggere un'immagine a colori in scala di grigi e visualizzarla utilizzando la finestra JavaFX. Qui abbiamo letto l'immagine passando la bandieraIMREAD_GRAYSCALE insieme alla stringa che tiene il percorso di un'immagine colorata.

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

Immagine in ingresso

Supponiamo che la seguente sia l'immagine in ingresso sample.jpg specificato nel programma di cui sopra.

Immagine di output

All'esecuzione del programma, otterrai il seguente output.

Il seguente programma mostra come leggere un'immagine colorata come immagine di tipo BGR e visualizzarla utilizzando la finestra JavaFX. Qui abbiamo letto l'immagine passando la bandieraIMREAD_COLOR al metodo imread() insieme alla stringa che tiene il percorso di un'immagine colorata.

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

Immagine in ingresso

Supponiamo che la seguente sia l'immagine in ingresso sample.jpg specificato nel programma di cui sopra.

Immagine di output

All'esecuzione del programma, otterrai il seguente output.

Nei capitoli precedenti, abbiamo discusso come leggere un'immagine di input come diversi tipi (binario, scala di grigi, BGR, ecc.). In questo capitolo impareremo come convertire un tipo di immagine in un altro.

La classe denominata Imgproc del pacchetto org.opencv.imgproc fornisce metodi per convertire un'immagine da un colore a un altro.

Conversione di immagini colorate in scala di grigi

Un metodo denominato cvtColor()viene utilizzato per convertire le immagini colorate in scala di grigi. Di seguito è riportata la sintassi di questo metodo.

cvtColor(Mat src, Mat dst, int code)

Questo metodo accetta i seguenti parametri:

• src - Una matrice che rappresenta la sorgente.

• dst - Una matrice che rappresenta la destinazione.

• code - Un codice intero che rappresenta il tipo di conversione, ad esempio, da RGB a Scala di grigi.

È possibile convertire le immagini colorate in scala di grigi passando il codice Imgproc.COLOR_RGB2GRAY insieme alle matrici di origine e di destinazione come parametro di cvtColor() metodo.

Esempio

Il seguente programma mostra come leggere un'immagine a colori come un'immagine in scala di grigi e visualizzarla utilizzando la finestra JavaFX.

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

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

import javafx.stage.Stage;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Immagine in ingresso

Supponiamo che la seguente sia l'immagine in ingresso sample.jpg specificato nel programma di cui sopra.

Immagine di output

All'esecuzione del programma, otterrai il seguente output.

Un metodo chiamato threshold()viene utilizzato per convertire immagini in scala di grigi in immagini binarie. Di seguito è riportata la sintassi di questo metodo.

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

Questo metodo accetta i seguenti parametri:

• mat - A Mat oggetto che rappresenta l'immagine di input.

• dst - A Mat oggetto che rappresenta l'immagine di output.

• thresh - Un numero intero che rappresenta il valore di soglia.

• maxval - Un numero intero che rappresenta il valore massimo da utilizzare con i tipi di soglia THRESH_BINARY e THRESH_BINARY_INV.

• type - Un codice intero che rappresenta il tipo di conversione, ad esempio, da RGB a Scala di grigi.

È possibile convertire un'immagine in scala di grigi in un'immagine binaria passando il codice Imgproc.THRESH_BINARY insieme ai valori dei parametri rimanenti.

Esempio

Il seguente programma mostra come leggere un'immagine colorata come immagine binaria e visualizzarla utilizzando la finestra JavaFX.

import java.awt.image.BufferedImage;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Immagine in ingresso

Supponiamo che la seguente sia l'immagine in ingresso sample.jpg specificato nel programma di cui sopra.

Immagine di output

All'esecuzione del programma, otterrai il seguente output.

È possibile utilizzare lo stesso metodo menzionato nel capitolo precedente per convertire un'immagine in scala di grigi in un'immagine binaria. Basta passare il percorso per un'immagine in scala di grigi come input per questo programma.

Esempio

Il seguente programma mostra come leggere un'immagine in scala di grigi come immagine binaria e visualizzarla utilizzando la finestra JavaFX.

import java.awt.image.BufferedImage;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Immagine in ingresso

Supponiamo che la seguente sia l'immagine in ingresso sample.jpg specificato nel programma di cui sopra.

Immagine di output

All'esecuzione del programma, otterrai il seguente output.

È possibile disegnare varie forme come Cerchio, Rettangolo, Linea, Ellisse, Polilinee, Convesse, Polilinee, Polilinee su un'immagine utilizzando i rispettivi metodi del org.opencv.imgproc pacchetto.

Puoi disegnare un cerchio su un'immagine usando il metodo circle() del imgprocclasse. Di seguito è riportata la sintassi di questo metodo:

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

Questo metodo accetta i seguenti parametri:

• mat - A Mat oggetto che rappresenta l'immagine su cui si vuole disegnare il cerchio.

• point - A Point oggetto che rappresenta il centro del cerchio.

• radius - Una variabile del tipo integer che rappresenta il raggio del cerchio.

• scalar - A Scalaroggetto che rappresenta il colore del cerchio. (BGR)

• thickness - An integerche rappresenta lo spessore del cerchio; per impostazione predefinita, il valore dello spessore è 1.

Esempio

Il seguente programma mostra come disegnare un cerchio su un'immagine e visualizzarlo utilizzando la finestra JavaFX.

import java.awt.image.BufferedImage;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Eseguendo il programma sopra, otterrai il seguente output:

Puoi disegnare una linea su un'immagine usando il metodo line() del imgprocclasse. Di seguito è riportata la sintassi di questo metodo.

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

Questo metodo accetta i seguenti parametri:

• mat - A Mat oggetto che rappresenta l'immagine su cui tracciare la linea.

• pt1 and pt2 - Due Point oggetti che rappresentano i punti tra i quali deve essere tracciata la linea.

• scalar - A Scalaroggetto che rappresenta il colore del cerchio. (BGR)

• thickness- Un numero intero che rappresenta lo spessore della linea; per impostazione predefinita, il valore dello spessore è 1.

Esempio

Il seguente programma mostra come disegnare una linea su un'immagine e visualizzarla utilizzando la finestra JavaFX.

import java.awt.image.BufferedImage;

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

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

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

public class DrawingLine extends Application {
   Mat matrix = null;

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

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

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

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

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

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

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

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

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

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

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

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

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

      this.matrix = matrix;

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

Eseguendo il programma sopra, otterrai il seguente output:

Puoi disegnare un rettangolo su un'immagine usando il metodo rectangle() del imgprocclasse. Di seguito è riportata la sintassi di questo metodo:

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

Questo metodo accetta i seguenti parametri:

• mat - A Mat oggetto che rappresenta l'immagine su cui si vuole disegnare il rettangolo.

• pt1 and pt2 - Due Point oggetti che rappresentano i vertici del rettangolo da disegnare.

• scalar - A Scalaroggetto che rappresenta il colore del rettangolo. (BGR)

• thickness- Un numero intero che rappresenta lo spessore del rettangolo; per impostazione predefinita, il valore dello spessore è 1.

Esempio

L'esempio seguente mostra come disegnare un rettangolo su un'immagine e visualizzarlo utilizzando la finestra JavaFX.

import java.awt.image.BufferedImage;

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

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

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

public class DrawingRectangle extends Application {
   Mat matrix = null;

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

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

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

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

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

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

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

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

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

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

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

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

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

      this.matrix = matrix;

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

Eseguendo il programma sopra, otterrai il seguente output:

Puoi disegnare un'ellisse su un'immagine usando il metodo rectangle() del imgprocclasse. Di seguito è riportata la sintassi di questo metodo:

ellipse(img, box, color, thickness)

Questo metodo accetta i seguenti parametri:

• mat - A Mat oggetto che rappresenta l'immagine su cui deve essere disegnato il Rettangolo.

• box - Un oggetto RotatedRect (l'ellisse è disegnata inscritta in questo rettangolo.)

• scalar - A Scalaroggetto che rappresenta il colore del rettangolo. (BGR)

• thickness- Un numero intero che rappresenta lo spessore del rettangolo; per impostazione predefinita, il valore dello spessore è 1.

Il costruttore di RotatedRect class accetta un oggetto della classe Point, un oggetto della classe Size e una variabile di tipo double, come mostrato di seguito.

RotatedRect(Point c, Size s, double a)

Esempio

Il seguente programma mostra come disegnare un'ellisse su un'immagine e visualizzarla utilizzando la finestra JavaFX.

import java.awt.image.BufferedImage;

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

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

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

public class DrawingEllipse extends Application {
   Mat matrix = null;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Eseguendo il programma sopra, otterrai il seguente output:

Puoi disegnare polilinee su un'immagine usando il metodo polylines() del imgprocclasse. Di seguito è riportata la sintassi di questo metodo.

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

Questo metodo accetta i seguenti parametri:

• mat - A Mat oggetto che rappresenta l'immagine su cui devono essere disegnate le Polilinee.

• pts - A List oggetto che contiene gli oggetti del tipo MatOfPoint.

• isClosed - Un parametro di tipo booleano che specifica il tempo in cui le polilinee sono chiuse.

• scalar - A Scalaroggetto che rappresenta il colore delle polilinee. (BGR)

• thickness- Un numero intero che rappresenta lo spessore delle polilinee; per impostazione predefinita, il valore dello spessore è 1.

Il costruttore di MatOfPoint class accetta oggetti della classe Point.

MatOfPoint(Point... a)

Esempio

Il seguente programma mostra come disegnare polilinee su un'immagine e visualizzarla utilizzando la finestra JavaFX.

import java.awt.image.BufferedImage;

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

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

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

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

public class DrawingPolyLines extends Application {
   Mat matrix = null;

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

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

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

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

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

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

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

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

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

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

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

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

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

      this.matrix = matrix;

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

Eseguendo il programma sopra, otterrai il seguente output:

È possibile disegnare polilinee convesse su un'immagine utilizzando il metodo fillconvexPoly() del imgprocclasse. Di seguito è riportata la sintassi di questo metodo.

fillConvexPoly(Mat img, MatOfPoint points, Scalar color)

Questo metodo accetta i seguenti parametri:

• mat - A Mat oggetto che rappresenta l'immagine su cui devono essere disegnate le Polilinee convesse.

• points - A MatOfPoint oggetto che rappresenta i punti tra i quali devono essere disegnate le polilinee convesse.

• scalar - A Scalaroggetto che rappresenta il colore delle polilinee convesse. (BGR)

Il costruttore di MatOfPoint class accetta oggetti della classe Point.

MatOfPoint(Point... a)

Esempio

Il seguente programma mostra come disegnare polilinee convesse su un'immagine e visualizzarla utilizzando la finestra JavaFX.

import java.awt.image.BufferedImage;

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

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

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

public class FillConvexPoly extends Application {
   Mat matrix = null;

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

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

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

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

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

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

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

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

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

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

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

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

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

Eseguendo il programma sopra, otterrai il seguente output:

Puoi disegnare una linea con la freccia su un'immagine usando il metodo arrowedLine() del imgprocclasse. Di seguito è riportata la sintassi di questo metodo:

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

Questo metodo accetta i seguenti parametri:

• mat - A Mat oggetto che rappresenta l'immagine su cui tracciare la linea con la freccia.

• pt1 and pt2 - Due Point oggetti che rappresentano i punti tra i quali deve essere tracciata la linea con la freccia.

• scalar - A Scalaroggetto che rappresenta il colore della linea con la freccia. (BGR)

Esempio

Il seguente programma mostra come disegnare una linea con la freccia su un'immagine e visualizzarla utilizzando la finestra JavaFX.

import java.awt.image.BufferedImage;

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

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

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

public class DrawingArrowedLine extends Application {
   Mat matrix = null;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Eseguendo il programma sopra, otterrai il seguente output:

Puoi aggiungere del testo a un'immagine usando il metodo arrowedLine() del imgprocclasse. Di seguito è riportata la sintassi di questo metodo.

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

Questo metodo accetta i seguenti parametri:

• mat - A Mat oggetto che rappresenta l'immagine a cui aggiungere il testo.

• text - A string variabile di rappresentare il testo che si vuole aggiungere.

• org - A Point oggetto che rappresenta la stringa di testo nell'angolo inferiore sinistro dell'immagine.

• fontFace - Una variabile di tipo intero che rappresenta il tipo di carattere.

• fontScale - Una variabile di tipo double che rappresenta il fattore di scala che viene moltiplicato per la dimensione di base specifica del carattere.

• scalar - A Scalaroggetto che rappresenta il colore del testo da aggiungere. (BGR)

• thickness - Un numero intero che rappresenta lo spessore della linea per impostazione predefinita, il valore dello spessore è 1.

Esempio

Il seguente programma mostra come aggiungere testo a un'immagine e visualizzarla utilizzando la finestra JavaFX.

import java.awt.image.BufferedImage;

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

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

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

public class AddingTextToImage extends Application {
   Mat matrix = null;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Eseguendo il programma sopra, otterrai il seguente output:

La sfocatura (smussatura) è l'operazione di elaborazione delle immagini comunemente utilizzata per ridurre il rumore dell'immagine. Il processo rimuove il contenuto ad alta frequenza, come i bordi, dall'immagine e la rende liscia.

In generale la sfocatura si ottiene convolgendo (ogni elemento dell'immagine viene aggiunto ai suoi vicini locali, pesati dal kernel) l'immagine attraverso un kernel di filtro passa basso.

Sfocatura (media)

Durante questa operazione, l'immagine viene convoluta con un box filter (normalizzato). In questo processo, l'elemento centrale dell'immagine viene sostituito dalla media di tutti i pixel nell'area del kernel.

È possibile eseguire questa operazione su un'immagine utilizzando il metodo blur() del imgprocclasse. Di seguito è riportata la sintassi di questo metodo:

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

Questo metodo accetta i seguenti parametri:

• src - A Mat oggetto che rappresenta la sorgente (immagine in ingresso) per questa operazione.

• dst - A Mat oggetto che rappresenta la destinazione (immagine di output) per questa operazione.

• ksize - A Size oggetto che rappresenta la dimensione del kernel.

• anchor - Una variabile di tipo intero che rappresenta il punto di ancoraggio.

• borderType - Una variabile di tipo intero che rappresenta il tipo di bordo da utilizzare per l'output.

Esempio

Il seguente programma mostra come eseguire l'operazione di media (sfocatura) su un'immagine.

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

Supponiamo che la seguente sia l'immagine in ingresso sample.jpg specificato nel programma di cui sopra.

Produzione

All'esecuzione del programma, otterrai il seguente output:

Image Processed

Se apri il percorso specificato, puoi osservare l'immagine di output come segue:

Nell'operazione Gaussian Blur, l'immagine è convoluta con un filtro gaussiano invece del filtro box. Il filtro gaussiano è un filtro passa-basso che rimuove i componenti ad alta frequenza ridotti.

È possibile eseguire questa operazione su un'immagine utilizzando il Gaussianblur() metodo del imgprocclasse. Di seguito è riportata la sintassi di questo metodo:

GaussianBlur(src, dst, ksize, sigmaX)

Questo metodo accetta i seguenti parametri:

• src - A Mat oggetto che rappresenta la sorgente (immagine in ingresso) per questa operazione.

• dst - A Mat oggetto che rappresenta la destinazione (immagine di output) per questa operazione.

• ksize - A Size oggetto che rappresenta la dimensione del kernel.

• sigmaX - Una variabile di tipo double che rappresenta la deviazione standard del kernel gaussiano in direzione X.

Esempio

Il seguente programma mostra come eseguire l'operazione di sfocatura gaussiana su un'immagine.

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

Supponiamo che la seguente sia l'immagine in ingresso sample.jpg specificato nel programma di cui sopra.

Produzione

All'esecuzione del programma, otterrai il seguente output:

Image Processed

Se apri il percorso specificato, puoi osservare l'immagine di output come segue:

L'operazione di sfocatura mediana è simile agli altri metodi di calcolo della media. Qui, l'elemento centrale dell'immagine è sostituito dalla mediana di tutti i pixel nell'area del kernel. Questa operazione elabora i bordi rimuovendo il rumore.

È possibile eseguire questa operazione su un'immagine utilizzando il medianBlur() metodo del imgprocclasse. Di seguito è riportata la sintassi di questo metodo:

medianBlur(src, dst, ksize)

Questo metodo accetta i seguenti parametri:

• src - A Mat oggetto che rappresenta la sorgente (immagine in ingresso) per questa operazione.

• dst - A Mat oggetto che rappresenta la destinazione (immagine di output) per questa operazione.

• ksize - A Size oggetto che rappresenta la dimensione del kernel.

Esempio

Il seguente programma mostra come eseguire l'operazione di sfocatura mediana su un'immagine.

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

Supponiamo che la seguente sia l'immagine in ingresso sample.jpg specificato nel programma di cui sopra.

Produzione

All'esecuzione del programma, otterrai il seguente output:

Image Processed

Se apri il percorso specificato, puoi osservare l'immagine di output come segue:

Il filtraggio delle immagini consente di applicare vari effetti a un'immagine. In questo capitolo e nei successivi tre capitoli, discuteremo varie operazioni di filtro come il filtro bilaterale, il filtro a scatola, il filtro a scatola SQR e il filtro2D.

Filtro bilaterale

L'operazione di filtro bilaterale applica un'immagine bilaterale a un filtro. È possibile eseguire questa operazione su un'immagine utilizzando ilmedianBlur() metodo del imgprocclasse. Di seguito è riportata la sintassi di questo metodo.

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

Questo metodo accetta i seguenti parametri:

• src - A Mat oggetto che rappresenta la sorgente (immagine in ingresso) per questa operazione.

• dst - A Mat oggetto che rappresenta la destinazione (immagine di output) per questa operazione.

• d - Una variabile di tipo intero che rappresenta il diametro del pixel adiacente.

• sigmaColor - Una variabile di tipo intero che rappresenta il filtro sigma nello spazio colore.

• sigmaSpace - Una variabile di tipo intero che rappresenta il filtro sigma nello spazio delle coordinate.

• borderType - Un oggetto intero che rappresenta il tipo di bordo utilizzato.

Esempio

Il seguente programma mostra come eseguire l'operazione di filtro bilaterale su un'immagine.

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

Supponiamo che la seguente sia l'immagine in ingresso filter_input.jpg specificato nel programma di cui sopra.

Produzione

All'esecuzione del programma, otterrai il seguente output:

Image Processed

Se apri il percorso specificato, puoi osservare l'immagine di output come segue:

L'operazione Box Filter è simile all'operazione di media sfocatura; applica un'immagine bilaterale a un filtro. Qui puoi scegliere se la scatola deve essere normalizzata o meno.

È possibile eseguire questa operazione su un'immagine utilizzando il boxFilter() metodo del imgprocclasse. Di seguito è riportata la sintassi di questo metodo:

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

Questo metodo accetta i seguenti parametri:

• src - A Mat oggetto che rappresenta la sorgente (immagine in ingresso) per questa operazione.

• dst - A Mat oggetto che rappresenta la destinazione (immagine di output) per questa operazione.

• ddepth - Una variabile di tipo intero che rappresenta la profondità dell'immagine di output.

• ksize - A Size oggetto che rappresenta la dimensione del kernel sfocato.

• anchor - Una variabile di tipo intero che rappresenta il punto di ancoraggio.

• Normalize - Una variabile di tipo booleano che specifica il tempo in cui il kernel deve essere normalizzato.

• borderType - Un oggetto intero che rappresenta il tipo di bordo utilizzato.

Esempio

Il seguente programma mostra come eseguire l'operazione Box Filter su un'immagine.

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

Supponiamo che la seguente sia l'immagine in ingresso filter_input.jpg specificato nel programma di cui sopra.

Produzione

All'esecuzione del programma, otterrai il seguente output:

Image Processed

Se apri il percorso specificato, puoi osservare l'immagine di output come segue:

È possibile eseguire l'operazione di filtro SQRBox su un'immagine utilizzando il boxFilter() metodo del imgprocclasse. Di seguito è riportata la sintassi di questo metodo:

sqrBoxFilter(src, dst, ddepth, ksize)

Questo metodo accetta i seguenti parametri:

• src - A Mat oggetto che rappresenta la sorgente (immagine in ingresso) per questa operazione.

• dst - A Mat oggetto che rappresenta la destinazione (immagine di output) per questa operazione.

• ddepth - Una variabile di tipo intero che rappresenta la profondità dell'immagine di output.

• ksize - A Size oggetto che rappresenta la dimensione del kernel sfocato.

Esempio

Il seguente programma mostra come eseguire l'operazione di filtro Sqrbox su una determinata immagine.

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

Supponiamo che la seguente sia l'immagine in ingresso filter_input.jpg specificato nel programma di cui sopra.

Produzione

All'esecuzione del programma, otterrai il seguente output:

Image Processed

Se apri il percorso specificato, puoi osservare l'immagine di output come segue:

L'operazione Filter2D convolge un'immagine con il kernel. È possibile eseguire questa operazione su un'immagine utilizzando ilFilter2D() metodo del imgprocclasse. Di seguito è riportata la sintassi di questo metodo:

filter2D(src, dst, ddepth, kernel)

Questo metodo accetta i seguenti parametri:

• src - A Mat oggetto che rappresenta la sorgente (immagine in ingresso) per questa operazione.

• dst - A Mat oggetto che rappresenta la destinazione (immagine di output) per questa operazione.

• ddepth - Una variabile di tipo intero che rappresenta la profondità dell'immagine di output.

• kernel - A Mat oggetto che rappresenta il kernel di convoluzione.

Esempio

Il seguente programma mostra come eseguire l'operazione Filter2D su un'immagine.

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

Supponiamo che la seguente sia l'immagine in ingresso filter_input.jpg specificato nel programma di cui sopra.

Produzione

All'esecuzione del programma, otterrai il seguente output:

Image Processed

Se apri il percorso specificato, puoi osservare l'immagine di output come segue:

Erosione e dilatazione sono i due tipi di operazioni morfologiche. Come suggerisce il nome, le operazioni morfologiche sono l'insieme di operazioni che elaborano le immagini in base alle loro forme.

Sulla base dell'immagine di input fornita viene sviluppato un "elemento strutturale". Questo potrebbe essere fatto in una qualsiasi delle due procedure. Questi hanno lo scopo di rimuovere il rumore e sistemare le imperfezioni, per rendere l'immagine chiara.

Dilatazione

Questa procedura segue la convoluzione con un nucleo di una forma specifica come un quadrato o un cerchio. Questo kernel ha un punto di ancoraggio, che ne indica il centro.

Questo kernel è sovrapposto all'immagine per calcolare il valore massimo dei pixel. Dopo il calcolo, l'immagine viene sostituita con l'ancora al centro. Con questa procedura, le aree delle regioni luminose crescono di dimensioni e quindi la dimensione dell'immagine aumenta.

Ad esempio, la dimensione di un oggetto in tonalità bianca o tonalità chiara aumenta, mentre la dimensione di un oggetto in tonalità nera o tonalità scura diminuisce.

È possibile eseguire l'operazione di dilatazione su un'immagine utilizzando il dilate() metodo del imgprocclasse. Di seguito è riportata la sintassi di questo metodo.

dilate(src, dst, kernel)

Questo metodo accetta i seguenti parametri:

• src - A Mat oggetto che rappresenta la sorgente (immagine in ingresso) per questa operazione.

• dst - A Mat oggetto che rappresenta la destinazione (immagine di output) per questa operazione.

• kernel - A Mat oggetto che rappresenta il kernel.

Esempio

È possibile preparare la matrice del kernel utilizzando il getStructuringElement()metodo. Questo metodo accetta un numero intero che rappresenta il filemorph_rect tipo e un oggetto del tipo Size.

Imgproc.getStructuringElement(int shape, Size ksize);

Il seguente programma mostra come eseguire l'operazione di dilatazione su una data immagine.

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

Ingresso

Supponiamo che la seguente sia l'immagine in ingresso sample.jpg specificato nel programma di cui sopra.

Produzione

All'esecuzione del programma, otterrai il seguente output:

Image Processed

Se apri il percorso specificato, puoi osservare l'immagine di output come segue:

L'erosione è un processo abbastanza simile alla dilatazione. Ma il valore del pixel calcolato qui è minimo piuttosto che massimo in dilatazione. L'immagine viene sostituita sotto il punto di ancoraggio con quel valore minimo di pixel.

Con questa procedura, le aree delle regioni scure aumentano di dimensioni e le regioni luminose si riducono. Ad esempio, la dimensione di un oggetto in tonalità scura o nera aumenta, mentre diminuisce in tonalità bianca o tonalità chiara.

Esempio

È possibile eseguire questa operazione su un'immagine utilizzando il erode() metodo del imgprocclasse. Di seguito è riportata la sintassi di questo metodo:

erode(src, dst, kernel)

Questo metodo accetta i seguenti parametri:

• src - A Mat oggetto che rappresenta la sorgente (immagine in ingresso) per questa operazione.

• dst - A Mat oggetto che rappresenta la destinazione (immagine di output) per questa operazione.

• kernel - A Mat oggetto che rappresenta il kernel.

È possibile preparare la matrice del kernel utilizzando il getStructuringElement()metodo. Questo metodo accetta un numero intero che rappresenta il filemorph_rect tipo e un oggetto del tipo Size.

Imgproc.getStructuringElement(int shape, Size ksize);

Il seguente programma mostra come eseguire l'operazione di erosione su una data immagine.

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

Supponiamo che la seguente sia l'immagine in ingresso sample.jpg specificato nel programma di cui sopra.

Produzione

All'esecuzione del programma, otterrai il seguente output:

Image Loaded

Se apri il percorso specificato, puoi osservare l'immagine di output come segue:

Nei capitoli precedenti, abbiamo discusso il processo di erosion e dilation. Oltre a questi due, OpenCV ha più trasformazioni morfologiche. IlmorphologyEx() del metodo della classe Imgproc viene utilizzato per eseguire queste operazioni su una determinata immagine.

Di seguito è riportata la sintassi di questo metodo:

morphologyEx(src, dst, op, kernel)

Questo metodo accetta i seguenti parametri:

• src - Un oggetto della classe Mat che rappresenta l'immagine sorgente (ingresso).

• dst - oggetto della classe Mat che rappresenta l'immagine di destinazione (output).

• op - Un numero intero che rappresenta il tipo di operazione morfologica.

• kernel - Una matrice del kernel.

Esempio

Il seguente programma mostra come applicare l'operazione morfologica "top-hat" su un'immagine utilizzando la libreria OpenCV.

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

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

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

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

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

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

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

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

Supponiamo che la seguente sia l'immagine in ingresso morph_input.jpg specificato nel programma di cui sopra.

Produzione

All'esecuzione del programma, otterrai il seguente output:

Image Processed

Se apri il percorso specificato, puoi osservare l'immagine di output come segue:

Più operazioni

Oltre all'operazione morfologica TOPHAT, dimostrato nel precedente example, OpenCV soddisfa vari altri tipi di morfologie. Tutti questi tipi sono rappresentati da campi statici predefiniti (valori fissi) diImgproc classe.

Puoi scegliere il tipo di morfologia di cui hai bisogno passando il rispettivo valore predefinito al parametro op del morphologyEx() metodo.

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

Di seguito sono riportati i valori che rappresentano il tipo di operazioni morfologiche e le rispettive uscite.

Funzionamento e descrizione	Produzione
MORPH_BLACKHAT
MORPH_CLOSE
MORPH_CROSS
MORPH_DILATE
MORPH_ELLIPSE
MORPH_ERODE
MORPH_GRADIENT
MORPH_OPEN
MORPH_RECT
MORPH_TOPHAT

Pyramid è un'operazione su un'immagine in cui,

• Un'immagine in ingresso viene inizialmente levigata utilizzando un particolare filtro di levigatura (es: gaussiano, laplaciano) e quindi l'immagine levigata viene sottocampionata.

• Questo processo viene ripetuto più volte.

Durante l'operazione piramidale, la levigatezza dell'immagine viene aumentata e la risoluzione (dimensione) viene ridotta.

Pyramid Up

In Pyramid Up, l'immagine viene inizialmente sovracampionata e quindi sfocata. È possibile eseguire l'operazione Pyramid Up su un'immagine utilizzando ilpyrUP() metodo del imgprocclasse. Di seguito è riportata la sintassi di questo metodo:

pyrUp(src, dst, dstsize, borderType)

Questo metodo accetta i seguenti parametri:

• src - Un oggetto della classe Mat che rappresenta l'immagine sorgente (ingresso).

• mat - Un oggetto della classe Mat che rappresenta l'immagine di destinazione (output).

• size - Un oggetto della classe Size che rappresenta la dimensione alla quale l'immagine deve essere aumentata o diminuita.

• borderType - Una variabile di tipo intero che rappresenta il tipo di bordo da utilizzare.

Esempio

Il seguente programma mostra come eseguire l'operazione Pyramid Up su un'immagine.

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

Supponiamo che la seguente sia l'immagine in ingresso pyramid_input.jpg specificato nel programma di cui sopra.

Produzione

All'esecuzione del programma, otterrai il seguente output:

Image Processed

Se apri il percorso specificato, puoi osservare l'immagine di output come segue:

Piramide verso il basso

In Pyramid Down, l'immagine è inizialmente sfocata e poi sottocampionata. È possibile eseguire l'operazione Pyramid Down su un'immagine utilizzando ilpyrDown() metodo del imgprocclasse. Di seguito è riportata la sintassi di questo metodo:

pyrDown(src, dst, dstsize, borderType)

Questo metodo accetta i seguenti parametri:

• src - Un oggetto della classe Mat che rappresenta l'immagine sorgente (ingresso).

• mat - Un oggetto della classe Mat che rappresenta l'immagine di destinazione (output).

• size - Un oggetto della classe Size che rappresenta la dimensione alla quale l'immagine deve essere aumentata o diminuita.

• borderType - Una variabile di tipo intero che rappresenta il tipo di bordo da utilizzare.

Esempio

Il seguente programma mostra come eseguire l'operazione Pyramid Down su un'immagine.

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

Supponiamo che la seguente sia l'immagine in ingresso pyramid_input.jpg specificato nel programma di cui sopra.

Produzione

All'esecuzione del programma, otterrai il seguente output:

Image Processed

Se apri il percorso specificato, puoi osservare l'immagine di output come segue:

Filtro a spostamento medio

Nell'operazione piramidale Mean Shifting, viene eseguita una fase iniziale di segmentazione dello spostamento medio di un'immagine.

È possibile eseguire l'operazione di filtraggio a spostamento medio piramidale su un'immagine utilizzando il pyrDown() metodo del imgprocclasse. Di seguito è riportata la sintassi di questo metodo.

pyrMeanShiftFiltering(src, dst, sp, sr)

Questo metodo accetta i seguenti parametri:

• src - Un oggetto della classe Mat che rappresenta l'immagine sorgente (ingresso).

• mat - Un oggetto della classe Mat che rappresenta l'immagine di destinazione (output).

• sp - Una variabile del tipo double che rappresenta il raggio della finestra spaziale.

• sr - Una variabile del tipo double che rappresenta il raggio della finestra del colore.

Esempio

Il seguente programma mostra come eseguire un'operazione di filtraggio a spostamento medio su una data immagine.

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

Supponiamo che la seguente sia l'immagine in ingresso pyramid_input.jpg specificato nel programma di cui sopra.

Produzione

All'esecuzione del programma, otterrai il seguente output:

Image Processed

Se apri il percorso specificato, puoi osservare l'immagine di output come segue:

Il Thresholding è un metodo di segmentazione delle immagini, in generale viene utilizzato per creare immagini binarie. La soglia è di due tipi: soglia semplice e soglia adattiva.

Soglia semplice

Nella semplice operazione di soglia, i pixel i cui valori sono maggiori del valore di soglia specificato, vengono assegnati con un valore standard.

È possibile eseguire una semplice operazione di soglia su un'immagine utilizzando il metodo threshold() del Imgproc classDi seguito è riportata la sintassi di questo metodo.

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

Questo metodo accetta i seguenti parametri:

• src - Un oggetto della classe Mat che rappresenta l'immagine sorgente (ingresso).

• dst - Un oggetto della classe Mat che rappresenta l'immagine di destinazione (output).

• thresh - Una variabile di tipo double che rappresenta il valore di soglia.

• maxval - Una variabile di tipo double che rappresenta il valore da fornire se il valore del pixel è maggiore del valore di soglia.

• type - Una variabile di tipo intero che rappresenta il tipo di soglia da utilizzare.

Esempio

Il seguente programma mostra come eseguire una semplice operazione di soglia su un'immagine in OpenCV.

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

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

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

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

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

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

Supponiamo che la seguente sia l'immagine in ingresso thresh_input.jpg specificato nel programma di cui sopra.

Produzione

All'esecuzione del programma, otterrai il seguente output:

Image Processed

Se apri il percorso specificato, puoi osservare l'immagine di output come segue:

Altri tipi di soglia semplice

In aggiunta a THRESH_BINARYoperazione dimostrata nell'esempio precedente, OpenCV soddisfa vari altri tipi di operazioni di soglia. Tutti questi tipi sono rappresentati da campi statici predefiniti (valori fissi) diImgproc classe.

È possibile scegliere il tipo di operazione di soglia necessaria, passando il rispettivo valore predefinito al parametro denominato type del threshold() metodo.

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

Di seguito sono riportati i valori che rappresentano i vari tipi di operazioni di soglia e le rispettive uscite.

Funzionamento e descrizione	Produzione
THRESH_BINARY
THRESH_BINARY_INV
THRESH_TRUNC
THRESH_TOZERO
THRESH_TOZERO_INV

In simple thresholding, il valore di soglia è globale, cioè è lo stesso per tutti i pixel dell'immagine. Adaptive thresholding è il metodo in cui il valore di soglia viene calcolato per le regioni più piccole e, pertanto, ci saranno valori di soglia diversi per le diverse regioni.

In OpenCV, puoi eseguire un'operazione di soglia adattiva su un'immagine utilizzando il metodo adaptiveThreshold() del Imgprocclasse. Di seguito è riportata la sintassi di questo metodo.

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

Questo metodo accetta i seguenti parametri:

• src - Un oggetto della classe Mat che rappresenta l'immagine sorgente (ingresso).

• dst - Un oggetto della classe Mat che rappresenta l'immagine di destinazione (output).

• maxValue - Una variabile di tipo double che rappresenta il valore da fornire se il valore del pixel è maggiore del valore di soglia.

• adaptiveMethod- Una variabile di numero intero il tipo che rappresenta il metodo adattivo da utilizzare. Questo sarà uno dei seguenti due valori

  • ADAPTIVE_THRESH_MEAN_C - il valore di soglia è la media dell'area di vicinato.

  • ADAPTIVE_THRESH_GAUSSIAN_C - il valore di soglia è la somma ponderata dei valori di vicinato dove i pesi sono una finestra gaussiana.

• thresholdType - Una variabile di tipo intero che rappresenta il tipo di soglia da utilizzare.

• blockSize - Una variabile di tipo intero che rappresenta la dimensione del pixel vicino utilizzato per calcolare il valore di soglia.

• C - Una variabile di tipo double che rappresenta la costante utilizzata in entrambi i metodi (sottratta dalla media o dalla media ponderata).

Esempio

Il seguente programma mostra come eseguire l'operazione di soglia adattiva su un'immagine in OpenCV. Qui stiamo scegliendo la soglia adattiva del tipobinary e ADAPTIVE_THRESH_MEAN_C per il metodo della soglia.

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

Supponiamo che la seguente sia l'immagine in ingresso thresh_input.jpg specificato nel programma di cui sopra.



Produzione

All'esecuzione del programma, otterrai il seguente output:

Image Processed

Se apri il percorso specificato, puoi osservare l'immagine di output come segue:



Altri tipi di soglia adattiva

In aggiunta a ADAPTIVE_THRESH_MEAN_C come metodo adattivo e THRESH_BINARY come tipo di soglia, come mostrato nell'esempio precedente, possiamo scegliere più combinazioni di questi due valori.

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

Di seguito sono riportati i valori che rappresentano varie combinazioni di valori per i parametri adaptiveMethod e thresholdType e le rispettive uscite.

AdaptiveMethod / thresholdType	ADAPTIVE_THRESH_MEAN_C	ADAPTIVE_THRESH_GAUSSIAN_C:
THRESH_BINARY
THRESH_BINARY_INV

Questo capitolo ti insegna come rospare i bordi di un'immagine.

Il metodo copyMakeBorder ()

È possibile aggiungere vari bordi a un'immagine utilizzando il metodo copyMakeBorder() della classe denominata Core, che appartiene al pacchetto org.opencv.core. la seguente è la sintassi di questo metodo.

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

Questo metodo accetta i seguenti parametri:

• src - Un oggetto della classe Mat che rappresenta l'immagine sorgente (ingresso).

• dst - Un oggetto della classe Mat che rappresenta l'immagine di destinazione (output).

• top - Una variabile di numero intero il tipo intero che rappresenta la lunghezza del bordo nella parte superiore dell'immagine.

• bottom - Una variabile di numero intero il tipo intero che rappresenta la lunghezza del bordo nella parte inferiore dell'immagine.

• left - Una variabile di numero intero il tipo intero che rappresenta la lunghezza del bordo a sinistra dell'immagine.

• right - Una variabile di numero intero il tipo intero che rappresenta la lunghezza del bordo a destra dell'immagine.

• borderType - Una variabile di tipo intero che rappresenta il tipo di bordo che deve essere utilizzato.

Esempio

Il seguente programma è un esempio che dimostra come aggiungere un bordo a una data immagine.

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

Supponiamo che la seguente sia l'immagine in ingresso thresh_input.jpg specificato nel programma di cui sopra.



Produzione

All'esecuzione del programma, otterrai il seguente output:

Image Processed

Se apri il percorso specificato, puoi osservare l'immagine di output come segue:



Altri tipi di bordi

Oltre al tipo di bordo, BORDER_CONSTANTdimostrato nell'esempio precedente, OpenCV soddisfa vari altri tipi di bordi. Tutti questi tipi sono rappresentati da campi statici predefiniti (valori fissi) della classe Core.

È possibile scegliere il tipo di operazione di soglia necessaria, passando il rispettivo valore predefinito al parametro denominato borderType del copyMakeBorder() metodo.

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

Di seguito sono riportati i valori che rappresentano i vari tipi di operazioni ai confini e le rispettive uscite.

Funzionamento e descrizione	Produzione
BORDER_CONSTANT
BORDER_ISOLATED
BORDER_DEFAULT
BORDER_REFLECT
BORDER_REFLECT_101
BORDER_REFLECT101
BORDER_REPLICATE
BORDER_WRAP

Usando il sobel operation, puoi rilevare i bordi di un'immagine sia in direzione orizzontale che verticale. È possibile applicare l'operazione sobel su un'immagine utilizzando il metodosobel(). Di seguito è riportata la sintassi di questo metodo:

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

Questo metodo accetta i seguenti parametri:

• src - Un oggetto della classe Mat che rappresenta l'immagine sorgente (ingresso).

• dst - Un oggetto della classe Mat che rappresenta l'immagine di destinazione (output).

• ddepth - Una variabile intera che rappresenta la profondità dell'immagine (-1)

• dx- Una variabile intera che rappresenta la derivata x. (0 o 1)

• dy- Una variabile intera che rappresenta la derivata y. (0 o 1)

Esempio

Il seguente programma mostra come eseguire l'operazione Sobel su una data immagine.

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

Supponiamo che la seguente sia l'immagine in ingresso sobel_input.jpg specificato nel programma di cui sopra.



Produzione

All'esecuzione del programma, otterrai il seguente output:

Image Processed

Se apri il percorso specificato, puoi osservare l'immagine di output come segue:



Varianti sobel

Passando valori diversi all'ultimo ai parametri (dx e dy) (tra 0 e 1), si ottengono output diversi -

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

La tabella seguente elenca vari valori per le variabili dx e dy del metodo Sobel() e le rispettive uscite.

Derivato X.	Derivata Y.	Produzione
0	1
1	0
1	1

Scharr viene utilizzato anche per rilevare le derivate seconde di un'immagine in direzione orizzontale e verticale. È possibile eseguire l'operazione scharr su un'immagine utilizzando il metodoscharr(). Di seguito è riportata la sintassi di questo metodo:

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

Questo metodo accetta i seguenti parametri:

• src - Un oggetto della classe Mat che rappresenta l'immagine sorgente (ingresso).

• dst - Un oggetto della classe Mat che rappresenta l'immagine di destinazione (output).

• ddepth - Una variabile intera che rappresenta la profondità dell'immagine (-1)

• dx- Una variabile intera che rappresenta la derivata x. (0 o 1)

• dy- Una variabile intera che rappresenta la derivata y. (0 o 1)

Esempio

Il seguente programma mostra come applicare scharr a una data immagine.

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

Supponiamo che la seguente sia l'immagine in ingresso scharr_input.jpg specificato nel programma di cui sopra.



Produzione

Eseguendolo, otterrai il seguente output:

Image Processed

Se apri il percorso specificato puoi osservare l'immagine di output come segue:



Più derivati ​​scharr

Passando valori diversi all'ultimo ai parametri (dx e dy) (tra 0 e 1) si ottengono output differenti -

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

Di seguito è riportata una tabella che elenca vari valori per le variabili dx e dy del metodo scharr() e le rispettive uscite.

Derivato X.	Derivata Y.	Produzione
0	1
1	0

L'operatore laplaciano è anche un operatore derivato utilizzato per trovare i bordi in un'immagine. È una maschera derivata del secondo ordine. In questa maschera abbiamo altre due classificazioni: una è Operatore laplaciano positivo e l'altra è Operatore laplaciano negativo.

A differenza di altri operatori, Laplacian non ha tolto i bordi in nessuna direzione particolare, ma li toglie nella classificazione successiva.

• Bordi interni
• Bordi esterni

Puoi esibirti Laplacian Transform operazione su un'immagine utilizzando il Laplacian() metodo del imgproc class, la seguente è la sintassi di questo metodo.

Laplacian(src, dst, ddepth)

Questo metodo accetta i seguenti parametri:

• src - A Mat oggetto che rappresenta la sorgente (immagine in ingresso) per questa operazione.

• dst - A Mat oggetto che rappresenta la destinazione (immagine di output) per questa operazione.

• ddepth - Una variabile di tipo intero che rappresenta la profondità dell'immagine di destinazione.

Esempio

Il seguente programma mostra come eseguire l'operazione di trasformazione di Laplace su una data immagine.

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

Supponiamo che la seguente sia l'immagine in ingresso laplacian_input.jpg specificato nel programma di cui sopra.



Produzione

All'esecuzione del programma, otterrai il seguente output:

Image Processed

Se apri il percorso specificato, puoi osservare l'immagine di output come segue:



Il distance transformL'operatore generalmente prende le immagini binarie come input. In questa operazione, le intensità del livello di grigio dei punti all'interno delle regioni in primo piano vengono modificate per distanziare le rispettive distanze dal valore 0 più vicino (confine).

È possibile applicare la trasformazione della distanza in OpenCV utilizzando il metodo distanceTransform(). Di seguito è riportata la sintassi di questo metodo.

distanceTransform(src, dst, distanceType, maskSize)

Questo metodo accetta i seguenti parametri:

• src - Un oggetto della classe Mat che rappresenta l'immagine sorgente (ingresso).

• dst - Un oggetto della classe Mat che rappresenta l'immagine di destinazione (output).

• distanceType - Una variabile di tipo intero che rappresenta il tipo di trasformazione della distanza da applicare.

• maskSize - Una variabile di tipo intero che rappresenta la dimensione della maschera da utilizzare.

Esempio

Il seguente programma mostra come eseguire un'operazione di trasformazione della distanza su una data immagine.

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

Supponiamo che la seguente sia l'immagine in ingresso input.jpg specificato nel programma di cui sopra.

Produzione

All'esecuzione del programma, otterrai il seguente output:

Image Processed

Se apri il percorso specificato, puoi osservare l'immagine di output come segue:

Tipi di operazioni di trasformazione della distanza

Oltre al tipo di operazione a distanza DIST_Cdimostrato nell'esempio precedente, OpenCV soddisfa vari altri tipi di operazioni di trasformazione della distanza. Tutti questi tipi sono rappresentati da campi statici predefiniti (valori fissi) della classe Imgproc.

È possibile scegliere il tipo di operazione di trasformazione della distanza necessaria, passando il rispettivo valore predefinito al parametro denominato distanceType del distanceTransform() metodo.

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

Di seguito sono riportati i valori che rappresentano vari tipi di distanceTransform operazioni e le rispettive uscite.

Funzionamento e descrizione	Produzione
DIST_C
DIST_L1
DIST_L2
DIST_LABEL_PIXEL
DIST_MASK_3

In questo capitolo impareremo come usare OpenCV per catturare fotogrammi usando la fotocamera del sistema. IlVideoCapture classe di org.opencv.videoiopacchetto contiene classi e metodi per acquisire video utilizzando la fotocamera. Andiamo passo dopo passo e impariamo come catturare i fotogrammi -

Passaggio 1: carica la libreria nativa di OpenCV

Durante la scrittura del codice Java utilizzando la libreria OpenCV, il primo passo che devi fare è caricare la libreria nativa di OpenCV utilizzando il loadLibrary(). Carica la libreria nativa di OpenCV come mostrato di seguito.

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

Passaggio 2: crea un'istanza della classe di acquisizione video

Istanziare la classe Mat utilizzando una delle funzioni menzionate in questo tutorial in precedenza.

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

Passaggio 3: leggere i frame

È possibile leggere i fotogrammi dalla fotocamera utilizzando il read() metodo del VideoCaptureclasse. Questo metodo accetta un oggetto della classeMat per memorizzare il frame letto.

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

Esempio

Il seguente programma mostra come acquisire un fotogramma utilizzando la fotocamera e visualizzarlo utilizzando la finestra JavaFX. Salva anche il fotogramma catturato.

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

Produzione

All'esecuzione del programma, otterrai il seguente output.

Se apri il percorso specificato, puoi osservare lo stesso frame salvato come file jpg.

Il VideoCapture classe di org.opencv.videoiopacchetto contiene classi e metodi per acquisire video utilizzando la fotocamera di sistema. Andiamo passo dopo passo e impariamo come farlo.

Passaggio 1: carica la libreria nativa di OpenCV

Durante la scrittura del codice Java utilizzando la libreria OpenCV, il primo passo che devi fare è caricare la libreria nativa di OpenCV utilizzando il loadLibrary(). Carica la libreria nativa di OpenCV come mostrato di seguito.

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

Passaggio 2: creare un'istanza della classe CascadeClassifier

Il CascadeClassifier classe del pacchetto org.opencv.objdetectviene utilizzato per caricare il file di classificazione. Istanziare questa classe passando ilxml file lbpcascade_frontalface.xml come mostrato di seguito.

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

Passaggio 3: rileva i volti

È possibile rilevare i volti nell'immagine utilizzando il metodo detectMultiScale() della classe denominata CascadeClassifier. Questo metodo accetta un oggetto della classeMat tenendo l'immagine di input e un oggetto della classe MatOfRect per memorizzare i volti rilevati.

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

Esempio

Il seguente programma mostra come rilevare i volti in un'immagine.

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

Supponiamo che la seguente sia l'immagine in ingresso facedetection_input.jpg specificato nel programma di cui sopra.

Produzione

All'esecuzione del programma, otterrai il seguente output:

Detected 3 faces 
Image Processed

Se apri il percorso specificato, puoi osservare l'immagine di output come segue:

Il seguente programma dimostra come rilevare i volti utilizzando la fotocamera del sistema e visualizzarli utilizzando la finestra JavaFX.

Esempio

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

Produzione

All'esecuzione del programma, otterrai il seguente output.

Se apri il percorso specificato, puoi vedere la stessa istantanea salvata come file jpg Immagine.

Puoi esibirti affine translation su un'immagine utilizzando il warpAffine()metodo della classe imgproc. Di seguito è riportata la sintassi di questo metodo:

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

Questo metodo accetta i seguenti parametri:

• src - A Mat oggetto che rappresenta la sorgente (immagine in ingresso) per questa operazione.

• dst - A Mat oggetto che rappresenta la destinazione (immagine di output) per questa operazione.

• tranformMatrix - A Mat oggetto che rappresenta la matrice di trasformazione.

• size - Una variabile di tipo intero che rappresenta la dimensione dell'immagine di output.

Esempio

Il seguente programma mostra come applicare un'operazione affine su una data immagine.

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

Supponiamo che la seguente sia l'immagine in ingresso transform_input.jpg specificato nel programma di cui sopra.

Produzione

Eseguendolo, otterrai il seguente output:

Image Processed

Se apri il percorso specificato, puoi osservare l'immagine di output come segue:

Puoi perform rotation operazione su un'immagine utilizzando il warpAffine() metodo del imgprocclasse. Di seguito è riportata la sintassi di questo metodo:

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

Questo metodo accetta i seguenti parametri:

• src - A Mat oggetto che rappresenta la sorgente (immagine in ingresso) per questa operazione.

• dst - A Mat oggetto che rappresenta la destinazione (immagine di output) per questa operazione.

• rotationMatrix - A Mat oggetto che rappresenta la matrice di rotazione.

• size - Una variabile di tipo intero che rappresenta la dimensione dell'immagine di output.

Esempio

Il seguente programma mostra come ruotare un'immagine.

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

Supponiamo che la seguente sia l'immagine in ingresso transform_input.jpg specificato nel programma di cui sopra.

Produzione

All'esecuzione del programma, otterrai il seguente output:

Image Processed

Se apri il percorso specificato, puoi osservare l'immagine di output come segue:

Puoi esibirti scaling su un'immagine utilizzando il resize() metodo del imgprocclasse. Di seguito è riportata la sintassi di questo metodo.

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

Questo metodo accetta i seguenti parametri:

• src - A Mat oggetto che rappresenta la sorgente (immagine in ingresso) per questa operazione.

• dst - A Mat oggetto che rappresenta la destinazione (immagine di output) per questa operazione.

• dsize - A Size oggetto che rappresenta la dimensione dell'immagine di output.

• fx - Una variabile di tipo double che rappresenta il fattore di scala lungo l'asse orizzontale.

• fy - Una variabile di tipo double che rappresenta il fattore di scala lungo l'asse verticale.

• Interpolation - Una variabile intera che rappresenta il metodo di interpolazione.

Esempio

Il seguente programma mostra come applicare scale transformation a un'immagine.

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

Supponiamo che la seguente sia l'immagine in ingresso transform_input.jpg specificato nel programma sopra (dimensioni - Larghezza: 300 px e altezza: 300 px).

Produzione

All'esecuzione del programma, otterrai il seguente output:

Image Processed

Se apri il percorso specificato, puoi osservare l'immagine di output come segue (dimensioni - Larghezza: 600 px e altezza: 600 px) -

In OpenCV, puoi applicare diverse mappe di colori a un'immagine utilizzando il metodo applyColorMap() della classe Imgproc. Di seguito è riportata la sintassi di questo metodo:

applyColorMap(Mat src, Mat dst, int colormap)

Accetta tre parametri:

• src - Un oggetto della classe Mat che rappresenta l'immagine sorgente (ingresso).

• dst - Un oggetto della classe Mat che rappresenta l'immagine di destinazione (output).

• colormap - Una variabile di tipo intero che rappresenta il tipo di mappa dei colori da applicare.

Esempio

Il seguente programma mostra come applicare color map a un'immagine.

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

Supponiamo che la seguente sia l'immagine in ingresso color_input.jpg specificato nel programma di cui sopra.

Produzione

Eseguendo il programma sopra, otterrai il seguente output:

Image Processed

Se apri il percorso specificato, puoi osservare l'immagine di output come segue:

Più operazioni

Inoltre COLORMAP_HOTdimostrato nell'esempio precedente, OpenCV soddisfa vari altri tipi di mappe dei colori. Tutti questi tipi sono rappresentati da campi statici predefiniti (valori fissi) della classe Imgproc.

È possibile scegliere il tipo di mappa di colori di cui si ha bisogno, passando il rispettivo valore predefinito al parametro denominato colormap del applyColorMap() metodo.

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

Di seguito sono riportati i valori che rappresentano i vari tipi di mappe dei colori e i rispettivi output.

Funzionamento e descrizione	Produzione
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 viene utilizzato per rilevare i bordi in un'immagine. Accetta un'immagine in scala di grigi come input e utilizza un algoritmo multistadio.

È possibile eseguire questa operazione su un'immagine utilizzando il Canny() metodo del imgproc class, la seguente è la sintassi di questo metodo.

Canny(image, edges, threshold1, threshold2)

Questo metodo accetta i seguenti parametri:

• image - A Mat oggetto che rappresenta la sorgente (immagine in ingresso) per questa operazione.

• edges - A Mat oggetto che rappresenta la destinazione (bordi) per questa operazione.

• threshold1 - Una variabile di tipo double che rappresenta la prima soglia per la procedura di isteresi.

• threshold2 - Una variabile di tipo double che rappresenta la seconda soglia per la procedura di isteresi.

Esempio

Il seguente programma è un esempio che dimostra come eseguire l'operazione Canny Edge Detection su una data immagine.

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

Supponiamo che la seguente sia l'immagine in ingresso canny_input.jpg specificato nel programma di cui sopra.

Produzione

Eseguendo il programma sopra, otterrai il seguente output:

Image Processed

Se apri il percorso specificato, puoi osservare l'immagine di output come segue:

È possibile rilevare la forma di una data immagine applicando il Hough Transform technique utilizzando il metodo HoughLines() del Imgprocclasse. Di seguito è riportata la sintassi di questo metodo.

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

Questo metodo accetta i seguenti parametri:

• image - Un oggetto della classe Mat che rappresenta l'immagine sorgente (ingresso).

• lines - Un oggetto della classe Mat che memorizza il vettore che memorizza i parametri (r, Φ) delle linee.

• rho - Una variabile di tipo double che rappresenta la risoluzione del parametro r in pixel.

• theta - Una variabile di tipo double che rappresenta la risoluzione del parametro Φ in radianti.

• threshold - Una variabile di tipo intero che rappresenta il numero minimo di intersezioni per "rilevare" una linea.

Esempio

Il seguente programma mostra come rilevare le linee di Hough in una data immagine.

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

Supponiamo che la seguente sia l'immagine in ingresso hough_input.jpg specificato nel programma di cui sopra.

Produzione

All'esecuzione del programma, otterrai il seguente output:

143 
1 
Image Processed

Se apri il percorso specificato, puoi osservare l'immagine di output come segue:

Il histogramdi un'immagine mostra la frequenza dei valori di intensità dei pixel. In un istogramma dell'immagine, l'asse X mostra le intensità del livello di grigio e l'asse Y mostra la frequenza di queste intensità.

Histogram equalizationmigliora il contrasto di un'immagine, al fine di allungare la gamma di intensità. Puoi equalizzare l'istogramma di una data immagine usando il metodoequalizeHist() del Imgprocclasse. Di seguito è riportata la sintassi di questo metodo.

equalizeHist(src, dst)

Questo metodo accetta i seguenti parametri:

• src - Un oggetto della classe Mat che rappresenta l'immagine sorgente (ingresso).

• dst - Un oggetto della classe Matche rappresenta l'output. (Immagine ottenuta dopo aver equalizzato l'istogramma)

Esempio

Il seguente programma mostra come equalizzare l'istogramma di una data immagine.

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

Supponiamo che la seguente sia l'immagine in ingresso histo_input.jpg specificato nel programma di cui sopra.

Produzione

All'esecuzione del programma, otterrai il seguente output:

Image Processed

Se apri il percorso specificato, puoi osservare l'immagine di output come segue: