OpenCV - Guia rápido

OpenCV é uma biblioteca multiplataforma com a qual podemos desenvolver em tempo real computer vision applications. Ele se concentra principalmente no processamento de imagem, captura e análise de vídeo, incluindo recursos como detecção de rosto e detecção de objeto.

Vamos começar o capítulo definindo o termo "Visão Computacional".

Visão Computacional

Visão computacional pode ser definida como uma disciplina que explica como reconstruir, interromper e compreender uma cena 3D a partir de suas imagens 2D, em termos das propriedades da estrutura presente na cena. Trata-se de modelar e replicar a visão humana usando software e hardware de computador.

A visão computacional se sobrepõe significativamente aos seguintes campos -

  • Image Processing - Concentra-se na manipulação de imagens.

  • Pattern Recognition - Explica várias técnicas para classificar padrões.

  • Photogrammetry - Preocupa-se em obter medidas precisas de imagens.

Visão Computacional Vs Processamento de Imagens

Image processinglida com a transformação de imagem em imagem. A entrada e a saída do processamento de imagem são imagens.

Computer visioné a construção de descrições explícitas e significativas de objetos físicos a partir de sua imagem. A saída da visão computacional é uma descrição ou interpretação de estruturas em cena 3D.

Aplicações da Visão Computacional

Listamos aqui alguns dos principais domínios em que a visão computacional é amplamente utilizada.

Aplicação de Robótica

  • Localização - determine a localização do robô automaticamente

  • Navigation

  • Evitar obstáculos

  • Montagem (peg-in-hole, soldagem, pintura)

  • Manipulação (por exemplo, robô manipulador PUMA)

  • Human Robot Interaction (HRI) - Robótica inteligente para interagir e servir as pessoas

Aplicação de medicamento

  • Classificação e detecção (por exemplo, lesão ou classificação de células e detecção de tumor)
  • Segmentação 2D / 3D
  • Reconstrução 3D de órgãos humanos (ressonância magnética ou ultrassom)
  • Cirurgia robótica guiada pela visão

Aplicação de automação industrial

  • Inspeção industrial (detecção de defeito)
  • Assembly
  • Leitura do código de barras e etiqueta da embalagem
  • Classificação de objetos
  • Compreensão de documentos (por exemplo, OCR)

Aplicativo de Segurança

  • Biometria (íris, impressão digital, reconhecimento facial)

  • Vigilância - Detecção de certas atividades ou comportamentos suspeitos

Aplicação de transporte

  • Veículo autônomo
  • Segurança, por exemplo, monitoramento de vigilância do motorista

Recursos da Biblioteca OpenCV

Usando a biblioteca OpenCV, você pode -

  • Ler e escrever imagens

  • Capture e salve vídeos

  • Processar imagens (filtrar, transformar)

  • Executar detecção de recursos

  • Detecte objetos específicos, como rostos, olhos, carros, nos vídeos ou imagens.

  • Analise o vídeo, ou seja, estime o movimento nele, subtraia o fundo e rastreie os objetos nele.

OpenCV foi originalmente desenvolvido em C ++. Além disso, foram fornecidos vínculos Python e Java. OpenCV é executado em vários sistemas operacionais, como windows, Linux, OSx, FreeBSD, Net BSD, Open BSD, etc.

Este tutorial explica os conceitos de OpenCV com exemplos usando ligações Java.

Módulos da biblioteca OpenCV

A seguir estão os principais módulos da biblioteca OpenCV.

Funcionalidade central

Este módulo cobre as estruturas de dados básicas, como escalar, ponto, intervalo, etc., que são usadas para construir aplicativos OpenCV. Além desses, também inclui a matriz multidimensionalMat, que é usado para armazenar as imagens. Na biblioteca Java do OpenCV, este módulo está incluído como um pacote com o nomeorg.opencv.core.

Processamento de imagem

Este módulo cobre várias operações de processamento de imagem, como filtragem de imagem, transformações geométricas de imagem, conversão de espaço de cores, histogramas, etc. Na biblioteca Java do OpenCV, este módulo está incluído como um pacote com o nome org.opencv.imgproc.

Vídeo

Este módulo cobre os conceitos de análise de vídeo, como estimativa de movimento, subtração de fundo e rastreamento de objetos. Na biblioteca Java do OpenCV, este módulo está incluído como um pacote com o nomeorg.opencv.video.

I / O de vídeo

Este módulo explica a captura de vídeo e codecs de vídeo usando a biblioteca OpenCV. Na biblioteca Java do OpenCV, este módulo está incluído como um pacote com o nomeorg.opencv.videoio.

calib3d

Este módulo inclui algoritmos relativos a algoritmos básicos de geometria de múltiplas visualizações, calibração de câmera única e estéreo, estimativa de pose de objeto, correspondência estéreo e elementos de reconstrução 3D. Na biblioteca Java do OpenCV, este módulo está incluído como um pacote com o nomeorg.opencv.calib3d.

features2d

Este módulo inclui os conceitos de detecção e descrição de recursos. Na biblioteca Java do OpenCV, este módulo está incluído como um pacote com o nomeorg.opencv.features2d.

Objdetect

Este módulo inclui a detecção de objetos e instâncias das classes predefinidas, como rostos, olhos, canecas, pessoas, carros, etc. Na biblioteca Java do OpenCV, este módulo está incluído como um pacote com o nome org.opencv.objdetect.

Highgui

Esta é uma interface fácil de usar com recursos de IU simples. Na biblioteca Java do OpenCV, os recursos deste módulo estão incluídos em dois pacotes diferentes, a saber,org.opencv.imgcodecs e org.opencv.videoio.

Uma breve história do OpenCV

OpenCV foi inicialmente uma iniciativa de pesquisa da Intel para aconselhar aplicativos com uso intenso de CPU. Foi lançado oficialmente em 1999.

  • No ano de 2006, sua primeira versão principal, OpenCV 1.0, foi lançada.
  • Em outubro de 2009, a segunda versão principal, OpenCV 2, foi lançada.
  • Em agosto de 2012, o OpenCV foi adquirido por uma organização sem fins lucrativos OpenCV.org.

Neste capítulo, você aprenderá como instalar o OpenCV e configurar seu ambiente em seu sistema.

Instalando OpenCV

Em primeiro lugar, você precisa baixar o OpenCV em seu sistema. Siga as etapas fornecidas abaixo.

Step 1 - Abra a página inicial de OpenCV clicando no seguinte link: http://opencv.org/ Ao clicar, você verá sua página inicial conforme mostrado abaixo.

Step 2 - Agora, clique no Downloadslink destacado na imagem acima. Ao clicar, você será direcionado para a página de downloads do OpenCV.

Step 3 - Ao clicar no link destacado na imagem acima, um arquivo chamado opencv-3.1.0.exeserá baixado. Extraia este arquivo para gerar uma pastaopencv em seu sistema, conforme mostrado na imagem a seguir.

Step 4 - Abra a pasta OpenCVbuildjava. Aqui você encontrará o arquivo jar do OpenCV chamadoopencv-310.jar. Salve este arquivo em uma pasta separada para uso posterior.

Instalação Eclipse

Depois de fazer download dos arquivos JAR necessários, você deve incorporar esses arquivos JAR ao seu ambiente Eclipse. Você pode fazer isso definindo o caminho de construção para esses arquivos JAR e usandopom.xml.

Definir caminho de construção

A seguir estão as etapas para configurar o OpenCV no Eclipse -

Step 1- Certifique-se de ter instalado o Eclipse em seu sistema. Caso contrário, baixe e instale o Eclipse em seu sistema.

Step 2 - Abra o Eclipse, clique em Arquivo, Novo e Abrir um novo projeto, conforme mostrado na captura de tela a seguir.

Step 3 - Ao selecionar o projeto, você obterá o New ProjectMago. Neste assistente, selecione o projeto Java e continue clicando noNext botão, como mostrado na imagem a seguir.

Step 4 - Ao prosseguir, você será direcionado para o New Java Project wizard. Crie um novo projeto e clique emNext, conforme mostrado na imagem a seguir.

Step 5- Após criar um novo projeto, clique com o botão direito sobre ele. SelecioneBuild Path e clique Configure Build Path… como mostrado na imagem a seguir.

Step 6 - Ao clicar no Build Path opção, você será direcionado para a Java Build Path wizard. Clique noAdd External JARs botão, como mostrado na imagem a seguir.

Step 7 - Selecione o caminho onde você salvou o arquivo opencv-310.jar.

Step 8 - Ao clicar no Open botão na imagem acima, esses arquivos serão adicionados à sua biblioteca.

Step 9 - Ao clicar OK, você adicionará com êxito os arquivos JAR necessários ao projeto atual e poderá verificar essas bibliotecas adicionadas expandindo as Bibliotecas Referidas.

Definindo o caminho para bibliotecas nativas

Além dos arquivos JAR, você precisa definir o caminho para as bibliotecas nativas (arquivos DLL) do OpenCV.

Location of DLL files - Abra a pasta de instalação do OpenCV e vá para a subpasta buildjava. Aqui você encontrará as duas pastasx64 (64 bits) e x86 (32 bits) que contêm o dll arquivos do OpenCV.

Abra a respectiva pasta adequada para o seu sistema operacional, então você pode ver o dll arquivo, como mostrado na imagem a seguir.

Agora, defina o caminho para este arquivo também seguindo as etapas abaixo -

Step 1- Mais uma vez, abra a janela JavaBuildPath. Aqui você pode observar o arquivo JAR adicionado e oJRE System Library.

Step 2 - Ao expandi-lo, você obterá as bibliotecas do sistema e Native library location, conforme destacado na captura de tela a seguir.

Step 3 - Clique duas vezes no Native library location. Aqui, você pode ver oNative Library Folder Configuration window como mostrado abaixo.

Aqui, clique no botão External Folder… e selecione a localização do dll arquivo em seu sistema.

Para capturar uma imagem, usamos dispositivos como câmeras e scanners. Esses dispositivos registram valores numéricos da imagem (Ex: valores de pixel). OpenCV é uma biblioteca que processa as imagens digitais, portanto precisamos armazenar essas imagens para processamento.

o MatA classe da biblioteca OpenCV é usada para armazenar os valores de uma imagem. Ele representa uma matriz n-dimensional e é usado para armazenar dados de imagem em tons de cinza ou imagens coloridas, volumes de voxel, campos de vetor, nuvens de pontos, tensores, histogramas, etc.

Esta classe é composta por duas partes de dados: o header e um pointer

  • Header - Contém informações como tamanho, método usado para armazenar e o endereço da matriz (tamanho constante).

  • Pointer - Armazena os valores de pixel da imagem (continua variando).

The Mat Class

A biblioteca OpenCV Java fornece a esta classe o mesmo nome (Mat) dentro do pacote org.opencv.core.

Construtores

A classe Mat da biblioteca OpenCV Java possui vários construtores, com os quais você pode construir o objeto Mat.

S.No Construtores e descrição
1

Mat()

Este é o construtor padrão sem parâmetros na maioria dos casos. Usamos isso como construtor para criar uma matriz vazia e passá-la para outros métodos OpenCV.

2

Mat(int rows, int cols, int type)

Este construtor aceita três parâmetros do tipo inteiro que representam o número de linhas e colunas em um array 2D e o tipo do array (que deve ser usado para armazenar dados).

3

Mat(int rows, int cols, int type, Scalar s)

Incluindo os parâmetros do anterior, este construtor aceita adicionalmente como parâmetro um objeto da classe Scalar.

4

Mat(Size size, int type)

Este construtor aceita dois parâmetros, um objeto que representa o tamanho da matriz e um inteiro que representa o tipo de array usado para armazenar os dados.

5

Mat(Size size, int type, Scalar s)

Incluindo os parâmetros do anterior, este construtor aceita adicionalmente como parâmetro um objeto da classe Scalar.

6

Mat(long addr)

7

Mat(Mat m, Range rowRange)

Este construtor aceita um objeto de outra matriz e um objeto da classe Range que representa o intervalo das linhas a serem utilizadas para criar uma nova matriz.

8

Mat(Mat m, Range rowRange, Range colRange)

Incluindo os parâmetros do anterior, este construtor aceita adicionalmente um objeto da classe. Intervalo que representa o intervalo da coluna.

9

Mat(Mat m, Rect roi)

Este construtor aceita dois objetos, um representando outra matriz e outro representando o Região Of Interest.

Note -

  • Tipo de matriz. Use CV_8UC1, ..., CV_64FC4 para criar matrizes de 1-4 canais ou CV_8UC (n), ..., CV_64FC (n) para criar matrizes de multicanais (até canais CV_CN_MAX).

  • O tipo das matrizes foram representados por vários campos da classe CvType que pertence ao pacote org.opencv.core.

Métodos e Descrição

A seguir estão alguns dos métodos fornecidos pela classe Mat.

S.No Métodos e Descrição
1

Mat col(int x)

Este método aceita um parâmetro inteiro que representa o índice de uma coluna e recupera e retorna essa coluna.

2

Mat row(int y)

Este método aceita um parâmetro inteiro que representa o índice de uma linha e recupera e retorna essa linha.

3

int cols()

Este método retorna o número de colunas na matriz.

4

int rows()

Este método retorna o número de linhas na matriz.

5

Mat setTo(Mat value)

Este método aceita um objeto da Mat digite e define os elementos da matriz com o valor especificado.

6

Mat setTo(Scalar s)

Este método aceita um objeto da Scalar digite e define os elementos da matriz com o valor especificado.

Criação e exibição da matriz

Nesta seção, vamos discutir nosso primeiro exemplo de OpenCV. Veremos como criar e exibir uma matriz OpenCV simples.

A seguir estão as etapas a serem seguidas para criar e exibir uma matriz em OpenCV.

Etapa 1: carregar a biblioteca nativa OpenCV

Ao escrever o código Java usando a biblioteca OpenCV, a primeira etapa que você precisa fazer é carregar a biblioteca nativa do OpenCV usando o loadLibrary(). Carregue a biblioteca nativa OpenCV conforme mostrado abaixo.

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

Etapa 2: instancie a classe Mat

Instancie a classe Mat usando qualquer uma das funções mencionadas neste capítulo anteriormente.

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

Etapa 3: Preencher a matriz usando os métodos

Você pode recuperar linhas / colunas específicas de uma matriz passando valores de índice para os métodos row()/col().

E você pode definir valores para eles usando qualquer uma das variantes do 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

Você pode usar o seguinte código de programa para criar e exibir uma matriz simples em Java usando a 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()); 
   } 
}

Ao executar o programa acima, você obterá a seguinte saída -

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]

Carregando imagem usando JavaSE API

o BufferedImage classe do java.awt.image.BufferedImage pacote é usado para armazenar uma imagem e o ImageIO classe do pacote import javax.imageio fornece métodos para ler e gravar imagens.

Example

Você pode usar o seguinte código de programa para carregar e salvar imagens usando a 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");
   } 
}

Ao executar o programa acima, você obterá a seguinte saída -

image Saved

Se você abrir o caminho especificado, você pode observar a imagem salva da seguinte maneira -

o Imgcodecs classe do pacote org.opencv.imgcodecsfornece métodos para ler e escrever imagens. Usando o OpenCV, você pode ler uma imagem e armazená-la em uma matriz (realizar transformações na matriz, se necessário). Posteriormente, você pode gravar a matriz processada em um arquivo.

o read() método do Imgcodecsclasse é usada para ler uma imagem usando OpenCV. A seguir está a sintaxe desse método.

imread(filename)

Aceita um argumento (filename), uma variável do tipo String que representa o caminho do arquivo que deve ser lido.

A seguir estão os passos a serem seguidos para ler imagens em Java usando a biblioteca OpenCV.

Etapa 1: carregar a biblioteca nativa OpenCV

Carregue a biblioteca nativa OpenCV usando o load() método, conforme mostrado abaixo.

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

Etapa 2: instancie a classe Imgcodecs

Instancie o Imgcodecs classe.

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

Etapa 3: ler a imagem

Leia a imagem usando o método imread(). Este método aceita um argumento string que representa o caminho da imagem e retorna a imagem lida comoMat objeto.

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

Exemplo

O seguinte código de programa mostra como você pode read an image usando a 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");     
   } 
}

Ao executar o programa acima, OpenCV carrega a imagem especificada e exibe a seguinte saída -

Image Loaded

o write() método do Imgcodecsclasse é usada para escrever uma imagem usando OpenCV. Para escrever uma imagem, repita as três primeiras etapas do exemplo anterior.

Para escrever uma imagem, você precisa invocar o imwrite() método do Imgcodecs classe.

A seguir está a sintaxe desse método.

imwrite(filename, mat)

Este método aceita os seguintes parâmetros -

  • filename - A String variável que representa o caminho onde salvar o arquivo.

  • mat - A Mat objeto que representa a imagem a ser escrita.

Exemplo

O programa a seguir é um exemplo para write an image usando o programa Java usando a 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 ............"); 
   } 
}

Ao executar o programa acima, você obterá a seguinte saída -

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

Se você abrir o caminho especificado, poderá observar a imagem salva conforme mostrado abaixo -

Nos capítulos anteriores, discutimos como ler e salvar uma imagem usando a biblioteca OpenCV Java. Além disso, também podemos exibir as imagens carregadas em uma janela separada usando bibliotecas GUI, como AWT / Swings e JavaFX.

Conversão de tapete em imagem com buffer

Para ler uma imagem, usamos o método imread(). Este método retorna a imagem lida na forma deMatrix. Mas, para usar esta imagem com bibliotecas GUI (AWT / Swings e JavaFX), ela deve ser convertida como um objeto da classeBufferedImage do pacote java.awt.image.BufferedImage.

A seguir estão as etapas para converter um Mat objeto do OpenCV para BufferedImage objeto.

Etapa 1: codificar o tapete para MatOfByte

Em primeiro lugar, você precisa converter a matriz em matriz de byte. Você pode fazer isso usando o métodoimencode() da classe Imgcodecs. A seguir está a sintaxe desse método.

imencode(ext, image, matOfByte);

Este método aceita os seguintes parâmetros -

  • Ext - Um parâmetro String que especifica o formato da imagem (.jpg, .png, etc.)

  • image - Um objeto Mat da imagem

  • matOfByte - Um objeto vazio da classe MatOfByte

Codifique a imagem usando este método conforme mostrado abaixo.

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

Etapa 2: converter o objeto MatOfByte em matriz de bytes

Converta o MatOfByte objeto em uma matriz de bytes usando o método toArray().

byte[] byteArray = matOfByte.toArray();

Etapa 3: Preparando o objeto InputStream

Prepare o objeto InputStream passando a matriz de bytes criada na etapa anterior para o construtor do ByteArrayInputStream classe.

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

Etapa 4: Preparar o objeto InputStream

Passe o objeto Input Stream criado na etapa anterior para o read() método do ImageIOclasse. Isso retornará um objeto BufferedImage.

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

Exibindo imagem usando AWT / Swings

Para exibir uma imagem usando o quadro AWT / Swings, em primeiro lugar, leia uma imagem usando o imread() método e convertê-lo em BufferedImage seguindo as etapas mencionadas acima.

Em seguida, instancie o JFrame classe e adicione a imagem em buffer criada ao ContentPane do JFrame, conforme mostrado abaixo -

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

O seguinte código de programa mostra como você pode read uma imagem e display através da janela giratória usando a 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");     
   } 
}

Ao executar o programa acima, você obterá a seguinte saída -

Image Loaded

Além disso, você pode ver uma janela exibindo a imagem carregada, da seguinte forma -

Exibindo imagens usando JavaFX

Para exibir uma imagem usando JavaFX, em primeiro lugar, leia uma imagem usando o imread() método e convertê-lo em BufferedImage. Em seguida, converta BufferedImage em WritableImage, conforme mostrado abaixo.

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

Passe isso WritableImage objeto para o construtor do ImageView classe.

ImageView imageView = new ImageView(writableImage);

Example

O código do programa a seguir mostra como read uma imagem e display através da janela JavaFX usando a 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); 
   } 
}

Ao executar o programa acima, você obterá a seguinte saída -

Image Loaded

Além disso, você pode ver uma janela exibindo a imagem carregada, da seguinte forma -

OpenCV oferece suporte a vários tipos de imagens, como coloridas, binárias, tons de cinza, etc. imread() método e campos predefinidos do Imgcodecs classe, você pode ler uma determinada imagem como outro tipo.

O parâmetro flags do método imread () (IMREAD_XXX)

Nos capítulos anteriores, vimos a sintaxe de imread() método do Imgcodecsclasse. Ele aceita um argumento de string que representa a localização da imagem que deve ser lida.

imread(filename)

o imread() método tem outra sintaxe.

imread(filename, int flags)

Esta sintaxe aceita dois parâmetros -

  • filename - Aceita um argumento (filename), uma variável do tipo String que representa o caminho do arquivo que deve ser lido.

  • flags- Um valor inteiro que representa um valor de sinalizador predefinido. Para cada valor, ele lê a imagem fornecida como um tipo específico (cor da escala de cinza etc.)

A seguir está a tabela que lista vários campos fornecidos no Imgproc classe como valores para este parâmetro.

S.No Campos e Descrição
1

IMREAD_COLOR

Se o sinalizador for definido com este valor, a imagem carregada será convertida em uma imagem colorida BGR (Blue Green Red) de 3 canais.

2

IMREAD_GRAYSCALE

Se o sinalizador for definido com este valor, a imagem carregada será convertida em uma imagem em tons de cinza de canal único.

3

IMREAD_LOAD_GDAL

Se o sinalizador estiver definido com este valor, você pode carregar a imagem usando o gdal motorista.

4

IMREAD_ANYCOLOR

Se o sinalizador for definido com este valor, a imagem é lida em qualquer formato de cor possível.

5

IMREAD_REDUCED_COLOR_2

IMREAD_REDUCED_COLOR_4

IMREAD_REDUCED_COLOR_8

Se a bandeira é definido para este valor, a imagem é lida como três canais BGR, e o tamanho da imagem é reduzida para ½, ¼ th ou ⅛ th do tamanho original da imagem com relação ao campo utilizado.

6

IMREAD_REDUCED_GRAYSCALE_2

IMREAD_REDUCED_GRAYSCALE_4

IMREAD_REDUCED_GRAYSCALE_8

Se a bandeira é definido para este valor, a imagem é lida como uma imagem em tons de cinzento com um único canal, e o tamanho da imagem é reduzida para ½ ¼, th ou ⅛ th do tamanho original da imagem com relação ao campo utilizados .

7

IMREAD_UNCHANGED

Se o sinalizador for definido com esse valor, a imagem carregada será retornada como está.

O programa a seguir demonstra como ler uma imagem colorida em tons de cinza e exibi-la usando a janela JavaFX. Aqui, lemos a imagem passando a bandeiraIMREAD_GRAYSCALE junto com a corda segurando o caminho de uma imagem colorida.

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

Imagem de entrada

Suponha que a seguir está a imagem de entrada sample.jpg especificado no programa acima.

Imagem de saída

Ao executar o programa, você obterá a seguinte saída.

O programa a seguir demonstra como ler uma imagem colorida como uma imagem do tipo BGR e exibi-la usando a janela JavaFX. Aqui, lemos a imagem passando a bandeiraIMREAD_COLOR ao método imread() junto com a corda segurando o caminho de uma imagem colorida.

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

Imagem de entrada

Suponha que a seguir está a imagem de entrada sample.jpg especificado no programa acima.

Imagem de saída

Ao executar o programa, você obterá a seguinte saída.

Nos capítulos anteriores, discutimos como ler uma imagem de entrada como tipos diferentes (binário, tons de cinza, BGR, etc.). Neste capítulo, aprenderemos como converter um tipo de imagem em outro.

A classe chamada Imgproc do pacote org.opencv.imgproc fornece métodos para converter uma imagem de uma cor para outra.

Converter imagens coloridas em tons de cinza

Um método chamado cvtColor()é usado para converter imagens coloridas em tons de cinza. A seguir está a sintaxe desse método.

cvtColor(Mat src, Mat dst, int code)

Este método aceita os seguintes parâmetros -

  • src - Uma matriz que representa a fonte.

  • dst - Uma matriz que representa o destino.

  • code - Um código inteiro que representa o tipo de conversão, por exemplo, RGB para tons de cinza.

Você pode converter imagens coloridas em escala de cinza passando o código Imgproc.COLOR_RGB2GRAY junto com as matrizes de origem e destino como um parâmetro para o cvtColor() método.

Exemplo

O programa a seguir demonstra como ler uma imagem colorida como uma imagem em tons de cinza e exibi-la usando a janela 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);
   }
}

Imagem de entrada

Suponha que a seguir está a imagem de entrada sample.jpg especificado no programa acima.

Imagem de saída

Ao executar o programa, você obterá a seguinte saída.

Um método chamado threshold()é usado para converter imagens em tons de cinza em imagem binária. A seguir está a sintaxe desse método.

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

Este método aceita os seguintes parâmetros -

  • mat - A Mat objeto que representa a imagem de entrada.

  • dst - A Mat objeto que representa a imagem de saída.

  • thresh - Um número inteiro que representa o valor limite.

  • maxval - Um número inteiro que representa o valor máximo a ser usado com os tipos de limite THRESH_BINARY e THRESH_BINARY_INV.

  • type - Um código inteiro que representa o tipo de conversão, por exemplo, RGB para tons de cinza.

Você pode converter uma imagem em tons de cinza em uma imagem binária passando o código Imgproc.THRESH_BINARY junto com os valores para os parâmetros restantes.

Exemplo

O programa a seguir demonstra como ler uma imagem colorida como uma imagem binária e exibi-la usando a janela 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);
   }
}

Imagem de entrada

Suponha que a seguir está a imagem de entrada sample.jpg especificado no programa acima.

Imagem de saída

Ao executar o programa, você obterá a seguinte saída.

Você pode usar o mesmo método mencionado no capítulo anterior para converter uma imagem em tons de cinza em uma imagem binária. Basta passar o caminho para uma imagem em tons de cinza como entrada para este programa.

Exemplo

O programa a seguir demonstra como ler uma imagem em tons de cinza como uma imagem binária e exibi-la usando a janela 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);
   }
}

Imagem de entrada

Suponha que a seguir está a imagem de entrada sample.jpg especificado no programa acima.

Imagem de saída

Ao executar o programa, você obterá a seguinte saída.

Você pode desenhar várias formas como Círculo, Retângulo, Linha, Elipse, Polilinhas, Convexo, Polilinhas, Polilinhas em uma imagem usando os respectivos métodos do org.opencv.imgproc pacote.

Você pode desenhar um círculo em uma imagem usando o método circle() do imgprocclasse. A seguir está a sintaxe deste método -

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

Este método aceita os seguintes parâmetros -

  • mat - A Mat objeto que representa a imagem na qual o círculo será desenhado.

  • point - A Point objeto que representa o centro do círculo.

  • radius - Uma variável do tipo integer representando o raio do círculo.

  • scalar - A Scalarobjeto que representa a cor do círculo. (BGR)

  • thickness - um integerrepresentando a espessura do círculo; por padrão, o valor da espessura é 1.

Exemplo

O programa a seguir demonstra como desenhar um círculo em uma imagem e exibi-lo usando a janela 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);
   }
}

Ao executar o programa acima, você obterá a seguinte saída -

Você pode desenhar uma linha em uma imagem usando o método line() do imgprocclasse. A seguir está a sintaxe desse método.

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

Este método aceita os seguintes parâmetros -

  • mat - A Mat objeto que representa a imagem na qual a linha deve ser desenhada.

  • pt1 and pt2 - dois Point objetos que representam os pontos entre os quais a linha deve ser desenhada.

  • scalar - A Scalarobjeto que representa a cor do círculo. (BGR)

  • thickness- Um inteiro representando a espessura da linha; por padrão, o valor da espessura é 1.

Exemplo

O programa a seguir demonstra como desenhar uma linha em uma imagem e exibi-la usando a janela 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);
   }
}

Ao executar o programa acima, você obterá a seguinte saída -

Você pode desenhar um retângulo em uma imagem usando o método rectangle() do imgprocclasse. A seguir está a sintaxe deste método -

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

Este método aceita os seguintes parâmetros -

  • mat - A Mat objeto que representa a imagem na qual o retângulo deve ser desenhado.

  • pt1 and pt2 - dois Point objetos que representam os vértices do retângulo que deve ser desenhado.

  • scalar - A Scalarobjeto que representa a cor do retângulo. (BGR)

  • thickness- Um número inteiro representando a espessura do retângulo; por padrão, o valor da espessura é 1.

Exemplo

O exemplo a seguir demonstra como desenhar um retângulo em uma imagem e exibi-lo usando a janela 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);
   }
}

Ao executar o programa acima, você obterá a seguinte saída -

Você pode desenhar uma elipse em uma imagem usando o método rectangle() do imgprocclasse. A seguir está a sintaxe deste método -

ellipse(img, box, color, thickness)

Este método aceita os seguintes parâmetros -

  • mat - A Mat objeto que representa a imagem na qual o retângulo será desenhado.

  • box - Um objeto RotatedRect (a elipse é desenhada inscrita neste retângulo.)

  • scalar - A Scalarobjeto que representa a cor do retângulo. (BGR)

  • thickness- Um inteiro representando a espessura do retângulo; por padrão, o valor da espessura é 1.

O construtor do RotatedRect classe aceita um objeto da classe Point, um objeto da classe Size e uma variável do tipo double, conforme mostrado a seguir.

RotatedRect(Point c, Size s, double a)

Exemplo

O programa a seguir demonstra como desenhar uma elipse em uma imagem e exibi-la usando a janela 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);
   }
}

Ao executar o programa acima, você obterá a seguinte saída -

Você pode desenhar polilinhas em uma imagem usando o método polylines() do imgprocclasse. A seguir está a sintaxe desse método.

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

Este método aceita os seguintes parâmetros -

  • mat - A Mat objeto que representa a imagem na qual as polilinhas serão desenhadas.

  • pts - A List objeto segurando os objetos do tipo MatOfPoint.

  • isClosed - Um parâmetro do tipo booleano especificando se as polilinhas são fechadas.

  • scalar - A Scalarobjeto que representa a cor das polilinhas. (BGR)

  • thickness- Um número inteiro que representa a espessura das polilinhas; por padrão, o valor da espessura é 1.

O construtor do MatOfPoint classe aceita objetos da classe Point.

MatOfPoint(Point... a)

Exemplo

O programa a seguir demonstra como desenhar polilinhas em uma imagem e exibi-la usando a janela 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);
   }
}

Ao executar o programa acima, você obterá a seguinte saída -

Você pode desenhar polilinhas convexas em uma imagem usando o método fillconvexPoly() do imgprocclasse. A seguir está a sintaxe desse método.

fillConvexPoly(Mat img, MatOfPoint points, Scalar color)

Este método aceita os seguintes parâmetros -

  • mat - A Mat objeto que representa a imagem na qual as polilinhas convexas serão desenhadas.

  • points - A MatOfPoint objeto que representa pontos entre os quais as polilinhas convexas devem ser desenhadas.

  • scalar - A Scalarobjeto que representa a cor das polilinhas convexas. (BGR)

O construtor do MatOfPoint classe aceita objetos da classe Point.

MatOfPoint(Point... a)

Exemplo

O programa a seguir demonstra como desenhar polilinhas convexas em uma imagem e exibi-la usando a janela 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);
   }
}

Ao executar o programa acima, você obterá a seguinte saída -

Você pode desenhar uma linha com seta em uma imagem usando o método arrowedLine() do imgprocclasse. A seguir está a sintaxe deste método -

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

Este método aceita os seguintes parâmetros -

  • mat - A Mat objeto que representa a imagem na qual a linha com seta deve ser desenhada.

  • pt1 and pt2 - dois Point objetos que representam os pontos entre os quais a linha com seta deve ser desenhada.

  • scalar - A Scalarobjeto que representa a cor da linha com setas. (BGR)

Exemplo

O programa a seguir demonstra como desenhar uma linha com seta em uma imagem e exibi-la usando a janela 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);
   }
}

Ao executar o programa acima, você obterá a seguinte saída -

Você pode adicionar texto a uma imagem usando o método arrowedLine() do imgprocclasse. A seguir está a sintaxe desse método.

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

Este método aceita os seguintes parâmetros -

  • mat - A Mat objeto que representa a imagem à qual o texto deve ser adicionado.

  • text - A string variável de representar o texto a ser adicionado.

  • org - A Point objeto que representa a sequência de texto do canto inferior esquerdo da imagem.

  • fontFace - Uma variável do tipo inteiro que representa o tipo de fonte.

  • fontScale - Uma variável do tipo double representando o fator de escala que é multiplicado pelo tamanho de base específico da fonte.

  • scalar - A Scalarobjeto que representa a cor do texto a ser adicionado. (BGR)

  • thickness - Um número inteiro que representa a espessura da linha por padrão, o valor da espessura é 1.

Exemplo

O programa a seguir demonstra como adicionar texto a uma imagem e exibi-lo usando a janela 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);
   }
}

Ao executar o programa acima, você obterá a seguinte saída -

Desfoque (suavização) é a operação de processamento de imagem comumente usada para reduzir o ruído da imagem. O processo remove conteúdo de alta frequência, como bordas, da imagem e a torna mais suave.

Em geral, o desfoque é obtido pela convolução (cada elemento da imagem é adicionado aos seus vizinhos locais, ponderados pelo kernel) a imagem por meio de um kernel de filtro passa-baixo.

Desfoque (média)

Durante esta operação, a imagem é convolvida com um filtro de caixa (normalizado). Nesse processo, o elemento central da imagem é substituído pela média de todos os pixels da área do kernel.

Você pode realizar esta operação em uma imagem usando o método blur() do imgprocclasse. A seguir está a sintaxe deste método -

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

Este método aceita os seguintes parâmetros -

  • src - A Mat objeto que representa a fonte (imagem de entrada) para esta operação.

  • dst - A Mat objeto que representa o destino (imagem de saída) para esta operação.

  • ksize - A Size objeto que representa o tamanho do kernel.

  • anchor - Uma variável do tipo inteiro que representa o ponto de ancoragem.

  • borderType - Uma variável do tipo inteiro que representa o tipo de borda a ser usada para a saída.

Exemplo

O programa a seguir demonstra como realizar a operação de cálculo da média (desfoque) em uma imagem.

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

Suponha que a seguir está a imagem de entrada sample.jpg especificado no programa acima.

Resultado

Ao executar o programa, você obterá a seguinte saída -

Image Processed

Se você abrir o caminho especificado, poderá observar a imagem de saída da seguinte maneira -

Na operação Gaussian Blur, a imagem é convolvida com um filtro Gaussiano em vez do filtro de caixa. O filtro Gaussiano é um filtro passa-baixa que remove os componentes de alta frequência são reduzidos.

Você pode realizar esta operação em uma imagem usando o Gaussianblur() método do imgprocclasse. A seguir está a sintaxe deste método -

GaussianBlur(src, dst, ksize, sigmaX)

Este método aceita os seguintes parâmetros -

  • src - A Mat objeto que representa a fonte (imagem de entrada) para esta operação.

  • dst - A Mat objeto que representa o destino (imagem de saída) para esta operação.

  • ksize - A Size objeto que representa o tamanho do kernel.

  • sigmaX - Uma variável do tipo double representando o desvio padrão do kernel gaussiano na direção X.

Exemplo

O programa a seguir demonstra como realizar a operação de desfoque gaussiano em uma imagem.

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

Suponha que a seguir está a imagem de entrada sample.jpg especificado no programa acima.

Resultado

Ao executar o programa, você obterá a seguinte saída -

Image Processed

Se você abrir o caminho especificado, poderá observar a imagem de saída da seguinte maneira -

A operação de desfoque médio é semelhante aos outros métodos de média. Aqui, o elemento central da imagem é substituído pela mediana de todos os pixels na área do kernel. Esta operação processa as bordas enquanto remove o ruído.

Você pode realizar esta operação em uma imagem usando o medianBlur() método do imgprocclasse. A seguir está a sintaxe deste método -

medianBlur(src, dst, ksize)

Este método aceita os seguintes parâmetros -

  • src - A Mat objeto que representa a fonte (imagem de entrada) para esta operação.

  • dst - A Mat objeto que representa o destino (imagem de saída) para esta operação.

  • ksize - A Size objeto que representa o tamanho do kernel.

Exemplo

O programa a seguir demonstra como realizar a operação de desfoque médio em uma imagem.

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

Suponha que a seguir está a imagem de entrada sample.jpg especificado no programa acima.

Resultado

Ao executar o programa, você obterá a seguinte saída -

Image Processed

Se você abrir o caminho especificado, poderá observar a imagem de saída da seguinte maneira -

A filtragem de imagens permite aplicar vários efeitos a uma imagem. Neste capítulo e nos três capítulos subsequentes, discutiremos várias operações de filtro, como Filtro Bilateral, Filtro de Caixa, Filtro de Caixa SQR e Filtro2D.

Filtro Bilateral

A operação Filtro Bilateral aplica uma imagem bilateral a um filtro. Você pode realizar esta operação em uma imagem usando omedianBlur() método do imgprocclasse. A seguir está a sintaxe desse método.

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

Este método aceita os seguintes parâmetros -

  • src - A Mat objeto que representa a fonte (imagem de entrada) para esta operação.

  • dst - A Mat objeto que representa o destino (imagem de saída) para esta operação.

  • d - Uma variável do tipo inteiro que representa o diâmetro da vizinhança do pixel.

  • sigmaColor - Uma variável do tipo inteiro que representa o sigma do filtro no espaço de cores.

  • sigmaSpace - Uma variável do tipo inteiro que representa o sigma do filtro no espaço de coordenadas.

  • borderType - Um objeto inteiro que representa o tipo de borda usada.

Exemplo

O programa a seguir demonstra como realizar a operação Filtro Bilateral em uma imagem.

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

Suponha que a seguir está a imagem de entrada filter_input.jpg especificado no programa acima.

Resultado

Ao executar o programa, você obterá a seguinte saída -

Image Processed

Se você abrir o caminho especificado, poderá observar a imagem de saída da seguinte maneira -

A operação do Box Filter é semelhante à operação de média de desfoque; ele aplica uma imagem bilateral a um filtro. Aqui, você pode escolher se a caixa deve ser normalizada ou não.

Você pode realizar esta operação em uma imagem usando o boxFilter() método do imgprocclasse. A seguir está a sintaxe deste método -

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

Este método aceita os seguintes parâmetros -

  • src - A Mat objeto que representa a fonte (imagem de entrada) para esta operação.

  • dst - A Mat objeto que representa o destino (imagem de saída) para esta operação.

  • ddepth - Uma variável do tipo inteiro que representa a profundidade da imagem de saída.

  • ksize - A Size objeto que representa o tamanho do kernel desfocado.

  • anchor - Uma variável do tipo inteiro que representa o ponto de ancoragem.

  • Normalize - Uma variável do tipo booleano especificando o clima do kernel deve ser normalizado.

  • borderType - Um objeto inteiro que representa o tipo de borda usada.

Exemplo

O programa a seguir demonstra como realizar a operação do Filtro de Caixa em uma imagem.

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

Suponha que a seguir está a imagem de entrada filter_input.jpg especificado no programa acima.

Resultado

Ao executar o programa, você obterá a seguinte saída -

Image Processed

Se você abrir o caminho especificado, poderá observar a imagem de saída da seguinte maneira -

Você pode realizar a operação de filtro SQRBox em uma imagem usando o boxFilter() método do imgprocclasse. A seguir está a sintaxe deste método -

sqrBoxFilter(src, dst, ddepth, ksize)

Este método aceita os seguintes parâmetros -

  • src - A Mat objeto que representa a fonte (imagem de entrada) para esta operação.

  • dst - A Mat objeto que representa o destino (imagem de saída) para esta operação.

  • ddepth - Uma variável do tipo inteiro que representa a profundidade da imagem de saída.

  • ksize - A Size objeto que representa o tamanho do kernel desfocado.

Exemplo

O programa a seguir demonstra como realizar a operação de filtro Sqrbox em uma determinada imagem.

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

Suponha que a seguir está a imagem de entrada filter_input.jpg especificado no programa acima.

Resultado

Ao executar o programa, você obterá a seguinte saída -

Image Processed

Se você abrir o caminho especificado, poderá observar a imagem de saída da seguinte maneira -

A operação Filter2D envolve uma imagem com o kernel. Você pode realizar esta operação em uma imagem usando oFilter2D() método do imgprocclasse. A seguir está a sintaxe deste método -

filter2D(src, dst, ddepth, kernel)

Este método aceita os seguintes parâmetros -

  • src - A Mat objeto que representa a fonte (imagem de entrada) para esta operação.

  • dst - A Mat objeto que representa o destino (imagem de saída) para esta operação.

  • ddepth - Uma variável do tipo inteiro que representa a profundidade da imagem de saída.

  • kernel - A Mat objeto que representa o kernel de convolução.

Exemplo

O programa a seguir demonstra como realizar a operação Filter2D em uma imagem.

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

Suponha que a seguir está a imagem de entrada filter_input.jpg especificado no programa acima.

Resultado

Ao executar o programa, você obterá a seguinte saída -

Image Processed

Se você abrir o caminho especificado, poderá observar a imagem de saída da seguinte maneira -

Erosão e dilatação são os dois tipos de operações morfológicas. Como o nome indica, operações morfológicas são o conjunto de operações que processam imagens de acordo com suas formas.

Com base na imagem de entrada fornecida, um "elemento estrutural" é desenvolvido. Isso pode ser feito em qualquer um dos dois procedimentos. Visam remover ruídos e regularizar as imperfeições, para tornar a imagem mais nítida.

Dilatação

Este procedimento segue a convolução com algum núcleo de uma forma específica, como um quadrado ou um círculo. Este kernel possui um ponto de ancoragem, que denota seu centro.

Este kernel é sobreposto à imagem para calcular o valor máximo do pixel. Após o cálculo, a imagem é substituída por âncora no centro. Com este procedimento, as áreas de regiões brilhantes aumentam de tamanho e, portanto, o tamanho da imagem aumenta.

Por exemplo, o tamanho de um objeto em tom branco ou tom claro aumenta, enquanto o tamanho de um objeto em tom preto ou tom escuro diminui.

Você pode realizar a operação de dilatação em uma imagem usando o dilate() método do imgprocclasse. A seguir está a sintaxe desse método.

dilate(src, dst, kernel)

Este método aceita os seguintes parâmetros -

  • src - A Mat objeto que representa a fonte (imagem de entrada) para esta operação.

  • dst - A Mat objeto que representa o destino (imagem de saída) para esta operação.

  • kernel - A Mat objeto que representa o kernel.

Exemplo

Você pode preparar a matriz do kernel usando o getStructuringElement()método. Este método aceita um número inteiro que representa omorph_rect tipo e um objeto do tipo Size.

Imgproc.getStructuringElement(int shape, Size ksize);

O programa a seguir demonstra como realizar a operação de dilatação em uma determinada imagem.

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

Suponha que a seguir está a imagem de entrada sample.jpg especificado no programa acima.

Resultado

Ao executar o programa, você obterá a seguinte saída -

Image Processed

Se você abrir o caminho especificado, poderá observar a imagem de saída da seguinte maneira -

A erosão é um processo bastante semelhante à dilatação. Mas o valor do pixel calculado aqui é mínimo e não máximo na dilatação. A imagem é substituída sob o ponto de ancoragem com aquele valor mínimo de pixel.

Com este procedimento, as áreas das regiões escuras aumentam de tamanho e as regiões claras diminuem. Por exemplo, o tamanho de um objeto na tonalidade escura ou na tonalidade preta aumenta, enquanto diminui na tonalidade branca ou brilhante.

Exemplo

Você pode realizar esta operação em uma imagem usando o erode() método do imgprocclasse. A seguir está a sintaxe deste método -

erode(src, dst, kernel)

Este método aceita os seguintes parâmetros -

  • src - A Mat objeto que representa a fonte (imagem de entrada) para esta operação.

  • dst - A Mat objeto que representa o destino (imagem de saída) para esta operação.

  • kernel - A Mat objeto que representa o kernel.

Você pode preparar a matriz do kernel usando o getStructuringElement()método. Este método aceita um número inteiro que representa omorph_rect tipo e um objeto do tipo Size.

Imgproc.getStructuringElement(int shape, Size ksize);

O programa a seguir demonstra como realizar a operação de erosão em uma determinada imagem.

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

Suponha que a seguir está a imagem de entrada sample.jpg especificado no programa acima.

Resultado

Ao executar o programa, você obterá a seguinte saída -

Image Loaded

Se você abrir o caminho especificado, poderá observar a imagem de saída da seguinte maneira -

Nos capítulos anteriores, discutimos o processo de erosion e dilation. Além desses dois, o OpenCV apresenta mais transformações morfológicas. omorphologyEx() do método da aula Imgproc é usado para realizar essas operações em uma determinada imagem.

A seguir está a sintaxe deste método -

morphologyEx(src, dst, op, kernel)

Este método aceita os seguintes parâmetros -

  • src - Um objeto da aula Mat representando a imagem de origem (entrada).

  • dst - objeto da aula Mat representando a imagem de destino (saída).

  • op - Um número inteiro que representa o tipo de operação morfológica.

  • kernel - Uma matriz de kernel.

Exemplo

O programa a seguir demonstra como aplicar a operação morfológica "top-hat" em uma imagem usando a 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");
   } 
}

Suponha que a seguir está a imagem de entrada morph_input.jpg especificado no programa acima.

Resultado

Ao executar o programa, você obterá a seguinte saída -

Image Processed

Se você abrir o caminho especificado, poderá observar a imagem de saída da seguinte maneira -

Mais operações

Além da operação morfológica TOPHAT, demonstrado no anterior example, OpenCV atende vários outros tipos de morfologias. Todos esses tipos são representados por campos estáticos predefinidos (valores fixos) deImgproc classe.

Você pode escolher o tipo de morfologia que você precisa passando seus respectivos valores predefinidos para o parâmetro op do morphologyEx() método.

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

A seguir estão os valores que representam o tipo de operações morfológicas e suas respectivas saídas.

Operação e descrição Resultado
MORPH_BLACKHAT
MORPH_CLOSE
MORPH_CROSS
MORPH_DILATE
MORPH_ELLIPSE
MORPH_ERODE
MORPH_GRADIENT
MORPH_OPEN
MORPH_RECT
MORPH_TOPHAT

Pirâmide é uma operação em uma imagem onde,

  • Uma imagem de entrada é inicialmente suavizada usando um filtro de suavização específico (ex: Gaussiano, Laplaciano) e então a imagem suavizada é subamostrada.

  • Este processo é repetido várias vezes.

Durante a operação de pirâmide, a suavidade da imagem é aumentada e a resolução (tamanho) é reduzida.

Pyramid Up

Em Pyramid Up, a imagem é inicialmente ampliada e depois desfocada. Você pode realizar a operação Pyramid Up em uma imagem usando opyrUP() método do imgprocclasse. A seguir está a sintaxe deste método -

pyrUp(src, dst, dstsize, borderType)

Este método aceita os seguintes parâmetros -

  • src - Um objeto da aula Mat representando a imagem de origem (entrada).

  • mat - Um objeto da aula Mat representando a imagem de destino (saída).

  • size - Um objeto da aula Size representando o tamanho para o qual a imagem deve ser aumentada ou diminuída.

  • borderType - Uma variável de tipo inteiro que representa o tipo de borda a ser usada.

Exemplo

O programa a seguir demonstra como realizar a operação Pyramid Up em uma imagem.

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

Suponha que a seguir está a imagem de entrada pyramid_input.jpg especificado no programa acima.

Resultado

Ao executar o programa, você obterá a seguinte saída -

Image Processed

Se você abrir o caminho especificado, poderá observar a imagem de saída da seguinte maneira -

Pyramid Down

Em Pyramid Down, a imagem é inicialmente desfocada e depois reduzida. Você pode realizar a operação Pyramid Down em uma imagem usando opyrDown() método do imgprocclasse. A seguir está a sintaxe deste método -

pyrDown(src, dst, dstsize, borderType)

Este método aceita os seguintes parâmetros -

  • src - Um objeto da aula Mat representando a imagem de origem (entrada).

  • mat - Um objeto da aula Mat representando a imagem de destino (saída).

  • size - Um objeto da aula Size representando o tamanho para o qual a imagem deve ser aumentada ou diminuída.

  • borderType - Uma variável de tipo inteiro que representa o tipo de borda a ser usada.

Exemplo

O programa a seguir demonstra como realizar a operação Pyramid Down em uma imagem.

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

Suponha que a seguir está a imagem de entrada pyramid_input.jpg especificado no programa acima.

Resultado

Ao executar o programa, você obterá a seguinte saída -

Image Processed

Se você abrir o caminho especificado, poderá observar a imagem de saída da seguinte maneira -

Filtro de desvio médio

Na operação de pirâmide de deslocamento médio, uma etapa inicial de segmentação de deslocamento médio de uma imagem é realizada.

Você pode realizar a operação de Filtragem de Mudança Média de pirâmide em uma imagem usando o pyrDown() método do imgprocclasse. A seguir está a sintaxe desse método.

pyrMeanShiftFiltering(src, dst, sp, sr)

Este método aceita os seguintes parâmetros -

  • src - Um objeto da aula Mat representando a imagem de origem (entrada).

  • mat - Um objeto da aula Mat representando a imagem de destino (saída).

  • sp - Uma variável do tipo double representando o raio da janela espacial.

  • sr - Uma variável do tipo double representando o raio da janela de cores.

Exemplo

O programa a seguir demonstra como realizar uma operação de Filtragem por deslocamento médio em uma determinada imagem.

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

Suponha que a seguir está a imagem de entrada pyramid_input.jpg especificado no programa acima.

Resultado

Ao executar o programa, você obterá a seguinte saída -

Image Processed

Se você abrir o caminho especificado, poderá observar a imagem de saída da seguinte maneira -

Thresholding é um método de segmentação de imagens, em geral é usado para criar imagens binárias. Limiar é de dois tipos, a saber, limite simples e limite adaptativo.

Limiar Simples

Na operação de limite simples, os pixels cujos valores são maiores do que o valor limite especificado são atribuídos a um valor padrão.

Você pode realizar uma operação simples de limite em uma imagem usando o método threshold() do Imgproc class, A seguir está a sintaxe desse método.

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

Este método aceita os seguintes parâmetros -

  • src - Um objeto da aula Mat representando a imagem de origem (entrada).

  • dst - Um objeto da aula Mat representando a imagem de destino (saída).

  • thresh - Uma variável de tipo duplo que representa o valor limite.

  • maxval - Uma variável de tipo duplo que representa o valor a ser fornecido se o valor do pixel for maior que o valor limite.

  • type - Uma variável de tipo inteiro que representa o tipo de limite a ser usado.

Exemplo

O programa a seguir demonstra como realizar uma operação simples de limiarização em uma imagem no 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");
   }
}

Suponha que a seguir está a imagem de entrada thresh_input.jpg especificado no programa acima.

Resultado

Ao executar o programa, você obterá a seguinte saída -

Image Processed

Se você abrir o caminho especificado, poderá observar a imagem de saída da seguinte maneira -

Outros tipos de limite simples

Em adição a THRESH_BINARYoperação demonstrada no exemplo anterior, OpenCV atende vários outros tipos de operações de limite. Todos esses tipos são representados por campos estáticos predefinidos (valores fixos) deImgproc classe.

Você pode escolher o tipo de operação de limite de que precisa, passando seu respectivo valor predefinido para o parâmetro denominado type do threshold() método.

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

A seguir estão os valores que representam vários tipos de operações de limite e suas respectivas saídas.

Operação e descrição Resultado
THRESH_BINARY
THRESH_BINARY_INV
THRESH_TRUNC
THRESH_TOZERO
THRESH_TOZERO_INV

Dentro simple thresholding, o valor do limite é global, ou seja, é o mesmo para todos os pixels da imagem. Adaptive thresholding é o método em que o valor do limite é calculado para regiões menores e, portanto, haverá valores de limite diferentes para regiões diferentes.

No OpenCV, você pode realizar a operação de limite adaptativo em uma imagem usando o método adaptiveThreshold() do Imgprocclasse. A seguir está a sintaxe desse método.

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

Este método aceita os seguintes parâmetros -

  • src - Um objeto da aula Mat representando a imagem de origem (entrada).

  • dst - Um objeto da aula Mat representando a imagem de destino (saída).

  • maxValue - Uma variável de tipo duplo que representa o valor a ser fornecido se o valor do pixel for maior que o valor limite.

  • adaptiveMethod- Uma variável de número inteiro do tipo que representa o método adaptativo a ser usado. Este será um dos seguintes dois valores

    • ADAPTIVE_THRESH_MEAN_C - o valor limite é a média da área da vizinhança.

    • ADAPTIVE_THRESH_GAUSSIAN_C - o valor limite é a soma ponderada dos valores da vizinhança em que os pesos são uma janela Gaussiana.

  • thresholdType - Uma variável de tipo inteiro que representa o tipo de limite a ser usado.

  • blockSize - Uma variável do tipo inteiro que representa o tamanho da vizinhança do pixel usada para calcular o valor limite.

  • C - Uma variável de tipo duplo que representa a constante utilizada nos dois métodos (subtraída da média ou média ponderada).

  • Exemplo

    O programa a seguir demonstra como realizar a operação de limite adaptativo em uma imagem no OpenCV. Aqui estamos escolhendo o limite adaptativo do tipobinary e ADAPTIVE_THRESH_MEAN_C para o método de limite.

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

    Suponha que a seguir está a imagem de entrada thresh_input.jpg especificado no programa acima.

    Resultado

    Ao executar o programa, você obterá a seguinte saída -

    Image Processed

    Se você abrir o caminho especificado, poderá observar a imagem de saída da seguinte maneira -

    Outros tipos de limiar adaptativo

    Em adição a ADAPTIVE_THRESH_MEAN_C como o método adaptativo e THRESH_BINARY como o tipo de limite, conforme demonstrado no exemplo anterior, podemos escolher mais combinações desses dois valores.

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

    A seguir estão os valores que representam várias combinações de valores para os parâmetros adaptiveMethod e thresholdType e suas respectivas saídas.

    adaptiveMethod / thresholdType ADAPTIVE_THRESH_MEAN_C ADAPTIVE_THRESH_GAUSSIAN_C:
    THRESH_BINARY
    THRESH_BINARY_INV

    Este capítulo ensina como o sapo faz fronteira com uma imagem.

    Método copyMakeBorder ()

    Você pode adicionar várias bordas a uma imagem usando o método copyMakeBorder() da classe chamada Core, que pertence ao pacote org.opencv.core. a seguir está a sintaxe desse método.

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

    Este método aceita os seguintes parâmetros -

    • src - Um objeto da aula Mat representando a imagem de origem (entrada).

    • dst - Um objeto da aula Mat representando a imagem de destino (saída).

    • top - Uma variável de número inteiro, o tipo inteiro, que representa o comprimento da borda no topo da imagem.

    • bottom - Uma variável de inteiro do tipo inteiro que representa o comprimento da borda na parte inferior da imagem.

    • left - Uma variável de inteiro do tipo inteiro que representa o comprimento da borda à esquerda da imagem.

    • right - Uma variável de inteiro do tipo inteiro que representa o comprimento da borda à direita da imagem.

    • borderType - Uma variável do tipo inteiro que representa o tipo de borda a ser usada.

    Exemplo

    O programa a seguir é um exemplo que demonstra como adicionar borda a uma determinada imagem.

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

    Suponha que a seguir está a imagem de entrada thresh_input.jpg especificado no programa acima.

    Resultado

    Ao executar o programa, você obterá a seguinte saída -

    Image Processed

    Se você abrir o caminho especificado, poderá observar a imagem de saída da seguinte maneira -

    Outros tipos de fronteiras

    Além do tipo de borda, BORDER_CONSTANTdemonstrado no exemplo anterior, o OpenCV atende a vários outros tipos de bordas. Todos esses tipos são representados por campos estáticos predefinidos (valores fixos) da classe Core.

    Você pode escolher o tipo de operação de limite de que precisa, passando seu respectivo valor predefinido para o parâmetro denominado borderType do copyMakeBorder() método.

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

    A seguir estão os valores que representam vários tipos de operações de fronteira e suas respectivas saídas.

    Operação e descrição Resultado
    BORDER_CONSTANT
    BORDER_ISOLATED
    BORDER_DEFAULT
    BORDER_REFLECT
    BORDER_REFLECT_101
    BORDER_REFLECT101
    BORDER_REPLICATE
    BORDER_WRAP

    Usando o sobel operation, você pode detectar as bordas de uma imagem nas direções horizontal e vertical. Você pode aplicar a operação sobel em uma imagem usando o métodosobel(). A seguir está a sintaxe deste método -

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

    Este método aceita os seguintes parâmetros -

    • src - Um objeto da aula Mat representando a imagem de origem (entrada).

    • dst - Um objeto da aula Mat representando a imagem de destino (saída).

    • ddepth - Uma variável inteira que representa a profundidade da imagem (-1)

    • dx- Uma variável inteira que representa a derivada x. (0 ou 1)

    • dy- Uma variável inteira que representa a derivada y. (0 ou 1)

    Exemplo

    O programa a seguir demonstra como realizar a operação Sobel em uma determinada imagem.

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

    Suponha que a seguir está a imagem de entrada sobel_input.jpg especificado no programa acima.

    Resultado

    Ao executar o programa, você obterá a seguinte saída -

    Image Processed

    Se você abrir o caminho especificado, poderá observar a imagem de saída da seguinte maneira -

    sobel Variantes

    Ao passar valores diferentes para o último para os parâmetros (dx e dy) (entre 0 e 1), você obterá resultados diferentes -

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

    A tabela a seguir lista vários valores para as variáveis dx e dy do método Sobel() e suas respectivas saídas.

    Derivado X Derivada Y Resultado
    0 1
    1 0
    1 1

    Scharr também é usado para detectar os derivados secundários de uma imagem nas direções horizontal e vertical. Você pode realizar a operação scharr em uma imagem usando o métodoscharr(). A seguir está a sintaxe deste método -

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

    Este método aceita os seguintes parâmetros -

    • src - Um objeto da aula Mat representando a imagem de origem (entrada).

    • dst - Um objeto da aula Mat representando a imagem de destino (saída).

    • ddepth - Uma variável inteira que representa a profundidade da imagem (-1)

    • dx- Uma variável inteira que representa a derivada x. (0 ou 1)

    • dy- Uma variável inteira que representa a derivada y. (0 ou 1)

    Exemplo

    O programa a seguir demonstra como aplicar scharr a uma determinada imagem.

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

    Suponha que a seguir está a imagem de entrada scharr_input.jpg especificado no programa acima.

    Resultado

    Ao executá-lo, você obterá a seguinte saída -

    Image Processed

    Se você abrir o caminho especificado, poderá observar a imagem de saída da seguinte maneira -

    Mais derivados scharr

    Ao passar valores diferentes para o último para os parâmetros (dx e dy) (entre 0 e 1), você obterá resultados diferentes -

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

    A seguir está uma tabela que lista vários valores para as variáveis dx e dy do método scharr() e suas respectivas saídas.

    Derivado X Derivada Y Resultado
    0 1
    1 0

    Operador Laplaciano também é um operador derivado que é usado para encontrar as bordas de uma imagem. É uma máscara derivada de segunda ordem. Nesta máscara, temos duas classificações adicionais, uma é Operador Laplaciano Positivo e a outra é Operador Laplaciano Negativo.

    Ao contrário de outros operadores, o Laplaciano não remove arestas em nenhuma direção específica, mas remove arestas na classificação seguinte.

    • Bordas Internas
    • Bordas Externas

    Você pode executar Laplacian Transform operação em uma imagem usando o Laplacian() método do imgproc classe, a seguir está a sintaxe deste método.

    Laplacian(src, dst, ddepth)

    Este método aceita os seguintes parâmetros -

    • src - A Mat objeto que representa a fonte (imagem de entrada) para esta operação.

    • dst - A Mat objeto que representa o destino (imagem de saída) para esta operação.

    • ddepth - Uma variável do tipo inteiro que representa a profundidade da imagem de destino.

    Exemplo

    O programa a seguir demonstra como realizar a operação de transformação de Laplace em uma determinada imagem.

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

    Suponha que a seguir está a imagem de entrada laplacian_input.jpg especificado no programa acima.

    Resultado

    Ao executar o programa, você obterá a seguinte saída -

    Image Processed

    Se você abrir o caminho especificado, poderá observar a imagem de saída da seguinte maneira -

    o distance transformoperador geralmente pega imagens binárias como entradas. Nesta operação, as intensidades do nível de cinza dos pontos dentro das regiões de primeiro plano são alteradas para distanciar suas respectivas distâncias do valor 0 mais próximo (limite).

    Você pode aplicar a transformação de distância em OpenCV usando o método distanceTransform(). A seguir está a sintaxe desse método.

    distanceTransform(src, dst, distanceType, maskSize)

    Este método aceita os seguintes parâmetros -

    • src - Um objeto da aula Mat representando a imagem de origem (entrada).

    • dst - Um objeto da aula Mat representando a imagem de destino (saída).

    • distanceType - Uma variável do tipo inteiro que representa o tipo da transformação de distância a ser aplicada.

    • maskSize - Uma variável do tipo inteiro que representa o tamanho da máscara a ser usada.

    Exemplo

    O programa a seguir demonstra como realizar a operação de transformação de distância em uma determinada imagem.

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

Suponha que a seguir está a imagem de entrada input.jpg especificado no programa acima.

Resultado

Ao executar o programa, você obterá a seguinte saída -

Image Processed

Se você abrir o caminho especificado, poderá observar a imagem de saída da seguinte maneira -

Tipos de operações de transformação de distância

Além do tipo de operação à distância DIST_Cdemonstrado no exemplo anterior, o OpenCV atende a vários outros tipos de operações de transformação de distância. Todos esses tipos são representados por campos estáticos predefinidos (valores fixos) da classe Imgproc.

Você pode escolher o tipo de operação de transformação de distância de que precisa, passando seu respectivo valor predefinido para o parâmetro denominado distanceType do distanceTransform() método.

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

A seguir estão os valores que representam vários tipos de distanceTransform operações e seus respectivos resultados.

Operação e descrição Resultado
DIST_C
DIST_L1
DIST_L2
DIST_LABEL_PIXEL
DIST_MASK_3

Neste capítulo, aprenderemos como usar o OpenCV para capturar quadros usando a câmera do sistema. oVideoCapture classe do org.opencv.videoiopacote contém classes e métodos para capturar vídeo usando a câmera. Vamos passo a passo e aprender como capturar frames -

Etapa 1: carregar a biblioteca nativa OpenCV

Ao escrever o código Java usando a biblioteca OpenCV, a primeira etapa que você precisa fazer é carregar a biblioteca nativa do OpenCV usando o loadLibrary(). Carregue a biblioteca nativa OpenCV conforme mostrado abaixo.

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

Etapa 2: instancie a classe de captura de vídeo

Instancie a classe Mat usando qualquer uma das funções mencionadas neste tutorial anteriormente.

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

Etapa 3: leia os quadros

Você pode ler os quadros da câmera usando o read() método do VideoCaptureclasse. Este método aceita um objeto da classeMat para armazenar o quadro lido.

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

Exemplo

O programa a seguir demonstra como capturar um quadro usando a câmera e exibi-lo usando a janela JavaFX. Ele também salva o quadro 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);
   }
}

Resultado

Ao executar o programa, você obterá a seguinte saída.

Se você abrir o caminho especificado, poderá observar o mesmo quadro que é salvo como um arquivo jpg.

o VideoCapture classe do org.opencv.videoiopacote contém classes e métodos para capturar vídeo usando a câmera do sistema. Vamos passo a passo e aprendamos como fazer.

Etapa 1: carregar a biblioteca nativa OpenCV

Ao escrever o código Java usando a biblioteca OpenCV, a primeira etapa que você precisa fazer é carregar a biblioteca nativa do OpenCV usando o loadLibrary(). Carregue a biblioteca nativa OpenCV conforme mostrado abaixo.

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

Etapa 2: instanciar a classe CascadeClassifier

o CascadeClassifier classe do pacote org.opencv.objdetecté usado para carregar o arquivo classificador. Instancie esta classe passando oxml Arquivo lbpcascade_frontalface.xml como mostrado abaixo.

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

Etapa 3: detectar os rostos

Você pode detectar os rostos na imagem usando o método detectMultiScale() da classe chamada CascadeClassifier. Este método aceita um objeto da classeMat segurando a imagem de entrada e um objeto da classe MatOfRect para armazenar os rostos detectados.

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

Exemplo

O programa a seguir demonstra como detectar rostos em uma imagem.

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

Suponha que a seguir está a imagem de entrada facedetection_input.jpg especificado no programa acima.

Resultado

Ao executar o programa, você obterá a seguinte saída -

Detected 3 faces 
Image Processed

Se você abrir o caminho especificado, poderá observar a imagem de saída da seguinte maneira -

O programa a seguir demonstra como detectar faces usando a câmera do sistema e exibi-la usando a janela JavaFX.

Exemplo

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

Resultado

Ao executar o programa, você obterá a seguinte saída.

Se você abrir o caminho especificado, você pode ver o mesmo instantâneo salvo como um jpg imagem.

Você pode executar affine translation em uma imagem usando o warpAffine()método da classe imgproc. A seguir está a sintaxe deste método -

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

Este método aceita os seguintes parâmetros -

  • src - A Mat objeto que representa a fonte (imagem de entrada) para esta operação.

  • dst - A Mat objeto que representa o destino (imagem de saída) para esta operação.

  • tranformMatrix - A Mat objeto que representa a matriz de transformação.

  • size - Uma variável do tipo inteiro que representa o tamanho da imagem de saída.

Exemplo

O programa a seguir demonstra como aplicar a operação afim em uma determinada imagem.

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

Suponha que a seguir está a imagem de entrada transform_input.jpg especificado no programa acima.

Resultado

Ao executá-lo, você obterá a seguinte saída -

Image Processed

Se você abrir o caminho especificado, poderá observar a imagem de saída da seguinte maneira -

Você pode perform rotation operação em uma imagem usando o warpAffine() método do imgprocclasse. A seguir está a sintaxe deste método -

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

Este método aceita os seguintes parâmetros -

  • src - A Mat objeto que representa a fonte (imagem de entrada) para esta operação.

  • dst - A Mat objeto que representa o destino (imagem de saída) para esta operação.

  • rotationMatrix - A Mat objeto que representa a matriz de rotação.

  • size - Uma variável do tipo inteiro que representa o tamanho da imagem de saída.

Exemplo

O programa a seguir demonstra como girar uma imagem.

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

Suponha que a seguir está a imagem de entrada transform_input.jpg especificado no programa acima.

Resultado

Ao executar o programa, você obterá a seguinte saída -

Image Processed

Se você abrir o caminho especificado, poderá observar a imagem de saída da seguinte maneira -

Você pode executar scaling em uma imagem usando o resize() método do imgprocclasse. A seguir está a sintaxe desse método.

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

Este método aceita os seguintes parâmetros -

  • src - A Mat objeto que representa a fonte (imagem de entrada) para esta operação.

  • dst - A Mat objeto que representa o destino (imagem de saída) para esta operação.

  • dsize - A Size objeto que representa o tamanho da imagem de saída.

  • fx - Uma variável do tipo double representando o fator de escala ao longo do eixo horizontal.

  • fy - Uma variável do tipo double representando o fator de escala ao longo do eixo vertical.

  • Interpolation - Uma variável inteira que representa o método de interpolação.

Exemplo

O programa a seguir demonstra como aplicar scale transformation a uma imagem.

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

Suponha que a seguir está a imagem de entrada transform_input.jpg especificado no programa acima (tamanho - Largura: 300px e altura: 300px).

Resultado

Ao executar o programa, você obterá a seguinte saída -

Image Processed

Se você abrir o caminho especificado, poderá observar a imagem de saída da seguinte maneira (tamanho - Largura: 600px e altura: 600px) -

No OpenCV, você pode aplicar mapas de cores diferentes a uma imagem usando o método applyColorMap() da classe Imgproc. A seguir está a sintaxe deste método -

applyColorMap(Mat src, Mat dst, int colormap)

Aceita três parâmetros -

  • src - Um objeto da aula Mat representando a imagem de origem (entrada).

  • dst - Um objeto da aula Mat representando a imagem de destino (saída).

  • colormap - Uma variável de tipo inteiro que representa o tipo de mapa de cores a ser aplicado.

Exemplo

O programa a seguir demonstra como aplicar color map a uma imagem.

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

Suponha que a seguir está a imagem de entrada color_input.jpg especificado no programa acima.

Resultado

Ao executar o programa acima, você obterá a seguinte saída -

Image Processed

Se você abrir o caminho especificado, poderá observar a imagem de saída da seguinte maneira -

Mais operações

Além de COLORMAP_HOTdemonstrado no exemplo anterior, o OpenCV atende a vários outros tipos de mapas de cores. Todos esses tipos são representados por campos estáticos predefinidos (valores fixos) da classe Imgproc.

Você pode escolher o tipo de mapa de cores que você precisa, passando seu respectivo valor predefinido para o parâmetro denominado colormap do applyColorMap() método.

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

A seguir estão os valores que representam vários tipos de mapas de cores e suas respectivas saídas.

Operação e descrição Resultado
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

O Canny Edge Detection é usado para detectar as bordas de uma imagem. Ele aceita uma imagem em escala de cinza como entrada e usa um algoritmo de vários estágios.

Você pode realizar esta operação em uma imagem usando o Canny() método do imgproc classe, a seguir está a sintaxe deste método.

Canny(image, edges, threshold1, threshold2)

Este método aceita os seguintes parâmetros -

  • image - A Mat objeto que representa a fonte (imagem de entrada) para esta operação.

  • edges - A Mat objeto que representa o destino (bordas) para esta operação.

  • threshold1 - Uma variável do tipo double representando o primeiro limite para o procedimento de histerese.

  • threshold2 - Uma variável do tipo double representando o segundo limite para o procedimento de histerese.

Exemplo

O programa a seguir é um exemplo de demonstração de como executar a operação Canny Edge Detection em uma determinada imagem.

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

Suponha que a seguir está a imagem de entrada canny_input.jpg especificado no programa acima.

Resultado

Ao executar o programa acima, você obterá a seguinte saída -

Image Processed

Se você abrir o caminho especificado, poderá observar a imagem de saída da seguinte maneira -

Você pode detectar a forma de uma determinada imagem aplicando o Hough Transform technique usando o método HoughLines() do Imgprocclasse. A seguir está a sintaxe desse método.

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

Este método aceita os seguintes parâmetros -

  • image - Um objeto da aula Mat representando a imagem de origem (entrada).

  • lines - Um objeto da aula Mat que armazena o vetor que armazena os parâmetros (r, Φ) das linhas.

  • rho - Uma variável do tipo double representando a resolução do parâmetro r em pixels.

  • theta - Uma variável do tipo double representando a resolução do parâmetro Φ em radianos.

  • threshold - Uma variável do tipo inteiro representando o número mínimo de interseções para “detectar” uma linha.

Exemplo

O programa a seguir demonstra como detectar linhas de Hough em uma determinada imagem.

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

Suponha que a seguir está a imagem de entrada hough_input.jpg especificado no programa acima.

Resultado

Ao executar o programa, você obterá a seguinte saída -

143 
1 
Image Processed

Se você abrir o caminho especificado, poderá observar a imagem de saída da seguinte maneira -

o histogramde uma imagem mostra a frequência dos valores de intensidade dos pixels. Em um histograma de imagem, o eixo X mostra as intensidades dos níveis de cinza e o eixo Y mostra a frequência dessas intensidades.

Histogram equalizationmelhora o contraste de uma imagem, a fim de estender o alcance da intensidade. Você pode equalizar o histograma de uma determinada imagem usando o métodoequalizeHist() do Imgprocclasse. A seguir está a sintaxe desse método.

equalizeHist(src, dst)

Este método aceita os seguintes parâmetros -

  • src - Um objeto da aula Mat representando a imagem de origem (entrada).

  • dst - Um objeto da aula Matrepresentando a saída. (Imagem obtida após equalizar o histograma)

Exemplo

O programa a seguir demonstra como equalizar o histograma de uma determinada imagem.

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

Suponha que a seguir está a imagem de entrada histo_input.jpg especificado no programa acima.

Resultado

Ao executar o programa, você obterá a seguinte saída -

Image Processed

Se você abrir o caminho especificado, poderá observar a imagem de saída da seguinte maneira -