OpenCV - Szybki przewodnik

OpenCV to wieloplatformowa biblioteka, za pomocą której możemy rozwijać się w czasie rzeczywistym computer vision applications. Skupia się głównie na przetwarzaniu obrazu, przechwytywaniu i analizie wideo, w tym na funkcjach takich jak wykrywanie twarzy i wykrywanie obiektów.

Zacznijmy ten rozdział od zdefiniowania terminu „Computer Vision”.

Wizja komputerowa

Komputerowe widzenie można zdefiniować jako dyscyplinę, która wyjaśnia, jak rekonstruować, przerywać i rozumieć scenę 3D na podstawie jej obrazów 2D, pod względem właściwości struktury obecnej na scenie. Zajmuje się modelowaniem i odtwarzaniem ludzkiego wzroku za pomocą oprogramowania i sprzętu komputerowego.

Wizja komputerowa w znacznym stopniu pokrywa się z następującymi polami -

• Image Processing - Koncentruje się na manipulacji obrazem.

• Pattern Recognition - Wyjaśnia różne techniki klasyfikacji wzorców.

• Photogrammetry - Chodzi o uzyskanie dokładnych pomiarów z obrazów.

Przetwarzanie obrazu komputerowego a przetwarzanie obrazu

Image processingzajmuje się transformacją obrazu w obraz. Dane wejściowe i wyjściowe przetwarzania obrazu to obrazy.

Computer visionjest konstruowaniem wyraźnych, znaczących opisów obiektów fizycznych na podstawie ich obrazu. Wynikiem widzenia komputerowego jest opis lub interpretacja struktur w scenie 3D.

Zastosowania widzenia komputerowego

Tutaj wymieniliśmy niektóre z głównych domen, w których widzenie komputerowe jest intensywnie wykorzystywane.

Aplikacja robotyki

• Lokalizacja - automatyczne określanie lokalizacji robota

• Navigation

• Unikanie przeszkód

• Montaż (kołek w otworze, spawanie, malowanie)

• Manipulacja (np. Manipulator robota PUMA)

• Interakcja człowieka z robotem (HRI) - inteligentna robotyka do interakcji z ludźmi i służenia im

Zastosowanie leku

• Klasyfikacja i wykrywanie (np. Klasyfikacja zmian lub komórek i wykrywanie guzów)
• Segmentacja 2D / 3D
• Rekonstrukcja 3D narządów ludzkich (MRI lub USG)
• Chirurgia robotyczna sterowana wzrokiem

Aplikacja automatyki przemysłowej

• Inspekcja przemysłowa (wykrywanie wad)
• Assembly
• Odczyt kodów kreskowych i etykiet opakowań
• Sortowanie obiektów
• Zrozumienie dokumentów (np. OCR)

Aplikacja bezpieczeństwa

• Biometria (tęczówka, odcisk palca, rozpoznawanie twarzy)

• Nadzór - Wykrywanie pewnych podejrzanych działań lub zachowań

Aplikacja transportowa

• Autonomiczny pojazd
• Bezpieczeństwo, np. Monitorowanie czujności kierowcy

Funkcje biblioteki OpenCV

Korzystając z biblioteki OpenCV, możesz -

• Czytaj i pisz obrazy

• Przechwytuj i zapisuj filmy

• Przetwarzaj obrazy (filtr, transformacja)

• Wykonaj wykrywanie funkcji

• Wykryj określone obiekty, takie jak twarze, oczy, samochody, na filmach lub obrazach.

• Przeanalizuj wideo, tj. Oszacuj ruch w nim, odejmij tło i śledź znajdujące się w nim obiekty.

OpenCV został pierwotnie opracowany w C ++. Oprócz tego zapewniono powiązania Python i Java. OpenCV działa na różnych systemach operacyjnych, takich jak Windows, Linux, OSx, FreeBSD, Net BSD, Open BSD itp.

Ten samouczek wyjaśnia koncepcje OpenCV z przykładami używającymi powiązań Java.

Moduły biblioteczne OpenCV

Poniżej znajdują się główne moduły biblioteczne biblioteki OpenCV.

Podstawowa funkcjonalność

Ten moduł obejmuje podstawowe struktury danych, takie jak Scalar, Point, Range, itp., Które są używane do tworzenia aplikacji OpenCV. Oprócz tego zawiera również tablicę wielowymiarowąMat, który służy do przechowywania obrazów. W bibliotece Java OpenCV ten moduł jest zawarty jako pakiet o nazwieorg.opencv.core.

Przetwarzanie obrazu

Ten moduł obejmuje różne operacje przetwarzania obrazu, takie jak filtrowanie obrazu, transformacje geometryczne obrazu, konwersja przestrzeni kolorów, histogramy itp. W bibliotece Java OpenCV moduł ten jest zawarty w pakiecie o nazwie org.opencv.imgproc.

Wideo

W tym module omówiono koncepcje analizy wideo, takie jak przewidywanie ruchu, odejmowanie tła i śledzenie obiektów. W bibliotece Java OpenCV ten moduł jest zawarty jako pakiet o nazwieorg.opencv.video.

We / wy wideo

W tym module opisano przechwytywanie wideo i kodeki wideo przy użyciu biblioteki OpenCV. W bibliotece Java OpenCV ten moduł jest zawarty jako pakiet o nazwieorg.opencv.videoio.

calib3d

Moduł ten zawiera algorytmy dotyczące podstawowych algorytmów geometrii wielu widoków, kalibracji kamery pojedynczej i stereoskopowej, estymacji pozycji obiektu, korespondencji stereo oraz elementów rekonstrukcji 3D. W bibliotece Java OpenCV ten moduł jest zawarty jako pakiet o nazwieorg.opencv.calib3d.

features2d

Ten moduł zawiera koncepcje wykrywania i opisu cech. W bibliotece Java OpenCV ten moduł jest zawarty jako pakiet o nazwieorg.opencv.features2d.

Objdetect

Ten moduł obejmuje wykrywanie obiektów i instancji predefiniowanych klas, takich jak twarze, oczy, kubki, ludzie, samochody itp. W bibliotece Java OpenCV moduł ten jest zawarty w pakiecie o nazwie org.opencv.objdetect.

Highgui

Jest to łatwy w użyciu interfejs z prostymi funkcjami interfejsu użytkownika. W bibliotece Java OpenCV funkcje tego modułu są zawarte w dwóch różnych pakietach, a mianowicie:org.opencv.imgcodecs i org.opencv.videoio.

Krótka historia OpenCV

OpenCV był początkowo inicjatywą badawczą firmy Intel mającą na celu doradzanie aplikacjom intensywnie wykorzystującym procesor. Został oficjalnie uruchomiony w 1999 roku.

• W roku 2006 została wydana jego pierwsza główna wersja, OpenCV 1.0.
• W październiku 2009 została wydana druga główna wersja, OpenCV 2.
• W sierpniu 2012 r. OpenCV został przejęty przez organizację non-profit OpenCV.org.

W tym rozdziale dowiesz się, jak zainstalować OpenCV i skonfigurować jego środowisko w swoim systemie.

Instalowanie OpenCV

Przede wszystkim musisz pobrać OpenCV do swojego systemu. Wykonaj czynności podane poniżej.

Step 1 - Otwórz stronę główną OpenCV klikając poniższy link: http://opencv.org/ Po kliknięciu zobaczysz jego stronę główną, jak pokazano poniżej.

Step 2 - Teraz kliknij Downloadslink zaznaczony na powyższym zrzucie ekranu. Po kliknięciu zostaniesz przekierowany do strony pobierania OpenCV.

Step 3 - Po kliknięciu podświetlonego łącza na powyższym zrzucie ekranu, plik o nazwie opencv-3.1.0.exezostanie pobrany. Wyodrębnij ten plik, aby wygenerować folderopencv w systemie, jak pokazano na poniższym zrzucie ekranu.

Step 4 - Otwórz folder OpenCV → build → java. Tutaj znajdziesz plik jar OpenCV o nazwieopencv-310.jar. Zapisz ten plik w oddzielnym folderze do dalszego użytku.

Instalacja Eclipse

Po pobraniu wymaganych plików JAR należy osadzić te pliki JAR w środowisku Eclipse. Możesz to zrobić, ustawiając ścieżkę kompilacji do tych plików JAR i używającpom.xml.

Ustawianie ścieżki budowania

Oto kroki, aby skonfigurować OpenCV w Eclipse -

Step 1- Upewnij się, że zainstalowałeś Eclipse w swoim systemie. Jeśli nie, pobierz i zainstaluj Eclipse w swoim systemie.

Step 2 - Otwórz Eclipse, kliknij Plik, Nowy i Otwórz nowy projekt, jak pokazano na poniższym zrzucie ekranu.

Step 3 - Po wybraniu projektu otrzymasz plik New Projectczarodziej. W tym kreatorze wybierz projekt Java i kontynuuj, klikającNext przycisk, jak pokazano na poniższym zrzucie ekranu.

Step 4 - Kontynuując, zostaniesz przekierowany do New Java Project wizard. Utwórz nowy projekt i kliknijNext, jak pokazano na poniższym zrzucie ekranu.

Step 5- Po utworzeniu nowego projektu kliknij go prawym przyciskiem myszy. WybierzBuild Path i kliknij Configure Build Path… jak pokazano na poniższym zrzucie ekranu.

Step 6 - Po kliknięciu Build Path zostaniesz przekierowany do Java Build Path wizard. KliknijAdd External JARs przycisk, jak pokazano na poniższym zrzucie ekranu.

Step 7 - Wybierz ścieżkę, w której zapisałeś plik opencv-310.jar.

Step 8 - Po kliknięciu Open na powyższym zrzucie ekranu pliki te zostaną dodane do Twojej biblioteki.

Step 9 - Po kliknięciu OK, pomyślnie dodasz wymagane pliki JAR do bieżącego projektu i możesz zweryfikować te dodane biblioteki, rozszerzając biblioteki, do których istnieją odniesienia.

Ustawianie ścieżki dla bibliotek natywnych

Oprócz plików JAR musisz ustawić ścieżkę do natywnych bibliotek (plików DLL) OpenCV.

Location of DLL files - Otwórz folder instalacyjny OpenCV i przejdź do podfolderu build → java. Tutaj znajdziesz dwa folderyx64 (Wersja 64-bitowa) i x86 (32-bitowy), który zawiera rozszerzenie dll pliki OpenCV.

Otwórz odpowiedni folder odpowiedni dla twojego systemu operacyjnego, a następnie możesz zobaczyć dll plik, jak pokazano na poniższym zrzucie ekranu.

Teraz ustaw ścieżkę również dla tego pliku, wykonując kroki podane poniżej -

Step 1- Ponownie otwórz okno JavaBuildPath. Tutaj możesz obserwować dodany plik JAR i rozszerzenieJRE System Library.

Step 2 - Po rozszerzeniu otrzymasz biblioteki systemowe i Native library location, jak podkreślono na poniższym zrzucie ekranu.

Step 3 - Kliknij dwukrotnie plik Native library location. Tutaj możesz zobaczyćNative Library Folder Configuration window jak pokazano niżej.

Tutaj kliknij przycisk External Folder… i wybierz lokalizację dll plik w systemie.

Do przechwytywania obrazu używamy urządzeń takich jak aparaty i skanery. Urządzenia te rejestrują wartości liczbowe obrazu (np. Wartości pikseli). OpenCV to biblioteka przetwarzająca obrazy cyfrowe, dlatego musimy przechowywać te obrazy do przetwarzania.

Plik Matklasa biblioteki OpenCV służy do przechowywania wartości obrazu. Reprezentuje n-wymiarową tablicę i służy do przechowywania danych obrazu w skali szarości lub kolorowych obrazów, objętości wokseli, pól wektorowych, chmur punktów, tensorów, histogramów itp.

Ta klasa składa się z dwóch części danych: header i a pointer

• Header - Zawiera informacje takie jak rozmiar, metoda użyta do przechowywania i adres macierzy (stały rozmiar).

• Pointer - Przechowuje wartości pikseli obrazu (zmienia się).

Klasa mat

Biblioteka OpenCV Java udostępnia tę klasę o tej samej nazwie (Mat) w pakiecie org.opencv.core.

Konstruktorzy

Klasa Mat biblioteki OpenCV Java ma różne konstruktory, za pomocą których można skonstruować obiekt Mat.

S.Nr	Konstruktorzy i opis
1	Mat() W większości przypadków jest to domyślny konstruktor bez parametrów. Używamy tego do konstruktora, aby utworzyć pustą macierz i przekazać ją do innych metod OpenCV.
2	Mat(int rows, int cols, int type) Ten konstruktor akceptuje trzy parametry typu całkowitego reprezentujące liczbę wierszy i kolumn w tablicy 2D oraz typ tablicy (która ma być używana do przechowywania danych).
3	Mat(int rows, int cols, int type, Scalar s) Uwzględniając parametry poprzedniego, konstruktor ten dodatkowo przyjmuje jako parametr obiekt klasy Scalar.
4	Mat(Size size, int type) Ten konstruktor przyjmuje dwa parametry, obiekt reprezentujący rozmiar macierzy i liczbę całkowitą reprezentującą typ tablicy używanej do przechowywania danych.
5	Mat(Size size, int type, Scalar s) Uwzględniając parametry poprzedniego, konstruktor ten dodatkowo przyjmuje jako parametr obiekt klasy Scalar.
6	Mat(long addr)
7	Mat(Mat m, Range rowRange) Ten konstruktor akceptuje obiekt innej macierzy i obiekt klasy Range reprezentujący zakres wierszy, które mają być użyte do utworzenia nowej macierzy.
8	Mat(Mat m, Range rowRange, Range colRange) Uwzględniając parametry poprzedniego, konstruktor ten dodatkowo akceptuje obiekt klasy. Zakres reprezentujący zakres kolumn.
9	Mat(Mat m, Rect roi) Ten konstruktor akceptuje dwa obiekty, jeden reprezentujący inną macierz, a drugi reprezentujący Region Ofa Interest.

Note -

• Typ tablicy. Użyj CV_8UC1, ..., CV_64FC4 do tworzenia macierzy 1-4 kanałów lub CV_8UC (n), ..., CV_64FC (n) do tworzenia macierzy wielokanałowych (do kanałów CV_CN_MAX).

• Typy macierzy były reprezentowane przez różne pola klasy CvType który należy do pakietu org.opencv.core.

Metody i opis

Poniżej przedstawiono niektóre metody dostarczane przez klasę Mat.

S.Nr	Metody i opis
1	Mat col(int x) Ta metoda akceptuje parametr będący liczbą całkowitą reprezentującą indeks kolumny oraz pobiera i zwraca tę kolumnę.
2	Mat row(int y) Ta metoda akceptuje parametr będący liczbą całkowitą reprezentującą indeks wiersza oraz pobiera i zwraca ten wiersz.
3	int cols() Ta metoda zwraca liczbę kolumn w macierzy.
4	int rows() Ta metoda zwraca liczbę wierszy w macierzy.
5	Mat setTo(Mat value) Ta metoda akceptuje obiekt klasy Mat type i ustawia elementy tablicy na określoną wartość.
6	Mat setTo(Scalar s) Ta metoda akceptuje obiekt klasy Scalar type i ustawia elementy tablicy na określoną wartość.

Tworzenie i wyświetlanie macierzy

W tej sekcji omówimy nasz pierwszy przykład OpenCV. Zobaczymy, jak stworzyć i wyświetlić prostą macierz OpenCV.

Poniżej podano kroki, które należy wykonać, aby utworzyć i wyświetlić macierz w OpenCV.

Krok 1: Załaduj natywną bibliotekę OpenCV

Podczas pisania kodu Java za pomocą biblioteki OpenCV, pierwszym krokiem, jaki należy wykonać, jest załadowanie natywnej biblioteki OpenCV za pomocą loadLibrary(). Załaduj natywną bibliotekę OpenCV, jak pokazano poniżej.

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

Krok 2: Utwórz instancję klasy Mat

Utwórz instancję klasy Mat, używając dowolnej funkcji wspomnianej wcześniej w tym rozdziale.

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

Krok 3: Wypełnij macierz za pomocą metod

Możesz pobrać określone wiersze / kolumny macierzy, przekazując wartości indeksu do metod row()/col().

I możesz ustawić wartości dla tych przy użyciu dowolnego z wariantów setTo() metody.

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

Możesz użyć następującego kodu programu, aby utworzyć i wyświetlić prostą macierz w Javie przy użyciu biblioteki 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()); 
   } 
}

Wykonując powyższy program, otrzymasz następujące dane wyjściowe -

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]

Ładowanie obrazu za pomocą JavaSE API

Plik BufferedImage klasa java.awt.image.BufferedImage pakiet służy do przechowywania obrazu i pliku ImageIO klasa pakietu import javax.imageio zapewnia metody odczytu i zapisu Images.

Example

Możesz użyć następującego kodu programu do ładowania i zapisywania obrazów za pomocą biblioteki 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");
   } 
}

Wykonując powyższy program, otrzymasz następujące dane wyjściowe -

image Saved

Jeśli otworzysz określoną ścieżkę, możesz obserwować zapisany obraz w następujący sposób -

Plik Imgcodecs klasa pakietu org.opencv.imgcodecszapewnia metody odczytu i zapisu obrazów. Korzystając z OpenCV, możesz odczytać obraz i zapisać go w macierzy (w razie potrzeby wykonać transformacje na macierzy). Później możesz zapisać przetworzoną macierz do pliku.

Plik read() metoda Imgcodecsklasa służy do odczytywania obrazu za pomocą OpenCV. Poniżej znajduje się składnia tej metody.

imread(filename)

Przyjmuje argument (filename), zmienna typu String reprezentująca ścieżkę do pliku, który ma zostać odczytany.

Poniżej podano kroki, które należy wykonać, aby odczytać obrazy w Javie przy użyciu biblioteki OpenCV.

Krok 1: Załaduj natywną bibliotekę OpenCV

Załaduj natywną bibliotekę OpenCV przy użyciu load() metoda, jak pokazano poniżej.

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

Krok 2: Utwórz wystąpienie klasy Imgcodecs

Utwórz wystąpienie Imgcodecs klasa.

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

Krok 3: Czytanie obrazu

Przeczytaj obraz używając metody imread(). Ta metoda przyjmuje argument w postaci ciągu reprezentującego ścieżkę obrazu i zwraca obraz odczytany jakoMat obiekt.

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

Przykład

Poniższy kod programu pokazuje, jak możesz read an image przy użyciu biblioteki 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");     
   } 
}

Podczas wykonywania powyższego programu OpenCV ładuje określony obraz i wyświetla następujące dane wyjściowe -

Image Loaded

Plik write() metoda Imgcodecsklasa służy do zapisywania obrazu przy użyciu OpenCV. Aby napisać obraz, powtórz pierwsze trzy kroki z poprzedniego przykładu.

Aby napisać obraz, musisz wywołać imwrite() metoda Imgcodecs klasa.

Poniżej znajduje się składnia tej metody.

imwrite(filename, mat)

Ta metoda akceptuje następujące parametry -

• filename - A String zmienna reprezentująca ścieżkę do zapisania pliku.

• mat - A Mat obiekt reprezentujący obraz, który ma zostać zapisany.

Przykład

Poniższy program jest przykładem do write an image za pomocą programu Java z wykorzystaniem biblioteki 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 ............"); 
   } 
}

Wykonując powyższy program, otrzymasz następujące dane wyjściowe -

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

Jeśli otworzysz określoną ścieżkę, możesz obserwować zapisany obraz, jak pokazano poniżej -

We wcześniejszych rozdziałach omówiliśmy sposób odczytywania i zapisywania obrazu za pomocą biblioteki OpenCV Java. Oprócz tego możemy również wyświetlać załadowane obrazy w osobnym oknie za pomocą bibliotek GUI, takich jak AWT / Swings i JavaFX.

Konwersja maty na buforowany obraz

Do odczytania obrazu używamy metody imread(). Ta metoda zwraca obraz odczytany w postaciMatrix. Aby jednak używać tego obrazu z bibliotekami GUI (AWT / Swings i JavaFX), należy go przekonwertować jako obiekt klasyBufferedImage pakietu java.awt.image.BufferedImage.

Poniżej przedstawiono kroki, aby przekonwertować plik Mat obiekt OpenCV do BufferedImage obiekt.

Krok 1: zakoduj Mat do MatOfByte

Przede wszystkim musisz przekonwertować macierz na macierz bajtów. Możesz to zrobić za pomocą metodyimencode() klasy Imgcodecs. Poniżej znajduje się składnia tej metody.

imencode(ext, image, matOfByte);

Ta metoda akceptuje następujące parametry -

• Ext - parametr typu String określający format obrazu (.jpg, .png itp.)

• image - Obiekt Mat obrazu

• matOfByte - Pusty obiekt klasy MatOfByte

Zakoduj obraz za pomocą tej metody, jak pokazano poniżej.

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

Krok 2: Konwertuj obiekt MatOfByte na tablicę bajtów

Konwertuj MatOfByte obiekt do tablicy bajtów przy użyciu metody toArray().

byte[] byteArray = matOfByte.toArray();

Krok 3: Przygotowanie obiektu InputStream

Przygotuj obiekt InputStream, przekazując tablicę bajtów utworzoną w poprzednim kroku do konstruktora ByteArrayInputStream klasa.

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

Krok 4: Przygotowanie obiektu InputStream

Przekaż obiekt strumienia wejściowego utworzony w poprzednim kroku do pliku read() metoda ImageIOklasa. To zwróci obiekt BufferedImage.

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

Wyświetlanie obrazu za pomocą AWT / Swings

Aby wyświetlić obraz za pomocą ramki AWT / Swings, najpierw przeczytaj obraz za pomocą imread() metoda i przekonwertuj ją na BufferedImage postępując zgodnie z wyżej wymienionymi krokami.

Następnie utwórz wystąpienie JFrame klasy i dodaj buforowany obraz utworzony do ContentPane elementu JFrame, jak pokazano poniżej -

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

Poniższy kod programu pokazuje, jak możesz read obraz i display przez okno wahadłowe za pomocą biblioteki 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");     
   } 
}

Wykonując powyższy program, otrzymasz następujące dane wyjściowe -

Image Loaded

Oprócz tego możesz zobaczyć okno wyświetlające załadowany obraz, w następujący sposób -

Wyświetlanie obrazu za pomocą JavaFX

Aby wyświetlić obraz za pomocą JavaFX, najpierw przeczytaj obraz za pomocą imread() metoda i przekonwertuj ją na BufferedImage. Następnie przekonwertuj BufferedImage na WritableImage, jak pokazano poniżej.

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

Podaj to WritableImage obiekt do konstruktora ImageView klasa.

ImageView imageView = new ImageView(writableImage);

Example

Poniższy kod programu pokazuje, jak to zrobić read obraz i display to przez okno JavaFX przy użyciu biblioteki 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); 
   } 
}

Wykonując powyższy program, otrzymasz następujące dane wyjściowe -

Image Loaded

Oprócz tego możesz zobaczyć okno wyświetlające załadowany obraz, w następujący sposób -

OpenCV obsługuje różne typy obrazów, takie jak kolorowe, binarne, w skali szarości itp. Korzystanie z imread() metoda i predefiniowane pola Imgcodecs możesz odczytać dany obrazek jako inny typ.

Parametr flag metody imread () (IMREAD_XXX)

We wcześniejszych rozdziałach widzieliśmy składnię imread() metoda Imgcodecsklasa. Akceptuje argument w postaci ciągu znaków reprezentujący lokalizację obrazu, który ma zostać odczytany.

imread(filename)

Plik imread() metoda ma inną składnię.

imread(filename, int flags)

Ta składnia akceptuje dwa parametry -

• filename - Przyjmuje argument (filename), zmienna typu String reprezentująca ścieżkę do pliku, który ma zostać odczytany.

• flags- Wartość całkowita reprezentująca wstępnie zdefiniowaną wartość flagi. Dla każdej wartości odczytuje dany obraz jako określony typ (kolor w skali szarości itp.)

Poniżej znajduje się tabela zawierająca różne pola dostępne w Imgproc class jako wartości tego parametru.

S.Nr	Pola i opis
1	IMREAD_COLOR Jeśli flaga jest ustawiona na tę wartość, załadowany obraz zostanie przekonwertowany na 3-kanałowy kolorowy obraz BGR (Blue Green Red).
2	IMREAD_GRAYSCALE Jeśli flaga jest ustawiona na tę wartość, załadowany obraz zostanie przekonwertowany na jednokanałowy obraz w skali szarości.
3	IMREAD_LOAD_GDAL Jeśli flaga jest ustawiona na tę wartość, możesz załadować obraz przy użyciu pliku gdal kierowca.
4	IMREAD_ANYCOLOR Jeśli flaga jest ustawiona na tę wartość, obraz jest czytany w dowolnym możliwym formacie kolorów.
5	IMREAD_REDUCED_COLOR_2 IMREAD_REDUCED_COLOR_4 IMREAD_REDUCED_COLOR_8 Jeśli flaga jest ustawiona na tę wartość, obraz jest odczytywany jako trzy-kanałowy BGR, a rozmiar obrazu jest zredukowana do ½, ¼ th lub ⅛ th oryginalnego rozmiaru obrazu w stosunku do pola używane.
6	IMREAD_REDUCED_GRAYSCALE_2 IMREAD_REDUCED_GRAYSCALE_4 IMREAD_REDUCED_GRAYSCALE_8 Jeśli flaga jest ustawiona na tę wartość, obraz jest odczytywany jako jednokanałowym skali szarości, a rozmiar obrazu jest zredukowana do ½, ¼ th lub ⅛ th oryginalnego rozmiaru obrazu w stosunku do pola wykorzystywane .
7	IMREAD_UNCHANGED Jeśli flaga jest ustawiona na tę wartość, załadowany obraz jest zwracany bez zmian.

Poniższy program pokazuje, jak odczytać kolorowy obraz w skali szarości i wyświetlić go za pomocą okna JavaFX. Tutaj przeczytaliśmy obraz, przekazując flagęIMREAD_GRAYSCALE wraz ze Stringiem trzymającym ścieżkę kolorowego obrazu.

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

Obraz wejściowy

Załóżmy, że poniżej jest obraz wejściowy sample.jpg określone w powyższym programie.

Obraz wyjściowy

Podczas wykonywania programu otrzymasz następujące dane wyjściowe.

Poniższy program demonstruje, jak odczytać kolorowy obraz jako obraz typu BGR i wyświetlić go za pomocą okna JavaFX. Tutaj przeczytaliśmy obraz, przekazując flagęIMREAD_COLOR do metody imread() wraz ze Stringiem trzymającym ścieżkę kolorowego obrazu.

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

Obraz wejściowy

Załóżmy, że poniżej jest obraz wejściowy sample.jpg określone w powyższym programie.

Obraz wyjściowy

Podczas wykonywania programu otrzymasz następujące dane wyjściowe.

We wcześniejszych rozdziałach omawialiśmy, jak odczytywać obraz wejściowy jako różne typy (binarny, w skali szarości, BGR itp.). W tym rozdziale dowiemy się, jak konwertować jeden typ obrazu na inny.

Klasa o nazwie Imgproc pakietu org.opencv.imgproc zapewnia metody konwersji obrazu z jednego koloru na inny.

Konwersja kolorowych obrazów do skali szarości

Metoda o nazwie cvtColor()służy do konwersji kolorowych obrazów na skalę szarości. Poniżej znajduje się składnia tej metody.

cvtColor(Mat src, Mat dst, int code)

Ta metoda akceptuje następujące parametry -

• src - macierz reprezentująca źródło.

• dst - macierz reprezentująca miejsce docelowe.

• code - Kod całkowity reprezentujący typ konwersji, na przykład RGB na Skala szarości.

Możesz przekonwertować kolorowe obrazy na skalę szarości, przekazując kod Imgproc.COLOR_RGB2GRAY wraz z macierzami źródłowymi i docelowymi jako parametrem pliku cvtColor() metoda.

Przykład

Poniższy program pokazuje, jak odczytać kolorowy obraz jako obraz w skali szarości i wyświetlić go za pomocą okna 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);
   }
}

Obraz wejściowy

Załóżmy, że poniżej jest obraz wejściowy sample.jpg określone w powyższym programie.

Obraz wyjściowy

Podczas wykonywania programu otrzymasz następujące dane wyjściowe.

Metoda o nazwie threshold()służy do konwersji obrazów w skali szarości na obraz binarny. Poniżej znajduje się składnia tej metody.

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

Ta metoda akceptuje następujące parametry -

• mat - A Mat obiekt reprezentujący obraz wejściowy.

• dst - A Mat obiekt reprezentujący obraz wyjściowy.

• thresh - liczba całkowita reprezentująca wartość progową.

• maxval - Liczba całkowita reprezentująca maksymalną wartość do użycia z typami progów THRESH_BINARY i THRESH_BINARY_INV.

• type - Kod całkowity reprezentujący typ konwersji, na przykład RGB na Skala szarości.

Możesz przekonwertować obraz w skali szarości na obraz binarny, przekazując kod Imgproc.THRESH_BINARY wraz z wartościami do pozostałych parametrów.

Przykład

Poniższy program pokazuje, jak odczytać kolorowy obraz jako obraz binarny i wyświetlić go za pomocą okna 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);
   }
}

Obraz wejściowy

Załóżmy, że poniżej jest obraz wejściowy sample.jpg określone w powyższym programie.

Obraz wyjściowy

Podczas wykonywania programu otrzymasz następujące dane wyjściowe.

Możesz użyć tej samej metody, co w poprzednim rozdziale, aby przekonwertować obraz w skali szarości na obraz binarny. Po prostu podaj ścieżkę do obrazu w skali szarości jako dane wejściowe do tego programu.

Przykład

Poniższy program demonstruje, jak odczytać obraz w skali szarości jako obraz binarny i wyświetlić go za pomocą okna 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);
   }
}

Obraz wejściowy

Załóżmy, że poniżej jest obraz wejściowy sample.jpg określone w powyższym programie.

Obraz wyjściowy

Podczas wykonywania programu otrzymasz następujące dane wyjściowe.

Możesz rysować różne kształty, takie jak Okrąg, Prostokąt, Linia, Elipsa, Polilinie, Wypukłe, Polilinie, Polilinie na obrazie przy użyciu odpowiednich metod org.opencv.imgproc pakiet.

Możesz narysować okrąg na obrazie za pomocą tej metody circle() z imgprocklasa. Poniżej znajduje się składnia tej metody -

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

Ta metoda akceptuje następujące parametry -

• mat - A Mat obiekt reprezentujący obraz, na którym ma zostać narysowany okrąg.

• point - A Point obiekt reprezentujący środek koła.

• radius - zmienna typu integer reprezentujący promień okręgu.

• scalar - A Scalarobiekt reprezentujący kolor koła. (BGR)

• thickness - An integerreprezentująca grubość koła; domyślnie wartość grubości wynosi 1.

Przykład

Poniższy program demonstruje, jak narysować okrąg na obrazie i wyświetlić go za pomocą okna 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);
   }
}

Wykonując powyższy program, otrzymasz następujące dane wyjściowe -

Możesz narysować linię na obrazie za pomocą tej metody line() z imgprocklasa. Poniżej znajduje się składnia tej metody.

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

Ta metoda akceptuje następujące parametry -

• mat - A Mat obiekt reprezentujący obraz, na którym ma zostać narysowana linia.

• pt1 and pt2 - Dwa Point obiekty reprezentujące punkty, pomiędzy którymi ma zostać narysowana linia.

• scalar - A Scalarobiekt reprezentujący kolor koła. (BGR)

• thickness- liczba całkowita reprezentująca grubość linii; domyślnie wartość grubości wynosi 1.

Przykład

Poniższy program demonstruje, jak narysować linię na obrazie i wyświetlić ją za pomocą okna 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);
   }
}

Wykonując powyższy program, otrzymasz następujące dane wyjściowe -

Za pomocą tej metody można narysować prostokąt na obrazie rectangle() z imgprocklasa. Poniżej znajduje się składnia tej metody -

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

Ta metoda akceptuje następujące parametry -

• mat - A Mat obiekt reprezentujący obraz, na którym ma zostać narysowany prostokąt.

• pt1 and pt2 - Dwa Point obiekty reprezentujące wierzchołki prostokąta, który ma zostać narysowany.

• scalar - A Scalarobiekt reprezentujący kolor prostokąta. (BGR)

• thickness- liczba całkowita reprezentująca grubość prostokąta; domyślnie wartość grubości wynosi 1.

Przykład

Poniższy przykład ilustruje, jak narysować prostokąt na obrazie i wyświetlić go za pomocą okna 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);
   }
}

Wykonując powyższy program, otrzymasz następujące dane wyjściowe -

Za pomocą tej metody można narysować elipsę na obrazie rectangle() z imgprocklasa. Poniżej znajduje się składnia tej metody -

ellipse(img, box, color, thickness)

Ta metoda akceptuje następujące parametry -

• mat - A Mat obiekt reprezentujący obraz, na którym ma zostać narysowany prostokąt.

• box - Obiekt RotatedRect (elipsa jest rysowana i wpisana w ten prostokąt).

• scalar - A Scalarobiekt reprezentujący kolor Rectangle. (BGR)

• thickness- liczba całkowita reprezentująca grubość prostokąta; domyślnie wartość grubości wynosi 1.

Konstruktor RotatedRect class akceptuje obiekt klasy Point, obiekt klasy Size i zmienną typu double, jak pokazano poniżej.

RotatedRect(Point c, Size s, double a)

Przykład

Poniższy program demonstruje, jak narysować elipsę na obrazie i wyświetlić ją za pomocą okna 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);
   }
}

Wykonując powyższy program, otrzymasz następujące dane wyjściowe -

Za pomocą tej metody można rysować polilinie na obrazie polylines() z imgprocklasa. Poniżej znajduje się składnia tej metody.

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

Ta metoda akceptuje następujące parametry -

• mat - A Mat obiekt reprezentujący obraz, na którym mają zostać narysowane polilinie.

• pts - A List obiekt zawierający obiekty typu MatOfPoint.

• isClosed - parametr typu boolean określający pogodę, w której polilinie są zamknięte.

• scalar - A Scalarobiekt reprezentujący kolor polilinii. (BGR)

• thickness- liczba całkowita reprezentująca grubość polilinii; domyślnie wartość grubości wynosi 1.

Konstruktor MatOfPoint klasa przyjmuje obiekty tej klasy Point.

MatOfPoint(Point... a)

Przykład

Poniższy program demonstruje, jak rysować polilinie na obrazie i wyświetlać je za pomocą okna 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);
   }
}

Wykonując powyższy program, otrzymasz następujące dane wyjściowe -

Za pomocą tej metody można rysować wypukłe polilinie na obrazie fillconvexPoly() z imgprocklasa. Poniżej znajduje się składnia tej metody.

fillConvexPoly(Mat img, MatOfPoint points, Scalar color)

Ta metoda akceptuje następujące parametry -

• mat - A Mat obiekt reprezentujący obraz, na którym mają zostać narysowane wypukłe polilinie.

• points - A MatOfPoint obiekt reprezentujący punkty, pomiędzy którymi mają być rysowane wypukłe polilinie.

• scalar - A Scalarobiekt reprezentujący kolor wypukłych polilinii. (BGR)

Konstruktor MatOfPoint klasa przyjmuje obiekty tej klasy Point.

MatOfPoint(Point... a)

Przykład

Poniższy program demonstruje, jak rysować wypukłe polilinie na obrazie i wyświetlać je za pomocą okna 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);
   }
}

Wykonując powyższy program, otrzymasz następujące dane wyjściowe -

Za pomocą tej metody można narysować na obrazie linię ze strzałką arrowedLine() z imgprocklasa. Poniżej znajduje się składnia tej metody -

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

Ta metoda akceptuje następujące parametry -

• mat - A Mat obiekt reprezentujący obraz, na którym ma zostać narysowana linia ze strzałką.

• pt1 and pt2 - Dwa Point obiekty reprezentujące punkty, pomiędzy którymi ma zostać narysowana linia ze strzałką.

• scalar - A Scalarobiekt reprezentujący kolor linii ze strzałką. (BGR)

Przykład

Poniższy program demonstruje, jak narysować linię ze strzałkami na obrazie i wyświetlić ją za pomocą okna 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);
   }
}

Wykonując powyższy program, otrzymasz następujące dane wyjściowe -

Możesz dodać tekst do obrazu za pomocą tej metody arrowedLine() z imgprocklasa. Poniżej znajduje się składnia tej metody.

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

Ta metoda akceptuje następujące parametry -

• mat - A Mat obiekt reprezentujący obrazek, do którego ma zostać dodany tekst.

• text - A string zmienna reprezentująca tekst, który ma zostać dodany.

• org - A Point obiekt reprezentujący ciąg tekstowy w lewym dolnym rogu obrazu.

• fontFace - zmienna typu integer reprezentująca typ czcionki.

• fontScale - Zmienna typu double reprezentująca współczynnik skali pomnożony przez rozmiar bazowy charakterystyczny dla czcionki.

• scalar - A Scalarobiekt reprezentujący kolor tekstu, który ma zostać dodany. (BGR)

• thickness - Liczba całkowita reprezentująca grubość linii, domyślnie wartość grubości wynosi 1.

Przykład

Poniższy program demonstruje, jak dodać tekst do obrazu i wyświetlić go za pomocą okna 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);
   }
}

Wykonując powyższy program, otrzymasz następujące dane wyjściowe -

Rozmycie (wygładzanie) to powszechnie stosowana operacja przetwarzania obrazu w celu zmniejszenia szumów obrazu. Proces usuwa z obrazu treści o wysokiej częstotliwości, takie jak krawędzie, i sprawia, że ​​jest on gładki.

Ogólnie rozmycie uzyskuje się poprzez splot (każdy element obrazu jest dodawany do swoich lokalnych sąsiadów, ważony przez jądro) obrazu przez jądro filtru dolnoprzepustowego.

Rozmycie (uśrednianie)

Podczas tej operacji obraz jest splatany z filtrem pudełkowym (znormalizowany). W tym procesie centralny element obrazu jest zastępowany przez średnią wszystkich pikseli w obszarze jądra.

Możesz wykonać tę operację na obrazie za pomocą tej metody blur() z imgprocklasa. Poniżej znajduje się składnia tej metody -

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

Ta metoda akceptuje następujące parametry -

• src - A Mat obiekt reprezentujący źródło (obraz wejściowy) dla tej operacji.

• dst - A Mat obiekt reprezentujący miejsce docelowe (obraz wyjściowy) dla tej operacji.

• ksize - A Size obiekt reprezentujący rozmiar jądra.

• anchor - zmienna typu integer reprezentująca punkt zakotwiczenia.

• borderType - zmienna typu integer reprezentująca typ obramowania, który ma być użyty do wyjścia.

Przykład

Poniższy program przedstawia sposób wykonywania operacji uśredniania (rozmycia) na obrazie.

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

Załóżmy, że poniżej jest obraz wejściowy sample.jpg określone w powyższym programie.

Wynik

Podczas wykonywania programu otrzymasz następujące dane wyjściowe -

Image Processed

Jeśli otworzysz określoną ścieżkę, możesz obserwować obraz wyjściowy w następujący sposób -

W operacji Rozmycie gaussowskie obraz jest spleciony z filtrem Gaussa zamiast filtru pudełkowego. Filtr Gaussa jest filtrem dolnoprzepustowym, który usuwa składowe o wysokiej częstotliwości i jest redukowany.

Możesz wykonać tę operację na obrazie za pomocą Gaussianblur() metoda imgprocklasa. Poniżej znajduje się składnia tej metody -

GaussianBlur(src, dst, ksize, sigmaX)

Ta metoda akceptuje następujące parametry -

• src - A Mat obiekt reprezentujący źródło (obraz wejściowy) dla tej operacji.

• dst - A Mat obiekt reprezentujący miejsce docelowe (obraz wyjściowy) dla tej operacji.

• ksize - A Size obiekt reprezentujący rozmiar jądra.

• sigmaX - Zmienna typu double reprezentująca odchylenie standardowe jądra Gaussa w kierunku X.

Przykład

Poniższy program przedstawia sposób wykonywania operacji rozmycia gaussowskiego na obrazie.

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

Załóżmy, że poniżej jest obraz wejściowy sample.jpg określone w powyższym programie.

Wynik

Podczas wykonywania programu otrzymasz następujące dane wyjściowe -

Image Processed

Jeśli otworzysz określoną ścieżkę, możesz obserwować obraz wyjściowy w następujący sposób -

Operacja rozmycia mediany jest podobna do innych metod uśredniania. Tutaj centralny element obrazu jest zastępowany przez medianę wszystkich pikseli w obszarze jądra. Ta operacja przetwarza krawędzie, jednocześnie usuwając szum.

Możesz wykonać tę operację na obrazie za pomocą medianBlur() metoda imgprocklasa. Poniżej znajduje się składnia tej metody -

medianBlur(src, dst, ksize)

Ta metoda akceptuje następujące parametry -

• src - A Mat obiekt reprezentujący źródło (obraz wejściowy) dla tej operacji.

• dst - A Mat obiekt reprezentujący miejsce docelowe (obraz wyjściowy) dla tej operacji.

• ksize - A Size obiekt reprezentujący rozmiar jądra.

Przykład

Poniższy program przedstawia sposób wykonywania operacji mediany rozmycia na obrazie.

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

Załóżmy, że poniżej jest obraz wejściowy sample.jpg określone w powyższym programie.

Wynik

Podczas wykonywania programu otrzymasz następujące dane wyjściowe -

Image Processed

Jeśli otworzysz określoną ścieżkę, możesz obserwować obraz wyjściowy w następujący sposób -

Filtrowanie obrazu umożliwia zastosowanie różnych efektów do obrazu. W tym rozdziale i w kolejnych trzech rozdziałach omówimy różne operacje filtrowania, takie jak filtr dwustronny, filtr pudełkowy, filtr pudełkowy SQR i filtrowanie 2D.

Filtr dwustronny

Operacja filtra dwustronnego powoduje zastosowanie dwustronnego obrazu do filtra. Możesz wykonać tę operację na obrazie za pomocąmedianBlur() metoda imgprocklasa. Poniżej znajduje się składnia tej metody.

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

Ta metoda akceptuje następujące parametry -

• src - A Mat obiekt reprezentujący źródło (obraz wejściowy) dla tej operacji.

• dst - A Mat obiekt reprezentujący miejsce docelowe (obraz wyjściowy) dla tej operacji.

• d - zmienna typu integer reprezentująca średnicę sąsiedztwa piksela.

• sigmaColor - zmienna typu integer reprezentująca sigma filtru w przestrzeni kolorów.

• sigmaSpace - zmienna typu integer reprezentująca sigma filtru w przestrzeni współrzędnych.

• borderType - Obiekt będący liczbą całkowitą reprezentujący typ używanego obramowania.

Przykład

Poniższy program demonstruje, jak wykonać operację filtra dwustronnego na obrazie.

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

Załóżmy, że poniżej jest obraz wejściowy filter_input.jpg określone w powyższym programie.

Wynik

Podczas wykonywania programu otrzymasz następujące dane wyjściowe -

Image Processed

Jeśli otworzysz określoną ścieżkę, możesz obserwować obraz wyjściowy w następujący sposób -

Operacja filtra pudełkowego jest podobna do operacji uśredniania rozmycia; nakłada dwustronny obraz na filtr. Tutaj możesz wybrać, czy pudełko ma być znormalizowane, czy nie.

Możesz wykonać tę operację na obrazie za pomocą boxFilter() metoda imgprocklasa. Poniżej znajduje się składnia tej metody -

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

Ta metoda akceptuje następujące parametry -

• src - A Mat obiekt reprezentujący źródło (obraz wejściowy) dla tej operacji.

• dst - A Mat obiekt reprezentujący miejsce docelowe (obraz wyjściowy) dla tej operacji.

• ddepth - Zmienna typu integer reprezentująca głębokość obrazu wyjściowego.

• ksize - A Size obiekt reprezentujący rozmiar rozmazanego jądra.

• anchor - zmienna typu integer reprezentująca punkt zakotwiczenia.

• Normalize - Zmienna typu boolean określająca pogodę jądra powinna zostać znormalizowana.

• borderType - Obiekt będący liczbą całkowitą reprezentujący typ używanego obramowania.

Przykład

Poniższy program demonstruje, jak wykonać operację Box Filter na obrazie.

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

Załóżmy, że poniżej jest obraz wejściowy filter_input.jpg określone w powyższym programie.

Wynik

Podczas wykonywania programu otrzymasz następujące dane wyjściowe -

Image Processed

Jeśli otworzysz określoną ścieżkę, możesz obserwować obraz wyjściowy w następujący sposób -

Możesz wykonać operację filtra SQRBox na obrazie przy użyciu rozszerzenia boxFilter() metoda imgprocklasa. Poniżej znajduje się składnia tej metody -

sqrBoxFilter(src, dst, ddepth, ksize)

Ta metoda akceptuje następujące parametry -

• src - A Mat obiekt reprezentujący źródło (obraz wejściowy) dla tej operacji.

• dst - A Mat obiekt reprezentujący miejsce docelowe (obraz wyjściowy) dla tej operacji.

• ddepth - Zmienna typu integer reprezentująca głębokość obrazu wyjściowego.

• ksize - A Size obiekt reprezentujący rozmiar rozmazanego jądra.

Przykład

Poniższy program demonstruje, jak wykonać operację filtru Sqrbox na danym obrazie.

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

Załóżmy, że poniżej jest obraz wejściowy filter_input.jpg określone w powyższym programie.

Wynik

Podczas wykonywania programu otrzymasz następujące dane wyjściowe -

Image Processed

Jeśli otworzysz określoną ścieżkę, możesz obserwować obraz wyjściowy w następujący sposób -

Operacja Filter2D polega na splątaniu obrazu z jądrem. Możesz wykonać tę operację na obrazie za pomocąFilter2D() metoda imgprocklasa. Poniżej znajduje się składnia tej metody -

filter2D(src, dst, ddepth, kernel)

Ta metoda akceptuje następujące parametry -

• src - A Mat obiekt reprezentujący źródło (obraz wejściowy) dla tej operacji.

• dst - A Mat obiekt reprezentujący miejsce docelowe (obraz wyjściowy) dla tej operacji.

• ddepth - Zmienna typu integer reprezentująca głębokość obrazu wyjściowego.

• kernel - A Mat obiekt reprezentujący jądro splotu.

Przykład

Poniższy program demonstruje, jak wykonać operację Filter2D na obrazie.

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

Załóżmy, że poniżej jest obraz wejściowy filter_input.jpg określone w powyższym programie.

Wynik

Podczas wykonywania programu otrzymasz następujące dane wyjściowe -

Image Processed

Jeśli otworzysz określoną ścieżkę, możesz obserwować obraz wyjściowy w następujący sposób -

Erozja i dylatacja to dwa rodzaje operacji morfologicznych. Jak sama nazwa wskazuje, operacje morfologiczne to zbiór operacji przetwarzających obrazy zgodnie z ich kształtami.

Na podstawie podanego obrazu wejściowego opracowywany jest „element strukturalny”. Można to zrobić w dowolnej z dwóch procedur. Mają one na celu usunięcie szumu i wyrównanie niedoskonałości, aby obraz był wyraźny.

Rozszerzanie się

Ta procedura następuje po splocie z pewnym jądrem o określonym kształcie, takim jak kwadrat lub okrąg. To jądro ma punkt zakotwiczenia, który oznacza jego środek.

To jądro jest nakładane na obraz, aby obliczyć maksymalną wartość piksela. Po obliczeniu obraz zostaje zastąpiony kotwicą pośrodku. Dzięki tej procedurze obszary jasnych obszarów zwiększają się, a tym samym rozmiar obrazu.

Na przykład rozmiar obiektu w odcieniu białym lub jasnym wzrasta, podczas gdy rozmiar obiektu w odcieniu czarnym lub ciemnym maleje.

Możesz wykonać operację dylatacji na obrazie za pomocą dilate() metoda imgprocklasa. Poniżej znajduje się składnia tej metody.

dilate(src, dst, kernel)

Ta metoda akceptuje następujące parametry -

• src - A Mat obiekt reprezentujący źródło (obraz wejściowy) dla tej operacji.

• dst - A Mat obiekt reprezentujący miejsce docelowe (obraz wyjściowy) dla tej operacji.

• kernel - A Mat obiekt reprezentujący jądro.

Przykład

Możesz przygotować macierz jądra za pomocą getStructuringElement()metoda. Ta metoda akceptuje liczbę całkowitą reprezentującąmorph_rect typ i obiekt typu Size.

Imgproc.getStructuringElement(int shape, Size ksize);

Poniższy program demonstruje, jak wykonać operację dylatacji na danym obrazie.

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

Wejście

Załóżmy, że poniżej jest obraz wejściowy sample.jpg określone w powyższym programie.

Wynik

Podczas wykonywania programu otrzymasz następujące dane wyjściowe -

Image Processed

Jeśli otworzysz określoną ścieżkę, możesz obserwować obraz wyjściowy w następujący sposób -

Erozja jest procesem podobnym do dylatacji. Ale obliczona tutaj wartość piksela jest rozszerzeniem minimalnym, a nie maksymalnym. Obraz jest zastępowany pod punktem kontrolnym z tą minimalną wartością piksela.

Dzięki tej procedurze obszary ciemnych regionów powiększają się, a jasne obszary zmniejszają się. Na przykład rozmiar obiektu w ciemnym lub czarnym odcieniu zwiększa się, podczas gdy zmniejsza się w białym lub jasnym odcieniu.

Przykład

Możesz wykonać tę operację na obrazie za pomocą erode() metoda imgprocklasa. Poniżej znajduje się składnia tej metody -

erode(src, dst, kernel)

Ta metoda akceptuje następujące parametry -

• src - A Mat obiekt reprezentujący źródło (obraz wejściowy) dla tej operacji.

• dst - A Mat obiekt reprezentujący miejsce docelowe (obraz wyjściowy) dla tej operacji.

• kernel - A Mat obiekt reprezentujący jądro.

Możesz przygotować macierz jądra za pomocą getStructuringElement()metoda. Ta metoda akceptuje liczbę całkowitą reprezentującąmorph_rect typ i obiekt typu Size.

Imgproc.getStructuringElement(int shape, Size ksize);

Poniższy program demonstruje jak wykonać operację erozji na zadanym obrazie.

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

Załóżmy, że poniżej jest obraz wejściowy sample.jpg określone w powyższym programie.

Wynik

Podczas wykonywania programu otrzymasz następujące dane wyjściowe -

Image Loaded

Jeśli otworzysz określoną ścieżkę, możesz obserwować obraz wyjściowy w następujący sposób -

We wcześniejszych rozdziałach omówiliśmy proces erosion i dilation. Oprócz tych dwóch, OpenCV ma więcej przekształceń morfologicznych. PlikmorphologyEx() metody klasy Imgproc służy do wykonywania tych operacji na danym obrazie.

Poniżej znajduje się składnia tej metody -

morphologyEx(src, dst, op, kernel)

Ta metoda akceptuje następujące parametry -

• src - Przedmiot z klasy Mat reprezentujący obraz źródłowy (wejściowy).

• dst - przedmiot zajęć Mat reprezentujący obraz docelowy (wyjściowy).

• op - liczba całkowita reprezentująca typ operacji morfologicznej.

• kernel - macierz jądra.

Przykład

Poniższy program pokazuje, jak zastosować operację morfologiczną "top-hat" na obrazie przy użyciu biblioteki 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");
   } 
}

Załóżmy, że poniżej jest obraz wejściowy morph_input.jpg określone w powyższym programie.

Wynik

Podczas wykonywania programu otrzymasz następujące dane wyjściowe -

Image Processed

Jeśli otworzysz określoną ścieżkę, możesz obserwować obraz wyjściowy w następujący sposób -

Więcej operacji

Oprócz operacji morfologicznej TOPHAT, pokazane w poprzednim example, OpenCV obsługuje różne inne typy morfologii. Wszystkie te typy są reprezentowane przez wstępnie zdefiniowane pola statyczne (wartości stałe)Imgproc klasa.

Możesz wybrać typ potrzebnej morfologii, przekazując odpowiednią wstępnie zdefiniowaną wartość do parametru op z morphologyEx() metoda.

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

Poniżej przedstawiono wartości reprezentujące typ operacji morfologicznych i ich odpowiednie wyniki.

Działanie i opis	Wynik
MORPH_BLACKHAT
MORPH_CLOSE
MORPH_CROSS
MORPH_DILATE
MORPH_ELLIPSE
MORPH_ERODE
MORPH_GRADIENT
MORPH_OPEN
MORPH_RECT
MORPH_TOPHAT

Piramida to operacja na obrazie, w której

• Obraz wejściowy jest początkowo wygładzany przy użyciu określonego filtra wygładzającego (np. Gaussa, Laplaca), a następnie wygładzany obraz jest poddawany próbkowaniu.

• Ten proces powtarza się wielokrotnie.

Podczas operacji piramidy zwiększa się płynność obrazu i zmniejsza rozdzielczość (rozmiar).

Pyramid Up

W Pyramid Up obraz jest wstępnie próbkowany, a następnie rozmyty. Możesz wykonać operację Pyramid Up na obrazie za pomocąpyrUP() metoda imgprocklasa. Poniżej znajduje się składnia tej metody -

pyrUp(src, dst, dstsize, borderType)

Ta metoda akceptuje następujące parametry -

• src - Przedmiot z klasy Mat reprezentujący obraz źródłowy (wejściowy).

• mat - Przedmiot z klasy Mat reprezentujący obraz docelowy (wyjściowy).

• size - Przedmiot z klasy Size reprezentujący rozmiar, do którego obraz ma zostać powiększony lub zmniejszony.

• borderType - zmienna typu całkowitego reprezentująca typ obramowania, który ma być użyty.

Przykład

Poniższy program demonstruje, jak wykonać operację Pyramid Up na obrazie.

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

Załóżmy, że poniżej jest obraz wejściowy pyramid_input.jpg określone w powyższym programie.

Wynik

Podczas wykonywania programu otrzymasz następujące dane wyjściowe -

Image Processed

Jeśli otworzysz określoną ścieżkę, możesz obserwować obraz wyjściowy w następujący sposób -

Piramida w dół

W Pyramid Down obraz jest początkowo rozmyty, a następnie próbkowany w dół. Możesz wykonać operację Pyramid Down na obrazie za pomocąpyrDown() metoda imgprocklasa. Poniżej znajduje się składnia tej metody -

pyrDown(src, dst, dstsize, borderType)

Ta metoda akceptuje następujące parametry -

• src - Przedmiot z klasy Mat reprezentujący obraz źródłowy (wejściowy).

• mat - Przedmiot z klasy Mat reprezentujący obraz docelowy (wyjściowy).

• size - Przedmiot z klasy Size reprezentujący rozmiar, do którego obraz ma zostać powiększony lub zmniejszony.

• borderType - zmienna typu całkowitego reprezentująca typ obramowania, który ma być użyty.

Przykład

Poniższy program demonstruje, jak wykonać operację piramidy w dół na obrazie.

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

Załóżmy, że poniżej jest obraz wejściowy pyramid_input.jpg określone w powyższym programie.

Wynik

Podczas wykonywania programu otrzymasz następujące dane wyjściowe -

Image Processed

Jeśli otworzysz określoną ścieżkę, możesz obserwować obraz wyjściowy w następujący sposób -

Filtrowanie z przesunięciem średnim

W operacji piramidy z przesunięciem średnim wykonywany jest początkowy etap segmentacji obrazu z przesunięciem średnim.

Operację filtrowania piramidowego z przesunięciem średniej można wykonać na obrazie przy użyciu funkcji pyrDown() metoda imgprocklasa. Poniżej znajduje się składnia tej metody.

pyrMeanShiftFiltering(src, dst, sp, sr)

Ta metoda akceptuje następujące parametry -

• src - Przedmiot z klasy Mat reprezentujący obraz źródłowy (wejściowy).

• mat - Przedmiot z klasy Mat reprezentujący obraz docelowy (wyjściowy).

• sp - zmienna typu double reprezentująca przestrzenny promień okna.

• sr - Zmienna typu double reprezentująca promień okna koloru.

Przykład

Poniższy program demonstruje, jak wykonać operację filtrowania z przesunięciem średnim na danym obrazie.

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

Załóżmy, że poniżej jest obraz wejściowy pyramid_input.jpg określone w powyższym programie.

Wynik

Podczas wykonywania programu otrzymasz następujące dane wyjściowe -

Image Processed

Jeśli otworzysz określoną ścieżkę, możesz obserwować obraz wyjściowy w następujący sposób -

Progowanie to metoda segmentacji obrazu, na ogół służy do tworzenia obrazów binarnych. Progi są dwojakiego rodzaju, a mianowicie proste i adaptacyjne.

Proste progowanie

W prostej operacji progowania pikselom, których wartości są większe od określonej wartości progowej, przypisuje się wartość standardową.

Za pomocą tej metody można wykonać prostą operację progową na obrazie threshold() z Imgproc class, Poniżej przedstawiono składnię tej metody.

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

Ta metoda akceptuje następujące parametry -

• src - Przedmiot z klasy Mat reprezentujący obraz źródłowy (wejściowy).

• dst - Przedmiot z klasy Mat reprezentujący obraz docelowy (wyjściowy).

• thresh - zmienna podwójnego typu reprezentująca wartość progową.

• maxval - Zmienna typu double reprezentująca wartość, która ma być podana, jeśli wartość piksela jest większa niż wartość progowa.

• type - zmienna typu integer reprezentująca typ progu, który ma być użyty.

Przykład

Poniższy program demonstruje, jak wykonać prostą operację progowania na obrazie w 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");
   }
}

Załóżmy, że poniżej jest obraz wejściowy thresh_input.jpg określone w powyższym programie.

Wynik

Podczas wykonywania programu otrzymasz następujące dane wyjściowe -

Image Processed

Jeśli otworzysz określoną ścieżkę, możesz obserwować obraz wyjściowy w następujący sposób -

Inne rodzaje prostego progowania

Dodatkowo THRESH_BINARYoperacja pokazana w poprzednim przykładzie, OpenCV obsługuje różne inne typy operacji progowych. Wszystkie te typy są reprezentowane przez wstępnie zdefiniowane pola statyczne (wartości stałe)Imgproc klasa.

Możesz wybrać typ wymaganej operacji progowej, przekazując odpowiednią predefiniowaną wartość do nazwanego parametru type z threshold() metoda.

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

Poniżej przedstawiono wartości reprezentujące różne typy operacji progowych i odpowiadające im wyniki.

Działanie i opis	Wynik
THRESH_BINARY
THRESH_BINARY_INV
THRESH_TRUNC
THRESH_TOZERO
THRESH_TOZERO_INV

W simple thresholding, wartość progowa jest globalna, tj. jest taka sama dla wszystkich pikseli obrazu. Adaptive thresholding to metoda, w której wartość progowa jest obliczana dla mniejszych regionów, a zatem będą różne wartości progowe dla różnych regionów.

W OpenCV można wykonać operację adaptacyjnego progu na obrazie przy użyciu tej metody adaptiveThreshold() z Imgprocklasa. Poniżej znajduje się składnia tej metody.

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

Ta metoda akceptuje następujące parametry -

• src - Przedmiot z klasy Mat reprezentujący obraz źródłowy (wejściowy).

• dst - Przedmiot z klasy Mat reprezentujący obraz docelowy (wyjściowy).

• maxValue - Zmienna typu double reprezentująca wartość, która ma być podana, jeśli wartość piksela jest większa niż wartość progowa.

• adaptiveMethod- zmienna typu integer reprezentująca metodę adaptacyjną, która ma zostać użyta. Będzie to jedna z następujących dwóch wartości

  • ADAPTIVE_THRESH_MEAN_C - wartość progowa to średnia z obszaru sąsiedztwa.

  • ADAPTIVE_THRESH_GAUSSIAN_C - wartość progowa to ważona suma wartości sąsiedztwa, gdzie wagi są oknem Gaussa.

• thresholdType - zmienna typu integer reprezentująca typ progu, który ma być użyty.

• blockSize - zmienna typu integer reprezentująca rozmiar otoczenia pikseli wykorzystywana do obliczenia wartości progowej.

• C - zmienna typu double reprezentująca stałą używaną w obu metodach (odjęta od średniej lub średniej ważonej).

Przykład

Poniższy program demonstruje, jak wykonać operację adaptacyjnego progu na obrazie w OpenCV. Tutaj wybieramy typ progu adaptacyjnegobinary i ADAPTIVE_THRESH_MEAN_C dla metody progowej.

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

Załóżmy, że poniżej jest obraz wejściowy thresh_input.jpg określone w powyższym programie.



Wynik

Podczas wykonywania programu otrzymasz następujące dane wyjściowe -

Image Processed

Jeśli otworzysz określoną ścieżkę, możesz obserwować obraz wyjściowy w następujący sposób -



Inne typy adaptacyjnego progowania

Dodatkowo ADAPTIVE_THRESH_MEAN_C jako metoda adaptacyjna i THRESH_BINARY jako typ progu, jak pokazano w poprzednim przykładzie, możemy wybrać więcej kombinacji tych dwóch wartości.

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

Poniżej przedstawiono wartości reprezentujące różne kombinacje wartości parametrów adaptiveMethod i thresholdType i ich odpowiednich wyników.

adaptiveMethod /resholdType	ADAPTIVE_THRESH_MEAN_C	ADAPTIVE_THRESH_GAUSSIAN_C:
THRESH_BINARY
THRESH_BINARY_INV

W tym rozdziale dowiesz się, jak ropucha obramowuje obraz.

Metoda copyMakeBorder ()

Możesz dodać różne obramowania do obrazu za pomocą tej metody copyMakeBorder() klasy o nazwie Core, która należy do pakietu org.opencv.core. Poniżej znajduje się składnia tej metody.

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

Ta metoda akceptuje następujące parametry -

• src - Przedmiot z klasy Mat reprezentujący obraz źródłowy (wejściowy).

• dst - Przedmiot z klasy Mat reprezentujący obraz docelowy (wyjściowy).

• top - zmienna typu integer, typu integer, reprezentująca długość obramowania u góry obrazu.

• bottom - zmienna typu integer, typu integer, reprezentująca długość obramowania na dole obrazu.

• left - zmienna typu integer, typu integer, reprezentująca długość krawędzi po lewej stronie obrazu.

• right - zmienna typu integer, typu integer, reprezentująca długość krawędzi po prawej stronie obrazu.

• borderType - zmienna typu integer reprezentująca typ obramowania, które ma być użyte.

Przykład

Poniższy program jest przykładem pokazującym, jak dodać obramowanie do danego obrazu.

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

Załóżmy, że poniżej jest obraz wejściowy thresh_input.jpg określone w powyższym programie.



Wynik

Podczas wykonywania programu otrzymasz następujące dane wyjściowe -

Image Processed

Jeśli otworzysz określoną ścieżkę, możesz obserwować obraz wyjściowy w następujący sposób -



Inne rodzaje granic

Oprócz typu obramowania BORDER_CONSTANTpokazane w poprzednim przykładzie, OpenCV obsługuje różne inne typy granic. Wszystkie te typy są reprezentowane przez predefiniowane pola statyczne (wartości stałe) klasy Core.

Możesz wybrać typ wymaganej operacji progowej, przekazując odpowiednią predefiniowaną wartość do nazwanego parametru borderType z copyMakeBorder() metoda.

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

Poniżej przedstawiono wartości reprezentujące różne typy operacji na granicach i ich odpowiednie wyniki.

Działanie i opis	Wynik
BORDER_CONSTANT
BORDER_ISOLATED
BORDER_DEFAULT
BORDER_REFLECT
BORDER_REFLECT_101
BORDER_REFLECT101
BORDER_REPLICATE
BORDER_WRAP

Używając sobel operation, możesz wykryć krawędzie obrazu zarówno w kierunku poziomym, jak i pionowym. Możesz zastosować operację Sobela na obrazie za pomocą tej metodysobel(). Poniżej znajduje się składnia tej metody -

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

Ta metoda akceptuje następujące parametry -

• src - Przedmiot z klasy Mat reprezentujący obraz źródłowy (wejściowy).

• dst - Przedmiot z klasy Mat reprezentujący obraz docelowy (wyjściowy).

• ddepth - zmienna całkowita reprezentująca głębię obrazu (-1)

• dx- zmienna całkowita reprezentująca pochodną x. (0 lub 1)

• dy- zmienna całkowita reprezentująca pochodną y. (0 lub 1)

Przykład

Poniższy program demonstruje, jak wykonać operację Sobel na danym obrazie.

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

Załóżmy, że poniżej jest obraz wejściowy sobel_input.jpg określone w powyższym programie.



Wynik

Podczas wykonywania programu otrzymasz następujące dane wyjściowe -

Image Processed

Jeśli otworzysz określoną ścieżkę, możesz obserwować obraz wyjściowy w następujący sposób -



sobel Variants

Przekazując różne wartości do ostatniej do parametrów (dx i dy) (między 0 i 1), otrzymasz różne wyniki -

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

Poniższa tabela zawiera listę różnych wartości zmiennych dx i dy metody Sobel() i ich odpowiednich wyników.

Pochodna X.	Pochodna Y	Wynik
0	1
1	0
1	1

Scharr jest również używany do wykrywania drugiej pochodnej obrazu w kierunku poziomym i pionowym. Za pomocą tej metody można wykonać operację scharr na obraziescharr(). Poniżej znajduje się składnia tej metody -

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

Ta metoda akceptuje następujące parametry -

• src - Przedmiot z klasy Mat reprezentujący obraz źródłowy (wejściowy).

• dst - Przedmiot z klasy Mat reprezentujący obraz docelowy (wyjściowy).

• ddepth - zmienna całkowita reprezentująca głębię obrazu (-1)

• dx- zmienna całkowita reprezentująca pochodną x. (0 lub 1)

• dy- zmienna całkowita reprezentująca pochodną y. (0 lub 1)

Przykład

Poniższy program demonstruje, jak zastosować scharr do danego obrazu.

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

Załóżmy, że poniżej jest obraz wejściowy scharr_input.jpg określone w powyższym programie.



Wynik

Wykonując go, otrzymasz następujący wynik -

Image Processed

Jeśli otworzysz określoną ścieżkę, możesz obserwować obraz wyjściowy w następujący sposób -



Więcej Scharr Pochodne

Przekazując różne wartości do ostatniej do parametrów (dx i dy) (między 0 i 1), otrzymasz różne wyniki -

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

Poniżej znajduje się tabela zawierająca różne wartości zmiennych dx i dy metody scharr() i ich odpowiednich wyników.

Pochodna X.	Pochodna Y	Wynik
0	1
1	0

Operator Laplacian jest również operatorem pochodnym, który służy do znajdowania krawędzi na obrazie. Jest to maska ​​pochodna drugiego rzędu. W tej masce mamy dwie dalsze klasyfikacje: jedna to pozytywny operator laplacki, a druga to ujemny operator laplacki.

W przeciwieństwie do innych operatorów Laplacian nie usuwa krawędzi w żadnym konkretnym kierunku, ale usuwa krawędzie w następującej klasyfikacji.

• Wewnętrzne krawędzie
• Zewnętrzne krawędzie

Możesz występować Laplacian Transform operacja na obrazie przy użyciu Laplacian() metoda imgproc class, poniżej jest składnia tej metody.

Laplacian(src, dst, ddepth)

Ta metoda akceptuje następujące parametry -

• src - A Mat obiekt reprezentujący źródło (obraz wejściowy) dla tej operacji.

• dst - A Mat obiekt reprezentujący miejsce docelowe (obraz wyjściowy) dla tej operacji.

• ddepth - zmienna typu integer reprezentująca głębokość docelowego obrazu.

Przykład

Poniższy program demonstruje, jak wykonać operację transformacji Laplace'a na danym obrazie.

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

Załóżmy, że poniżej jest obraz wejściowy laplacian_input.jpg określone w powyższym programie.



Wynik

Podczas wykonywania programu otrzymasz następujące dane wyjściowe -

Image Processed

Jeśli otworzysz określoną ścieżkę, możesz obserwować obraz wyjściowy w następujący sposób -



Plik distance transformoperator zazwyczaj przyjmuje obrazy binarne jako dane wejściowe. W tej operacji intensywność szarości punktów wewnątrz obszarów pierwszego planu jest zmieniana w celu oddalenia ich odpowiednich odległości od najbliższej wartości 0 (granicy).

Możesz zastosować transformację odległości w OpenCV za pomocą metody distanceTransform(). Poniżej znajduje się składnia tej metody.

distanceTransform(src, dst, distanceType, maskSize)

Ta metoda akceptuje następujące parametry -

• src - Przedmiot z klasy Mat reprezentujący obraz źródłowy (wejściowy).

• dst - Przedmiot z klasy Mat reprezentujący obraz docelowy (wyjściowy).

• distanceType - zmienna typu integer reprezentująca typ zastosowanej transformacji odległości.

• maskSize - zmienna typu całkowitego reprezentująca rozmiar maski, która ma być używana.

Przykład

Poniższy program demonstruje, jak wykonać operację transformacji odległości na danym obrazie.

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

Załóżmy, że poniżej jest obraz wejściowy input.jpg określone w powyższym programie.

Wynik

Podczas wykonywania programu otrzymasz następujące dane wyjściowe -

Image Processed

Jeśli otworzysz określoną ścieżkę, możesz obserwować obraz wyjściowy w następujący sposób -

Rodzaje operacji przekształcania odległości

Oprócz typu operacji na odległość DIST_Cpokazane w poprzednim przykładzie, OpenCV obsługuje różne inne typy operacji przekształcania odległości. Wszystkie te typy są reprezentowane przez predefiniowane pola statyczne (wartości stałe) klasy Imgproc.

Możesz wybrać typ operacji transformacji odległości, której potrzebujesz, przekazując odpowiednią wstępnie zdefiniowaną wartość do nazwanego parametru distanceType z distanceTransform() metoda.

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

Poniżej przedstawiono wartości reprezentujące różne typy plików distanceTransform operacje i ich odpowiednie wyniki.

Działanie i opis	Wynik
DIST_C
DIST_L1
DIST_L2
DIST_LABEL_PIXEL
DIST_MASK_3

W tym rozdziale dowiemy się, jak używać OpenCV do przechwytywania klatek za pomocą kamery systemowej. PlikVideoCapture klasa org.opencv.videoioPakiet zawiera klasy i metody do przechwytywania wideo za pomocą kamery. Przejdźmy krok po kroku i dowiedzmy się, jak przechwytywać klatki -

Krok 1: Załaduj natywną bibliotekę OpenCV

Podczas pisania kodu Java za pomocą biblioteki OpenCV, pierwszym krokiem, jaki należy wykonać, jest załadowanie natywnej biblioteki OpenCV za pomocą loadLibrary(). Załaduj natywną bibliotekę OpenCV, jak pokazano poniżej.

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

Krok 2: Utwórz wystąpienie klasy przechwytywania wideo

Utwórz wystąpienie klasy Mat, używając dowolnej funkcji wspomnianej wcześniej w tym samouczku.

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

Krok 3: Przeczytaj ramki

Możesz odczytać klatki z aparatu za pomocą read() metoda VideoCaptureklasa. Ta metoda akceptuje obiekt klasyMat aby zapisać ramkę do odczytu.

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

Przykład

Poniższy program pokazuje, jak przechwycić klatkę za pomocą kamery i wyświetlić ją za pomocą okna JavaFX. Zapisuje również przechwyconą ramkę.

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

Wynik

Podczas wykonywania programu otrzymasz następujące dane wyjściowe.

Jeśli otworzysz określoną ścieżkę, możesz zobaczyć tę samą klatkę, która jest zapisana jako plik jpg.

Plik VideoCapture klasa org.opencv.videoioPakiet zawiera klasy i metody do przechwytywania wideo za pomocą kamery systemowej. Przejdźmy krok po kroku i nauczmy się, jak to zrobić.

Krok 1: Załaduj natywną bibliotekę OpenCV

Podczas pisania kodu Java za pomocą biblioteki OpenCV, pierwszym krokiem, jaki należy wykonać, jest załadowanie natywnej biblioteki OpenCV za pomocą loadLibrary(). Załaduj natywną bibliotekę OpenCV, jak pokazano poniżej.

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

Krok 2: Utwórz wystąpienie klasy CascadeClassifier

Plik CascadeClassifier klasa pakietu org.opencv.objdetectsłuży do ładowania pliku klasyfikatora. Utwórz wystąpienie tej klasy, przekazując plikxml plik lbpcascade_frontalface.xml jak pokazano niżej.

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

Krok 3: Wykryj twarze

Możesz wykryć twarze na obrazie za pomocą metody detectMultiScale() klasy o nazwie CascadeClassifier. Ta metoda akceptuje obiekt klasyMat przechowujący obraz wejściowy i obiekt klasy MatOfRect aby zapisać wykryte twarze.

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

Przykład

Poniższy program demonstruje, jak wykrywać twarze na obrazie.

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

Załóżmy, że poniżej jest obraz wejściowy facedetection_input.jpg określone w powyższym programie.

Wynik

Podczas wykonywania programu otrzymasz następujące dane wyjściowe -

Detected 3 faces 
Image Processed

Jeśli otworzysz określoną ścieżkę, możesz obserwować obraz wyjściowy w następujący sposób -

Poniższy program pokazuje, jak wykrywać twarze za pomocą kamery systemowej i wyświetlać je za pomocą okna JavaFX.

Przykład

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

Wynik

Podczas wykonywania programu otrzymasz następujące dane wyjściowe.

Jeśli otworzysz określoną ścieżkę, zobaczysz tę samą migawkę zapisaną jako plik jpg wizerunek.

Możesz występować affine translation na obrazie przy użyciu warpAffine()metoda klasy imgproc. Poniżej znajduje się składnia tej metody -

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

Ta metoda akceptuje następujące parametry -

• src - A Mat obiekt reprezentujący źródło (obraz wejściowy) dla tej operacji.

• dst - A Mat obiekt reprezentujący miejsce docelowe (obraz wyjściowy) dla tej operacji.

• tranformMatrix - A Mat obiekt reprezentujący macierz transformacji.

• size - zmienna typu integer reprezentująca rozmiar obrazu wyjściowego.

Przykład

Poniższy program demonstruje, jak zastosować operację afiniczną na danym obrazie.

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

Załóżmy, że poniżej jest obraz wejściowy transform_input.jpg określone w powyższym programie.

Wynik

Wykonując go, otrzymasz następujący wynik -

Image Processed

Jeśli otworzysz określoną ścieżkę, możesz obserwować obraz wyjściowy w następujący sposób -

Możesz perform rotation operacja na obrazie przy użyciu warpAffine() metoda imgprocklasa. Poniżej znajduje się składnia tej metody -

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

Ta metoda akceptuje następujące parametry -

• src - A Mat obiekt reprezentujący źródło (obraz wejściowy) dla tej operacji.

• dst - A Mat obiekt reprezentujący miejsce docelowe (obraz wyjściowy) dla tej operacji.

• rotationMatrix - A Mat obiekt reprezentujący macierz rotacji.

• size - zmienna typu integer reprezentująca rozmiar obrazu wyjściowego.

Przykład

Poniższy program przedstawia sposób obracania obrazu.

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

Załóżmy, że poniżej jest obraz wejściowy transform_input.jpg określone w powyższym programie.

Wynik

Podczas wykonywania programu otrzymasz następujące dane wyjściowe -

Image Processed

Jeśli otworzysz określoną ścieżkę, możesz obserwować obraz wyjściowy w następujący sposób -

Możesz występować scaling na obrazie przy użyciu resize() metoda imgprocklasa. Poniżej znajduje się składnia tej metody.

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

Ta metoda akceptuje następujące parametry -

• src - A Mat obiekt reprezentujący źródło (obraz wejściowy) dla tej operacji.

• dst - A Mat obiekt reprezentujący miejsce docelowe (obraz wyjściowy) dla tej operacji.

• dsize - A Size obiekt reprezentujący rozmiar obrazu wyjściowego.

• fx - Zmienna typu double reprezentująca współczynnik skali wzdłuż osi poziomej.

• fy - Zmienna typu double reprezentująca współczynnik skali wzdłuż osi pionowej.

• Interpolation - zmienna całkowita reprezentująca metodę interpolacji.

Przykład

Poniższy program demonstruje, jak stosować scale transformation do obrazu.

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

Załóżmy, że poniżej jest obraz wejściowy transform_input.jpg określone w powyższym programie (rozmiar - Szerokość: 300px i wysokość: 300px).

Wynik

Podczas wykonywania programu otrzymasz następujące dane wyjściowe -

Image Processed

Jeśli otworzysz określoną ścieżkę, możesz obserwować obraz wyjściowy w następujący sposób (rozmiar - Szerokość: 600 pikseli i wysokość: 600 pikseli) -

W OpenCV możesz zastosować różne mapy kolorów do obrazu za pomocą tej metody applyColorMap() klasy Imgproc. Poniżej znajduje się składnia tej metody -

applyColorMap(Mat src, Mat dst, int colormap)

Akceptuje trzy parametry -

• src - Przedmiot z klasy Mat reprezentujący obraz źródłowy (wejściowy).

• dst - Przedmiot z klasy Mat reprezentujący obraz docelowy (wyjściowy).

• colormap - Zmienna typu całkowitego reprezentująca typ stosowanej mapy kolorów.

Przykład

Poniższy program demonstruje, jak stosować color map do obrazu.

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

Załóżmy, że poniżej jest obraz wejściowy color_input.jpg określone w powyższym programie.

Wynik

Wykonując powyższy program, otrzymasz następujące dane wyjściowe -

Image Processed

Jeśli otworzysz określoną ścieżkę, możesz obserwować obraz wyjściowy w następujący sposób -

Więcej operacji

Oprócz COLORMAP_HOTpokazane w poprzednim przykładzie, OpenCV obsługuje różne inne typy map kolorów. Wszystkie te typy są reprezentowane przez predefiniowane pola statyczne (wartości stałe) klasy Imgproc.

Możesz wybrać typ potrzebnej mapy kolorów, przekazując odpowiednią predefiniowaną wartość do nazwanego parametru colormap z applyColorMap() metoda.

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

Poniżej przedstawiono wartości reprezentujące różne typy map kolorów i ich odpowiednie wyniki.

Działanie i opis	Wynik
COLORMAP_AUTUMN
COLORMAP_BONE
COLORMAP_COOL
COLORMAP_HOT
COLORMAP_HSV
COLORMAP_JET
COLORMAP_OCEAN
COLORMAP_PARULA
COLORMAP_PINK
COLORMAP_RAINBOW
COLORMAP_SPRING
COLORMAP_SUMMER
COLORMAP_WINTER

Canny Edge Detection służy do wykrywania krawędzi obrazu. Akceptuje obraz w skali szarości jako dane wejściowe i używa algorytmu wielostopniowego.

Możesz wykonać tę operację na obrazie za pomocą Canny() metoda imgproc class, poniżej jest składnia tej metody.

Canny(image, edges, threshold1, threshold2)

Ta metoda akceptuje następujące parametry -

• image - A Mat obiekt reprezentujący źródło (obraz wejściowy) dla tej operacji.

• edges - A Mat obiekt reprezentujący cel (krawędzie) dla tej operacji.

• threshold1 - Zmienna typu double reprezentująca pierwszy próg procedury histerezy.

• threshold2 - Zmienna typu double reprezentująca drugi próg procedury histerezy.

Przykład

Poniższy program jest przykładem pokazującym, jak wykonać operację Canny Edge Detection na danym obrazie.

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

Załóżmy, że poniżej jest obraz wejściowy canny_input.jpg określone w powyższym programie.

Wynik

Wykonując powyższy program, otrzymasz następujące dane wyjściowe -

Image Processed

Jeśli otworzysz określoną ścieżkę, możesz obserwować obraz wyjściowy w następujący sposób -

Możesz wykryć kształt danego obrazu, stosując rozszerzenie Hough Transform technique przy użyciu metody HoughLines() z Imgprocklasa. Poniżej znajduje się składnia tej metody.

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

Ta metoda akceptuje następujące parametry -

• image - Przedmiot z klasy Mat reprezentujący obraz źródłowy (wejściowy).

• lines - Przedmiot z klasy Mat przechowujący wektor przechowujący parametry (r, Φ) linii.

• rho - zmienna typu double reprezentująca rozdzielczość parametru r w pikselach.

• theta - zmienna typu double reprezentująca rozdzielczość parametru Φ w radianach.

• threshold - Zmienna typu integer reprezentująca minimalną liczbę przecięć do „wykrycia” wiersza.

Przykład

Poniższy program pokazuje, jak wykryć linie Hougha na danym obrazie.

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

Załóżmy, że poniżej jest obraz wejściowy hough_input.jpg określone w powyższym programie.

Wynik

Podczas wykonywania programu otrzymasz następujące dane wyjściowe -

143 
1 
Image Processed

Jeśli otworzysz określoną ścieżkę, możesz obserwować obraz wyjściowy w następujący sposób -

Plik histogramobrazu przedstawia częstotliwość wartości intensywności pikseli. Na histogramie obrazu oś X przedstawia intensywność poziomu szarości, a oś Y przedstawia częstotliwość tych intensywności.

Histogram equalizationpoprawia kontrast obrazu, aby rozszerzyć zakres intensywności. Metodą można wyrównać histogram danego obrazuequalizeHist() z Imgprocklasa. Poniżej znajduje się składnia tej metody.

equalizeHist(src, dst)

Ta metoda akceptuje następujące parametry -

• src - Przedmiot z klasy Mat reprezentujący obraz źródłowy (wejściowy).

• dst - Przedmiot z klasy Matreprezentujące wyjście. (Obraz uzyskany po wyrównaniu histogramu)

Przykład

Poniższy program pokazuje, jak wyrównać histogram danego obrazu.

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

Załóżmy, że poniżej jest obraz wejściowy histo_input.jpg określone w powyższym programie.

Wynik

Podczas wykonywania programu otrzymasz następujące dane wyjściowe -

Image Processed

Jeśli otworzysz określoną ścieżkę, możesz obserwować obraz wyjściowy w następujący sposób -