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 OpenCV → build → java. 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 build → java. 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 SavedSe 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 Loadedo 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 LoadedAlé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 LoadedAlé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 ProcessedSe 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 ProcessedSe 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 ProcessedSe 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 ProcessedSe 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 ProcessedSe 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 ProcessedSe 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 ProcessedSe 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 ProcessedSe 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 LoadedSe 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 ProcessedSe 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 ProcessedSe 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 ProcessedSe 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 ProcessedSe 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 ProcessedSe 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 ProcessedSe 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 ProcessedSe 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 ProcessedSe 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 ProcessedSe 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 ProcessedSe 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 ProcessedSe 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 ProcessedSe 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 ProcessedSe 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 ProcessedSe 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 ProcessedSe 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 ProcessedSe 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 ProcessedSe 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 ProcessedSe 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 ProcessedSe você abrir o caminho especificado, poderá observar a imagem de saída da seguinte maneira -
