OpenCV - Hızlı Kılavuz

OpenCV, gerçek zamanlı olarak geliştirebileceğimiz bir çapraz platform kitaplığıdır. computer vision applications. Esas olarak görüntü işleme, video yakalama ve yüz algılama ve nesne algılama gibi özellikleri içeren analizlere odaklanır.

"Bilgisayarla Görme" terimini tanımlayarak bölüme başlayalım.

Bilgisayar görüşü

Computer Vision, sahnede bulunan yapının özellikleri açısından bir 3D sahnenin 2D görüntülerinden nasıl yeniden yapılandırılacağını, kesileceğini ve anlaşılacağını açıklayan bir disiplin olarak tanımlanabilir. Bilgisayar yazılımı ve donanımı kullanarak insan vizyonunun modellenmesi ve kopyalanmasıyla ilgilenir.

Computer Vision, aşağıdaki alanlarla önemli ölçüde örtüşmektedir -

  • Image Processing - Görüntü işlemeye odaklanır.

  • Pattern Recognition - Kalıpları sınıflandırmak için çeşitli teknikleri açıklar.

  • Photogrammetry - Görüntülerden doğru ölçümler elde etmekle ilgilenir.

Computer Vision Vs Görüntü İşleme

Image processinggörüntüden görüntüye dönüştürme ile ilgilenir. Görüntü işlemenin girişi ve çıkışı her iki görüntüdür.

Computer visionfiziksel nesnelerin görüntülerinden açık, anlamlı tanımlarının oluşturulmasıdır. Bilgisayarla görmenin çıktısı, 3B sahnedeki yapıların açıklaması veya yorumudur.

Bilgisayarla Görme Uygulamaları

Burada, Computer Vision'ın yoğun olarak kullanıldığı bazı ana alanları listeledik.

Robotik Uygulaması

  • Yerelleştirme - Robot konumunu otomatik olarak belirleyin

  • Navigation

  • Engellerden kaçınma

  • Montaj (delik içi, kaynak, boyama)

  • Manipülasyon (örneğin PUMA robot manipülatörü)

  • İnsan Robot Etkileşimi (HRI) - İnsanlarla etkileşim kurmak ve insanlara hizmet etmek için akıllı robotik

İlaç Başvurusu

  • Sınıflandırma ve tespit (örn. Lezyon veya hücre sınıflandırması ve tümör tespiti)
  • 2D / 3D segmentasyon
  • 3D insan organı rekonstrüksiyonu (MRI veya ultrason)
  • Görme güdümlü robotik cerrahi

Endüstriyel Otomasyon Uygulaması

  • Endüstriyel muayene (kusur tespiti)
  • Assembly
  • Barkod ve paket etiketi okuma
  • Nesne sıralama
  • Belgenin anlaşılması (örneğin OCR)

Güvenlik Uygulaması

  • Biyometri (iris, parmak izi, yüz tanıma)

  • Gözetim - Belirli şüpheli etkinlikleri veya davranışları tespit etme

Ulaşım Uygulaması

  • Otonom araç
  • Güvenlik, örneğin sürücü dikkat izleme

OpenCV Kitaplığının Özellikleri

OpenCV kitaplığını kullanarak şunları yapabilirsiniz:

  • Görselleri okuyun ve yazın

  • Videoları yakalayın ve kaydedin

  • Görüntüleri işleme (filtre, dönüştürme)

  • Özellik algılama gerçekleştirin

  • Videolar veya görüntülerdeki yüzler, gözler, arabalar gibi belirli nesneleri tespit edin.

  • Videoyu analiz edin, yani içindeki hareketi tahmin edin, arka planı çıkarın ve içindeki nesneleri izleyin.

OpenCV orijinal olarak C ++ ile geliştirilmiştir. Buna ek olarak Python ve Java bağlantıları sağlandı. OpenCV, windows, Linux, OSx, FreeBSD, Net BSD, Open BSD, vb. Gibi çeşitli İşletim Sistemlerinde çalışır.

Bu eğitici, Java bağlamalarını kullanan örneklerle OpenCV kavramlarını açıklar.

OpenCV Kütüphane Modülleri

OpenCV kütüphanesinin ana kütüphane modülleri aşağıdadır.

Temel İşlevsellik

Bu modül, OpenCV uygulamaları oluşturmak için kullanılan Skalar, Point, Range vb. Gibi temel veri yapılarını kapsar. Bunlara ek olarak çok boyutlu diziyi de içerir.Mat, görüntüleri saklamak için kullanılır. OpenCV'nin Java kitaplığında bu modül, adıyla bir paket olarak yer almaktadır.org.opencv.core.

Görüntü işleme

Bu modül, görüntü filtreleme, geometrik görüntü dönüştürmeleri, renk alanı dönüştürme, histogramlar vb. Gibi çeşitli görüntü işleme işlemlerini kapsar. OpenCV Java kitaplığında bu modül, adıyla bir paket olarak yer almaktadır. org.opencv.imgproc.

Video

Bu modül, hareket tahmini, arka plan çıkarma ve nesne izleme gibi video analizi kavramlarını kapsar. OpenCV'nin Java kitaplığında bu modül, adıyla bir paket olarak yer almaktadır.org.opencv.video.

Video G / Ç

Bu modül, OpenCV kitaplığını kullanarak video yakalama ve video codec bileşenlerini açıklar. OpenCV'nin Java kitaplığında bu modül, adıyla bir paket olarak yer almaktadır.org.opencv.videoio.

calib3d

Bu modül, temel çoklu görünüm geometri algoritmaları, tek ve stereo kamera kalibrasyonu, nesne poz tahmini, stereo yazışma ve 3B yeniden yapılandırma unsurları ile ilgili algoritmaları içerir. OpenCV'nin Java kitaplığında bu modül, adıyla bir paket olarak yer almaktadır.org.opencv.calib3d.

özellikler2d

Bu modül, özellik algılama ve açıklama kavramlarını içerir. OpenCV'nin Java kitaplığında bu modül, adıyla bir paket olarak yer almaktadır.org.opencv.features2d.

Objdetect

Bu modül, yüzler, gözler, kupalar, insanlar, arabalar vb. Gibi önceden tanımlanmış sınıfların nesnelerinin ve örneklerinin algılanmasını içerir. OpenCV Java kütüphanesinde bu modül, adıyla bir paket olarak yer almaktadır. org.opencv.objdetect.

Highgui

Bu, basit UI yeteneklerine sahip, kullanımı kolay bir arayüzdür. OpenCV Java kütüphanesinde bu modülün özellikleri iki farklı paket içerisinde yer almaktadır:org.opencv.imgcodecs ve org.opencv.videoio.

OpenCV'nin Kısa Tarihi

OpenCV, başlangıçta CPU yoğun uygulamaları tavsiye etmek için bir Intel araştırma girişimiydi. Resmi olarak 1999'da başlatıldı.

  • 2006 yılında, ilk büyük sürümü olan OpenCV 1.0 piyasaya sürüldü.
  • Ekim 2009'da, ikinci büyük sürüm olan OpenCV 2 piyasaya sürüldü.
  • Ağustos 2012'de OpenCV, kâr amacı gütmeyen bir kuruluş olan OpenCV.org tarafından alındı.

Bu bölümde, OpenCV'yi nasıl kuracağınızı ve ortamını sisteminize nasıl kuracağınızı öğreneceksiniz.

OpenCV'yi yükleme

Öncelikle OpenCV'yi sisteminize indirmeniz gerekiyor. Aşağıda verilen adımları izleyin.

Step 1 - ana sayfasını açın OpenCV aşağıdaki bağlantıya tıklayarak: http://opencv.org/ Tıkladığınızda, aşağıda gösterildiği gibi ana sayfasını göreceksiniz.

Step 2 - Şimdi tıklayın Downloadsyukarıdaki ekran görüntüsünde vurgulanan bağlantı. Tıkladığınızda OpenCV'nin indirilenler sayfasına yönlendirileceksiniz.

Step 3 - Yukarıdaki ekran görüntüsünde vurgulanan bağlantıya tıklandığında, opencv-3.1.0.exeindirilecek. Bir klasör oluşturmak için bu dosyayı çıkarınopencv aşağıdaki ekran görüntüsünde gösterildiği gibi sisteminizde.

Step 4 - Klasörü açın OpenCVbuildjava. Burada OpenCV'nin jar dosyasını bulacaksınız.opencv-310.jar. Daha sonra kullanmak için bu dosyayı ayrı bir klasöre kaydedin.

Eclipse Kurulumu

Gerekli JAR dosyalarını indirdikten sonra, bu JAR dosyalarını Eclipse ortamınıza yerleştirmelisiniz. Bunu, bu JAR dosyalarının Derleme Yolunu ayarlayarak ve şunu kullanarak yapabilirsiniz:pom.xml.

Derleme Yolunu Ayarlama

Eclipse'de OpenCV'yi kurma adımları aşağıdadır -

Step 1- Sisteminize Eclipse'i kurduğunuzdan emin olun. Değilse, sisteminize Eclipse'i indirin ve kurun.

Step 2 - Eclipse'i açın, Dosya, Yeni'ye tıklayın ve aşağıdaki ekran görüntüsünde gösterildiği gibi yeni bir proje açın.

Step 3 - Projeyi seçerken, New Projectsihirbaz. Bu sihirbazda, Java projesini seçin veNext düğmesi, aşağıdaki ekran görüntüsünde gösterildiği gibi.

Step 4 - İlerlerken, şu adrese yönlendirileceksiniz: New Java Project wizard. Yeni bir proje oluşturun ve tıklayınNext, aşağıdaki ekran görüntüsünde gösterildiği gibi.

Step 5- Yeni bir proje oluşturduktan sonra üzerine sağ tıklayın. SeçinizBuild Path ve tıkla Configure Build Path… aşağıdaki ekran görüntüsünde gösterildiği gibi.

Step 6 - Tıklandığında Build Path seçeneği, yönlendirileceksiniz Java Build Path wizard. TıklaAdd External JARs düğmesi, aşağıdaki ekran görüntüsünde gösterildiği gibi.

Step 7 - Dosyayı kaydettiğiniz yolu seçin opencv-310.jar.

Step 8 - Tıklandığında Open Yukarıdaki ekran görüntüsündeki düğmesine basın, bu dosyalar kitaplığınıza eklenecektir.

Step 9 - Tıklandığında OK, gerekli JAR dosyalarını mevcut projeye başarıyla ekleyeceksiniz ve Referanslı Kitaplıkları genişleterek bu eklenen kitaplıkları doğrulayabilirsiniz.

Yerel Kitaplıkların Yolunu Ayarlama

JAR dosyalarına ek olarak, OpenCV'nin yerel kitaplıkları (DLL dosyaları) için yol ayarlamanız gerekir.

Location of DLL files - Kurulum klasörünü açın OpenCV ve alt klasöre gidin buildjava. Burada iki klasörü bulacaksınızx64 (64 bit) ve x86 (32 bit) içeren dll OpenCV dosyaları.

İşletim sisteminize uygun ilgili klasörü açın, ardından dll dosya, aşağıdaki ekran görüntüsünde gösterildiği gibi.

Şimdi, aşağıda verilen adımları izleyerek bu dosyanın yolunu da ayarlayın -

Step 1- Bir kez daha JavaBuildPath penceresini açın. Burada eklenen JAR dosyasını veJRE System Library.

Step 2 - Genişlettiğinizde, sistem kitaplıklarını ve Native library location, aşağıdaki ekran görüntüsünde vurgulandığı gibi.

Step 3 - Çift tıklayın Native library location. Burada görebilirsinizNative Library Folder Configuration window Aşağıda gösterildiği gibi.

Burada düğmeyi tıklayın External Folder… ve konumunu seçin dll sisteminizdeki dosya.

Bir görüntüyü yakalamak için kamera ve tarayıcı gibi cihazlar kullanıyoruz. Bu cihazlar görüntünün sayısal değerlerini kaydeder (Örn: piksel değerleri). OpenCV, dijital görüntüleri işleyen bir kitaplıktır, bu nedenle bu görüntüleri işlemek için saklamamız gerekir.

MatOpenCV kütüphanesi sınıfı, bir görüntünün değerlerini depolamak için kullanılır. N boyutlu bir diziyi temsil eder ve gri tonlamalı veya renkli görüntülerin, voksel hacimlerinin, vektör alanlarının, nokta bulutlarının, tensörlerin, histogramların vb. Görüntü verilerini depolamak için kullanılır.

Bu sınıf iki veri bölümünden oluşur: header ve bir pointer

  • Header - Boyut, saklama için kullanılan yöntem ve matrisin adresi (boyut olarak sabit) gibi bilgileri içerir.

  • Pointer - Görüntünün piksel değerlerini depolar (Değişken kalır).

Mat Sınıfı

OpenCV Java kitaplığı bu sınıfa aynı adı verir (Mat) paket içinde org.opencv.core.

İnşaatçılar

OpenCV Java kitaplığının Mat sınıfı, Mat nesnesini oluşturabileceğiniz çeşitli oluşturuculara sahiptir.

S.No Oluşturucular ve Açıklama
1

Mat()

Bu, çoğu durumda parametre içermeyen varsayılan kurucudur. Bunu, boş bir matris oluşturmak ve bunu diğer OpenCV yöntemlerine geçirmek için yapıcı olarak kullanırız.

2

Mat(int rows, int cols, int type)

Bu yapıcı, bir 2D dizideki satır ve sütun sayısını ve dizinin türünü (yani verileri depolamak için kullanılacak) temsil eden üç tamsayı tipi parametresi kabul eder.

3

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

Bir öncekinin parametrelerini de içeren bu yapıcı, ek olarak Scalar sınıfının bir nesnesini parametre olarak kabul eder.

4

Mat(Size size, int type)

Bu yapıcı, iki parametreyi kabul eder; matrisin boyutunu temsil eden bir nesne ve verileri depolamak için kullanılan dizinin türünü temsil eden bir tam sayı.

5

Mat(Size size, int type, Scalar s)

Bir öncekinin parametrelerini de içeren bu yapıcı, ek olarak Scalar sınıfının bir nesnesini parametre olarak kabul eder.

6

Mat(long addr)

7

Mat(Mat m, Range rowRange)

Bu yapıcı, başka bir matrisin bir nesnesini ve yeni bir matris oluşturmak için alınacak satırların aralığını temsil eden Range sınıfının bir nesnesini kabul eder.

8

Mat(Mat m, Range rowRange, Range colRange)

Bir öncekinin parametrelerini de içeren bu yapıcı, ek olarak sınıfın bir nesnesini de kabul eder. Sütun aralığını temsil eden aralık.

9

Mat(Mat m, Rect roi)

Bu kurucu, biri başka bir matrisi temsil eden ve diğeri de Region Of Iilgi.

Note -

  • Dizi türü. 1-4 kanal matrisleri oluşturmak için CV_8UC1, ..., CV_64FC4 veya çok kanallı (CV_CN_MAX kanala kadar) matrisler oluşturmak için CV_8UC (n), ..., CV_64FC (n) kullanın.

  • Matrislerin türü, sınıfın çeşitli alanları tarafından temsil edildi CvType hangisi pakete ait org.opencv.core.

Yöntemler ve Açıklama

Mat sınıfı tarafından sağlanan yöntemlerden bazıları aşağıdadır.

S.No Yöntemler ve Açıklama
1

Mat col(int x)

Bu yöntem, bir sütunun dizinini temsil eden bir tamsayı parametresini kabul eder ve bu sütunu alır ve döndürür.

2

Mat row(int y)

Bu yöntem, bir satırın dizinini temsil eden bir tamsayı parametresini kabul eder ve bu satırı alır ve döndürür.

3

int cols()

Bu yöntem, matristeki sütun sayısını döndürür.

4

int rows()

Bu yöntem, matristeki satır sayısını döndürür.

5

Mat setTo(Mat value)

Bu yöntem, bir nesneyi kabul eder. Mat yazın ve dizi öğelerini belirtilen değere ayarlar.

6

Mat setTo(Scalar s)

Bu yöntem, bir nesneyi kabul eder. Scalar yazın ve dizi öğelerini belirtilen değere ayarlar.

Matris Oluşturma ve Görüntüleme

Bu bölümde, ilk OpenCV örneğimizi tartışacağız. Basit bir OpenCV matrisinin nasıl oluşturulacağını ve görüntüleneceğini göreceğiz.

Aşağıda, OpenCV'de bir matris oluşturmak ve görüntülemek için izlenecek adımlar verilmiştir.

1. Adım: OpenCV yerel kitaplığını yükleyin

OpenCV kitaplığını kullanarak Java kodu yazarken yapmanız gereken ilk adım, OpenCV'nin yerel kitaplığını, loadLibrary(). OpenCV yerel kitaplığını aşağıda gösterildiği gibi yükleyin.

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

Adım 2: Mat sınıfını somutlaştırın

Bu bölümde daha önce bahsedilen işlevlerden herhangi birini kullanarak Mat sınıfını somutlaştırın.

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

3. Adım: Yöntemleri kullanarak matrisi doldurun

İndeks değerlerini yöntemlere ileterek bir matrisin belirli satırlarını / sütunlarını alabilirsiniz. row()/col().

Ve, bunların herhangi bir varyantını kullanarak bunlara değerler ayarlayabilirsiniz. setTo() yöntemler.

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

OpenCV kitaplığını kullanarak Java'da basit bir matris oluşturmak ve görüntülemek için aşağıdaki program kodunu kullanabilirsiniz.

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

Yukarıdaki programı çalıştırırken aşağıdaki çıktıyı alacaksınız -

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]

JavaSE API kullanarak Görüntü Yükleme

BufferedImage sınıfı java.awt.image.BufferedImage paketi bir görüntüyü saklamak için kullanılır ve ImageIO paketin sınıfı import javax.imageio Görüntüleri okumak ve yazmak için yöntemler sağlar.

Example

JavaSE kitaplığını kullanarak görüntüleri yüklemek ve kaydetmek için aşağıdaki program kodunu kullanabilirsiniz.

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

Yukarıdaki programı çalıştırırken aşağıdaki çıktıyı alacaksınız -

image Saved

Belirtilen yolu açarsanız, kaydedilen görüntüyü aşağıdaki gibi gözlemleyebilirsiniz -

Imgcodecs paketin sınıfı org.opencv.imgcodecsgörüntüleri okumak ve yazmak için yöntemler sağlar. OpenCV'yi kullanarak bir görüntüyü okuyabilir ve bir matriste saklayabilirsiniz (gerekirse matris üzerinde dönüşümler gerçekleştirin). Daha sonra işlenmiş matrisi bir dosyaya yazabilirsiniz.

read() yöntemi Imgcodecssınıfı, OpenCV kullanarak bir görüntüyü okumak için kullanılır. Bu yöntemin sözdizimi aşağıdadır.

imread(filename)

Bir argümanı kabul eder (filename), okunacak dosyanın yolunu temsil eden String türünde bir değişken.

Aşağıda, OpenCV kütüphanesini kullanarak Java'daki resimleri okumak için izlenecek adımlar verilmiştir.

1. Adım: OpenCV yerel kitaplığını yükleyin

OpenCV yerel kitaplığını, load() yöntemi aşağıda gösterildiği gibi.

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

Adım 2: Imgcodecs sınıfını somutlaştırın

Örnekleyin Imgcodecs sınıf.

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

3. Adım: Görüntünün okunması

Yöntemi kullanarak resmi okuyun imread(). Bu yöntem, görüntünün yolunu temsil eden bir dize bağımsız değişkenini kabul eder ve şu şekilde okunan görüntüyü döndürür:Mat nesne.

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

Misal

Aşağıdaki program kodu, nasıl yapabileceğinizi gösterir. read an image OpenCV kitaplığını kullanarak.

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

Yukarıdaki programı çalıştırırken, OpenCV belirtilen görüntüyü yükler ve aşağıdaki çıktıyı görüntüler -

Image Loaded

write() yöntemi Imgcodecsclass, OpenCV kullanarak bir görüntü yazmak için kullanılır. Bir görüntü yazmak için önceki örnekten ilk üç adımı tekrarlayın.

Bir görüntü yazmak için, imwrite() yöntemi Imgcodecs sınıf.

Bu yöntemin sözdizimi aşağıdadır.

imwrite(filename, mat)

Bu yöntem aşağıdaki parametreleri kabul eder -

  • filename - bir String değişken dosyanın kaydedileceği yeri temsil eder.

  • mat - bir Mat yazılacak görüntüyü temsil eden nesne.

Misal

Aşağıdaki program bir örnektir. write an image OpenCV kütüphanesini kullanarak Java programını kullanarak.

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

Yukarıdaki programı çalıştırırken aşağıdaki çıktıyı alacaksınız -

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

Belirtilen yolu açarsanız, kaydedilen görüntüyü aşağıda gösterildiği gibi gözlemleyebilirsiniz -

Önceki bölümlerde, OpenCV Java kitaplığını kullanarak bir görüntünün nasıl okunacağını ve kaydedileceğini tartışmıştık. Buna ek olarak, yüklenen görüntüleri AWT / Swings ve JavaFX gibi GUI kitaplıklarını kullanarak ayrı bir pencerede de görüntüleyebiliriz.

Matı Tamponlanmış Görüntüye Dönüştürme

Bir resmi okumak için yöntemi kullanıyoruz imread(). Bu yöntem, okunan görüntüyü şu şekilde döndürür:Matrix. Ancak, bu görüntüyü GUI kitaplıklarıyla (AWT / Swings ve JavaFX) kullanmak için, sınıfın bir nesnesi olarak dönüştürülmesi gerekir.BufferedImage paketin java.awt.image.BufferedImage.

Aşağıdakiler, bir Mat OpenCV'nin nesnesi BufferedImage nesne.

Adım 1: Mat'ı MatOfByte'a kodlayın

Her şeyden önce, matrisi bayt matrisine dönüştürmeniz gerekir. Yöntemi kullanarak yapabilirsinizimencode() sınıfın Imgcodecs. Bu yöntemin sözdizimi aşağıdadır.

imencode(ext, image, matOfByte);

Bu yöntem aşağıdaki parametreleri kabul eder -

  • Ext - Görüntü biçimini (.jpg, .png, vb.) Belirten bir Dize parametresi

  • image - Görüntünün Mat nesnesi

  • matOfByte - MatOfByte sınıfının boş bir nesnesi

Görüntüyü aşağıda gösterildiği gibi bu yöntemi kullanarak kodlayın.

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

//instantiating an empty MatOfByte class 
MatOfByte matOfByte = new MatOfByte();

//Converting the Mat object to MatOfByte 
Imgcodecs.imencode(".jpg", image, matOfByte);

Adım 2: MatOfByte nesnesini bayt dizisine dönüştürün

Dönüştür MatOfByte yöntemi kullanarak bir bayt dizisine nesne toArray().

byte[] byteArray = matOfByte.toArray();

Adım 3: InputStream nesnesini hazırlama

Önceki adımda oluşturulan bayt dizisini öğenin yapıcısına ileterek InputStream nesnesini hazırlayın. ByteArrayInputStream sınıf.

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

Adım 4: InputStream nesnesini hazırlama

Önceki adımda oluşturulan Giriş Akışı nesnesini read() yöntemi ImageIOsınıf. Bu bir BufferedImage nesnesi döndürecektir.

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

AWT / Swings kullanarak Görüntüyü Görüntüleme

AWT / Swings çerçevesini kullanarak bir görüntüyü görüntülemek için, her şeyden önce, imread() yöntem ve onu BufferedImage yukarıda belirtilen adımları takip ederek.

Ardından, JFrame aşağıda gösterildiği gibi, JFrame'in ContentPane'ine oluşturulan arabelleğe alınmış görüntüyü ekleyin ve ekleyin -

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

Aşağıdaki program kodu, nasıl yapabileceğinizi gösterir. read bir görüntü ve display OpenCV kitaplığını kullanarak açılır pencereden.

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

Yukarıdaki programı çalıştırırken aşağıdaki çıktıyı alacaksınız -

Image Loaded

Buna ek olarak, aşağıdaki gibi yüklenen görüntüyü gösteren bir pencere görebilirsiniz -

JavaFX kullanarak Görüntüyü Görüntüleme

JavaFX kullanarak bir görüntüyü görüntülemek için, her şeyden önce, imread() yöntem ve onu BufferedImage. Ardından, BufferedImage'ı aşağıda gösterildiği gibi WritableImage'a dönüştürün.

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

Bunu geç WritableImage yapıcısına itiraz ImageView sınıf.

ImageView imageView = new ImageView(writableImage);

Example

Aşağıdaki program kodu, nasıl yapılacağını gösterir. read bir görüntü ve display OpenCV kitaplığını kullanarak JavaFX penceresi aracılığıyla.

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

Yukarıdaki programı çalıştırırken aşağıdaki çıktıyı alacaksınız -

Image Loaded

Buna ek olarak, aşağıdaki gibi yüklenen görüntüyü gösteren bir pencere görebilirsiniz -

OpenCV, renkli, ikili, gri tonlamalı vb. Gibi çeşitli görüntü türlerini destekler. imread() yöntemi ve önceden tanımlanmış alanları Imgcodecs sınıf, belirli bir resmi başka bir tür olarak okuyabilirsiniz.

İmread () yönteminin (IMREAD_XXX) işaretler parametresi

Önceki bölümlerde, sözdizimini gördük imread() yöntemi Imgcodecssınıf. Okunacak görüntünün konumunu temsil eden bir dize argümanı kabul eder.

imread(filename)

imread() yöntem başka bir sözdizimine sahiptir.

imread(filename, int flags)

Bu sözdizimi iki parametreyi kabul eder -

  • filename - Bir argümanı kabul ediyor (filename), okunacak dosyanın yolunu temsil eden String türünde bir değişken.

  • flags- Önceden tanımlanmış bir bayrak değerini temsil eden bir tamsayı değeri. Her değer için bu, verilen resmi belirli bir tür olarak okur (gri tonlama rengi vb.)

Aşağıda, içinde sağlanan çeşitli alanları listeleyen tablo bulunmaktadır. Imgproc Bu parametre için değerler olarak sınıf.

S.No Alanlar ve Açıklama
1

IMREAD_COLOR

Bayrak bu değere ayarlanırsa, yüklenen görüntü 3 kanallı BGR (Mavi Yeşil Kırmızı) renkli görüntüye dönüştürülecektir.

2

IMREAD_GRAYSCALE

Bayrak bu değere ayarlanırsa, yüklenen görüntü tek kanallı gri tonlamalı bir görüntüye dönüştürülecektir.

3

IMREAD_LOAD_GDAL

Bayrak bu değere ayarlanmışsa, görüntüyü kullanarak yükleyebilirsiniz. gdal sürücü.

4

IMREAD_ANYCOLOR

Bayrak bu değere ayarlanırsa, görüntü olası herhangi bir renk biçiminde okunur.

5

IMREAD_REDUCED_COLOR_2

IMREAD_REDUCED_COLOR_4

IMREAD_REDUCED_COLOR_8

Bayrak bu değere ayarlanmışsa, resim, üç kanallı bgr olarak okunur ve görüntünün boyutu ¼ ½ indirgenir inci ya da ⅛ inci kullanılan alanlara göre görüntünün orijinal boyutta.

6

IMREAD_REDUCED_GRAYSCALE_2

IMREAD_REDUCED_GRAYSCALE_4

IMREAD_REDUCED_GRAYSCALE_8

Bayrak bu değere ayarlanmışsa, görüntü tek kanallı gri ölçekli görüntüsünün olarak okunur ve görüntünün boyutu ¼ ½ indirgenir inci ya da ⅛ inci alana göre görüntünün orijinal boyutunun kullanılan .

7

IMREAD_UNCHANGED

Bayrak bu değere ayarlanırsa, yüklenen görüntü olduğu gibi döndürülür.

Aşağıdaki program renkli bir görüntünün gri tonlamalı olarak nasıl okunacağını ve JavaFX penceresi kullanılarak nasıl görüntüleneceğini göstermektedir. Burada bayrağı geçerek görseli okuduk.IMREAD_GRAYSCALE Renkli bir görüntünün yolunu tutan Dize ile birlikte.

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

Giriş Resmi

Aşağıdakinin giriş görüntüsü olduğunu varsayalım sample.jpg yukarıdaki programda belirtilmiştir.

Çıktı Resmi

Programı çalıştırırken aşağıdaki çıktıyı alacaksınız.

Aşağıdaki program renkli bir görüntünün BGR tipi görüntü olarak nasıl okunacağını ve JavaFX penceresi kullanılarak nasıl görüntüleneceğini göstermektedir. Burada bayrağı geçerek görseli okuduk.IMREAD_COLOR yönteme imread() Renkli bir görüntünün yolunu tutan Dize ile birlikte.

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

Giriş Resmi

Aşağıdakinin giriş görüntüsü olduğunu varsayalım sample.jpg yukarıdaki programda belirtilmiştir.

Çıktı Resmi

Programı çalıştırırken aşağıdaki çıktıyı alacaksınız.

Önceki bölümlerde, bir girdi görüntüsünün farklı türler (ikili, gri tonlamalı, BGR, vb.) Olarak nasıl okunacağını tartışmıştık. Bu bölümde, bir görüntü türünü diğerine nasıl dönüştüreceğimizi öğreneceğiz.

Adlı sınıf Imgproc paketin org.opencv.imgproc bir görüntüyü bir renkten diğerine dönüştürmek için yöntemler sağlar.

Renkli Görüntüleri Gri Tonlamaya Dönüştürme

Adlı bir yöntem cvtColor()renkli görüntüleri gri tonlamaya dönüştürmek için kullanılır. Bu yöntemin sözdizimi aşağıdadır.

cvtColor(Mat src, Mat dst, int code)

Bu yöntem aşağıdaki parametreleri kabul eder -

  • src - Kaynağı temsil eden bir matris.

  • dst - Hedefi temsil eden bir matris.

  • code - Dönüşümün türünü temsil eden bir tamsayı kodu; örneğin, RGB'den Gri Tonlamaya.

Kodu ileterek renkli görüntüleri gri tonlamaya dönüştürebilirsiniz. Imgproc.COLOR_RGB2GRAY bir parametre olarak kaynak ve hedef matrislerle birlikte cvtColor() yöntem.

Misal

Aşağıdaki program renkli bir görüntünün gri tonlamalı bir görüntü olarak nasıl okunacağını ve JavaFX penceresi kullanılarak nasıl görüntüleneceğini göstermektedir.

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

Giriş Resmi

Aşağıdakinin giriş görüntüsü olduğunu varsayalım sample.jpg yukarıdaki programda belirtilmiştir.

Çıktı Resmi

Programı çalıştırırken aşağıdaki çıktıyı alacaksınız.

Adlı bir yöntem threshold()gri tonlamalı görüntüleri ikili görüntüye dönüştürmek için kullanılır. Bu yöntemin sözdizimi aşağıdadır.

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

Bu yöntem aşağıdaki parametreleri kabul eder -

  • mat - bir Mat girdi görüntüsünü temsil eden nesne.

  • dst - bir Mat çıktı görüntüsünü temsil eden nesne.

  • thresh - Eşik değerini temsil eden bir tam sayı.

  • maxval - THRESH_BINARY ve THRESH_BINARY_INV eşikleme türleriyle kullanılacak maksimum değeri temsil eden bir tam sayı.

  • type - Dönüşümün türünü temsil eden bir tamsayı kodu; örneğin, RGB'den Gri Tonlamaya.

Gri tonlamalı bir görüntüyü kodu ileterek ikili görüntüye dönüştürebilirsiniz. Imgproc.THRESH_BINARY kalan parametrelerin değerleri ile birlikte.

Misal

Aşağıdaki program renkli bir görüntünün ikili görüntü olarak nasıl okunacağını ve JavaFX penceresi kullanılarak nasıl görüntüleneceğini göstermektedir.

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

Giriş Resmi

Aşağıdakinin giriş görüntüsü olduğunu varsayalım sample.jpg yukarıdaki programda belirtilmiştir.

Çıktı Resmi

Programı çalıştırırken aşağıdaki çıktıyı alacaksınız.

Gri tonlamalı bir görüntüyü ikili görüntüye dönüştürmek için önceki bölümde bahsedilen aynı yöntemi kullanabilirsiniz. Bu programa girdi olarak gri tonlamalı bir görüntünün yolunu iletmeniz yeterlidir.

Misal

Aşağıdaki program gri tonlamalı bir görüntünün ikili görüntü olarak nasıl okunacağını ve JavaFX penceresini kullanarak nasıl görüntüleneceğini göstermektedir.

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

Giriş Resmi

Aşağıdakinin giriş görüntüsü olduğunu varsayalım sample.jpg yukarıdaki programda belirtilmiştir.

Çıktı Resmi

Programı çalıştırırken aşağıdaki çıktıyı alacaksınız.

Bir görüntünün ilgili yöntemlerini kullanarak Daire, Dikdörtgen, Çizgi, Elips, Çoklu Çizgiler, Dışbükey, Çoklu Çizgiler, Çoklu Çizgiler gibi çeşitli şekiller çizebilirsiniz. org.opencv.imgproc paketi.

Yöntemi kullanarak bir görüntünün üzerine daire çizebilirsiniz. circle() of imgprocsınıf. Bu yöntemin sözdizimi aşağıdadır -

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

Bu yöntem aşağıdaki parametreleri kabul eder -

  • mat - bir Mat dairenin üzerine çizileceği görüntüyü temsil eden nesne.

  • point - bir Point dairenin merkezini temsil eden nesne.

  • radius - Tipin bir değişkeni integer dairenin yarıçapını temsil eder.

  • scalar - bir Scalardairenin rengini temsil eden nesne. (BGR)

  • thickness - Bir integerdairenin kalınlığını temsil eden; varsayılan olarak kalınlık değeri 1'dir.

Misal

Aşağıdaki program, bir görüntünün üzerine nasıl daire çizileceğini ve JavaFX penceresi kullanılarak nasıl görüntüleneceğini göstermektedir.

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

Yukarıdaki programı çalıştırırken aşağıdaki çıktıyı alacaksınız -

Yöntemi kullanarak bir görüntü üzerine çizgi çizebilirsiniz. line() of imgprocsınıf. Bu yöntemin sözdizimi aşağıdadır.

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

Bu yöntem aşağıdaki parametreleri kabul eder -

  • mat - bir Mat Çizginin üzerine çizileceği görüntüyü temsil eden nesne.

  • pt1 and pt2 - iki Point çizginin çizileceği noktaları temsil eden nesneler.

  • scalar - bir Scalardairenin rengini temsil eden nesne. (BGR)

  • thickness- Çizginin kalınlığını temsil eden bir tam sayı; varsayılan olarak kalınlık değeri 1'dir.

Misal

Aşağıdaki program bir görüntü üzerine nasıl çizgi çizileceğini ve JavaFX penceresi kullanılarak nasıl görüntüleneceğini göstermektedir.

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

Yukarıdaki programı çalıştırırken aşağıdaki çıktıyı alacaksınız -

Yöntemi kullanarak bir görüntüye dikdörtgen çizebilirsiniz. rectangle() of imgprocsınıf. Bu yöntemin sözdizimi aşağıdadır -

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

Bu yöntem aşağıdaki parametreleri kabul eder -

  • mat - bir Mat Dikdörtgenin üzerine çizileceği görüntüyü temsil eden nesne.

  • pt1 and pt2 - iki Point çizilecek dikdörtgenin köşelerini temsil eden nesneler.

  • scalar - bir Scalardikdörtgenin rengini temsil eden nesne. (BGR)

  • thickness- Dikdörtgenin kalınlığını temsil eden bir tam sayı; varsayılan olarak kalınlık değeri 1'dir.

Misal

Aşağıdaki örnek, bir görüntü üzerine nasıl dikdörtgen çizileceğini ve JavaFX penceresi kullanılarak nasıl görüntüleneceğini gösterir.

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

Yukarıdaki programı çalıştırırken aşağıdaki çıktıyı alacaksınız -

Yöntemi kullanarak bir görüntü üzerine elips çizebilirsiniz. rectangle() of imgprocsınıf. Bu yöntemin sözdizimi aşağıdadır -

ellipse(img, box, color, thickness)

Bu yöntem aşağıdaki parametreleri kabul eder -

  • mat - bir Mat Dikdörtgenin üzerine çizileceği görüntüyü temsil eden nesne.

  • box - Bir RotatedRect nesnesi (Elips, bu dikdörtgenin içine yazılacak şekilde çizilir.)

  • scalar - bir ScalarDikdörtgenin rengini temsil eden nesne. (BGR)

  • thickness- Dikdörtgenin kalınlığını temsil eden bir tam sayı; varsayılan olarak kalınlık değeri 1'dir.

Yapıcı RotatedRect sınıf, sınıfın bir nesnesini kabul eder PointAşağıda gösterildiği gibi, Size sınıfının bir nesnesi ve double türünde bir değişken.

RotatedRect(Point c, Size s, double a)

Misal

Aşağıdaki program, bir görüntünün üzerine nasıl elips çizileceğini ve JavaFX penceresi kullanılarak nasıl görüntüleneceğini gösterir.

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

Yukarıdaki programı çalıştırırken aşağıdaki çıktıyı alacaksınız -

Yöntemi kullanarak bir görüntünün üzerine Polylines çizebilirsiniz polylines() of imgprocsınıf. Bu yöntemin sözdizimi aşağıdadır.

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

Bu yöntem aşağıdaki parametreleri kabul eder -

  • mat - bir Mat Polylines'in üzerine çizileceği görüntüyü temsil eden nesne.

  • pts - bir List türdeki nesneleri tutan nesne MatOfPoint.

  • isClosed - Çoklu çizgilerin kapalı olduğu hava durumunu belirten boolean tipinde bir parametre.

  • scalar - bir ScalarÇoklu Çizgilerin rengini temsil eden nesne. (BGR)

  • thickness- Polilinlerin kalınlığını temsil eden bir tam sayı; varsayılan olarak kalınlık değeri 1'dir.

Yapıcı MatOfPoint sınıf, sınıfın nesnelerini kabul eder Point.

MatOfPoint(Point... a)

Misal

Aşağıdaki program, bir görüntü üzerinde çoklu çizgilerin nasıl çizileceğini ve bunun JavaFX penceresi kullanılarak nasıl görüntüleneceğini gösterir.

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

Yukarıdaki programı çalıştırırken aşağıdaki çıktıyı alacaksınız -

Yöntemi kullanarak bir görüntü üzerine dışbükey çoklu çizgiler çizebilirsiniz. fillconvexPoly() of imgprocsınıf. Bu yöntemin sözdizimi aşağıdadır.

fillConvexPoly(Mat img, MatOfPoint points, Scalar color)

Bu yöntem aşağıdaki parametreleri kabul eder -

  • mat - bir Mat Dışbükey Polylines'in çizileceği görüntüyü temsil eden nesne.

  • points - bir MatOfPoint dışbükey çoklu çizgilerin çizileceği noktaları temsil eden nesne.

  • scalar - bir Scalardışbükey Polylines rengini temsil eden nesne. (BGR)

Yapıcı MatOfPoint sınıf, sınıfın nesnelerini kabul eder Point.

MatOfPoint(Point... a)

Misal

Aşağıdaki program, bir görüntü üzerine dışbükey çoklu çizgilerin nasıl çizileceğini ve JavaFX penceresi kullanılarak nasıl görüntüleneceğini gösterir.

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

Yukarıdaki programı çalıştırırken aşağıdaki çıktıyı alacaksınız -

Yöntemi kullanarak bir görüntü üzerine oklu bir çizgi çizebilirsiniz. arrowedLine() of imgprocsınıf. Bu yöntemin sözdizimi aşağıdadır -

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

Bu yöntem aşağıdaki parametreleri kabul eder -

  • mat - bir Mat Oklu çizginin çizileceği görüntüyü temsil eden nesne.

  • pt1 and pt2 - iki Point oklu çizginin çizileceği noktaları temsil eden nesneler.

  • scalar - bir Scalaroklu çizginin rengini temsil eden nesne. (BGR)

Misal

Aşağıdaki program bir görüntü üzerinde oklu çizginin nasıl çizileceğini ve JavaFX penceresi kullanılarak nasıl görüntüleneceğini göstermektedir.

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

Yukarıdaki programı çalıştırırken aşağıdaki çıktıyı alacaksınız -

Yöntemi kullanarak bir görüntüye metin ekleyebilirsiniz arrowedLine() of imgprocsınıf. Bu yöntemin sözdizimi aşağıdadır.

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

Bu yöntem aşağıdaki parametreleri kabul eder -

  • mat - bir Mat metnin ekleneceği görüntüyü temsil eden nesne.

  • text - bir string eklenecek metni temsil eden değişken.

  • org - bir Point görüntüde sol alt köşe metin dizesini temsil eden nesne.

  • fontFace - Yazı tipi türünü temsil eden tam sayı türündeki bir değişken.

  • fontScale - Yazı tipine özgü temel boyutla çarpılan ölçek faktörünü temsil eden double türünde bir değişken.

  • scalar - bir Scalareklenecek metnin rengini temsil eden nesne. (BGR)

  • thickness - Varsayılan olarak çizginin kalınlığını temsil eden bir tam sayı, kalınlık değeri 1'dir.

Misal

Aşağıdaki program, bir görüntüye nasıl metin ekleneceğini ve JavaFX penceresi kullanılarak nasıl görüntüleneceğini göstermektedir.

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

Yukarıdaki programı çalıştırırken aşağıdaki çıktıyı alacaksınız -

Bulanıklaştırma (yumuşatma), görüntü parazitini azaltmak için yaygın olarak kullanılan görüntü işleme işlemidir. İşlem, görüntüden kenarlar gibi yüksek frekanslı içeriği kaldırır ve pürüzsüz hale getirir.

Genel olarak bulanıklaştırma, görüntünün düşük geçişli bir filtre çekirdeği aracılığıyla kıvrılmasıyla (görüntünün her bir öğesi yerel komşularına eklenir, çekirdek tarafından ağırlıklandırılır) elde edilir.

Bulanıklaştırma (Ortalama)

Bu işlem sırasında, görüntü bir kutu filtresi (normalleştirilmiş) ile çevrilir. Bu süreçte, görüntünün merkezi öğesi, çekirdek alanındaki tüm piksellerin ortalaması ile değiştirilir.

Bu işlemi, yöntemi kullanarak bir görüntü üzerinde gerçekleştirebilirsiniz. blur() of imgprocsınıf. Bu yöntemin sözdizimi aşağıdadır -

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

Bu yöntem aşağıdaki parametreleri kabul eder -

  • src - bir Mat Bu işlem için kaynağı (giriş görüntüsü) temsil eden nesne.

  • dst - bir Mat Bu işlem için hedefi (çıktı görüntüsü) temsil eden nesne.

  • ksize - bir Size çekirdeğin boyutunu temsil eden nesne.

  • anchor - Çapa noktasını temsil eden tam sayı türünde bir değişken.

  • borderType - Çıktıda kullanılacak sınırın türünü temsil eden tamsayı türünde bir değişken.

Misal

Aşağıdaki program, bir görüntü üzerinde ortalama alma (bulanıklaştırma) işleminin nasıl gerçekleştirileceğini gösterir.

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

Aşağıdakinin giriş görüntüsü olduğunu varsayalım sample.jpg yukarıdaki programda belirtilmiştir.

Çıktı

Programı çalıştırırken aşağıdaki çıktıyı alacaksınız -

Image Processed

Belirtilen yolu açarsanız, çıktı görüntüsünü aşağıdaki gibi gözlemleyebilirsiniz -

Gauss Bulanıklığı işleminde, görüntü, kutu filtresi yerine bir Gauss filtresi ile dönüştürülür. Gauss filtresi, yüksek frekanslı bileşenleri azaltan düşük geçişli bir filtredir.

Bu işlemi kullanarak bir görüntü üzerinde gerçekleştirebilirsiniz. Gaussianblur() yöntemi imgprocsınıf. Bu yöntemin sözdizimi aşağıdadır -

GaussianBlur(src, dst, ksize, sigmaX)

Bu yöntem aşağıdaki parametreleri kabul eder -

  • src - bir Mat Bu işlem için kaynağı (giriş görüntüsü) temsil eden nesne.

  • dst - bir Mat Bu işlem için hedefi (çıktı görüntüsü) temsil eden nesne.

  • ksize - bir Size çekirdeğin boyutunu temsil eden nesne.

  • sigmaX - X yönündeki Gauss kernel standart sapmasını temsil eden double türünde bir değişken.

Misal

Aşağıdaki program, bir görüntü üzerinde Gauss bulanıklaştırma işleminin nasıl gerçekleştirileceğini göstermektedir.

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

Aşağıdakinin giriş görüntüsü olduğunu varsayalım sample.jpg yukarıdaki programda belirtilmiştir.

Çıktı

Programı çalıştırırken aşağıdaki çıktıyı alacaksınız -

Image Processed

Belirtilen yolu açarsanız, çıktı görüntüsünü aşağıdaki gibi gözlemleyebilirsiniz -

Medyan bulanıklaştırma işlemi, diğer ortalama alma yöntemlerine benzer. Burada, görüntünün merkezi öğesi, çekirdek alanındaki tüm piksellerin medyanı ile değiştirilir. Bu işlem gürültüyü ortadan kaldırırken kenarları işler.

Bu işlemi kullanarak bir görüntü üzerinde gerçekleştirebilirsiniz. medianBlur() yöntemi imgprocsınıf. Bu yöntemin sözdizimi aşağıdadır -

medianBlur(src, dst, ksize)

Bu yöntem aşağıdaki parametreleri kabul eder -

  • src - bir Mat Bu işlem için kaynağı (giriş görüntüsü) temsil eden nesne.

  • dst - bir Mat Bu işlem için hedefi (çıktı görüntüsü) temsil eden nesne.

  • ksize - bir Size çekirdeğin boyutunu temsil eden nesne.

Misal

Aşağıdaki program, bir görüntü üzerinde medyan bulanıklaştırma işleminin nasıl gerçekleştirileceğini göstermektedir.

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

Aşağıdakinin giriş görüntüsü olduğunu varsayalım sample.jpg yukarıdaki programda belirtilmiştir.

Çıktı

Programı çalıştırırken aşağıdaki çıktıyı alacaksınız -

Image Processed

Belirtilen yolu açarsanız, çıktı görüntüsünü aşağıdaki gibi gözlemleyebilirsiniz -

Görüntü filtreleme, bir görüntüye çeşitli efektler uygulamanıza olanak tanır. Bu bölümde ve sonraki üç bölümde, İkili Filtre, Kutu Filtresi, SQR Kutu Filtresi ve Filtre2D gibi çeşitli filtre işlemlerini tartışacağız.

İkili Filtre

İkili Filtre işlemi, bir filtreye iki taraflı bir görüntü uygular. Bu işlemi kullanarak bir görüntü üzerinde gerçekleştirebilirsiniz.medianBlur() yöntemi imgprocsınıf. Bu yöntemin sözdizimi aşağıdadır.

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

Bu yöntem aşağıdaki parametreleri kabul eder -

  • src - bir Mat Bu işlem için kaynağı (giriş görüntüsü) temsil eden nesne.

  • dst - bir Mat Bu işlem için hedefi (çıktı görüntüsü) temsil eden nesne.

  • d - Piksel mahallesinin çapını temsil eden tür tamsayısının bir değişkeni.

  • sigmaColor - Renk uzayında filtre sigmasını temsil eden tip tamsayı değişkeni.

  • sigmaSpace - Koordinat alanındaki filtre sigmasını temsil eden tam sayı türünde bir değişken.

  • borderType - Kullanılan sınırın türünü temsil eden bir tamsayı nesnesi.

Misal

Aşağıdaki program, bir görüntü üzerinde İkili Filtre işleminin nasıl gerçekleştirileceğini göstermektedir.

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

Aşağıdakinin giriş görüntüsü olduğunu varsayalım filter_input.jpg yukarıdaki programda belirtilmiştir.

Çıktı

Programı çalıştırırken aşağıdaki çıktıyı alacaksınız -

Image Processed

Belirtilen yolu açarsanız, çıktı görüntüsünü aşağıdaki gibi gözlemleyebilirsiniz -

Kutu Filtresi işlemi, ortalama bulanıklaştırma işlemine benzer; bir filtreye iki taraflı bir görüntü uygular. Burada kutunun normalleştirilip normalleştirilmeyeceğini seçebilirsiniz.

Bu işlemi kullanarak bir görüntü üzerinde gerçekleştirebilirsiniz. boxFilter() yöntemi imgprocsınıf. Bu yöntemin sözdizimi aşağıdadır -

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

Bu yöntem aşağıdaki parametreleri kabul eder -

  • src - bir Mat Bu işlem için kaynağı (giriş görüntüsü) temsil eden nesne.

  • dst - bir Mat Bu işlem için hedefi (çıktı görüntüsü) temsil eden nesne.

  • ddepth - Çıktı görüntüsünün derinliğini temsil eden tür tamsayı değişkeni.

  • ksize - bir Size Bulanıklaştırılan çekirdeğin boyutunu temsil eden nesne.

  • anchor - Çapa noktasını temsil eden tam sayı türünde bir değişken.

  • Normalize - Çekirdeğin normalleştirilmesi gereken hava durumunu belirten boolean türünde bir değişken.

  • borderType - Kullanılan sınırın türünü temsil eden bir tamsayı nesnesi.

Misal

Aşağıdaki program, bir görüntü üzerinde Kutu Filtresi işleminin nasıl gerçekleştirileceğini gösterir.

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

Aşağıdakinin giriş görüntüsü olduğunu varsayalım filter_input.jpg yukarıdaki programda belirtilmiştir.

Çıktı

Programı çalıştırırken aşağıdaki çıktıyı alacaksınız -

Image Processed

Belirtilen yolu açarsanız, çıktı görüntüsünü aşağıdaki gibi gözlemleyebilirsiniz -

SQRBox Filtresi işlemini bir görüntü üzerinde gerçekleştirebilirsiniz. boxFilter() yöntemi imgprocsınıf. Bu yöntemin sözdizimi aşağıdadır -

sqrBoxFilter(src, dst, ddepth, ksize)

Bu yöntem aşağıdaki parametreleri kabul eder -

  • src - bir Mat Bu işlem için kaynağı (giriş görüntüsü) temsil eden nesne.

  • dst - bir Mat Bu işlem için hedefi (çıktı görüntüsü) temsil eden nesne.

  • ddepth - Çıktı görüntüsünün derinliğini temsil eden tür tamsayı değişkeni.

  • ksize - bir Size Bulanıklaştırılan çekirdeğin boyutunu temsil eden nesne.

Misal

Aşağıdaki program, belirli bir görüntü üzerinde Sqrbox filtre işleminin nasıl gerçekleştirileceğini gösterir.

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

Aşağıdakinin giriş görüntüsü olduğunu varsayalım filter_input.jpg yukarıdaki programda belirtilmiştir.

Çıktı

Programı çalıştırırken aşağıdaki çıktıyı alacaksınız -

Image Processed

Belirtilen yolu açarsanız, çıktı görüntüsünü aşağıdaki gibi gözlemleyebilirsiniz -

Filter2D işlemi bir görüntüyü çekirdek ile birleştirir. Bu işlemi kullanarak bir görüntü üzerinde gerçekleştirebilirsiniz.Filter2D() yöntemi imgprocsınıf. Bu yöntemin sözdizimi aşağıdadır -

filter2D(src, dst, ddepth, kernel)

Bu yöntem aşağıdaki parametreleri kabul eder -

  • src - bir Mat Bu işlem için kaynağı (giriş görüntüsü) temsil eden nesne.

  • dst - bir Mat Bu işlem için hedefi (çıktı görüntüsü) temsil eden nesne.

  • ddepth - Çıktı görüntüsünün derinliğini temsil eden tür tamsayı değişkeni.

  • kernel - bir Mat evrişim çekirdeğini temsil eden nesne.

Misal

Aşağıdaki program, bir görüntü üzerinde Filter2D işleminin nasıl gerçekleştirileceğini göstermektedir.

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

Aşağıdakinin giriş görüntüsü olduğunu varsayalım filter_input.jpg yukarıdaki programda belirtilmiştir.

Çıktı

Programı çalıştırırken aşağıdaki çıktıyı alacaksınız -

Image Processed

Belirtilen yolu açarsanız, çıktı görüntüsünü aşağıdaki gibi gözlemleyebilirsiniz -

Erozyon ve genişleme iki tür morfolojik işlemdir. Adından da anlaşılacağı gibi, morfolojik işlemler, görüntüleri şekillerine göre işleyen işlemler dizisidir.

Verilen girdi görüntüsüne bağlı olarak bir "yapısal eleman" geliştirilir. Bu, iki prosedürden herhangi birinde yapılabilir. Bunlar, görüntüyü netleştirmek için gürültüyü gidermeyi ve kusurları gidermeyi amaçlamaktadır.

Genişleme

Bu prosedür, kare veya daire gibi belirli bir şeklin bazı çekirdeği ile evrişimi takip eder. Bu çekirdeğin merkezini belirten bir çapa noktası vardır.

Bu çekirdek, maksimum piksel değerini hesaplamak için resmin üzerine biner. Hesaplandıktan sonra resim ortada çapa ile değiştirilir. Bu prosedürle, parlak bölgelerin alanları boyut olarak büyür ve dolayısıyla görüntü boyutu artar.

Örneğin, beyaz gölgeli veya parlak gölgeli bir nesnenin boyutu artarken, siyah veya koyu gölgeli bir nesnenin boyutu azalır.

Genişletme işlemini bir görüntü üzerinde, dilate() yöntemi imgprocsınıf. Bu yöntemin sözdizimi aşağıdadır.

dilate(src, dst, kernel)

Bu yöntem aşağıdaki parametreleri kabul eder -

  • src - bir Mat Bu işlem için kaynağı (giriş görüntüsü) temsil eden nesne.

  • dst - bir Mat Bu işlem için hedefi (çıktı görüntüsü) temsil eden nesne.

  • kernel - bir Mat çekirdeği temsil eden nesne.

Misal

Çekirdek matrisini şu şekilde hazırlayabilirsiniz: getStructuringElement()yöntem. Bu yöntem, temsil eden bir tamsayı kabul edermorph_rect tip ve tipte bir nesne Size.

Imgproc.getStructuringElement(int shape, Size ksize);

Aşağıdaki program, belirli bir görüntü üzerinde genişletme işleminin nasıl gerçekleştirileceğini gösterir.

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

Giriş

Aşağıdakinin giriş görüntüsü olduğunu varsayalım sample.jpg yukarıdaki programda belirtilmiştir.

Çıktı

Programı çalıştırırken aşağıdaki çıktıyı alacaksınız -

Image Processed

Belirtilen yolu açarsanız, çıktı görüntüsünü aşağıdaki gibi gözlemleyebilirsiniz -

Erozyon, genişlemeyle oldukça benzer bir süreçtir. Ancak burada hesaplanan piksel değeri, genişlemede maksimumdan ziyade minimumdur. Görüntü, bağlantı noktasının altında bu minimum piksel değeriyle değiştirilir.

Bu işlemle karanlık bölgelerin alanları büyür ve parlak bölgeler küçülür. Örneğin, koyu gölgeli veya siyah gölgeli bir nesnenin boyutu artarken, beyaz veya parlak gölgede küçülür.

Misal

Bu işlemi kullanarak bir görüntü üzerinde gerçekleştirebilirsiniz. erode() yöntemi imgprocsınıf. Bu yöntemin sözdizimi aşağıdadır -

erode(src, dst, kernel)

Bu yöntem aşağıdaki parametreleri kabul eder -

  • src - bir Mat Bu işlem için kaynağı (giriş görüntüsü) temsil eden nesne.

  • dst - bir Mat Bu işlem için hedefi (çıktı görüntüsü) temsil eden nesne.

  • kernel - bir Mat çekirdeği temsil eden nesne.

Çekirdek matrisini şu şekilde hazırlayabilirsiniz: getStructuringElement()yöntem. Bu yöntem, temsil eden bir tamsayı kabul edermorph_rect tip ve tipte bir nesne Size.

Imgproc.getStructuringElement(int shape, Size ksize);

Aşağıdaki program, belirli bir görüntü üzerinde erozyon işleminin nasıl gerçekleştirileceğini göstermektedir.

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

Aşağıdakinin giriş görüntüsü olduğunu varsayalım sample.jpg yukarıdaki programda belirtilmiştir.

Çıktı

Programı çalıştırırken aşağıdaki çıktıyı alacaksınız -

Image Loaded

Belirtilen yolu açarsanız, çıktı görüntüsünü aşağıdaki gibi gözlemleyebilirsiniz -

Önceki bölümlerde, erosion ve dilation. Bu ikisine ek olarak, OpenCV daha morfolojik dönüşümlere sahiptir. morphologyEx() sınıfın yönteminin Imgproc bu işlemleri belirli bir görüntü üzerinde gerçekleştirmek için kullanılır.

Bu yöntemin sözdizimi aşağıdadır -

morphologyEx(src, dst, op, kernel)

Bu yöntem aşağıdaki parametreleri kabul eder -

  • src - Sınıfın bir nesnesi Mat kaynak (giriş) görüntüsünü temsil eder.

  • dst - sınıfın nesnesi Mat hedef (çıktı) görüntüsünü temsil eder.

  • op - Morfolojik işlemin türünü temsil eden bir tam sayı.

  • kernel - Bir çekirdek matrisi.

Misal

Aşağıdaki program morfolojik işlemin nasıl uygulanacağını göstermektedir "top-hat" OpenCV kitaplığını kullanarak bir görüntü üzerinde.

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

Aşağıdakinin giriş görüntüsü olduğunu varsayalım morph_input.jpg yukarıdaki programda belirtilmiştir.

Çıktı

Programı çalıştırırken aşağıdaki çıktıyı alacaksınız -

Image Processed

Belirtilen yolu açarsanız, çıktı görüntüsünü aşağıdaki gibi gözlemleyebilirsiniz -

Daha Fazla İşlem

Morfolojik operasyona ek olarak TOPHAT, daha önce gösterilen exampleOpenCV, çeşitli diğer morfoloji türlerine de hitap eder. Tüm bu türler, önceden tanımlanmış statik alanlar (sabit değerler) ile temsil edilir.Imgproc sınıf.

İlgili önceden tanımlanmış değerleri parametreye ileterek ihtiyacınız olan morfoloji türünü seçebilirsiniz. op of morphologyEx() yöntem.

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

Aşağıda, morfolojik işlemlerin türünü ve ilgili çıktılarını temsil eden değerler verilmiştir.

Kullanım ve Açıklama Çıktı
MORPH_BLACKHAT
MORPH_CLOSE
MORPH_CROSS
MORPH_DILATE
MORPH_ELLIPSE
MORPH_ERODE
MORPH_GRADIENT
MORPH_OPEN
MORPH_RECT
MORPH_TOPHAT

Piramit, bir görüntü üzerinde bir işlemdir.

  • Bir girdi görüntüsü, başlangıçta belirli bir yumuşatma filtresi (ör. Gauss, Laplacian) kullanılarak düzleştirilir ve ardından düzleştirilmiş görüntü alt örneklenir.

  • Bu işlem birçok kez tekrarlanır.

Piramit işlemi sırasında görüntünün düzgünlüğü artırılır ve çözünürlüğü (boyutu) azaltılır.

Piramit Yukarı

Pyramid Up'ta, görüntü başlangıçta yukarı örneklenir ve ardından bulanıklaştırılır. Pyramid Up işlemini bir görüntü üzerinde,pyrUP() yöntemi imgprocsınıf. Bu yöntemin sözdizimi aşağıdadır -

pyrUp(src, dst, dstsize, borderType)

Bu yöntem aşağıdaki parametreleri kabul eder -

  • src - Sınıfın bir nesnesi Mat kaynak (giriş) görüntüsünü temsil eder.

  • mat - Sınıfın bir nesnesi Mat hedef (çıktı) görüntüsünü temsil eder.

  • size - Sınıfın bir nesnesi Size görüntünün artırılacağı veya azaltılacağı boyutu temsil eder.

  • borderType - Kullanılacak kenarlık türünü temsil eden tam sayı türünde bir değişken.

Misal

Aşağıdaki program, bir görüntü üzerinde Pyramid Up işleminin nasıl gerçekleştirileceğini gösterir.

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

Aşağıdakinin giriş görüntüsü olduğunu varsayalım pyramid_input.jpg yukarıdaki programda belirtilmiştir.

Çıktı

Programı çalıştırırken aşağıdaki çıktıyı alacaksınız -

Image Processed

Belirtilen yolu açarsanız, çıktı görüntüsünü aşağıdaki gibi gözlemleyebilirsiniz -

Piramit Aşağı

Pyramid Down'da, görüntü başlangıçta bulanıklaştırılır ve ardından aşağı örneklenir. Pyramid Down işlemini bir görüntü üzerinde,pyrDown() yöntemi imgprocsınıf. Bu yöntemin sözdizimi aşağıdadır -

pyrDown(src, dst, dstsize, borderType)

Bu yöntem aşağıdaki parametreleri kabul eder -

  • src - Sınıfın bir nesnesi Mat kaynak (giriş) görüntüsünü temsil eder.

  • mat - Sınıfın bir nesnesi Mat hedef (çıktı) görüntüsünü temsil eder.

  • size - Sınıfın bir nesnesi Size görüntünün artırılacağı veya azaltılacağı boyutu temsil eder.

  • borderType - Kullanılacak kenarlık türünü temsil eden tam sayı türünde bir değişken.

Misal

Aşağıdaki program, bir görüntü üzerinde Pyramid Down işleminin nasıl gerçekleştirileceğini göstermektedir.

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

Aşağıdakinin giriş görüntüsü olduğunu varsayalım pyramid_input.jpg yukarıdaki programda belirtilmiştir.

Çıktı

Programı çalıştırırken aşağıdaki çıktıyı alacaksınız -

Image Processed

Belirtilen yolu açarsanız, çıktı görüntüsünü aşağıdaki gibi gözlemleyebilirsiniz -

Ortalama Vardiya Filtreleme

Ortalama Kaydırma piramidi işleminde, bir görüntünün ortalama kaydırma segmentasyonunun ilk adımı gerçekleştirilir.

Piramit Ortalama Kaydırma Filtreleme işlemini bir görüntü üzerinde, pyrDown() yöntemi imgprocsınıf. Bu yöntemin sözdizimi aşağıdadır.

pyrMeanShiftFiltering(src, dst, sp, sr)

Bu yöntem aşağıdaki parametreleri kabul eder -

  • src - Sınıfın bir nesnesi Mat kaynak (giriş) görüntüsünü temsil eder.

  • mat - Sınıfın bir nesnesi Mat hedef (çıktı) görüntüsünü temsil eder.

  • sp - Uzamsal pencere yarıçapını temsil eden double türünde bir değişken.

  • sr - Renk penceresi yarıçapını temsil eden double türünde bir değişken.

Misal

Aşağıdaki program, belirli bir görüntü üzerinde Ortalama Kayma Filtreleme işleminin nasıl gerçekleştirileceğini gösterir.

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

Aşağıdakinin giriş görüntüsü olduğunu varsayalım pyramid_input.jpg yukarıdaki programda belirtilmiştir.

Çıktı

Programı çalıştırırken aşağıdaki çıktıyı alacaksınız -

Image Processed

Belirtilen yolu açarsanız, çıktı görüntüsünü aşağıdaki gibi gözlemleyebilirsiniz -

Eşikleme, bir görüntü bölümleme yöntemidir, genel olarak ikili görüntüler oluşturmak için kullanılır. Eşikleme, basit eşikleme ve uyarlamalı eşikleme olmak üzere iki türdendir.

Basit Eşikleme

Basit eşikleme işleminde, değerleri belirtilen eşik değerinden daha büyük olan piksellere standart bir değer atanır.

Yöntemi kullanarak bir görüntü üzerinde basit eşik işlemi gerçekleştirebilirsiniz threshold() of Imgproc classBu yöntemin sözdizimi aşağıdadır.

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

Bu yöntem aşağıdaki parametreleri kabul eder -

  • src - Sınıfın bir nesnesi Mat kaynak (giriş) görüntüsünü temsil eder.

  • dst - Sınıfın bir nesnesi Mat hedef (çıktı) görüntüsünü temsil eder.

  • thresh - Eşik değerini temsil eden çift tipli bir değişken.

  • maxval - Piksel değeri eşik değerden fazla ise verilecek değeri temsil eden çift tipli bir değişken.

  • type - Kullanılacak eşik türünü temsil eden tam sayı tipi bir değişken.

Misal

Aşağıdaki program, OpenCV'de bir görüntü üzerinde basit eşikleme işleminin nasıl gerçekleştirileceğini gösterir.

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

Aşağıdakinin giriş görüntüsü olduğunu varsayalım thresh_input.jpg yukarıdaki programda belirtilmiştir.

Çıktı

Programı çalıştırırken aşağıdaki çıktıyı alacaksınız -

Image Processed

Belirtilen yolu açarsanız, çıktı görüntüsünü aşağıdaki gibi gözlemleyebilirsiniz -

Diğer basit eşik türleri

Buna ek olarak THRESH_BINARYÖnceki örnekte gösterilen işlem, OpenCV çeşitli diğer eşik işlem türlerini de sunar. Tüm bu türler, önceden tanımlanmış statik alanlar (sabit değerler) ile temsil edilir.Imgproc sınıf.

Önceden tanımlanmış ilgili değeri adlı parametreye ileterek, ihtiyacınız olan eşik işleminin türünü seçebilirsiniz. type of threshold() yöntem.

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

Aşağıda, çeşitli eşik işlem türlerini ve ilgili çıktılarını temsil eden değerler yer almaktadır.

Kullanım ve Açıklama Çıktı
THRESH_BINARY
THRESH_BINARY_INV
THRESH_TRUNC
THRESH_TOZERO
THRESH_TOZERO_INV

İçinde simple thresholdingeşik değeri globaldir, yani görüntüdeki tüm pikseller için aynıdır. Adaptive thresholding daha küçük bölgeler için eşik değerin hesaplandığı yöntemdir ve bu nedenle farklı bölgeler için farklı eşik değerleri olacaktır.

OpenCV'de, yöntemi kullanarak bir görüntü üzerinde Uyarlanabilir eşik işlemi gerçekleştirebilirsiniz. adaptiveThreshold() of Imgprocsınıf. Bu yöntemin sözdizimi aşağıdadır.

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

Bu yöntem aşağıdaki parametreleri kabul eder -

  • src - Sınıfın bir nesnesi Mat kaynak (giriş) görüntüsünü temsil eder.

  • dst - Sınıfın bir nesnesi Mat hedef (çıktı) görüntüsünü temsil eder.

  • maxValue - Piksel değeri eşik değerden fazla ise verilecek değeri temsil eden çift tipli bir değişken.

  • adaptiveMethod- Kullanılacak uyarlamalı yöntemi temsil eden tipte bir tamsayı değişkeni. Bu, aşağıdaki iki değerden biri olacaktır

    • ADAPTIVE_THRESH_MEAN_C - eşik değeri, mahalle alanının ortalamasıdır.

    • ADAPTIVE_THRESH_GAUSSIAN_C - eşik değeri, ağırlıkların bir Gauss penceresi olduğu mahalle değerlerinin ağırlıklı toplamıdır.

  • thresholdType - Kullanılacak eşik türünü temsil eden tam sayı tipi bir değişken.

  • blockSize - Eşik değerini hesaplamak için kullanılan piksel mahallesinin boyutunu temsil eden tam sayı türünde bir değişken.

  • C - Her iki yöntemde de kullanılan sabiti temsil eden çift tipli bir değişken (ortalamadan veya ağırlıklı ortalamadan çıkarılır).

  • Misal

    Aşağıdaki program, OpenCV'de bir görüntü üzerinde Uyarlamalı eşik işleminin nasıl gerçekleştirileceğini gösterir. Burada uyarlanabilir eşiği seçiyoruzbinary ve ADAPTIVE_THRESH_MEAN_C eşik yöntemi için.

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

    Aşağıdakinin giriş görüntüsü olduğunu varsayalım thresh_input.jpg yukarıdaki programda belirtilmiştir.

    Çıktı

    Programı çalıştırırken aşağıdaki çıktıyı alacaksınız -

    Image Processed

    Belirtilen yolu açarsanız, çıktı görüntüsünü aşağıdaki gibi gözlemleyebilirsiniz -

    Diğer Uyarlanabilir Eşik Türleri

    Buna ek olarak ADAPTIVE_THRESH_MEAN_C uyarlanabilir yöntem olarak ve THRESH_BINARY Önceki örnekte gösterildiği gibi eşik türü olarak, bu iki değerin daha fazla kombinasyonunu seçebiliriz.

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

    Aşağıdakiler, parametreler için çeşitli değer kombinasyonlarını temsil eden değerlerdir adaptiveMethod ve thresholdType ve ilgili çıktıları.

    adaptiveMethod / eşik Tipi ADAPTIVE_THRESH_MEAN_C ADAPTIVE_THRESH_GAUSSIAN_C:
    THRESH_BINARY
    THRESH_BINARY_INV

    Bu bölüm size bir resme nasıl kara kurbağası yapılacağını öğretir.

    CopyMakeBorder () Yöntemi

    Yöntemi kullanarak bir görüntüye çeşitli kenarlıklar ekleyebilirsiniz. copyMakeBorder() pakete ait olan Core isimli sınıfın org.opencv.core. Bu yöntemin sözdizimi aşağıdadır.

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

    Bu yöntem aşağıdaki parametreleri kabul eder -

    • src - Sınıfın bir nesnesi Mat kaynak (giriş) görüntüsünü temsil eder.

    • dst - Sınıfın bir nesnesi Mat hedef (çıktı) görüntüsünü temsil eder.

    • top - Görüntünün üst kısmındaki sınırın uzunluğunu temsil eden tam sayı tipi tamsayı değişkeni.

    • bottom - Görüntünün altındaki kenarlığın uzunluğunu temsil eden tip tamsayı olan bir tamsayı değişkeni.

    • left - Görüntünün solundaki sınırın uzunluğunu temsil eden tam sayı tipi tamsayı değişkeni.

    • right - Görüntünün sağ tarafındaki sınırın uzunluğunu temsil eden tam sayı tipi tamsayı değişkeni.

    • borderType - Kullanılacak sınırın türünü temsil eden tamsayı türünde bir değişken.

    Misal

    Aşağıdaki program, belirli bir görüntüye nasıl kenarlık ekleneceğini gösteren bir örnektir.

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

    Aşağıdakinin giriş görüntüsü olduğunu varsayalım thresh_input.jpg yukarıdaki programda belirtilmiştir.

    Çıktı

    Programı çalıştırırken aşağıdaki çıktıyı alacaksınız -

    Image Processed

    Belirtilen yolu açarsanız, çıktı görüntüsünü aşağıdaki gibi gözlemleyebilirsiniz -

    Diğer Sınır Türleri

    Kenarlık tipine ek olarak, BORDER_CONSTANTönceki örnekte gösterildiği gibi, OpenCV çeşitli diğer sınır türlerini de sunar. Tüm bu türler, Core sınıfının önceden tanımlanmış statik alanları (sabit değerler) ile temsil edilir.

    Önceden tanımlanmış ilgili değeri adlı parametreye ileterek, ihtiyacınız olan eşik işleminin türünü seçebilirsiniz. borderType of copyMakeBorder() yöntem.

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

    Aşağıda, çeşitli sınır işlemleri türlerini ve ilgili çıktılarını temsil eden değerler yer almaktadır.

    Kullanım ve Açıklama Çıktı
    BORDER_CONSTANT
    BORDER_ISOLATED
    BORDER_DEFAULT
    BORDER_REFLECT
    BORDER_REFLECT_101
    BORDER_REFLECT101
    BORDER_REPLICATE
    BORDER_WRAP

    Kullanmak sobel operation, bir görüntünün kenarlarını hem yatay hem de dikey yönlerde algılayabilirsiniz. Yöntemi kullanarak bir görüntüye sobel işlemi uygulayabilirsiniz.sobel(). Bu yöntemin sözdizimi aşağıdadır -

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

    Bu yöntem aşağıdaki parametreleri kabul eder -

    • src - Sınıfın bir nesnesi Mat kaynak (giriş) görüntüsünü temsil eder.

    • dst - Sınıfın bir nesnesi Mat hedef (çıktı) görüntüsünü temsil eder.

    • ddepth - Görüntünün derinliğini temsil eden bir tam sayı değişkeni (-1)

    • dx- X türevini temsil eden bir tamsayı değişkeni. (0 veya 1)

    • dy- Y türevini temsil eden bir tamsayı değişkeni. (0 veya 1)

    Misal

    Aşağıdaki program, belirli bir görüntü üzerinde Sobel işleminin nasıl gerçekleştirileceğini gösterir.

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

    Aşağıdakinin giriş görüntüsü olduğunu varsayalım sobel_input.jpg yukarıdaki programda belirtilmiştir.

    Çıktı

    Programı çalıştırırken aşağıdaki çıktıyı alacaksınız -

    Image Processed

    Belirtilen yolu açarsanız, çıktı görüntüsünü aşağıdaki gibi gözlemleyebilirsiniz -

    sobel Varyantları

    En son parametrelere (dx ve dy) (0 ve 1 arasında) farklı değerler ilettiğinizde, farklı çıktılar elde edersiniz -

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

    Aşağıdaki tablo değişkenler için çeşitli değerleri listeler dx ve dy yöntemin Sobel() ve ilgili çıktıları.

    X türevi Y türevi Çıktı
    0 1
    1 0
    1 1

    Scharr ayrıca bir görüntünün ikinci türevlerini yatay ve dikey yönlerde tespit etmek için kullanılır. Yöntemi kullanarak bir görüntü üzerinde scharr işlemi gerçekleştirebilirsiniz.scharr(). Bu yöntemin sözdizimi aşağıdadır -

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

    Bu yöntem aşağıdaki parametreleri kabul eder -

    • src - Sınıfın bir nesnesi Mat kaynak (giriş) görüntüsünü temsil eder.

    • dst - Sınıfın bir nesnesi Mat hedef (çıktı) görüntüsünü temsil eder.

    • ddepth - Görüntünün derinliğini temsil eden bir tam sayı değişkeni (-1)

    • dx- X türevini temsil eden bir tamsayı değişkeni. (0 veya 1)

    • dy- Y türevini temsil eden bir tamsayı değişkeni. (0 veya 1)

    Misal

    Aşağıdaki program, belirli bir görüntüye scharr'ın nasıl uygulanacağını gösterir.

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

    Aşağıdakinin giriş görüntüsü olduğunu varsayalım scharr_input.jpg yukarıdaki programda belirtilmiştir.

    Çıktı

    Yürüttüğünüzde aşağıdaki çıktıyı alacaksınız -

    Image Processed

    Belirtilen yolu açarsanız, çıktı görüntüsünü aşağıdaki gibi gözlemleyebilirsiniz -

    Daha fazla scharr Türevleri

    En son parametrelere (dx ve dy) (0 ve 1 arasında) farklı değerler ilettiğinizde farklı çıktılar elde edersiniz -

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

    Değişkenler için çeşitli değerleri listeleyen bir tablo aşağıdadır dx ve dy yöntemin scharr() ve ilgili çıktıları.

    X türevi Y türevi Çıktı
    0 1
    1 0

    Laplacian Operatörü ayrıca bir görüntüdeki kenarları bulmak için kullanılan bir türev operatördür. İkinci dereceden türev maskedir. Bu maskede, biri Pozitif Laplacian Operatörü ve diğeri Negatif Laplacian Operatörü olmak üzere iki sınıflandırmaya sahibiz.

    Diğer operatörlerin aksine Laplacian, belirli bir yönde kenar çıkarmaz, ancak aşağıdaki sınıflandırmada kenarları kaldırır.

    • İç Kenarlar
    • Dış Kenarlar

    Gerçekleştirebilirsin Laplacian Transform kullanarak bir görüntü üzerinde işlem Laplacian() yöntemi imgproc sınıf, bu yöntemin sözdizimi aşağıdadır.

    Laplacian(src, dst, ddepth)

    Bu yöntem aşağıdaki parametreleri kabul eder -

    • src - bir Mat Bu işlem için kaynağı (giriş görüntüsü) temsil eden nesne.

    • dst - bir Mat Bu işlem için hedefi (çıktı görüntüsü) temsil eden nesne.

    • ddepth - Hedef görüntünün derinliğini temsil eden tip tamsayı değişkeni.

    Misal

    Aşağıdaki program, belirli bir görüntü üzerinde Laplace dönüştürme işleminin nasıl gerçekleştirileceğini gösterir.

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

    Aşağıdakinin giriş görüntüsü olduğunu varsayalım laplacian_input.jpg yukarıdaki programda belirtilmiştir.

    Çıktı

    Programı çalıştırırken aşağıdaki çıktıyı alacaksınız -

    Image Processed

    Belirtilen yolu açarsanız, çıktı görüntüsünü aşağıdaki gibi gözlemleyebilirsiniz -

    distance transformoperatör genellikle ikili görüntüleri girdi olarak alır. Bu işlemde, ön plan bölgeleri içindeki noktaların gri seviye yoğunlukları, ilgili mesafeleri en yakın 0 değerinden (sınır) uzaklaşacak şekilde değiştirilir.

    Yöntemi kullanarak OpenCV'de mesafe dönüşümü uygulayabilirsiniz distanceTransform(). Bu yöntemin sözdizimi aşağıdadır.

    distanceTransform(src, dst, distanceType, maskSize)

    Bu yöntem aşağıdaki parametreleri kabul eder -

    • src - Sınıfın bir nesnesi Mat kaynak (giriş) görüntüsünü temsil eder.

    • dst - Sınıfın bir nesnesi Mat hedef (çıktı) görüntüsünü temsil eder.

    • distanceType - Uygulanacak mesafe dönüşümünün türünü temsil eden tam sayı türünde bir değişken.

    • maskSize - Kullanılacak maske boyutunu temsil eden bir tam sayı türü değişkeni.

    Misal

    Aşağıdaki program, belirli bir görüntü üzerinde mesafe dönüştürme işleminin nasıl gerçekleştirileceğini göstermektedir.

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

Aşağıdakinin giriş görüntüsü olduğunu varsayalım input.jpg yukarıdaki programda belirtilmiştir.

Çıktı

Programı çalıştırırken aşağıdaki çıktıyı alacaksınız -

Image Processed

Belirtilen yolu açarsanız, çıktı görüntüsünü aşağıdaki gibi gözlemleyebilirsiniz -

Mesafe Dönüşümü İşlemlerinin Türleri

Mesafe operasyon tipine ek olarak DIST_Cönceki örnekte gösterildiği gibi, OpenCV çeşitli diğer mesafe dönüştürme işlemlerini de sunar. Tüm bu türler, Imgproc sınıfının önceden tanımlanmış statik alanları (sabit değerler) ile temsil edilir.

İhtiyacınız olan mesafe dönüştürme işleminin türünü, ilgili önceden tanımlı değerini adlı parametreye ileterek seçebilirsiniz. distanceType of distanceTransform() yöntem.

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

Aşağıda, çeşitli türlerini temsil eden değerler verilmiştir. distanceTransform işlemler ve ilgili çıktıları.

Kullanım ve Açıklama Çıktı
DIST_C
DIST_L1
DIST_L2
DIST_LABEL_PIXEL
DIST_MASK_3

Bu bölümde, sistem kamerasını kullanarak kare yakalamak için OpenCV'yi nasıl kullanacağımızı öğreneceğiz. VideoCapture sınıfı org.opencv.videoiopaketi, kamerayı kullanarak video çekmek için sınıflar ve yöntemler içerir. Adım adım gidelim ve kareleri nasıl yakalayacağınızı öğrenelim -

1. Adım: OpenCV yerel kitaplığını yükleyin

OpenCV kitaplığını kullanarak Java kodu yazarken yapmanız gereken ilk adım, OpenCV'nin yerel kitaplığını, loadLibrary(). OpenCV yerel kitaplığını aşağıda gösterildiği gibi yükleyin.

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

2. Adım: Video yakalama sınıfını somutlaştırın

Bu öğreticide daha önce bahsedilen işlevlerden herhangi birini kullanarak Mat sınıfını somutlaştırın.

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

3. Adım: Çerçeveleri okuyun

Kameradan kareleri okuyabilirsiniz. read() yöntemi VideoCapturesınıf. Bu yöntem, sınıfın bir nesnesini kabul ederMat okunan çerçeveyi saklamak için.

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

Misal

Aşağıdaki program, kamera kullanarak bir çerçevenin nasıl çekileceğini ve JavaFX penceresi kullanılarak nasıl görüntüleneceğini gösterir. Ayrıca yakalanan kareyi de kaydeder.

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

Çıktı

Programı çalıştırırken aşağıdaki çıktıyı alacaksınız.

Belirtilen yolu açarsanız, jpg dosyası olarak kaydedilen aynı kareyi görebilirsiniz.

VideoCapture sınıfı org.opencv.videoiopaketi, sistem kamerasını kullanarak video çekmek için sınıflar ve yöntemler içerir. Adım adım gidelim ve nasıl yapılacağını öğrenelim.

1. Adım: OpenCV yerel kitaplığını yükleyin

OpenCV kitaplığını kullanarak Java kodu yazarken yapmanız gereken ilk adım, OpenCV'nin yerel kitaplığını, loadLibrary(). OpenCV yerel kitaplığını aşağıda gösterildiği gibi yükleyin.

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

Adım 2: CascadeClassifier sınıfını somutlaştırın

CascadeClassifier paketin sınıfı org.opencv.objdetectsınıflandırıcı dosyasını yüklemek için kullanılır. Bu sınıfı,xml dosya lbpcascade_frontalface.xml Aşağıda gösterildiği gibi.

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

3. Adım: Yüzleri tespit edin

Yöntemi kullanarak görüntüdeki yüzleri tespit edebilirsiniz detectMultiScale() sınıfın adı CascadeClassifier. Bu yöntem, sınıfın bir nesnesini kabul ederMat girdi görüntüsünü ve sınıfın bir nesnesini tutmak MatOfRect tespit edilen yüzleri saklamak için.

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

Misal

Aşağıdaki program, bir görüntüdeki yüzlerin nasıl tespit edileceğini göstermektedir.

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

Aşağıdakinin giriş görüntüsü olduğunu varsayalım facedetection_input.jpg yukarıdaki programda belirtilmiştir.

Çıktı

Programı çalıştırırken aşağıdaki çıktıyı alacaksınız -

Detected 3 faces 
Image Processed

Belirtilen yolu açarsanız, çıktı görüntüsünü aşağıdaki gibi gözlemleyebilirsiniz -

Aşağıdaki program, sistem kamerası kullanılarak yüzlerin nasıl algılanacağını ve JavaFX penceresi kullanılarak nasıl görüntüleneceğini göstermektedir.

Misal

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

Çıktı

Programı çalıştırırken aşağıdaki çıktıyı alacaksınız.

Belirtilen yolu açarsanız, aynı anlık görüntünün bir jpg görüntü.

Gerçekleştirebilirsin affine translation kullanarak bir görüntüde warpAffine()imgproc sınıfının yöntemi. Bu yöntemin sözdizimi aşağıdadır -

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

Bu yöntem aşağıdaki parametreleri kabul eder -

  • src - bir Mat Bu işlem için kaynağı (giriş görüntüsü) temsil eden nesne.

  • dst - bir Mat Bu işlem için hedefi (çıktı görüntüsü) temsil eden nesne.

  • tranformMatrix - bir Mat dönüştürme matrisini temsil eden nesne.

  • size - Çıktı görüntüsünün boyutunu temsil eden tam sayı türünde bir değişken.

Misal

Aşağıdaki program, belirli bir görüntüye afin işleminin nasıl uygulanacağını gösterir.

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

Aşağıdakinin giriş görüntüsü olduğunu varsayalım transform_input.jpg yukarıdaki programda belirtilmiştir.

Çıktı

Yürüttüğünüzde aşağıdaki çıktıyı alacaksınız -

Image Processed

Belirtilen yolu açarsanız, çıktı görüntüsünü aşağıdaki gibi gözlemleyebilirsiniz -

Yapabilirsin perform rotation kullanarak bir görüntü üzerinde işlem warpAffine() yöntemi imgprocsınıf. Bu yöntemin sözdizimi aşağıdadır -

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

Bu yöntem aşağıdaki parametreleri kabul eder -

  • src - bir Mat Bu işlem için kaynağı (giriş görüntüsü) temsil eden nesne.

  • dst - bir Mat Bu işlem için hedefi (çıktı görüntüsü) temsil eden nesne.

  • rotationMatrix - bir Mat döndürme matrisini temsil eden nesne.

  • size - Çıktı görüntüsünün boyutunu temsil eden tam sayı türünde bir değişken.

Misal

Aşağıdaki program bir görüntünün nasıl döndürüleceğini göstermektedir.

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

Aşağıdakinin giriş görüntüsü olduğunu varsayalım transform_input.jpg yukarıdaki programda belirtilmiştir.

Çıktı

Programı çalıştırırken aşağıdaki çıktıyı alacaksınız -

Image Processed

Belirtilen yolu açarsanız, çıktı görüntüsünü aşağıdaki gibi gözlemleyebilirsiniz -

Gerçekleştirebilirsin scaling kullanarak bir görüntüde resize() yöntemi imgprocsınıf. Bu yöntemin sözdizimi aşağıdadır.

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

Bu yöntem aşağıdaki parametreleri kabul eder -

  • src - bir Mat Bu işlem için kaynağı (giriş görüntüsü) temsil eden nesne.

  • dst - bir Mat Bu işlem için hedefi (çıktı görüntüsü) temsil eden nesne.

  • dsize - bir Size çıktı görüntüsünün boyutunu temsil eden nesne.

  • fx - Yatay eksen boyunca ölçek faktörünü temsil eden double türünde bir değişken.

  • fy - Dikey eksen boyunca ölçek faktörünü temsil eden double türünde bir değişken.

  • Interpolation - Enterpolasyon yöntemini temsil eden bir tamsayı değişkeni.

Misal

Aşağıdaki program nasıl başvurulacağını göstermektedir scale transformation bir resme.

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

Aşağıdakinin giriş görüntüsü olduğunu varsayalım transform_input.jpg yukarıdaki programda belirtilmiştir (boyut - Genişlik: 300 piksel ve yükseklik: 300 piksel).

Çıktı

Programı çalıştırırken aşağıdaki çıktıyı alacaksınız -

Image Processed

Belirtilen yolu açarsanız, çıktı görüntüsünü şu şekilde gözlemleyebilirsiniz (boyut - Genişlik: 600 piksel ve yükseklik: 600 piksel) -

OpenCV'de, yöntemi kullanarak bir görüntüye farklı renk haritaları uygulayabilirsiniz. applyColorMap() sınıfın Imgproc. Bu yöntemin sözdizimi aşağıdadır -

applyColorMap(Mat src, Mat dst, int colormap)

Üç parametreyi kabul eder -

  • src - Sınıfın bir nesnesi Mat kaynak (giriş) görüntüsünü temsil eder.

  • dst - Sınıfın bir nesnesi Mat hedef (çıktı) görüntüsünü temsil eder.

  • colormap - Uygulanacak renk haritasının türünü temsil eden tam sayı türünde bir değişken.

Misal

Aşağıdaki program nasıl başvurulacağını göstermektedir color map bir resme.

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

Aşağıdakinin giriş görüntüsü olduğunu varsayalım color_input.jpg yukarıdaki programda belirtilmiştir.

Çıktı

Yukarıdaki programı çalıştırırken aşağıdaki çıktıyı alacaksınız -

Image Processed

Belirtilen yolu açarsanız, çıktı görüntüsünü aşağıdaki gibi gözlemleyebilirsiniz -

Daha Fazla İşlem

Ek olarak COLORMAP_HOTönceki örnekte gösterildiği gibi, OpenCV çeşitli diğer renk haritası türlerini de sunar. Tüm bu türler, Imgproc sınıfının önceden tanımlanmış statik alanları (sabit değerler) ile temsil edilir.

Önceden tanımlanmış ilgili değerini adlı parametreye ileterek ihtiyacınız olan renk haritasının türünü seçebilirsiniz. colormap of applyColorMap() yöntem.

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

Aşağıda, çeşitli renk haritalarını ve bunların çıktılarını temsil eden değerler yer almaktadır.

Kullanım ve Açıklama Çıktı
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, bir görüntüdeki kenarları tespit etmek için kullanılır. Gri tonlamalı bir görüntüyü girdi olarak kabul eder ve çok aşamalı bir algoritma kullanır.

Bu işlemi kullanarak bir görüntü üzerinde gerçekleştirebilirsiniz. Canny() yöntemi imgproc sınıf, bu yöntemin sözdizimi aşağıdadır.

Canny(image, edges, threshold1, threshold2)

Bu yöntem aşağıdaki parametreleri kabul eder -

  • image - bir Mat Bu işlem için kaynağı (giriş görüntüsü) temsil eden nesne.

  • edges - bir Mat bu işlem için hedefi (kenarları) temsil eden nesne.

  • threshold1 - Histerez prosedürü için ilk eşiği temsil eden çift tipli bir değişken.

  • threshold2 - Histerez prosedürü için ikinci eşiği temsil eden çift tipli bir değişken.

Misal

Aşağıdaki program, belirli bir görüntü üzerinde Canny Edge Detection işleminin nasıl gerçekleştirileceğini gösteren bir örnektir.

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

Aşağıdakinin giriş görüntüsü olduğunu varsayalım canny_input.jpg yukarıdaki programda belirtilmiştir.

Çıktı

Yukarıdaki programı çalıştırırken aşağıdaki çıktıyı alacaksınız -

Image Processed

Belirtilen yolu açarsanız, çıktı görüntüsünü aşağıdaki gibi gözlemleyebilirsiniz -

Belirli bir görüntünün şeklini, Hough Transform technique yöntemi kullanarak HoughLines() of Imgprocsınıf. Bu yöntemin sözdizimi aşağıdadır.

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

Bu yöntem aşağıdaki parametreleri kabul eder -

  • image - Sınıfın bir nesnesi Mat kaynak (giriş) görüntüsünü temsil eder.

  • lines - Sınıfın bir nesnesi Mat satırların parametrelerini (r, Φ) saklayan vektörü depolayan.

  • rho - r parametresinin piksel cinsinden çözünürlüğünü temsil eden double türünde bir değişken.

  • theta - Φ parametresinin radyan cinsinden çözünürlüğünü temsil eden double türünde bir değişken.

  • threshold - Bir çizgiyi "algılamak" için minimum kesişim sayısını temsil eden tam sayı türünde bir değişken.

Misal

Aşağıdaki program, belirli bir görüntüdeki Hough çizgilerinin nasıl tespit edileceğini göstermektedir.

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

Aşağıdakinin giriş görüntüsü olduğunu varsayalım hough_input.jpg yukarıdaki programda belirtilmiştir.

Çıktı

Programı çalıştırırken aşağıdaki çıktıyı alacaksınız -

143 
1 
Image Processed

Belirtilen yolu açarsanız, çıktı görüntüsünü aşağıdaki gibi gözlemleyebilirsiniz -

histogramBir görüntünün, piksellerin yoğunluk değerlerinin frekansını gösterir. Bir görüntü histogramında, X ekseni gri seviye yoğunluklarını gösterir ve Y ekseni bu yoğunlukların frekansını gösterir.

Histogram equalizationYoğun aralığı genişletmek için bir görüntünün kontrastını iyileştirir. Yöntemi kullanarak belirli bir görüntünün histogramını eşitleyebilirsinizequalizeHist() of Imgprocsınıf. Bu yöntemin sözdizimi aşağıdadır.

equalizeHist(src, dst)

Bu yöntem aşağıdaki parametreleri kabul eder -

  • src - Sınıfın bir nesnesi Mat kaynak (giriş) görüntüsünü temsil eder.

  • dst - Sınıfın bir nesnesi Matçıktıyı temsil eden. (Histogram eşitlendikten sonra elde edilen görüntü)

Misal

Aşağıdaki program, belirli bir görüntünün histogramının nasıl eşitleneceğini gösterir.

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

Aşağıdakinin giriş görüntüsü olduğunu varsayalım histo_input.jpg yukarıdaki programda belirtilmiştir.

Çıktı

Programı çalıştırırken aşağıdaki çıktıyı alacaksınız -

Image Processed

Belirtilen yolu açarsanız, çıktı görüntüsünü aşağıdaki gibi gözlemleyebilirsiniz -