OpenCV - Guía rápida

OpenCV es una biblioteca multiplataforma con la que podemos desarrollar en tiempo real computer vision applications. Se centra principalmente en el procesamiento de imágenes, la captura y el análisis de vídeo, incluidas funciones como la detección de rostros y la detección de objetos.

Comencemos el capítulo definiendo el término "Visión por computadora".

Visión por computador

La Visión por Computador se puede definir como una disciplina que explica cómo reconstruir, interrumpir y comprender una escena 3D a partir de sus imágenes 2D, en términos de las propiedades de la estructura presente en la escena. Se trata de modelar y replicar la visión humana utilizando software y hardware de computadora.

Computer Vision se superpone significativamente con los siguientes campos:

Image Processing - Se centra en la manipulación de imágenes.
Pattern Recognition - Explica diversas técnicas para clasificar patrones.
Photogrammetry - Se ocupa de obtener medidas precisas a partir de imágenes.

Visión por computadora Vs Procesamiento de imágenes

Image processingse ocupa de la transformación de imagen a imagen. La entrada y la salida del procesamiento de imágenes son imágenes.

Computer visiones la construcción de descripciones explícitas y significativas de objetos físicos a partir de su imagen. El resultado de la visión por computadora es una descripción o una interpretación de estructuras en una escena 3D.

Aplicaciones de la visión por computadora

Aquí hemos enumerado algunos de los principales dominios en los que Computer Vision se usa mucho.

Aplicación de robótica

Localización: determina la ubicación del robot automáticamente
Navigation
Evitación de obstáculos
Montaje (clavija en agujero, soldadura, pintura)
Manipulación (por ejemplo, manipulador de robot PUMA)
Interacción de robot humano (HRI): robótica inteligente para interactuar y servir a las personas

Aplicación de medicina

Clasificación y detección (por ejemplo, clasificación de lesiones o células y detección de tumores)
Segmentación 2D / 3D
Reconstrucción de órganos humanos en 3D (resonancia magnética o ultrasonido)
Cirugía robótica guiada por visión

Aplicación de automatización industrial

Inspección industrial (detección de defectos)
Assembly
Lectura de códigos de barras y etiquetas de paquetes
Clasificación de objetos
Comprensión de documentos (por ejemplo, OCR)

Aplicación de seguridad

Biometría (iris, huellas dactilares, reconocimiento facial)
Vigilancia: detección de determinadas actividades o comportamientos sospechosos

Solicitud de transporte

Vehículo autónomo
Seguridad, por ejemplo, vigilancia de la vigilancia del conductor

Características de la biblioteca OpenCV

Usando la biblioteca OpenCV, puede:

Leer y escribir imágenes
Captura y guarda videos
Procesar imágenes (filtrar, transformar)
Realizar detección de características
Detecta objetos específicos como rostros, ojos, autos, en los videos o imágenes.
Analizar el video, es decir, estimar el movimiento en él, restar el fondo y rastrear los objetos en él.

OpenCV se desarrolló originalmente en C ++. Además, se proporcionaron enlaces de Python y Java. OpenCV se ejecuta en varios sistemas operativos como Windows, Linux, OSx, FreeBSD, Net BSD, Open BSD, etc.

Este tutorial explica los conceptos de OpenCV con ejemplos que utilizan enlaces de Java.

Módulos de biblioteca OpenCV

A continuación se muestran los principales módulos de la biblioteca de OpenCV.

Funcionalidad central

Este módulo cubre las estructuras de datos básicas como escalar, punto, rango, etc., que se utilizan para construir aplicaciones OpenCV. Además de estos, también incluye la matriz multidimensionalMat, que se utiliza para almacenar las imágenes. En la biblioteca Java de OpenCV, este módulo se incluye como un paquete con el nombreorg.opencv.core.

Procesamiento de imágenes

Este módulo cubre varias operaciones de procesamiento de imágenes como filtrado de imágenes, transformaciones de imágenes geométricas, conversión de espacio de color, histogramas, etc. En la biblioteca Java de OpenCV, este módulo se incluye como un paquete con el nombre org.opencv.imgproc.

Vídeo

Este módulo cubre los conceptos de análisis de video como estimación de movimiento, sustracción de fondo y seguimiento de objetos. En la biblioteca Java de OpenCV, este módulo se incluye como un paquete con el nombreorg.opencv.video.

E / S de video

Este módulo explica la captura de video y los códecs de video usando la biblioteca OpenCV. En la biblioteca Java de OpenCV, este módulo se incluye como un paquete con el nombreorg.opencv.videoio.

calib3d

Este módulo incluye algoritmos relacionados con los algoritmos básicos de geometría de múltiples vistas, calibración de cámara única y estéreo, estimación de la pose de objeto, correspondencia estéreo y elementos de reconstrucción 3D. En la biblioteca Java de OpenCV, este módulo se incluye como un paquete con el nombreorg.opencv.calib3d.

características2d

Este módulo incluye los conceptos de detección y descripción de características. En la biblioteca Java de OpenCV, este módulo se incluye como un paquete con el nombreorg.opencv.features2d.

Objdetect

Este módulo incluye la detección de objetos e instancias de las clases predefinidas como rostros, ojos, tazas, personas, autos, etc. En la biblioteca Java de OpenCV, este módulo se incluye como un paquete con el nombre org.opencv.objdetect.

Highgui

Esta es una interfaz fácil de usar con capacidades de interfaz de usuario simples. En la biblioteca Java de OpenCV, las características de este módulo se incluyen en dos paquetes diferentes, a saber,org.opencv.imgcodecs y org.opencv.videoio.

Una breve historia de OpenCV

OpenCV fue inicialmente una iniciativa de investigación de Intel para asesorar aplicaciones con uso intensivo de CPU. Fue lanzado oficialmente en 1999.

En el año 2006, se lanzó su primera versión principal, OpenCV 1.0.
En octubre de 2009, se lanzó la segunda versión principal, OpenCV 2.
En agosto de 2012, OpenCV fue adquirida por una organización sin fines de lucro, OpenCV.org.

En este capítulo, aprenderá cómo instalar OpenCV y configurar su entorno en su sistema.

Instalación de OpenCV

En primer lugar, debe descargar OpenCV en su sistema. Siga los pasos que se indican a continuación.

Step 1 - Abra la página de inicio de OpenCV haciendo clic en el siguiente enlace: http://opencv.org/ Al hacer clic, verá su página de inicio como se muestra a continuación.

Step 2 - Ahora, haga clic en el Downloadsenlace resaltado en la captura de pantalla anterior. Al hacer clic, se le dirigirá a la página de descargas de OpenCV.

Step 3 - Al hacer clic en el enlace resaltado en la captura de pantalla anterior, un archivo llamado opencv-3.1.0.exese descargará. Extrae este archivo para generar una carpetaopencv en su sistema, como se muestra en la siguiente captura de pantalla.

Step 4 - Abre la carpeta OpenCV → build → java. Aquí encontrará el archivo jar de OpenCV llamadoopencv-310.jar. Guarde este archivo en una carpeta separada para su uso posterior.

Instalación de Eclipse

Después de descargar los archivos JAR necesarios, debe incrustar estos archivos JAR en su entorno Eclipse. Puede hacer esto configurando la ruta de compilación para estos archivos JAR y utilizandopom.xml.

Establecer ruta de compilación

Los siguientes son los pasos para configurar OpenCV en Eclipse:

Step 1- Asegúrese de haber instalado Eclipse en su sistema. Si no es así, descargue e instale Eclipse en su sistema.

Step 2 - Abra Eclipse, haga clic en Archivo, Nuevo y Abra un nuevo proyecto como se muestra en la siguiente captura de pantalla.

Step 3 - Al seleccionar el proyecto, obtendrá el New Projectmago. En este asistente, seleccione el proyecto Java y continúe haciendo clic en elNext , como se muestra en la siguiente captura de pantalla.

Step 4 - Al continuar, se le dirigirá al New Java Project wizard. Cree un nuevo proyecto y haga clic enNext, como se muestra en la siguiente captura de pantalla.

Step 5- Después de crear un nuevo proyecto, haga clic derecho sobre él. SeleccioneBuild Path y haga clic en Configure Build Path… como se muestra en la siguiente captura de pantalla.

Step 6 - Al hacer clic en el Build Path opción, se le dirigirá a la Java Build Path wizard. Haga clic en elAdd External JARs , como se muestra en la siguiente captura de pantalla.

Step 7 - Seleccione la ruta donde ha guardado el archivo opencv-310.jar.

Step 8 - Al hacer clic en el Open en la captura de pantalla anterior, esos archivos se agregarán a su biblioteca.

Step 9 - Al hacer clic OK, agregará con éxito los archivos JAR requeridos al proyecto actual y podrá verificar estas bibliotecas agregadas expandiendo las Bibliotecas de referencia.

Establecer el camino para las bibliotecas nativas

Además de los archivos JAR, debe establecer la ruta para las bibliotecas nativas (archivos DLL) de OpenCV.

Location of DLL files - Abra la carpeta de instalación de OpenCV y ve a la subcarpeta build → java. Aquí encontrarás las dos carpetasx64 (64 bits) y x86 (32 bits) que contienen el dll archivos de OpenCV.

Abra la carpeta respectiva adecuada para su sistema operativo, luego podrá ver la dll archivo, como se muestra en la siguiente captura de pantalla.

Ahora, establezca la ruta para este archivo también siguiendo los pasos que se detallan a continuación:

Step 1- Una vez más, abra la ventana JavaBuildPath. Aquí puede observar el archivo JAR agregado y elJRE System Library.

Step 2 - Al expandirlo, obtendrá las bibliotecas del sistema y Native library location, como se destaca en la siguiente captura de pantalla.

Step 3 - Haga doble clic en el Native library location. Aquí puedes ver elNative Library Folder Configuration window Como se muestra abajo.

Aquí, haga clic en el botón External Folder… y seleccione la ubicación del dll archivo en su sistema.

Para capturar una imagen, utilizamos dispositivos como cámaras y escáneres. Estos dispositivos registran valores numéricos de la imagen (Ej .: valores de píxeles). OpenCV es una biblioteca que procesa las imágenes digitales, por lo tanto, necesitamos almacenar estas imágenes para su procesamiento.

los MatLa clase de biblioteca OpenCV se utiliza para almacenar los valores de una imagen. Representa una matriz n-dimensional y se utiliza para almacenar datos de imágenes de imágenes en escala de grises o en color, volúmenes de voxel, campos vectoriales, nubes de puntos, tensores, histogramas, etc.

Esta clase consta de dos partes de datos: el header y un pointer

Header - Contiene información como el tamaño, el método utilizado para almacenar y la dirección de la matriz (tamaño constante).
Pointer - Almacena los valores de píxeles de la imagen (sigue variando).

La clase Mat

La biblioteca OpenCV Java proporciona esta clase con el mismo nombre (Mat) dentro del paquete org.opencv.core.

Constructores

La clase Mat de la biblioteca OpenCV Java tiene varios constructores, con los que puede construir el objeto Mat.

S. No	Constructores y descripción
1	Mat() Este es el constructor predeterminado sin parámetros en la mayoría de los casos. Usamos esto en el constructor para crear una matriz vacía y pasar esto a otros métodos OpenCV.
2	Mat(int rows, int cols, int type) Este constructor acepta tres parámetros de tipo entero que representan el número de filas y columnas en una matriz 2D y el tipo de matriz (que se utilizará para almacenar datos).
3	Mat(int rows, int cols, int type, Scalar s) Incluyendo los parámetros del anterior, este constructor acepta adicionalmente un objeto de la clase Scalar como parámetro.
4	Mat(Size size, int type) Este constructor acepta dos parámetros, un objeto que representa el tamaño de la matriz y un número entero que representa el tipo de matriz utilizada para almacenar los datos.
5	Mat(Size size, int type, Scalar s) Incluyendo los parámetros del anterior, este constructor acepta adicionalmente un objeto de la clase Scalar como parámetro.
6	Mat(long addr)
7	Mat(Mat m, Range rowRange) Este constructor acepta un objeto de otra matriz y un objeto de la clase Range que representa el rango de las filas que se tomarán para crear una nueva matriz.
8	Mat(Mat m, Range rowRange, Range colRange) Incluyendo los parámetros del anterior, este constructor acepta adicionalmente un objeto de la clase. Rango que representa el rango de la columna.
9	Mat(Mat m, Rect roi) Este constructor acepta dos objetos, uno que representa otra matriz y el otro que representa la Region OF Iinterés.

Note -

Tipo de matriz. Utilice CV_8UC1, ..., CV_64FC4 para crear matrices de 1-4 canales, o CV_8UC (n), ..., CV_64FC (n) para crear matrices multicanal (hasta canales CV_CN_MAX).
El tipo de matrices estuvo representado por varios campos de la clase. CvType que pertenece al paquete org.opencv.core.

Métodos y descripción

A continuación se muestran algunos de los métodos proporcionados por la clase Mat.

S. No	Métodos y descripción
1	Mat col(int x) Este método acepta un parámetro entero que representa el índice de una columna y recupera y devuelve esa columna.
2	Mat row(int y) Este método acepta un parámetro entero que representa el índice de una fila y recupera y devuelve esa fila.
3	int cols() Este método devuelve el número de columnas de la matriz.
4	int rows() Este método devuelve el número de filas de la matriz.
5	Mat setTo(Mat value) Este método acepta un objeto del Mat type y establece los elementos de la matriz en el valor especificado.
6	Mat setTo(Scalar s) Este método acepta un objeto del Scalar type y establece los elementos de la matriz en el valor especificado.

Creación y visualización de la matriz

En esta sección, vamos a discutir nuestro primer ejemplo de OpenCV. Veremos cómo crear y mostrar una matriz OpenCV simple.

A continuación se muestran los pasos a seguir para crear y mostrar una matriz en OpenCV.

Paso 1: Cargue la biblioteca nativa de OpenCV

Mientras escribe código Java usando la biblioteca OpenCV, el primer paso que debe hacer es cargar la biblioteca nativa de OpenCV usando el loadLibrary(). Cargue la biblioteca nativa de OpenCV como se muestra a continuación.

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

Paso 2: crear una instancia de la clase Mat

Cree una instancia de la clase Mat usando cualquiera de las funciones mencionadas anteriormente en este capítulo.

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

Paso 3: llene la matriz usando los métodos

Puede recuperar filas / columnas particulares de una matriz pasando valores de índice a los métodos row()/col().

Y puede establecer valores para estos utilizando cualquiera de las variantes del setTo() métodos.

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

Puede usar el siguiente código de programa para crear y mostrar una matriz simple en Java usando la biblioteca 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()); 
   } 
}

Al ejecutar el programa anterior, obtendrá el siguiente resultado:

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]

Cargando imagen usando la API de JavaSE

los BufferedImage clase de la java.awt.image.BufferedImage El paquete se utiliza para almacenar una imagen y el ImageIO clase del paquete import javax.imageio proporciona métodos para leer y escribir imágenes.

Example

Puede utilizar el siguiente código de programa para cargar y guardar imágenes utilizando la biblioteca 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");
   } 
}

Al ejecutar el programa anterior, obtendrá el siguiente resultado:

image Saved

Si abre la ruta especificada, puede observar la imagen guardada de la siguiente manera:

los Imgcodecs clase del paquete org.opencv.imgcodecsproporciona métodos para leer y escribir imágenes. Con OpenCV, puede leer una imagen y almacenarla en una matriz (realice transformaciones en la matriz si es necesario). Posteriormente, puede escribir la matriz procesada en un archivo.

los read() método del ImgcodecsLa clase se usa para leer una imagen usando OpenCV. A continuación se muestra la sintaxis de este método.

imread(filename)

Acepta un argumento (filename), una variable del tipo String que representa la ruta del archivo que se va a leer.

A continuación se muestran los pasos a seguir para leer imágenes en Java utilizando la biblioteca OpenCV.

Paso 1: Cargue la biblioteca nativa de OpenCV

Cargue la biblioteca nativa de OpenCV usando el load() método, como se muestra a continuación.

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

Paso 2: crear una instancia de la clase Imgcodecs

Instancia del Imgcodecs clase.

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

Paso 3: leer la imagen

Leer la imagen usando el método imread(). Este método acepta un argumento de cadena que representa la ruta de la imagen y devuelve la imagen leída comoMat objeto.

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

Ejemplo

El siguiente código de programa muestra cómo puede read an image utilizando la biblioteca 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");     
   } 
}

Al ejecutar el programa anterior, OpenCV carga la imagen especificada y muestra la siguiente salida:

Image Loaded

los write() método del ImgcodecsLa clase se usa para escribir una imagen usando OpenCV. Para escribir una imagen, repita los primeros tres pasos del ejemplo anterior.

Para escribir una imagen, debe invocar el imwrite() método del Imgcodecs clase.

A continuación se muestra la sintaxis de este método.

imwrite(filename, mat)

Este método acepta los siguientes parámetros:

filename - A String variable que representa la ruta donde guardar el archivo.
mat - A Mat objeto que representa la imagen a escribir.

Ejemplo

El siguiente programa es un ejemplo para write an image usando el programa Java usando la biblioteca 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 ............"); 
   } 
}

Al ejecutar el programa anterior, obtendrá el siguiente resultado:

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

Si abre la ruta especificada, puede observar la imagen guardada como se muestra a continuación:

En los capítulos anteriores, hemos discutido cómo leer y guardar una imagen usando la biblioteca OpenCV Java. Además de eso, también podemos mostrar las imágenes cargadas en una ventana separada usando bibliotecas GUI como AWT / Swings y JavaFX.

Conversión de tapete en imagen con búfer

Para leer una imagen usamos el método imread(). Este método devuelve la imagen leída en forma deMatrix. Pero, para usar esta imagen con bibliotecas GUI (AWT / Swings y JavaFX), debe convertirse como un objeto de la clase.BufferedImage del paquete java.awt.image.BufferedImage.

Los siguientes son los pasos para convertir un Mat objeto de OpenCV para BufferedImage objeto.

Paso 1: codifique el Mat en MatOfByte

En primer lugar, debe convertir la matriz en una matriz de bytes. Puedes hacerlo usando el métodoimencode() de la clase Imgcodecs. A continuación se muestra la sintaxis de este método.

imencode(ext, image, matOfByte);

Este método acepta los siguientes parámetros:

Ext - Un parámetro de cadena que especifica el formato de la imagen (.jpg, .png, etc.)
image - Un objeto Mat de la imagen
matOfByte - Un objeto vacío de la clase MatOfByte

Codifique la imagen utilizando este método como se muestra a continuación.

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

Paso 2: Convierta el objeto MatOfByte en una matriz de bytes

Convertir el MatOfByte objeto en una matriz de bytes usando el método toArray().

byte[] byteArray = matOfByte.toArray();

Paso 3: preparar el objeto InputStream

Prepare el objeto InputStream pasando la matriz de bytes creada en el paso anterior al constructor del ByteArrayInputStream clase.

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

Paso 4: preparación del objeto InputStream

Pase el objeto Flujo de entrada creado en el paso anterior al read() método del ImageIOclase. Esto devolverá un objeto BufferedImage.

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

Visualización de imágenes usando AWT / Swings

Para mostrar una imagen usando el marco AWT / Swings, primero que nada, lea una imagen usando el imread() método y convertirlo en BufferedImage siguiendo los pasos antes mencionados.

Luego, instancia el JFrame class y agregue la imagen almacenada en búfer creada al ContentPane del JFrame, como se muestra a continuación:

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

El siguiente código de programa muestra cómo puede read una imagen y display a través de la ventana oscilante utilizando la biblioteca 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");     
   } 
}

Al ejecutar el programa anterior, obtendrá el siguiente resultado:

Image Loaded

Además de eso, puede ver una ventana que muestra la imagen cargada, de la siguiente manera:

Visualización de imágenes usando JavaFX

Para mostrar una imagen usando JavaFX, en primer lugar, lea una imagen usando el imread() método y convertirlo en BufferedImage. Luego, convierta BufferedImage en WritableImage, como se muestra a continuación.

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

Pasa esto WritableImage objeto al constructor del ImageView clase.

ImageView imageView = new ImageView(writableImage);

Example

El siguiente código de programa muestra cómo read una imagen y display a través de la ventana JavaFX utilizando la biblioteca 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); 
   } 
}

Al ejecutar el programa anterior, obtendrá el siguiente resultado:

Image Loaded

Además de eso, puede ver una ventana que muestra la imagen cargada, de la siguiente manera:

OpenCV admite varios tipos de imágenes, como colores, binarias, escala de grises, etc. imread() método y campos predefinidos del Imgcodecs class, puede leer una imagen dada como otro tipo.

El parámetro flags del método imread () (IMREAD_XXX)

En los capítulos anteriores, hemos visto la sintaxis de imread() método del Imgcodecsclase. Acepta un argumento de cadena que representa la ubicación de la imagen que se va a leer.

imread(filename)

los imread() El método tiene otra sintaxis.

imread(filename, int flags)

Esta sintaxis acepta dos parámetros:

filename - Acepta un argumento (filename), una variable del tipo String que representa la ruta del archivo que se va a leer.
flags- Un valor entero que representa un valor de bandera predefinido. Para cada valor, esto lee la imagen dada como un tipo específico (color de escala de grises, etc.)

A continuación se muestra la tabla que enumera varios campos proporcionados en el Imgproc class como valores para este parámetro.

S. No	Campos y descripción
1	IMREAD_COLOR Si la bandera se establece en este valor, la imagen cargada se convertirá en una imagen de color BGR (azul verde rojo) de 3 canales.
2	IMREAD_GRAYSCALE Si la bandera se establece en este valor, la imagen cargada se convertirá en una imagen en escala de grises de un solo canal.
3	IMREAD_LOAD_GDAL Si la bandera se establece en este valor, puede cargar la imagen usando el gdal conductor.
4	IMREAD_ANYCOLOR Si la bandera se establece en este valor, la imagen se lee en cualquier formato de color posible.
5	IMREAD_REDUCED_COLOR_2 IMREAD_REDUCED_COLOR_4 IMREAD_REDUCED_COLOR_8 Si el indicador se establece en este valor, la imagen se lee como de tres canales BGR, y el tamaño de la imagen se reduce a ½, ¼ ^º o ⅛ ^º del tamaño original de la imagen con respecto al campo utilizado.
6	IMREAD_REDUCED_GRAYSCALE_2 IMREAD_REDUCED_GRAYSCALE_4 IMREAD_REDUCED_GRAYSCALE_8 Si el indicador se establece en este valor, la imagen se lee una imagen de escala de grises de un solo canal como, y el tamaño de la imagen se reduce a ½, ¼ ^º o ⅛ ^º del tamaño original de la imagen con respecto al campo utilizado .
7	IMREAD_UNCHANGED Si el indicador se establece en este valor, la imagen cargada se devuelve como está.

El siguiente programa demuestra cómo leer una imagen coloreada en escala de grises y mostrarla usando la ventana JavaFX. Aquí, hemos leído la imagen pasando la bandera.IMREAD_GRAYSCALE junto con la Cadena que sostiene el camino de una imagen coloreada.

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

Imagen de entrada

Suponga que la siguiente es la imagen de entrada sample.jpg especificado en el programa anterior.

Imagen de salida

Al ejecutar el programa, obtendrá el siguiente resultado.

El siguiente programa demuestra cómo leer una imagen coloreada como imagen de tipo BGR y mostrarla usando la ventana JavaFX. Aquí, hemos leído la imagen pasando la bandera.IMREAD_COLOR al método imread() junto con la Cadena que sostiene el camino de una imagen coloreada.

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

Imagen de entrada

Suponga que la siguiente es la imagen de entrada sample.jpg especificado en el programa anterior.

Imagen de salida

Al ejecutar el programa, obtendrá el siguiente resultado.

En los capítulos anteriores, discutimos cómo leer una imagen de entrada en diferentes tipos (binaria, escala de grises, BGR, etc.). En este capítulo, aprenderemos cómo convertir un tipo de imagen en otro.

La clase nombrada Imgproc del paquete org.opencv.imgproc proporciona métodos para convertir una imagen de un color a otro.

Conversión de imágenes en color a escala de grises

Un método llamado cvtColor()se utiliza para convertir imágenes en color a escala de grises. A continuación se muestra la sintaxis de este método.

cvtColor(Mat src, Mat dst, int code)

Este método acepta los siguientes parámetros:

src - Una matriz que representa la fuente.
dst - Una matriz que representa el destino.
code - Un código entero que representa el tipo de conversión, por ejemplo, RGB a escala de grises.

Puede convertir imágenes en color a escala de grises pasando el código Imgproc.COLOR_RGB2GRAY junto con las matrices de origen y destino como un parámetro para el cvtColor() método.

Ejemplo

El siguiente programa demuestra cómo leer una imagen en color como una imagen en escala de grises y mostrarla usando la ventana 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);
   }
}

Imagen de entrada

Suponga que la siguiente es la imagen de entrada sample.jpg especificado en el programa anterior.

Imagen de salida

Al ejecutar el programa, obtendrá el siguiente resultado.

Un método llamado threshold()se utiliza para convertir imágenes en escala de grises a imágenes binarias. A continuación se muestra la sintaxis de este método.

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

Este método acepta los siguientes parámetros:

mat - A Mat objeto que representa la imagen de entrada.
dst - A Mat objeto que representa la imagen de salida.
thresh : Un número entero que representa el valor umbral.
maxval : Un número entero que representa el valor máximo que se debe utilizar con los tipos de umbral THRESH_BINARY y THRESH_BINARY_INV.
type - Un código entero que representa el tipo de conversión, por ejemplo, RGB a escala de grises.

Puede convertir una imagen en escala de grises en una imagen binaria pasando el código Imgproc.THRESH_BINARY junto con los valores de los parámetros restantes.

Ejemplo

El siguiente programa demuestra cómo leer una imagen coloreada como una imagen binaria y mostrarla usando la ventana 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);
   }
}

Imagen de entrada

Suponga que la siguiente es la imagen de entrada sample.jpg especificado en el programa anterior.

Imagen de salida

Al ejecutar el programa, obtendrá el siguiente resultado.

Puede utilizar el mismo método mencionado en el capítulo anterior para convertir una imagen en escala de grises en una imagen binaria. Simplemente pase la ruta de una imagen en escala de grises como entrada a este programa.

Ejemplo

El siguiente programa demuestra cómo leer una imagen en escala de grises como una imagen binaria y mostrarla usando la ventana 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);
   }
}

Imagen de entrada

Suponga que la siguiente es la imagen de entrada sample.jpg especificado en el programa anterior.

Imagen de salida

Al ejecutar el programa, obtendrá el siguiente resultado.

Puede dibujar varias formas como círculo, rectángulo, línea, elipse, polilíneas, convexas, polilíneas, polilíneas en una imagen usando los métodos respectivos de la org.opencv.imgproc paquete.

Puedes dibujar un círculo en una imagen usando el método circle() del imgprocclase. A continuación se muestra la sintaxis de este método:

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

Este método acepta los siguientes parámetros:

mat - A Mat objeto que representa la imagen en la que se va a dibujar el círculo.
point - A Point objeto que representa el centro del círculo.
radius - Una variable del tipo integer que representa el radio del círculo.
scalar - A Scalarobjeto que representa el color del círculo. (BGR)
thickness - un integerque representa el grosor del círculo; por defecto, el valor del grosor es 1.

Ejemplo

El siguiente programa demuestra cómo dibujar un círculo en una imagen y mostrarlo usando la ventana 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);
   }
}

Al ejecutar el programa anterior, obtendrá el siguiente resultado:

Puedes dibujar una línea en una imagen usando el método line() del imgprocclase. A continuación se muestra la sintaxis de este método.

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

Este método acepta los siguientes parámetros:

mat - A Mat objeto que representa la imagen en la que se dibujará la línea.
pt1 and pt2 - dos Point objetos que representan los puntos entre los que se trazará la línea.
scalar - A Scalarobjeto que representa el color del círculo. (BGR)
thickness- Un número entero que representa el grosor de la línea; por defecto, el valor del grosor es 1.

Ejemplo

El siguiente programa demuestra cómo dibujar una línea en una imagen y mostrarla usando la ventana 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);
   }
}

Al ejecutar el programa anterior, obtendrá el siguiente resultado:

Puedes dibujar un rectángulo en una imagen usando el método rectangle() del imgprocclase. A continuación se muestra la sintaxis de este método:

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

Este método acepta los siguientes parámetros:

mat - A Mat objeto que representa la imagen en la que se va a dibujar el rectángulo.
pt1 and pt2 - dos Point objetos que representan los vértices del rectángulo que se va a dibujar.
scalar - A Scalarobjeto que representa el color del rectángulo. (BGR)
thickness- Un número entero que representa el grosor del rectángulo; por defecto, el valor del grosor es 1.

Ejemplo

El siguiente ejemplo demuestra cómo dibujar un rectángulo en una imagen y mostrarlo usando la ventana 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);
   }
}

Al ejecutar el programa anterior, obtendrá el siguiente resultado:

Puedes dibujar una elipse en una imagen usando el método rectangle() del imgprocclase. A continuación se muestra la sintaxis de este método:

ellipse(img, box, color, thickness)

Este método acepta los siguientes parámetros:

mat - A Mat objeto que representa la imagen en la que se dibujará el rectángulo.
box - Un objeto RotatedRect (la elipse se dibuja inscrita en este rectángulo).
scalar - A Scalarobjeto que representa el color del rectángulo. (BGR)
thickness- Un número entero que representa el grosor del rectángulo; por defecto, el valor del grosor es 1.

El constructor del RotatedRect la clase acepta un objeto de la clase Point, un objeto de la clase Size y una variable de tipo double, como se muestra a continuación.

RotatedRect(Point c, Size s, double a)

Ejemplo

El siguiente programa demuestra cómo dibujar una elipse en una imagen y mostrarla usando la ventana 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);
   }
}

Al ejecutar el programa anterior, obtendrá el siguiente resultado:

Puede dibujar polilíneas en una imagen usando el método polylines() del imgprocclase. A continuación se muestra la sintaxis de este método.

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

Este método acepta los siguientes parámetros:

mat - A Mat objeto que representa la imagen en la que se dibujarán las polilíneas.
pts - A List objeto que sostiene los objetos del tipo MatOfPoint.
isClosed - Un parámetro de tipo booleano que especifica si las polilíneas están cerradas.
scalar - A Scalarobjeto que representa el color de las polilíneas. (BGR)
thickness- Un número entero que representa el grosor de las polilíneas; por defecto, el valor del grosor es 1.

El constructor del MatOfPoint la clase acepta objetos de la clase Point.

MatOfPoint(Point... a)

Ejemplo

El siguiente programa demuestra cómo dibujar polilíneas en una imagen y mostrarla usando la ventana 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);
   }
}

Al ejecutar el programa anterior, obtendrá el siguiente resultado:

Puede dibujar polilíneas convexas en una imagen utilizando el método fillconvexPoly() del imgprocclase. A continuación se muestra la sintaxis de este método.

fillConvexPoly(Mat img, MatOfPoint points, Scalar color)

Este método acepta los siguientes parámetros:

mat - A Mat objeto que representa la imagen en la que se dibujarán las polilíneas convexas.
points - A MatOfPoint objeto que representa los puntos entre los que se dibujarán las polilíneas convexas.
scalar - A Scalarobjeto que representa el color de las polilíneas convexas. (BGR)

El constructor del MatOfPoint la clase acepta objetos de la clase Point.

MatOfPoint(Point... a)

Ejemplo

El siguiente programa demuestra cómo dibujar polilíneas convexas en una imagen y mostrarla usando la ventana 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);
   }
}

Al ejecutar el programa anterior, obtendrá el siguiente resultado:

Puede dibujar una línea con flechas en una imagen usando el método arrowedLine() del imgprocclase. A continuación se muestra la sintaxis de este método:

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

Este método acepta los siguientes parámetros:

mat - A Mat objeto que representa la imagen en la que se va a dibujar la línea con flechas.
pt1 and pt2 - dos Point objetos que representan los puntos entre los cuales se debe trazar la línea con flechas.
scalar - A Scalarobjeto que representa el color de la línea con flechas. (BGR)

Ejemplo

El siguiente programa demuestra cómo dibujar una línea con flechas en una imagen y mostrarla usando la ventana 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);
   }
}

Al ejecutar el programa anterior, obtendrá el siguiente resultado:

Puedes agregar texto a una imagen usando el método arrowedLine() del imgprocclase. A continuación se muestra la sintaxis de este método.

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

Este método acepta los siguientes parámetros:

mat - A Mat objeto que representa la imagen a la que se agregará el texto.
text - A string variable de representación del texto que se va a agregar.
org - A Point objeto que representa la cadena de texto de la esquina inferior izquierda de la imagen.
fontFace - Una variable de tipo entero que representa el tipo de fuente.
fontScale - Una variable del tipo double que representa el factor de escala que se multiplica por el tamaño base específico de la fuente.
scalar - A Scalarobjeto que representa el color del texto que se va a agregar. (BGR)
thickness - Un número entero que representa el grosor de la línea de forma predeterminada, el valor del grosor es 1.

Ejemplo

El siguiente programa demuestra cómo agregar texto a una imagen y mostrarlo usando la ventana 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);
   }
}

Al ejecutar el programa anterior, obtendrá el siguiente resultado:

El desenfoque (suavizado) es la operación de procesamiento de imágenes más utilizada para reducir el ruido de la imagen. El proceso elimina el contenido de alta frecuencia, como los bordes, de la imagen y la suaviza.

En general, el desenfoque se logra convolucionando (cada elemento de la imagen se agrega a sus vecinos locales, ponderados por el núcleo) la imagen a través de un núcleo de filtro de paso bajo.

Desenfoque (promediado)

Durante esta operación, la imagen se convoluciona con un filtro de caja (normalizado). En este proceso, el elemento central de la imagen se reemplaza por el promedio de todos los píxeles en el área del núcleo.

Puede realizar esta operación en una imagen utilizando el método blur() del imgprocclase. A continuación se muestra la sintaxis de este método:

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

Este método acepta los siguientes parámetros:

src - A Mat objeto que representa la fuente (imagen de entrada) para esta operación.
dst - A Mat objeto que representa el destino (imagen de salida) para esta operación.
ksize - A Size objeto que representa el tamaño del kernel.
anchor - Una variable de tipo entero que representa el punto de ancla.
borderType - Una variable de tipo entero que representa el tipo de borde que se utilizará en la salida.

Ejemplo

El siguiente programa demuestra cómo realizar la operación de promediado (desenfoque) en una imagen.

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

Suponga que la siguiente es la imagen de entrada sample.jpg especificado en el programa anterior.

Salida

Al ejecutar el programa, obtendrá el siguiente resultado:

Image Processed

Si abre la ruta especificada, puede observar la imagen de salida de la siguiente manera:

En la operación de Desenfoque gaussiano, la imagen se convoluciona con un filtro gaussiano en lugar del filtro de caja. El filtro gaussiano es un filtro de paso bajo que elimina los componentes de alta frecuencia que se reducen.

Puede realizar esta operación en una imagen utilizando el Gaussianblur() método del imgprocclase. A continuación se muestra la sintaxis de este método:

GaussianBlur(src, dst, ksize, sigmaX)

Este método acepta los siguientes parámetros:

src - A Mat objeto que representa la fuente (imagen de entrada) para esta operación.
dst - A Mat objeto que representa el destino (imagen de salida) para esta operación.
ksize - A Size objeto que representa el tamaño del kernel.
sigmaX - Una variable del tipo double que representa la desviación estándar del kernel de Gauss en la dirección X.

Ejemplo

El siguiente programa demuestra cómo realizar la operación de desenfoque gaussiano en una imagen.

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

Suponga que la siguiente es la imagen de entrada sample.jpg especificado en el programa anterior.

Salida

Al ejecutar el programa, obtendrá el siguiente resultado:

Image Processed

Si abre la ruta especificada, puede observar la imagen de salida de la siguiente manera:

La operación de Desenfoque mediano es similar a los otros métodos de promediado. Aquí, el elemento central de la imagen se reemplaza por la mediana de todos los píxeles en el área del kernel. Esta operación procesa los bordes mientras elimina el ruido.

Puede realizar esta operación en una imagen utilizando el medianBlur() método del imgprocclase. A continuación se muestra la sintaxis de este método:

medianBlur(src, dst, ksize)

Este método acepta los siguientes parámetros:

src - A Mat objeto que representa la fuente (imagen de entrada) para esta operación.
dst - A Mat objeto que representa el destino (imagen de salida) para esta operación.
ksize - A Size objeto que representa el tamaño del kernel.

Ejemplo

El siguiente programa demuestra cómo realizar la operación de desenfoque medio en una imagen.

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

Suponga que la siguiente es la imagen de entrada sample.jpg especificado en el programa anterior.

Salida

Al ejecutar el programa, obtendrá el siguiente resultado:

Image Processed

Si abre la ruta especificada, puede observar la imagen de salida de la siguiente manera:

El filtrado de imágenes le permite aplicar varios efectos a una imagen. En este capítulo y los tres capítulos siguientes, vamos a discutir varias operaciones de filtro como Filtro Bilateral, Filtro de Caja, Filtro de Caja SQR y Filter2D.

Filtro bilateral

La operación Filtro bilateral aplica una imagen bilateral a un filtro. Puede realizar esta operación en una imagen utilizando elmedianBlur() método del imgprocclase. A continuación se muestra la sintaxis de este método.

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

Este método acepta los siguientes parámetros:

src - A Mat objeto que representa la fuente (imagen de entrada) para esta operación.
dst - A Mat objeto que representa el destino (imagen de salida) para esta operación.
d - Una variable de tipo entero que representa el diámetro de la vecindad de píxeles.
sigmaColor - Una variable de tipo integer que representa el filtro sigma en el espacio de color.
sigmaSpace - Una variable de tipo entero que representa el filtro sigma en el espacio de coordenadas.
borderType - Un objeto entero que representa el tipo de borde utilizado.

Ejemplo

El siguiente programa demuestra cómo realizar la operación de filtro bilateral en una imagen.

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

Suponga que la siguiente es la imagen de entrada filter_input.jpg especificado en el programa anterior.

Salida

Al ejecutar el programa, obtendrá el siguiente resultado:

Image Processed

Si abre la ruta especificada, puede observar la imagen de salida de la siguiente manera:

La operación de filtro de caja es similar a la operación de promediado de desenfoque; aplica una imagen bilateral a un filtro. Aquí puede elegir si el cuadro debe normalizarse o no.

Puede realizar esta operación en una imagen utilizando el boxFilter() método del imgprocclase. A continuación se muestra la sintaxis de este método:

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

Este método acepta los siguientes parámetros:

src - A Mat objeto que representa la fuente (imagen de entrada) para esta operación.
dst - A Mat objeto que representa el destino (imagen de salida) para esta operación.
ddepth - Una variable de tipo entero que representa la profundidad de la imagen de salida.
ksize - A Size objeto que representa el tamaño del kernel difuminado.
anchor - Una variable de tipo entero que representa el punto de ancla.
Normalize - Una variable de tipo booleano que especifica si el kernel debe normalizarse.
borderType - Un objeto entero que representa el tipo de borde utilizado.

Ejemplo

El siguiente programa demuestra cómo realizar la operación de filtro de caja en una imagen.

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

Suponga que la siguiente es la imagen de entrada filter_input.jpg especificado en el programa anterior.

Salida

Al ejecutar el programa, obtendrá el siguiente resultado:

Image Processed

Si abre la ruta especificada, puede observar la imagen de salida de la siguiente manera:

Puede realizar la operación de filtro SQRBox en una imagen utilizando el boxFilter() método del imgprocclase. A continuación se muestra la sintaxis de este método:

sqrBoxFilter(src, dst, ddepth, ksize)

Este método acepta los siguientes parámetros:

src - A Mat objeto que representa la fuente (imagen de entrada) para esta operación.
dst - A Mat objeto que representa el destino (imagen de salida) para esta operación.
ddepth - Una variable de tipo entero que representa la profundidad de la imagen de salida.
ksize - A Size objeto que representa el tamaño del kernel difuminado.

Ejemplo

El siguiente programa demuestra cómo realizar la operación de filtro Sqrbox en una imagen determinada.

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

Suponga que la siguiente es la imagen de entrada filter_input.jpg especificado en el programa anterior.

Salida

Al ejecutar el programa, obtendrá el siguiente resultado:

Image Processed

Si abre la ruta especificada, puede observar la imagen de salida de la siguiente manera:

La operación Filter2D convoluciona una imagen con el kernel. Puede realizar esta operación en una imagen utilizando elFilter2D() método del imgprocclase. A continuación se muestra la sintaxis de este método:

filter2D(src, dst, ddepth, kernel)

Este método acepta los siguientes parámetros:

src - A Mat objeto que representa la fuente (imagen de entrada) para esta operación.
dst - A Mat objeto que representa el destino (imagen de salida) para esta operación.
ddepth - Una variable de tipo entero que representa la profundidad de la imagen de salida.
kernel - A Mat objeto que representa el núcleo de convolución.

Ejemplo

El siguiente programa demuestra cómo realizar la operación Filter2D en una imagen.

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

Suponga que la siguiente es la imagen de entrada filter_input.jpg especificado en el programa anterior.

Salida

Al ejecutar el programa, obtendrá el siguiente resultado:

Image Processed

Si abre la ruta especificada, puede observar la imagen de salida de la siguiente manera:

La erosión y la dilatación son los dos tipos de operaciones morfológicas. Como su nombre lo indica, las operaciones morfológicas son el conjunto de operaciones que procesan imágenes según sus formas.

Basado en la imagen de entrada dada, se desarrolla un "elemento estructural". Esto se puede realizar en cualquiera de los dos procedimientos. Estos tienen como objetivo eliminar el ruido y asentar las imperfecciones, para aclarar la imagen.

Dilatación

Este procedimiento sigue a la convolución con algún núcleo de una forma específica, como un cuadrado o un círculo. Este núcleo tiene un punto de anclaje, que denota su centro.

Este núcleo se superpone sobre la imagen para calcular el valor máximo de píxeles. Después de calcular, la imagen se reemplaza con un ancla en el centro. Con este procedimiento, las áreas de las regiones brillantes aumentan de tamaño y, por lo tanto, aumenta el tamaño de la imagen.

Por ejemplo, el tamaño de un objeto en tono blanco o tono brillante aumenta, mientras que el tamaño de un objeto en tono negro o tono oscuro disminuye.

Puede realizar la operación de dilatación en una imagen utilizando el dilate() método del imgprocclase. A continuación se muestra la sintaxis de este método.

dilate(src, dst, kernel)

Este método acepta los siguientes parámetros:

src - A Mat objeto que representa la fuente (imagen de entrada) para esta operación.
dst - A Mat objeto que representa el destino (imagen de salida) para esta operación.
kernel - A Mat objeto que representa el kernel.

Ejemplo

Puede preparar la matriz del kernel utilizando el getStructuringElement()método. Este método acepta un número entero que representa elmorph_rect tipo y un objeto del tipo Size.

Imgproc.getStructuringElement(int shape, Size ksize);

El siguiente programa demuestra cómo realizar la operación de dilatación en una imagen determinada.

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

Entrada

Suponga que la siguiente es la imagen de entrada sample.jpg especificado en el programa anterior.

Salida

Al ejecutar el programa, obtendrá el siguiente resultado:

Image Processed

Si abre la ruta especificada, puede observar la imagen de salida de la siguiente manera:

La erosión es un proceso bastante similar a la dilatación. Pero el valor de píxel calculado aquí es mínimo en lugar de máximo en dilatación. La imagen se reemplaza debajo del punto de anclaje con ese valor de píxel mínimo.

Con este procedimiento, las áreas de las regiones oscuras aumentan de tamaño y las regiones brillantes se reducen. Por ejemplo, el tamaño de un objeto en tono oscuro o tono negro aumenta, mientras que disminuye en tono blanco o tono brillante.

Ejemplo

Puede realizar esta operación en una imagen utilizando el erode() método del imgprocclase. A continuación se muestra la sintaxis de este método:

erode(src, dst, kernel)

Este método acepta los siguientes parámetros:

src - A Mat objeto que representa la fuente (imagen de entrada) para esta operación.
dst - A Mat objeto que representa el destino (imagen de salida) para esta operación.
kernel - A Mat objeto que representa el kernel.

Puede preparar la matriz del kernel utilizando el getStructuringElement()método. Este método acepta un número entero que representa elmorph_rect tipo y un objeto del tipo Size.

Imgproc.getStructuringElement(int shape, Size ksize);

El siguiente programa demuestra cómo realizar la operación de erosión en una imagen determinada.

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

Suponga que la siguiente es la imagen de entrada sample.jpg especificado en el programa anterior.

Salida

Al ejecutar el programa, obtendrá el siguiente resultado:

Image Loaded

Si abre la ruta especificada, puede observar la imagen de salida de la siguiente manera:

En los capítulos anteriores, discutimos el proceso de erosion y dilation. Además de estos dos, OpenCV tiene más transformaciones morfológicas. losmorphologyEx() del método de la clase Imgproc se utiliza para realizar estas operaciones en una imagen determinada.

A continuación se muestra la sintaxis de este método:

morphologyEx(src, dst, op, kernel)

Este método acepta los siguientes parámetros:

src - Un objeto de la clase Mat que representa la imagen de origen (entrada).
dst - objeto de la clase Mat que representa la imagen de destino (salida).
op - Un número entero que representa el tipo de operación morfológica.
kernel - Una matriz de kernel.

Ejemplo

El siguiente programa demuestra cómo aplicar la operación morfológica "top-hat" en una imagen usando la biblioteca 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");
   } 
}

Suponga que la siguiente es la imagen de entrada morph_input.jpg especificado en el programa anterior.

Salida

Al ejecutar el programa, obtendrá el siguiente resultado:

Image Processed

Si abre la ruta especificada, puede observar la imagen de salida de la siguiente manera:

Más operaciones

Además de la operación morfológica TOPHAT, demostrado en la anterior example, OpenCV se adapta a otros tipos de morfologías. Todos estos tipos están representados por campos estáticos predefinidos (valores fijos) deImgproc clase.

Puede elegir el tipo de morfología que necesita pasando su respectivo valor predefinido al parámetro op del morphologyEx() método.

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

A continuación se muestran los valores que representan el tipo de operaciones morfológicas y sus respectivos resultados.

Operación y descripción	Salida
MORPH_BLACKHAT
MORPH_CLOSE
MORPH_CROSS
MORPH_DILATE
MORPH_ELLIPSE
MORPH_ERODE
MORPH_GRADIENT
MORPH_OPEN
MORPH_RECT
MORPH_TOPHAT

Pyramid es una operación en una imagen donde,

Una imagen de entrada se suaviza inicialmente utilizando un filtro de suavizado particular (por ejemplo, gaussiano, laplaciano) y luego se submuestrea la imagen suavizada.
Este proceso se repite varias veces.

Durante la operación piramidal, la suavidad de la imagen aumenta y la resolución (tamaño) disminuye.

Pirámide arriba

En Pyramid Up, la imagen se muestra inicialmente y luego se difumina. Puede realizar la operación Pyramid Up en una imagen usando elpyrUP() método del imgprocclase. A continuación se muestra la sintaxis de este método:

pyrUp(src, dst, dstsize, borderType)

Este método acepta los siguientes parámetros:

src - Un objeto de la clase Mat que representa la imagen de origen (entrada).
mat - Un objeto de la clase Mat que representa la imagen de destino (salida).
size - Un objeto de la clase Size que representa el tamaño al que se va a aumentar o disminuir la imagen.
borderType - Una variable de tipo entero que representa el tipo de borde que se utilizará.

Ejemplo

El siguiente programa demuestra cómo realizar la operación Pyramid Up en una imagen.

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

Suponga que la siguiente es la imagen de entrada pyramid_input.jpg especificado en el programa anterior.

Salida

Al ejecutar el programa, obtendrá el siguiente resultado:

Image Processed

Si abre la ruta especificada, puede observar la imagen de salida de la siguiente manera:

Pirámide abajo

En Pyramid Down, la imagen se difumina inicialmente y luego se reduce la muestra. Puede realizar la operación Pyramid Down en una imagen usando elpyrDown() método del imgprocclase. A continuación se muestra la sintaxis de este método:

pyrDown(src, dst, dstsize, borderType)

Este método acepta los siguientes parámetros:

src - Un objeto de la clase Mat que representa la imagen de origen (entrada).
mat - Un objeto de la clase Mat que representa la imagen de destino (salida).
size - Un objeto de la clase Size que representa el tamaño al que se va a aumentar o disminuir la imagen.
borderType - Una variable de tipo entero que representa el tipo de borde que se utilizará.

Ejemplo

El siguiente programa demuestra cómo realizar la operación Pyramid Down en una imagen.

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

Suponga que la siguiente es la imagen de entrada pyramid_input.jpg especificado en el programa anterior.

Salida

Al ejecutar el programa, obtendrá el siguiente resultado:

Image Processed

Si abre la ruta especificada, puede observar la imagen de salida de la siguiente manera:

Filtrado de cambio medio

En la operación de pirámide de cambio medio, se lleva a cabo un paso inicial de segmentación del cambio medio de una imagen.

Puede realizar la operación de filtrado de cambio medio piramidal en una imagen utilizando el pyrDown() método del imgprocclase. A continuación se muestra la sintaxis de este método.

pyrMeanShiftFiltering(src, dst, sp, sr)

Este método acepta los siguientes parámetros:

src - Un objeto de la clase Mat que representa la imagen de origen (entrada).
mat - Un objeto de la clase Mat que representa la imagen de destino (salida).
sp - Una variable de tipo double que representa el radio espacial de la ventana.
sr - Una variable del tipo double que representa el radio de la ventana de color.

Ejemplo

El siguiente programa demuestra cómo realizar una operación de filtrado de cambio medio en una imagen determinada.

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

Suponga que la siguiente es la imagen de entrada pyramid_input.jpg especificado en el programa anterior.

Salida

Al ejecutar el programa, obtendrá el siguiente resultado:

Image Processed

Si abre la ruta especificada, puede observar la imagen de salida de la siguiente manera:

La creación de umbrales es un método de segmentación de imágenes, en general se utiliza para crear imágenes binarias. El umbral es de dos tipos, a saber, umbral simple y umbral adaptativo.

Umbral simple

En una operación de umbral simple, a los píxeles cuyos valores son mayores que el valor umbral especificado, se les asigna un valor estándar.

Puede realizar una operación de umbral simple en una imagen utilizando el método threshold() del Imgproc class, A continuación se muestra la sintaxis de este método.

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

Este método acepta los siguientes parámetros:

src - Un objeto de la clase Mat que representa la imagen de origen (entrada).
dst - Un objeto de la clase Mat que representa la imagen de destino (salida).
thresh - Una variable de tipo doble que representa el valor umbral.
maxval - Una variable de tipo doble que representa el valor que se debe dar si el valor del píxel es mayor que el valor umbral.
type - Una variable de tipo entero que representa el tipo de umbral que se utilizará.

Ejemplo

El siguiente programa demuestra cómo realizar una operación de umbral simple en una imagen en 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");
   }
}

Suponga que la siguiente es la imagen de entrada thresh_input.jpg especificado en el programa anterior.

Salida

Al ejecutar el programa, obtendrá el siguiente resultado:

Image Processed

Si abre la ruta especificada, puede observar la imagen de salida de la siguiente manera:

Otros tipos de umbrales simples

Además de THRESH_BINARYOperación demostrada en el ejemplo anterior, OpenCV abastece a varios otros tipos de operaciones de umbral. Todos estos tipos están representados por campos estáticos predefinidos (valores fijos) deImgproc clase.

Puede elegir el tipo de operación de umbral que necesita, pasando su valor predefinido respectivo al parámetro denominado type del threshold() método.

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

A continuación se muestran los valores que representan varios tipos de operaciones de umbral y sus respectivas salidas.

Operación y descripción	Salida
THRESH_BINARY
THRESH_BINARY_INV
THRESH_TRUNC
THRESH_TOZERO
THRESH_TOZERO_INV

En simple thresholding, el valor de umbral es global, es decir, es el mismo para todos los píxeles de la imagen. Adaptive thresholding es el método en el que el valor de umbral se calcula para regiones más pequeñas y, por lo tanto, habrá diferentes valores de umbral para diferentes regiones.

En OpenCV, puede realizar una operación de umbral adaptativo en una imagen utilizando el método adaptiveThreshold() del Imgprocclase. A continuación se muestra la sintaxis de este método.

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

Este método acepta los siguientes parámetros:

src - Un objeto de la clase Mat que representa la imagen de origen (entrada).
dst - Un objeto de la clase Mat que representa la imagen de destino (salida).
maxValue - Una variable de tipo doble que representa el valor que se debe dar si el valor del píxel es mayor que el valor umbral.
adaptiveMethod- Una variable de tipo entero que representa el método adaptativo que se utilizará. Este será cualquiera de los dos valores siguientes
- ADAPTIVE_THRESH_MEAN_C - el valor umbral es la media del área del vecindario.
- ADAPTIVE_THRESH_GAUSSIAN_C - el valor umbral es la suma ponderada de los valores de vecindad donde los pesos son una ventana gaussiana.
thresholdType - Una variable de tipo entero que representa el tipo de umbral que se utilizará.
blockSize - Una variable de tipo entero que representa el tamaño de la vecindad de píxeles utilizada para calcular el valor de umbral.
C - Una variable de tipo doble que representa la constante utilizada en ambos métodos (restada de la media o media ponderada).

Ejemplo

El siguiente programa demuestra cómo realizar la operación de umbral adaptativo en una imagen en OpenCV. Aquí estamos eligiendo un umbral adaptativo de tipobinary y ADAPTIVE_THRESH_MEAN_C para el método de umbral.

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

Suponga que la siguiente es la imagen de entrada thresh_input.jpg especificado en el programa anterior.

Salida

Al ejecutar el programa, obtendrá el siguiente resultado:

Image Processed

Si abre la ruta especificada, puede observar la imagen de salida de la siguiente manera:

Otros tipos de umbralización adaptativa

Además de ADAPTIVE_THRESH_MEAN_C como el método adaptativo y THRESH_BINARY como tipo de umbral como se demostró en el ejemplo anterior, podemos elegir más combinaciones de estos dos valores.

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

A continuación se muestran los valores que representan varias combinaciones de valores para los parámetros. adaptiveMethod y thresholdType y sus respectivos productos.

adaptiveMethod /resholdType	ADAPTIVE_THRESH_MEAN_C	ADAPTIVE_THRESH_GAUSSIAN_C:
THRESH_BINARY
THRESH_BINARY_INV

Este capítulo le enseña cómo agregar bordes a una imagen.

El método copyMakeBorder ()

Puede agregar varios bordes a una imagen usando el método copyMakeBorder() de la clase denominada Core, que pertenece al paquete org.opencv.core. A continuación se muestra la sintaxis de este método.

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

Este método acepta los siguientes parámetros:

src - Un objeto de la clase Mat que representa la imagen de origen (entrada).
dst - Un objeto de la clase Mat que representa la imagen de destino (salida).
top - Una variable de entero del tipo entero que representa la longitud del borde en la parte superior de la imagen.
bottom - Una variable de entero del tipo entero que representa la longitud del borde en la parte inferior de la imagen.
left - Una variable de entero del tipo entero que representa la longitud del borde a la izquierda de la imagen.
right - Una variable de entero del tipo entero que representa la longitud del borde a la derecha de la imagen.
borderType - Una variable de tipo entero que representa el tipo de borde que se va a utilizar.

Ejemplo

El siguiente programa es un ejemplo que demuestra cómo agregar un borde a una imagen determinada.

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

Suponga que la siguiente es la imagen de entrada thresh_input.jpg especificado en el programa anterior.

Salida

Al ejecutar el programa, obtendrá el siguiente resultado:

Image Processed

Si abre la ruta especificada, puede observar la imagen de salida de la siguiente manera:

Otros tipos de fronteras

Además del tipo de borde, BORDER_CONSTANTComo se demostró en el ejemplo anterior, OpenCV se adapta a otros tipos de fronteras. Todos estos tipos están representados por campos estáticos predefinidos (valores fijos) de clase Core.

Puede elegir el tipo de operación de umbral que necesita, pasando su valor predefinido respectivo al parámetro denominado borderType del copyMakeBorder() método.

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

A continuación se muestran los valores que representan varios tipos de operaciones fronterizas y sus respectivos resultados.

Operación y descripción	Salida
BORDER_CONSTANT
BORDER_ISOLATED
BORDER_DEFAULT
BORDER_REFLECT
BORDER_REFLECT_101
BORDER_REFLECT101
BORDER_REPLICATE
BORDER_WRAP

Utilizando el sobel operation, puede detectar los bordes de una imagen tanto en dirección horizontal como vertical. Puede aplicar la operación de sobel en una imagen usando el métodosobel(). A continuación se muestra la sintaxis de este método:

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

Este método acepta los siguientes parámetros:

src - Un objeto de la clase Mat que representa la imagen de origen (entrada).
dst - Un objeto de la clase Mat que representa la imagen de destino (salida).
ddepth - Una variable entera que representa la profundidad de la imagen (-1)
dx- Una variable entera que representa la derivada x. (0 o 1)
dy- Una variable entera que representa la derivada y. (0 o 1)

Ejemplo

El siguiente programa demuestra cómo realizar la operación Sobel en una imagen determinada.

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

Suponga que la siguiente es la imagen de entrada sobel_input.jpg especificado en el programa anterior.

Salida

Al ejecutar el programa, obtendrá el siguiente resultado:

Image Processed

Si abre la ruta especificada, puede observar la imagen de salida de la siguiente manera:

Variantes sobel

Al pasar diferentes valores al último a los parámetros (dx y dy) (entre 0 y 1), obtendrá diferentes salidas:

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

La siguiente tabla enumera varios valores para las variables dx y dy del método Sobel() y sus respectivos productos.

Derivado X	Derivado de Y	Salida
0	1
1	0
1	1

Scharr también se utiliza para detectar las segundas derivadas de una imagen en direcciones horizontal y vertical. Puede realizar la operación Scharr en una imagen utilizando el métodoscharr(). A continuación se muestra la sintaxis de este método:

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

Este método acepta los siguientes parámetros:

src - Un objeto de la clase Mat que representa la imagen de origen (entrada).
dst - Un objeto de la clase Mat que representa la imagen de destino (salida).
ddepth - Una variable entera que representa la profundidad de la imagen (-1)
dx- Una variable entera que representa la derivada x. (0 o 1)
dy- Una variable entera que representa la derivada y. (0 o 1)

Ejemplo

El siguiente programa demuestra cómo aplicar scharr a una imagen determinada.

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

Suponga que la siguiente es la imagen de entrada scharr_input.jpg especificado en el programa anterior.

Salida

Al ejecutarlo, obtendrá el siguiente resultado:

Image Processed

Si abre la ruta especificada, puede observar la imagen de salida de la siguiente manera:

Más derivados de scharr

Al pasar diferentes valores al último a los parámetros (dx y dy) (entre 0 y 1) obtendrá diferentes salidas:

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

A continuación se muestra una tabla que enumera varios valores para las variables dx y dy del método scharr() y sus respectivos productos.

Derivado X	Derivado de Y	Salida
0	1
1	0

El operador laplaciano es también un operador derivado que se utiliza para encontrar bordes en una imagen. Es una máscara derivada de segundo orden. En esta máscara tenemos dos clasificaciones más, una es Operador Laplaciano Positivo y otra es Operador Laplaciano Negativo.

A diferencia de otros operadores, Laplacian no eliminó los bordes en ninguna dirección en particular, sino que eliminó los bordes en la siguiente clasificación.

Bordes hacia adentro
Bordes exteriores

Puedes realizar Laplacian Transform operación en una imagen usando el Laplacian() método del imgproc class, a continuación se muestra la sintaxis de este método.

Laplacian(src, dst, ddepth)

Este método acepta los siguientes parámetros:

src - A Mat objeto que representa la fuente (imagen de entrada) para esta operación.
dst - A Mat objeto que representa el destino (imagen de salida) para esta operación.
ddepth - Una variable de tipo entero que representa la profundidad de la imagen de destino.

Ejemplo

El siguiente programa demuestra cómo realizar la operación de transformación de Laplace en una imagen dada.

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

Suponga que la siguiente es la imagen de entrada laplacian_input.jpg especificado en el programa anterior.

Salida

Al ejecutar el programa, obtendrá el siguiente resultado:

Image Processed

Si abre la ruta especificada, puede observar la imagen de salida de la siguiente manera:

los distance transformEl operador generalmente toma imágenes binarias como entradas. En esta operación, las intensidades del nivel de gris de los puntos dentro de las regiones de primer plano se cambian para distanciar sus respectivas distancias del valor 0 más cercano (límite).

Puede aplicar la transformación de distancia en OpenCV usando el método distanceTransform(). A continuación se muestra la sintaxis de este método.

distanceTransform(src, dst, distanceType, maskSize)

Este método acepta los siguientes parámetros:

src - Un objeto de la clase Mat que representa la imagen de origen (entrada).
dst - Un objeto de la clase Mat que representa la imagen de destino (salida).
distanceType - Una variable de tipo entero que representa el tipo de transformación de distancia que se aplicará.
maskSize - Una variable de tipo entero que representa el tamaño de la máscara que se utilizará.

Ejemplo

El siguiente programa demuestra cómo realizar la operación de transformación de distancia en una imagen dada.

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

Suponga que la siguiente es la imagen de entrada input.jpg especificado en el programa anterior.

Salida

Al ejecutar el programa, obtendrá el siguiente resultado:

Image Processed

Si abre la ruta especificada, puede observar la imagen de salida de la siguiente manera:

Tipos de operaciones de transformación de distancia

Además del tipo de operación a distancia DIST_CComo se demostró en el ejemplo anterior, OpenCV ofrece otros tipos de operaciones de transformación de distancia. Todos estos tipos están representados por campos estáticos predefinidos (valores fijos) de la clase Imgproc.

Puede elegir el tipo de operación de transformación de distancia que necesita, pasando su valor predefinido respectivo al parámetro denominado distanceType del distanceTransform() método.

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

A continuación se muestran los valores que representan varios tipos de distanceTransform operaciones y sus respectivos productos.

Operación y descripción	Salida
DIST_C
DIST_L1
DIST_L2
DIST_LABEL_PIXEL
DIST_MASK_3

En este capítulo, aprenderemos cómo usar OpenCV para capturar cuadros usando la cámara del sistema. losVideoCapture clase de la org.opencv.videoioEl paquete contiene clases y métodos para capturar video usando la cámara. Vayamos paso a paso y aprendamos a capturar fotogramas:

Paso 1: Cargue la biblioteca nativa de OpenCV

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

Paso 2: crear una instancia de la clase de captura de video

Cree una instancia de la clase Mat utilizando cualquiera de las funciones mencionadas anteriormente en este tutorial.

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

Paso 3: lee los marcos

Puede leer los fotogramas de la cámara utilizando el read() método del VideoCaptureclase. Este método acepta un objeto de la clase.Mat para almacenar el marco leído.

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

Ejemplo

El siguiente programa demuestra cómo capturar un fotograma usando la cámara y mostrarlo usando la ventana JavaFX. También guarda el fotograma capturado.

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

Salida

Al ejecutar el programa, obtendrá el siguiente resultado.

Si abre la ruta especificada, puede observar el mismo marco que se guarda como un archivo jpg.

los VideoCapture clase de la org.opencv.videoioEl paquete contiene clases y métodos para capturar video usando la cámara del sistema. Vayamos paso a paso y aprendamos a hacerlo.

Paso 1: Cargue la biblioteca nativa de OpenCV

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

Paso 2: crear una instancia de la clase CascadeClassifier

los CascadeClassifier clase del paquete org.opencv.objdetectse utiliza para cargar el archivo clasificador. Cree una instancia de esta clase pasando elxml archivo lbpcascade_frontalface.xml Como se muestra abajo.

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

Paso 3: detecta las caras

Puede detectar las caras en la imagen usando el método detectMultiScale() de la clase nombrada CascadeClassifier. Este método acepta un objeto de la clase.Mat sosteniendo la imagen de entrada y un objeto de la clase MatOfRect para almacenar los rostros detectados.

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

Ejemplo

El siguiente programa demuestra cómo detectar caras en una imagen.

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

Suponga que la siguiente es la imagen de entrada facedetection_input.jpg especificado en el programa anterior.

Salida

Al ejecutar el programa, obtendrá el siguiente resultado:

Detected 3 faces 
Image Processed

Si abre la ruta especificada, puede observar la imagen de salida de la siguiente manera:

El siguiente programa demuestra cómo detectar rostros usando la cámara del sistema y mostrarlo usando la ventana JavaFX.

Ejemplo

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

Salida

Al ejecutar el programa, obtendrá el siguiente resultado.

Si abre la ruta especificada, puede ver la misma instantánea guardada como un jpg imagen.

Puedes realizar affine translation en una imagen usando el warpAffine()método de la clase imgproc. A continuación se muestra la sintaxis de este método:

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

Este método acepta los siguientes parámetros:

src - A Mat objeto que representa la fuente (imagen de entrada) para esta operación.
dst - A Mat objeto que representa el destino (imagen de salida) para esta operación.
tranformMatrix - A Mat objeto que representa la matriz de transformación.
size - Una variable de tipo entero que representa el tamaño de la imagen de salida.

Ejemplo

El siguiente programa demuestra cómo aplicar una operación afín en una imagen determinada.

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

Suponga que la siguiente es la imagen de entrada transform_input.jpg especificado en el programa anterior.

Salida

Al ejecutarlo, obtendrá el siguiente resultado:

Image Processed

Si abre la ruta especificada, puede observar la imagen de salida de la siguiente manera:

Usted puede perform rotation operación en una imagen usando el warpAffine() método del imgprocclase. A continuación se muestra la sintaxis de este método:

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

Este método acepta los siguientes parámetros:

src - A Mat objeto que representa la fuente (imagen de entrada) para esta operación.
dst - A Mat objeto que representa el destino (imagen de salida) para esta operación.
rotationMatrix - A Mat objeto que representa la matriz de rotación.
size - Una variable de tipo entero que representa el tamaño de la imagen de salida.

Ejemplo

El siguiente programa demuestra cómo rotar una imagen.

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

Suponga que la siguiente es la imagen de entrada transform_input.jpg especificado en el programa anterior.

Salida

Al ejecutar el programa, obtendrá el siguiente resultado:

Image Processed

Si abre la ruta especificada, puede observar la imagen de salida de la siguiente manera:

Puedes realizar scaling en una imagen usando el resize() método del imgprocclase. A continuación se muestra la sintaxis de este método.

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

Este método acepta los siguientes parámetros:

src - A Mat objeto que representa la fuente (imagen de entrada) para esta operación.
dst - A Mat objeto que representa el destino (imagen de salida) para esta operación.
dsize - A Size objeto que representa el tamaño de la imagen de salida.
fx - Una variable del tipo double que representa el factor de escala a lo largo del eje horizontal.
fy - Una variable del tipo double que representa el factor de escala a lo largo del eje vertical.
Interpolation - Una variable entera que representa el método de interpolación.

Ejemplo

El siguiente programa demuestra cómo aplicar scale transformation a una imagen.

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

Suponga que la siguiente es la imagen de entrada transform_input.jpg especificado en el programa anterior (tamaño - Ancho: 300px y alto: 300px).

Salida

Al ejecutar el programa, obtendrá el siguiente resultado:

Image Processed

Si abre la ruta especificada, puede observar la imagen de salida de la siguiente manera (tamaño - Ancho: 600px y alto: 600px) -

En OpenCV, puede aplicar diferentes mapas de color a una imagen usando el método applyColorMap() de la clase Imgproc. A continuación se muestra la sintaxis de este método:

applyColorMap(Mat src, Mat dst, int colormap)

Acepta tres parámetros:

src - Un objeto de la clase Mat que representa la imagen de origen (entrada).
dst - Un objeto de la clase Mat que representa la imagen de destino (salida).
colormap - Una variable de tipo entero que representa el tipo de mapa de color que se aplicará.

Ejemplo

El siguiente programa demuestra cómo aplicar color map a una imagen.

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

Suponga que la siguiente es la imagen de entrada color_input.jpg especificado en el programa anterior.

Salida

Al ejecutar el programa anterior, obtendrá el siguiente resultado:

Image Processed

Si abre la ruta especificada, puede observar la imagen de salida de la siguiente manera:

Más operaciones

Además de COLORMAP_HOTComo se demostró en el ejemplo anterior, OpenCV ofrece otros tipos de mapas de color. Todos estos tipos están representados por campos estáticos predefinidos (valores fijos) de la clase Imgproc.

Puede elegir el tipo de mapa de colores que necesita, pasando su respectivo valor predefinido al parámetro denominado colormap del applyColorMap() método.

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

A continuación se muestran los valores que representan varios tipos de mapas de color y sus respectivos resultados.

Operación y descripción	Salida
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 se utiliza para detectar los bordes en una imagen. Acepta una imagen en escala de grises como entrada y utiliza un algoritmo de varias etapas.

Puede realizar esta operación en una imagen utilizando el Canny() método del imgproc class, a continuación se muestra la sintaxis de este método.

Canny(image, edges, threshold1, threshold2)

Este método acepta los siguientes parámetros:

image - A Mat objeto que representa la fuente (imagen de entrada) para esta operación.
edges - A Mat objeto que representa el destino (bordes) de esta operación.
threshold1 - Una variable del tipo double que representa el primer umbral para el procedimiento de histéresis.
threshold2 - Una variable del tipo double que representa el segundo umbral del procedimiento de histéresis.

Ejemplo

El siguiente programa es un ejemplo que demuestra cómo realizar la operación Canny Edge Detection en una imagen determinada.

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

Suponga que la siguiente es la imagen de entrada canny_input.jpg especificado en el programa anterior.

Salida

Al ejecutar el programa anterior, obtendrá el siguiente resultado:

Image Processed

Si abre la ruta especificada, puede observar la imagen de salida de la siguiente manera:

Puede detectar la forma de una imagen determinada aplicando el Hough Transform technique usando el método HoughLines() del Imgprocclase. A continuación se muestra la sintaxis de este método.

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

Este método acepta los siguientes parámetros:

image - Un objeto de la clase Mat que representa la imagen de origen (entrada).
lines - Un objeto de la clase Mat que almacena el vector que almacena los parámetros (r, Φ) de las líneas.
rho - Una variable de tipo double que representa la resolución del parámetro r en píxeles.
theta - Una variable de tipo double que representa la resolución del parámetro Φ en radianes.
threshold - Una variable de tipo entero que representa el número mínimo de intersecciones para "detectar" una línea.

Ejemplo

El siguiente programa demuestra cómo detectar líneas Hough en una imagen determinada.

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

Suponga que la siguiente es la imagen de entrada hough_input.jpg especificado en el programa anterior.

Salida

Al ejecutar el programa, obtendrá el siguiente resultado:

143 
1 
Image Processed

Si abre la ruta especificada, puede observar la imagen de salida de la siguiente manera:

los histogramde una imagen muestra la frecuencia de los valores de intensidad de los píxeles. En un histograma de imagen, el eje X muestra las intensidades del nivel de gris y el eje Y muestra la frecuencia de estas intensidades.

Histogram equalizationmejora el contraste de una imagen para ampliar el rango de intensidad. Puede ecualizar el histograma de una imagen determinada utilizando el métodoequalizeHist() del Imgprocclase. A continuación se muestra la sintaxis de este método.

equalizeHist(src, dst)

Este método acepta los siguientes parámetros:

src - Un objeto de la clase Mat que representa la imagen de origen (entrada).
dst - Un objeto de la clase Matque representa la salida. (Imagen obtenida tras ecualizar el histograma)

Ejemplo

El siguiente programa demuestra cómo ecualizar el histograma de una imagen dada.

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

Suponga que la siguiente es la imagen de entrada histo_input.jpg especificado en el programa anterior.