OpenCV是一個跨平台的庫，使用它我們可以開發實時的計算機視覺應用程式。它主要關注圖像處理、視頻採集和分析，包括人臉檢測和目標檢測等特徵。
讓我們從定義術語「計算機視覺」開始這一章。
Computer Vision
計算機視覺可以被定義爲一門學科，它根據場景中存在的結構特性，解釋如何從二維圖像中重建、中斷和理解三維場景。它使用計算機軟體和硬體對人類視覺進行建模和複製。
計算機視覺與下列領域有著顯著的重疊;
圖像處理的重點是圖像處理。
模式識別−它解釋了對模式進行分類的各種技術。
攝影測量學是指從圖像中獲得精確的測量值。
Computer Vision Vs Image Processing
圖像處理處理圖像到圖像的轉換。圖像處理的輸入和輸出都是圖像。
計算機視覺是從圖像中對物體進行明確、有意義的描述。計算機視覺的輸出是對三維場景中結構的描述或解釋。
Applications of Computer Vision
在這裡，我們列出了一些主要領域，其中計算機視覺是大量使用。
Robotics Application
自動確定機器人位置
導航
障礙迴避
裝配（銷釘孔、焊接、噴漆）
操縱（例如美洲獅機器人操縱器）
人機互動（HRI）&負;與人交互並爲人服務的智能機器人
Medicine Application
- Classification and detection (e.g. lesion or cells classification and tumor detection)
- 2D/3D segmentation
- 3D human organ reconstruction (MRI or ultrasound)
- Vision-guided robotics surgery
Industrial Automation Application
- Industrial inspection (defect detection)
- Assembly
- Barcode and package label reading
- Object sorting
- Document understanding (e.g. OCR)
Security Application
生物測定（虹膜、指紋、人臉識別）
監視-檢測某些可疑活動或行爲
Transportation Application
- Autonomous vehicle
- Safety, e.g., driver vigilance monitoring
Features of OpenCV Library
使用OpenCV庫，您可以−
讀寫圖像
捕獲和保存視頻
處理圖像（過濾、變換）
執行特徵檢測
檢測視頻或圖像中的特定對象，如人臉、眼睛、汽車。
分析視頻，即估計其中的運動，減去背景，然後跟蹤其中的對象。
OpenCV最初是在C++中開發的;。除此之外，還提供了Python和Java綁定。OpenCV運行在各種作業系統上，如windows、Linux、OSx、FreeBSD、Net BSD、openbsd等。
本教程通過使用Java綁定的示例解釋OpenCV的概念。
OpenCV Library Modules
以下是OpenCV庫的主要庫模塊。
Core Functionality
本模塊涵蓋用於構建OpenCV應用程式的基本數據結構，如標量、點、範圍等。除此之外，它還包括用於存儲圖像的多維數組Mat。在OpenCV的Java庫中，這個模塊作爲一個名爲org.OpenCV.core的包包含。
Image Processing
本模塊涵蓋圖像過濾、幾何圖像轉換、顏色空間轉換、直方圖等各種圖像處理操作。在OpenCV的Java庫中，本模塊作爲一個名爲org.OpenCV.imgproc的包被包含。
Video
本模塊涵蓋視頻分析概念，如運動估計、背景減法和目標跟蹤。在OpenCV的Java庫中，這個模塊作爲一個名爲org.OpenCV.video的包包含。
Video I/O
本模塊介紹使用OpenCV庫的視頻捕獲和視頻編解碼器。在OpenCV的Java庫中，這個模塊作爲一個名爲org.OpenCV.videoio的包包含。
calib3d
該模塊包括基本的多視圖幾何算法、單攝像機和立體攝像機標定、目標姿態估計、立體對應和三維重建元素等算法。在OpenCV的Java庫中，這個模塊作爲一個名爲org.OpenCV.calib3d的包包含。
features2d
本模塊包括特徵檢測和描述的概念。在OpenCV的Java庫中，這個模塊作爲一個名爲org.OpenCV.features2d的包包含。
Objdetect
該模塊包括對預定義類的對象和實例的檢測，如人臉、眼睛、杯子、人、汽車等。在OpenCV的Java庫中，該模塊作爲名爲org.OpenCV.objdetect的包包含。
Highgui
這是一個易於使用的界面，具有簡單的UI功能。在OpenCV的Java庫中，這個模塊的特性包含在兩個不同的包中，即org.OpenCV.imgcodecs和org.OpenCV.videoio。
A Brief History of OpenCV
OpenCV最初是英特爾的一項研究計劃，旨在爲CPU密集型應用程式提供建議。1999年正式啓動。
- In the year 2006, its first major version, OpenCV 1.0 was released.
- In October 2009, the second major version, OpenCV 2 was released.
- In August 2012, OpenCV was taken by a nonprofit organization OpenCV.org.
OpenCV - Environment
在本章中，您將學習如何安裝OpenCV並在系統中設置其環境。
Installing OpenCV
首先，你需要把OpenCV下載到你的系統上。遵循以下步驟。
第1步−單擊以下連結打開OpenCV的主頁：單擊http://OpenCV.org/時，您將看到其主頁，如下所示。
第2步−現在，單擊上面螢幕截圖中突出顯示的下載連結。點擊後，您將被引導到OpenCV的下載頁面。
第3步−單擊上面螢幕截圖中突出顯示的連結時，將下載名爲opencv-3.1.0.exe的文件。提取此文件以在系統中生成文件夾opencv，如下圖所示。
步驟4−打開文件夾OpenCV→build→java。在這裡您可以找到OpenCV的jar文件，名爲OpenCV-310.jar。將此文件保存在單獨的文件夾中以供進一步使用。
Eclipse Installation
下載所需的JAR文件後，必須將這些JAR文件嵌入到Eclipse環境中。您可以通過設置這些JAR文件的構建路徑並使用pom.xml。
Setting Build Path
以下是在Eclipse−中設置OpenCV的步驟;
步驟1−確保已在系統中安裝了Eclipse。如果沒有，請下載並在系統中安裝Eclipse。
步驟2−打開Eclipse，單擊File、New，然後打開一個新項目，如下面的螢幕截圖所示。
第3步−選擇項目時，您將獲得新建項目嚮導。在此嚮導中，選擇Java project並單擊下一步按鈕繼續，如下圖所示。
步驟4−繼續，您將被引導到新建Java項目嚮導。創建一個新項目並單擊「下一步」，如下圖所示。
步驟5−創建新項目後，右鍵單擊它。選擇生成路徑，然後單擊配置生成路徑…，如下圖所示。
第6步−單擊構建路徑選項時，將指向Java構建路徑嚮導。單擊「添加外部jar」按鈕，如下圖所示。
步驟7−選擇保存文件的路徑opencv-310.jar。
第8步−單擊上述螢幕截圖中的「打開」按鈕，這些文件將添加到庫中。
第9步−單擊確定，您將成功地將所需的JAR文件添加到當前項目中，您可以通過展開引用的庫來驗證這些添加的庫。
Setting the Path for Native Libraries
除了JAR文件之外，還需要爲OpenCV的本機庫（DLL文件）設置路徑。
DLL文件的位置−打開OpenCV的安裝文件夾並轉到子文件夾build→java。在這裡您將找到兩個文件夾x64（64位）和x86（32位），其中包含OpenCV的dll文件。
打開適合您的作業系統的相應文件夾，然後您可以看到dll文件，如下面的螢幕截圖所示。
現在，按照下面給出的步驟設置這個文件的路徑;
步驟1再次打開JavaBuildPath窗口。在這裡，您可以看到添加的JAR文件和JRE系統庫。
第2步−展開後，您將得到系統庫和本地庫位置，如下面的螢幕截圖所示。
第3步−雙擊本機庫位置。在這裡，您可以看到本機庫文件夾配置窗口，如下所示。
在這裡，單擊按鈕外部文件夾…並選擇系統中dll文件的位置。
OpenCV - Storing Images
爲了捕捉圖像，我們使用相機和掃描儀等設備。這些設備記錄圖像的數值（例如：像素值）。OpenCV是一個處理數字圖像的庫，因此我們需要存儲這些圖像進行處理。
OpenCV庫的Mat類用於存儲圖像的值。它表示一個n維數組，用於存儲灰度或彩色圖像、體素體積、向量場、點雲、張量、直方圖等圖像數據。
這個類包含兩個數據部分：頭和指針
Header−包含諸如大小、用於存儲的方法和矩陣地址（大小恆定）等信息。
指針存儲圖像的像素值（保持變化）。
The Mat Class
OpenCV Java庫在包org.OpenCV.core中爲這個類提供了相同的名稱（Mat）。
Constructors
OpenCV Java庫的Mat類有各種構造函數，使用它們可以構造Mat對象。
| S.No | Constructors and Description |
|---|---|
| 1 |
材料（） 在大多數情況下，這是沒有參數的默認構造函數。我們使用它來構造一個空矩陣並將其傳遞給其他OpenCV方法。 |
| 2 |
Mat（int行，int列，int類型） 此構造函數接受三個整數類型的參數，表示2D數組中的行數和列數以及數組的類型（用於存儲數據）。 |
| 3 |
Mat（int行，int列，int類型，標量s） 包括前一個構造函數的參數，此構造函數還接受類標量的對象作爲參數。 |
| 4 |
Mat（大小，int類型） 此構造函數接受兩個參數，一個表示矩陣大小的對象，一個表示用於存儲數據的數組類型的整數。 |
| 5 |
Mat（大小、int類型、標量s） 包括前一個構造函數的參數，此構造函數還接受類標量的對象作爲參數。 |
| 6 | 材料（長地址） |
| 7 |
墊子（墊子m，靶場行） 此構造函數接受另一個矩陣的對象和表示要創建新矩陣的行範圍的類範圍的對象。 |
| 8 |
mat（>mat m，range rowrange，range colrange 包括前一個構造函數的參數，這個構造函數還接受類的一個對象。表示列範圍的範圍。 |
| 9 |
墊子（墊子m，矩形roi） 這個構造函數接受兩個對象，一個表示另一個矩陣，另一個表示RegionOfInteest。 |
注−
數組類型。使用CV_8UC1，…，CV_64FC4創建1-4通道矩陣，或使用CV_8UC（n），…，CV_64FC（n）創建多通道（最多CV_8UC（u）MAX通道）矩陣。
矩陣的類型由屬於包org.opencv.core的類CvType的各個欄位表示。
Methods and Description
下面是Mat類提供的一些方法。
| S.No | Methods and Description |
|---|---|
| 1 |
Mat col（整數x） 此方法接受表示列索引的整數參數，並檢索並返回該列。 |
| 2 |
材料行（國際） 此方法接受表示行索引的整數參數，並檢索並返回該行。 |
| 3 |
整數列（） 此方法返回矩陣中的列數。 |
| 4 |
整數行（） 此方法返回矩陣中的行數。 |
| 5 |
Mat setTo（Mat值） 此方法接受Mat類型的對象，並將數組元素設置爲指定值。 |
| 6 |
Mat setTo（標量s） 此方法接受標量類型的對象，並將數組元素設置爲指定值。 |
Creating and Displaying the Matrix
在本節中，我們將討論第一個OpenCV示例。我們將看到如何創建和顯示一個簡單的OpenCV矩陣。
下面給出了在OpenCV中創建和顯示矩陣的步驟。
Step 1: Load the OpenCV native library
在使用OpenCV庫編寫Java代碼時，首先需要使用load library（）加載OpenCV的本機庫。加載OpenCV本機庫，如下所示。
//Loading the core library System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
Step 2: Instantiate the Mat class
使用本章前面提到的任何函數實例化Mat類。
//Creating a matrix Mat matrix = new Mat(5, 5, CvType.CV_8UC1, new Scalar(0));
Step 3: Fill the matrix using the methods
通過將索引值傳遞給方法row（）/col（），可以檢索矩陣的特定行/列。
而且，您可以使用set to（）方法的任何變體來設置這些值。
//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));
示例
您可以使用以下程序代碼使用OpenCV庫在Java中創建和顯示一個簡單的矩陣。
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());
}
}
在執行上述程序時，您將得到以下輸出&負;
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]
Loading Image using JavaSE API
java.awt.image.BufferedImage包的BufferedImage類用於存儲圖像，包的ImageIO類提供讀取和寫入圖像的方法。
示例
您可以使用以下程序代碼使用JavaSE庫加載和保存圖像。
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import javax.imageio.ImageIO;
public class LoadingImage_JSE_library {
public static void main( String[] args ) throws IOException {
//Input File
File input = new File("C:/EXAMPLES/OpenCV/sample.jpg");
//Reading the image
BufferedImage image = ImageIO.read(input);
//Saving the image with a different name
File ouptut = new File("C:/OpenCV/sample.jpg");
ImageIO.write(image, "jpg", ouptut);
System.out.println("image Saved");
}
}
在執行上述程序時，您將得到以下輸出&負;
image Saved
如果打開指定的路徑，則可以按以下方式觀察保存的圖像−
OpenCV - Reading Images
包的Imgcodecs類org.opencv.Imgcodecs提供讀取和寫入圖像的方法。使用OpenCV，您可以讀取圖像並將其存儲在矩陣中（如果需要，對矩陣執行轉換）。稍後，您可以將處理後的矩陣寫入文件。
類的read（）方法用於使用OpenCV讀取圖像。下面是這個方法的語法。
imread(filename)
它接受一個參數（filename），這是一個字符串類型的變量，表示要讀取的文件的路徑。
下面給出了使用OpenCV庫在Java中讀取圖像的步驟。
Step 1: Load the OpenCV native library
使用Load（）方法加載OpenCV本機庫，如下所示。
//Loading the core library System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
Step 2: Instantiate the Imgcodecs class
實例化Imgcodecs類。
//Instantiating the Imgcodecs class Imgcodecs imageCodecs = new Imgcodecs();
Step 3: Reading the image
使用imread（）方法讀取圖像。此方法接受表示圖像路徑的字符串參數，並返回讀取爲Mat對象的圖像。
//Reading the Image from the file Mat matrix = imageCodecs.imread(Path of the image);
Example
下面的程序代碼演示如何使用OpenCV庫讀取圖像。
import org.opencv.core.Core;
import org.opencv.core.Mat;
import org.opencv.imgcodecs.Imgcodecs;
public class ReadingImages {
public static void main(String args[]) {
//Loading the OpenCV core library
System.loadLibrary( Core.NATIVE_LIBRARY_NAME );
//Instantiating the Imagecodecs class
Imgcodecs imageCodecs = new Imgcodecs();
//Reading the Image from the file
String file ="C:/EXAMPLES/OpenCV/sample.jpg";
Mat matrix = imageCodecs.imread(file);
System.out.println("Image Loaded");
}
}
在執行上述程序時，OpenCV加載指定的圖像並顯示以下輸出−
Image Loaded
OpenCV - Writing an Image
類的write（）方法用於使用OpenCV編寫圖像。要編寫圖像，請重複前面示例中的前三個步驟。
要編寫圖像，需要調用Imgcodecs類的imwrite（）方法。
下面是這個方法的語法。
imwrite(filename, mat)
此方法接受以下參數&負;
文件名−A字符串表示保存文件的路徑的變量。
mat−Amat表示要寫入的圖像的對象。
Example
下面的程序是一個使用OpenCV庫的Java程序編寫圖像的例子。
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 ............");
}
}
在執行上述程序時，您將得到以下輸出&負;
Image Loaded .......... Image Saved ...........
如果打開指定的路徑，則可以看到保存的圖像，如下所示−
OpenCV - GUI
在前面的章節中，我們已經討論了如何使用OpenCV Java庫讀取和保存圖像。除此之外，我們還可以使用AWT/Swings和JavaFX等GUI庫在單獨的窗口中顯示加載的圖像。
Converting Mat to Buffered Image
要讀取圖像，我們使用imread（）方法。此方法返回以矩陣形式讀取的圖像。但是，要將這個映像與GUI庫（AWT/Swings和JavaFX）一起使用，它應該被轉換爲包的java.AWT.image.BufferedImage類的對象。
下面是將OpenCV的aMat對象轉換爲BufferedImage對象的步驟。
Step 1: encode the Mat to MatOfByte
First of all, you need to convert the matrix to matrix of byte. You can do it using the method imencode() of the class Imgcodecs. 下面是這個方法的語法。
imencode(ext, image, matOfByte);
此方法接受以下參數&負;
Ext−指定圖像格式的字符串參數（.jpg、.png等）
圖像的Mat對象
matOfByte−matOfByte類的空對象
使用此方法對圖像進行編碼，如下所示。
//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);
Step 2: Convert the MatOfByte object to byte array
使用方法toArray（）將MatOfByte對象轉換爲字節數組。
byte[] byteArray = matOfByte.toArray();
Step 3: Preparing the InputStream object
準備InputStream對象，方法是將上一步創建的字節數組傳遞給ByteArrayInputStream類的構造函數。
//Preparing the InputStream object InputStream in = new ByteArrayInputStream(byteArray);
Step 4: Preparing the InputStream object
將上一步創建的輸入流對象傳遞給ImageIO類的read（）方法。這將返回一個BufferedImage對象。
//Preparing the BufferedImage BufferedImage bufImage = ImageIO.read(in);
Displaying Image using AWT/Swings
要使用AWT/Swings框架顯示圖像，首先，使用imread（）方法讀取圖像，然後按照上述步驟將其轉換爲BufferedImage。
然後，實例化JFrame類，並將創建的緩衝圖像添加到JFrame的ContentPane中，如下所示−
//Instantiate JFrame JFrame frame = new JFrame(); //Set Content to the JFrame frame.getContentPane().add(new JLabel(new ImageIcon(bufImage))); frame.pack(); frame.setVisible(true);
示例
下面的程序代碼演示如何使用OpenCV庫通過swing窗口讀取圖像並顯示圖像。
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");
}
}
在執行上述程序時，您將得到以下輸出&負;
Image Loaded
除此之外，您還可以看到一個窗口顯示加載的圖像，如下所示;
Displaying Image using JavaFX
要使用JavaFX顯示圖像，首先，使用imread（）方法讀取圖像並將其轉換爲BufferedImage。然後，將BufferedImage轉換爲WritableImage，如下所示。
WritableImage writableImage = SwingFXUtils.toFXImage(bufImage, null);
將這個writebleimage對象傳遞給ImageView類的構造函數。
ImageView imageView = new ImageView(writableImage);
示例
下面的程序代碼演示如何使用OpenCV庫通過JavaFX窗口讀取圖像並顯示圖像。
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);
}
}
在執行上述程序時，您將得到以下輸出&負;
Image Loaded
除此之外，您還可以看到一個窗口顯示加載的圖像，如下所示;
OpenCV - The IMREAD_XXX Flag
OpenCV支持各種類型的圖像，如彩色、二進位、灰度等。使用imread（）方法和Imgcodecs類的預定義欄位，可以將給定的圖像作爲另一種類型讀取。
The flags parameter of imread() method (IMREAD_XXX)
在前面的章節中，我們已經看到了Imgcodecs類的imread（）方法的語法。它接受一個字符串參數，表示要讀取的圖像的位置。
imread(filename)
imread（）方法有另一種語法。
imread(filename, int flags)
此語法接受兩個參數-minus;
filename − 它接受一個參數（filename），這是一個字符串類型的變量，表示要讀取的文件的路徑。
標誌−表示預定義標誌值的整數值。對於每個值，這會將給定圖像讀取爲特定類型（灰度顏色等）
下表列出了Imgproc類中提供的各種欄位作爲此參數的值。
| S.No | Fields and Description |
|---|---|
| 1 |
圖像顏色 如果將標誌設置爲此值，則加載的圖像將轉換爲3通道BGR（藍綠紅）彩色圖像。 |
| 2 |
圖像灰度 如果將標誌設置爲此值，則加載的圖像將轉換爲單通道灰度圖像。 |
| 3 |
讀取加載GDAL 如果標誌設置爲此值，則可以使用gdal驅動程序加載圖像。 |
| 4 |
我讀任何顏色 如果將標誌設置爲此值，則會以任何可能的顏色格式讀取圖像。 |
| 5 |
減色 減少顏色 IMREAD_REDUCED_COLOR_8顏色 如果將標誌設置爲該值，則圖像將被讀取爲三通道BGR，並且圖像的大小將減小爲相對於所用欄位的圖像原始大小的½、¼th或⅛th。 |
| 6 |
圖像還原灰度 圖像還原灰度4 圖像還原灰度 如果將標誌設置爲該值，則將圖像讀取爲單通道灰度圖像，並且圖像的大小將減小爲相對於所用欄位的圖像原始大小的½、¼th或⅛th。 |
| 7 |
未更改 如果標誌設置爲此值，則加載的圖像將按原樣返回。 |
OpenCV - Reading an Image as Grayscale
The following program demonstrates how to read a colored image as grayscale and display it using JavaFX window. In here, we have read the image by passing the flag 圖像灰度 along with the String holding the path of a colored image.
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);
}
}
Input Image
假設下面是上面程序中指定的輸入圖像sample.jpg。
Output Image
在執行程序時，您將得到以下輸出。
OpenCV - Reading Image as BGR
The following program demonstrates how to read a colored image as BGR type image and display it using JavaFX window. In here, we have read the image by passing the flag 圖像顏色 to the method imread() along with the String holding the path of a colored image.
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);
}
}
Input Image
假設下面是上面程序中指定的輸入圖像sample.jpg。
Output Image
在執行程序時，您將得到以下輸出。
OpenCV - Colored Images to GrayScale
在前面的章節中，我們討論了如何將輸入圖像讀取爲不同類型（二進位、灰度、BGR等）。在本章中，我們將學習如何將一種類型的圖像轉換爲另一種類型的圖像。
包org.opencv.Imgproc中名爲Imgproc的類提供了將圖像從一種顏色轉換爲另一種顏色的方法。
Converting Colored Images to Grayscale
A method named cvtColor() is used to convert colored images to grayscale. 下面是這個方法的語法。
cvtColor(Mat src, Mat dst, int code)
此方法接受以下參數&負;
src−表示源的矩陣。
dst−表示目的地的矩陣。
code−表示轉換類型的整數代碼，例如RGB到灰度。
通過將代碼Imgproc.COLOR\u RGB2GRAY以及源和目標矩陣作爲參數傳遞給cvtColor（）方法，可以將彩色圖像轉換爲灰度。
Example
下面的程序演示如何將彩色圖像讀取爲灰度圖像並使用JavaFX窗口顯示它。
import java.awt.image.BufferedImage;
import org.opencv.core.Core;
import org.opencv.core.Mat;
import org.opencv.imgcodecs.Imgcodecs;
import org.opencv.imgproc.Imgproc;
import javafx.application.Application;
import javafx.embed.swing.SwingFXUtils;
import javafx.scene.Group;
import javafx.scene.Scene;
import javafx.scene.image.ImageView;
import javafx.scene.image.WritableImage;
import javafx.stage.Stage;
public class ColorToGrayscale extends Application {
@Override
public void start(Stage stage) throws Exception {
WritableImage writableImage = loadAndConvert();
// Setting the image view
ImageView imageView = new ImageView(writableImage);
// Setting the position of the image
imageView.setX(10);
imageView.setY(10);
// setting the fit height and width of the image view
imageView.setFitHeight(400);
imageView.setFitWidth(600);
// Setting the preserve ratio of the image view
imageView.setPreserveRatio(true);
// Creating a Group object
Group root = new Group(imageView);
// Creating a scene object
Scene scene = new Scene(root, 600, 400);
// Setting title to the Stage
stage.setTitle("Colored to grayscale image");
// Adding scene to the stage
stage.setScene(scene);
// Displaying the contents of the stage
stage.show();
}
public WritableImage loadAndConvert() throws Exception {
//Loading the OpenCV core library
System.loadLibrary( Core.NATIVE_LIBRARY_NAME );
String input = "C:/EXAMPLES/OpenCV/sample.jpg";
//Reading the image
Mat src = Imgcodecs.imread(input);
//Creating the empty destination matrix
Mat dst = new Mat();
//Converting the image to gray sacle and saving it in the dst matrix
Imgproc.cvtColor(src, dst, Imgproc.COLOR_RGB2GRAY);
//Extracting data from the transformed image (dst)
byte[] data1 = new byte[dst.rows() * dst.cols() * (int)(dst.elemSize())];
dst.get(0, 0, data1);
//Creating Buffered image using the data
BufferedImage bufImage = new BufferedImage(dst.cols(),dst.rows(),
BufferedImage.TYPE_BYTE_GRAY);
//Setting the data elements to the image
bufImage.getRaster().setDataElements(0, 0, dst.cols(), dst.rows(), data1);
//Creating a WritableImage
WritableImage writableImage = SwingFXUtils.toFXImage(bufImage, null);
System.out.println("Converted to Grayscale");
return writableImage;
}
public static void main(String args[]) throws Exception {
launch(args);
}
}
Input Image
假設下面是上面程序中指定的輸入圖像sample.jpg。
Output Image
在執行程序時，您將得到以下輸出。
OpenCV - Colored Image to Binary
A method called threshold() is used to convert grayscale images to binary image. 下面是這個方法的語法。
threshold(Mat src, Mat dst, double thresh, double maxval, int type)
此方法接受以下參數&負;
mat−Amat表示輸入圖像的對象。
dst−AMat表示輸出圖像的對象。
thresh−表示閾值的整數。
maxval−一個整數，表示要與THRESH_BINARY和THRESH_BINARY_INV閾值類型一起使用的最大值。
鍵入−表示轉換類型的整數代碼，例如RGB到灰度。
通過將代碼Imgproc.THRESH_binary以及值傳遞給其餘參數，可以將灰度圖像轉換爲二進位圖像。
Example
下面的程序演示如何將彩色圖像讀取爲二進位圖像並使用JavaFX窗口顯示它。
import java.awt.image.BufferedImage;
import org.opencv.core.Core;
import org.opencv.core.Mat;
import org.opencv.imgcodecs.Imgcodecs;
import org.opencv.imgproc.Imgproc;
import javafx.application.Application;
import javafx.embed.swing.SwingFXUtils;
import javafx.scene.Group;
import javafx.scene.Scene;
import javafx.scene.image.ImageView;
import javafx.scene.image.WritableImage;
import javafx.stage.Stage;
public class ColorToBinary extends Application {
@Override
public void start(Stage stage) throws Exception {
WritableImage writableImage = loadAndConvert();
// Setting the image view
ImageView imageView = new ImageView(writableImage);
// Setting the position of the image
imageView.setX(10);
imageView.setY(10);
// setting the fit height and width of the image view
imageView.setFitHeight(400);
imageView.setFitWidth(600);
// Setting the preserve ratio of the image view
imageView.setPreserveRatio(true);
// Creating a Group object
Group root = new Group(imageView);
// Creating a scene object
Scene scene = new Scene(root, 600, 400);
// Setting title to the Stage
stage.setTitle("Loading an image");
// Adding scene to the stage
stage.setScene(scene);
// Displaying the contents of the stage
stage.show();
}
public WritableImage loadAndConvert() throws Exception {
// Loading the OpenCV core library
System.loadLibrary( Core.NATIVE_LIBRARY_NAME );
// Instantiating the Imgcodecs class
Imgcodecs imageCodecs = new Imgcodecs();
// File input = new File("C:/EXAMPLES/OpenCV/sample.jpg");
String input = "C:/EXAMPLES/OpenCV/sample.jpg";
// Reading the image
Mat src = imageCodecs.imread(input);
// Creating the destination matrix
Mat dst = new Mat();
// Converting to binary image...
Imgproc.threshold(src, dst, 200, 500, Imgproc.THRESH_BINARY);
// Extracting data from the transformed image (dst)
byte[] data1 = new byte[dst.rows() * dst.cols() * (int)(dst.elemSize())];
dst.get(0, 0, data1);
// Creating Buffered image using the data
BufferedImage bufImage = new BufferedImage(dst.cols(),dst.rows(),
BufferedImage.TYPE_BYTE_GRAY);
// Setting the data elements to the image
bufImage.getRaster().setDataElements(0, 0, dst.cols(), dst.rows(), data1);
// Creating a Writable image
WritableImage writableImage = SwingFXUtils.toFXImage(bufImage, null);
System.out.println("Converted to binary");
return writableImage;
}
public static void main(String args[]) throws Exception {
launch(args);
}
}
Input Image
假設下面是上面程序中指定的輸入圖像sample.jpg。
Output Image
在執行程序時，您將得到以下輸出。
OpenCV - Grayscale to Binary
可以使用上一章中提到的相同方法將灰度圖像轉換爲二進位圖像。只需將灰度圖像的路徑作爲輸入傳遞給此程序。
Example
下面的程序演示如何將灰度圖像讀取爲二進位圖像並使用JavaFX窗口顯示它。
import java.awt.image.BufferedImage;
import org.opencv.core.Core;
import org.opencv.core.Mat;
import org.opencv.imgcodecs.Imgcodecs;
import org.opencv.imgproc.Imgproc;
import javafx.application.Application;
import javafx.embed.swing.SwingFXUtils;
import javafx.scene.Group;
import javafx.scene.Scene;
import javafx.scene.image.ImageView;
import javafx.scene.image.WritableImage;
import javafx.stage.Stage;
public class GrayScaleToBinary extends Application {
@Override
public void start(Stage stage) throws Exception {
WritableImage writableImage = loadAndConvert();
// Setting the image view
ImageView imageView = new ImageView(writableImage);
// Setting the position of the image
imageView.setX(10);
imageView.setY(10);
// Setting the fit height and width of the image view
imageView.setFitHeight(400);
imageView.setFitWidth(600);
// Setting the preserve ratio of the image view
imageView.setPreserveRatio(true);
// Creating a Group object
Group root = new Group(imageView);
// Creating a scene object
Scene scene = new Scene(root, 600, 400);
// Setting title to the Stage
stage.setTitle("Grayscale to binary image");
// Adding scene to the stage
stage.setScene(scene);
// Displaying the contents of the stage
stage.show();
}
public WritableImage loadAndConvert() throws Exception {
// Loading the OpenCV core library
System.loadLibrary( Core.NATIVE_LIBRARY_NAME );
// Instantiating the imagecodecs class
Imgcodecs imageCodecs = new Imgcodecs();
String input = "E:/OpenCV/chap7/grayscale.jpg";
// Reading the image
Mat src = imageCodecs.imread(input);
// Creating the destination matrix
Mat dst = new Mat();
// Converting to binary image...
Imgproc.threshold(src, dst, 200, 500, Imgproc.THRESH_BINARY);
// Extracting data from the transformed image (dst)
byte[] data1 = new byte[dst.rows() * dst.cols() * (int)(dst.elemSize())];
dst.get(0, 0, data1);
// Creating Buffered image using the data
BufferedImage bufImage = new BufferedImage(dst.cols(),dst.rows(),
BufferedImage.TYPE_BYTE_BINARY);
// Setting the data elements to the image
bufImage.getRaster().setDataElements(0, 0, dst.cols(), dst.rows(), data1);
// Creating a Writable image
WritableImage writableImage = SwingFXUtils.toFXImage(bufImage, null);
System.out.println("Converted to binary");
return writableImage;
}
public static void main(String args[]) throws Exception {
launch(args);
}
}
Input Image
假設下面是上面程序中指定的輸入圖像sample.jpg。
Output Image
在執行程序時，您將得到以下輸出。
OpenCV - Drawing a Circle
您可以使用org.opencv.imgproc包的相應方法在圖像上繪製各種形狀，如圓、矩形、直線、橢圓、多段線、凸、多段線、多段線。
您可以使用imgproc類的circle（）方法在圖像上繪製圓。下面是這個方法的語法−
circle(img, center, radius, color, thickness)
此方法接受以下參數&負;
mat−Amat表示要在其上繪製圓的圖像的對象。
點−A點表示圓中心的對象。
radius−表示圓半徑的整型變量。
標量−A標量表示圓顏色的對象。（BGR）
thickness−Aninteger表示圓的厚度;默認情況下，thickness的值爲1。
Example
下面的程序演示如何在圖像上畫一個圓，並使用JavaFX窗口顯示它。
import java.awt.image.BufferedImage;
import java.io.ByteArrayInputStream;
import java.io.InputStream;
import javax.imageio.ImageIO;
import javafx.application.Application;
import javafx.embed.swing.SwingFXUtils;
import javafx.scene.Group;
import javafx.scene.Scene;
import javafx.scene.image.ImageView;
import javafx.scene.image.WritableImage;
import javafx.stage.Stage;
import org.opencv.core.Core;
import org.opencv.core.Mat;
import org.opencv.core.MatOfByte;
import org.opencv.core.Point;
import org.opencv.core.Scalar;
import org.opencv.imgcodecs.Imgcodecs;
import org.opencv.imgproc.Imgproc;
public class DrawingCircle extends Application {
Mat matrix = null;
@Override
public void start(Stage stage) throws Exception {
// Capturing the snapshot from the camera
DrawingCircle obj = new DrawingCircle();
WritableImage writableImage = obj.LoadImage();
// Setting the image view
ImageView imageView = new ImageView(writableImage);
// setting the fit height and width of the image view
imageView.setFitHeight(600);
imageView.setFitWidth(600);
// Setting the preserve ratio of the image view
imageView.setPreserveRatio(true);
// Creating a Group object
Group root = new Group(imageView);
// Creating a scene object
Scene scene = new Scene(root, 600, 400);
// Setting title to the Stage
stage.setTitle("Drawing Circle on the image");
// Adding scene to the stage
stage.setScene(scene);
// Displaying the contents of the stage
stage.show();
}
public WritableImage LoadImage() throws Exception {
// Loading the OpenCV core library
System.loadLibrary( Core.NATIVE_LIBRARY_NAME );
// Reading the Image from the file and storing it in to a Matrix object
String file ="E:/OpenCV/chap8/input.jpg";
Mat matrix = Imgcodecs.imread(file);
//Drawing a Circle
Imgproc.circle (
matrix, //Matrix obj of the image
new Point(230, 160), //Center of the circle
100, //Radius
new Scalar(0, 0, 255), //Scalar object for color
10 //Thickness of the circle
);
// Encoding the image
MatOfByte matOfByte = new MatOfByte();
Imgcodecs.imencode(".jpg", matrix, matOfByte);
// Storing the encoded Mat in a byte array
byte[] byteArray = matOfByte.toArray();
// Displaying the image
InputStream in = new ByteArrayInputStream(byteArray);
BufferedImage bufImage = ImageIO.read(in);
this.matrix = matrix;
// Creating the Writable Image
WritableImage writableImage = SwingFXUtils.toFXImage(bufImage, null);
return writableImage;
}
public static void main(String args[]) {
launch(args);
}
}
在執行上述程序時，您將得到以下輸出&負;
OpenCV - Drawing a Line
You can draw a line on an image using the method line() of the imgproc class. 下面是這個方法的語法。
line(img, pt1, pt2, color, thickness)
此方法接受以下參數&負;
mat−Amat表示要在其上繪製線的圖像的對象。
pt1和pt2−兩個點對象，表示要繪製直線的點。
標量−A標量表示圓顏色的對象。（BGR）
thickness−一個表示線條粗細的整數;默認情況下，thickness的值爲1。
Example
下面的程序演示如何在圖像上畫一條線並使用JavaFX窗口顯示它。
import java.awt.image.BufferedImage;
import java.io.ByteArrayInputStream;
import java.io.InputStream;
import javax.imageio.ImageIO;
import javafx.application.Application;
import javafx.embed.swing.SwingFXUtils;
import javafx.scene.Group;
import javafx.scene.Scene;
import javafx.scene.image.ImageView;
import javafx.scene.image.WritableImage;
import javafx.stage.Stage;
import org.opencv.core.Core;
import org.opencv.core.Mat;
import org.opencv.core.MatOfByte;
import org.opencv.core.Point;
import org.opencv.core.Scalar;
import org.opencv.imgcodecs.Imgcodecs;
import org.opencv.imgproc.Imgproc;
public class DrawingLine extends Application {
Mat matrix = null;
@Override
public void start(Stage stage) throws Exception {
// Capturing the snapshot from the camera
DrawingLine obj = new DrawingLine();
WritableImage writableImage = obj.LoadImage();
// Setting the image view
ImageView imageView = new ImageView(writableImage);
// setting the fit height and width of the image view
imageView.setFitHeight(600);
imageView.setFitWidth(600);
// Setting the preserve ratio of the image view
imageView.setPreserveRatio(true);
// Creating a Group object
Group root = new Group(imageView);
// Creating a scene object
Scene scene = new Scene(root, 600, 400);
// Setting title to the Stage
stage.setTitle("Drawing a line on the image");
// Adding scene to the stage
stage.setScene(scene);
// Displaying the contents of the stage
stage.show();
}
public WritableImage LoadImage() throws Exception {
// Loading the OpenCV core library
System.loadLibrary( Core.NATIVE_LIBRARY_NAME );
// Reading the Image from the file and storing it in to a Matrix object
String file ="E:/OpenCV/chap8/input.jpg";
Mat matrix = Imgcodecs.imread(file);
// Drawing a line
Imgproc.line (
matrix, //Matrix obj of the image
new Point(10, 200), //p1
new Point(300, 200), //p2
new Scalar(0, 0, 255), //Scalar object for color
5 //Thickness of the line
);
// Encoding the image
MatOfByte matOfByte = new MatOfByte();
Imgcodecs.imencode(".jpg", matrix, matOfByte);
// Storing the encoded Mat in a byte array
byte[] byteArray = matOfByte.toArray();
// Displaying the image
InputStream in = new ByteArrayInputStream(byteArray);
BufferedImage bufImage = ImageIO.read(in);
this.matrix = matrix;
// Creating the Writable Image
WritableImage writableImage = SwingFXUtils.toFXImage(bufImage, null);
return writableImage;
}
public static void main(String args[]) {
launch(args);
}
}
在執行上述程序時，您將得到以下輸出&負;
OpenCV - Drawing a Rectangle
可以使用imgproc類的方法rectangle（）在圖像上繪製矩形。下面是這個方法的語法−
rectangle(img, pt1, pt2, color, thickness)
此方法接受以下參數&負;
mat−Amat表示要在其上繪製矩形的圖像的對象。
pt1和pt2−兩個點對象，表示要繪製的矩形的頂點。
標量−A標量表示矩形顏色的對象。（BGR）
thickness−表示矩形厚度的整數;默認情況下，thickness的值爲1。
Example
下面的示例演示如何在圖像上繪製矩形並使用JavaFX窗口顯示它。
import java.awt.image.BufferedImage;
import java.io.ByteArrayInputStream;
import java.io.InputStream;
import javax.imageio.ImageIO;
import javafx.application.Application;
import javafx.embed.swing.SwingFXUtils;
import javafx.scene.Group;
import javafx.scene.Scene;
import javafx.scene.image.ImageView;
import javafx.scene.image.WritableImage;
import javafx.stage.Stage;
import org.opencv.core.Core;
import org.opencv.core.Mat;
import org.opencv.core.MatOfByte;
import org.opencv.core.Point;
import org.opencv.core.Scalar;
import org.opencv.imgcodecs.Imgcodecs;
import org.opencv.imgproc.Imgproc;
public class DrawingRectangle extends Application {
Mat matrix = null;
@Override
public void start(Stage stage) throws Exception {
// Capturing the snapshot from the camera
DrawingRectangle obj = new DrawingRectangle();
WritableImage writableImage = obj.LoadImage();
// Setting the image view
ImageView imageView = new ImageView(writableImage);
// setting the fit height and width of the image view
imageView.setFitHeight(600);
imageView.setFitWidth(600);
// Setting the preserve ratio of the image view
imageView.setPreserveRatio(true);
// Creating a Group object
Group root = new Group(imageView);
// Creating a scene object
Scene scene = new Scene(root, 600, 400);
// Setting title to the Stage
stage.setTitle("Drawing Rectangle on the image");
// Adding scene to the stage
stage.setScene(scene);
// Displaying the contents of the stage
stage.show();
}
public WritableImage LoadImage() throws Exception {
// Loading the OpenCV core library
System.loadLibrary( Core.NATIVE_LIBRARY_NAME );
// Reading the Image from the file and storing it in to a Matrix object
String file ="E:/OpenCV/chap8/input.jpg";
Mat matrix = Imgcodecs.imread(file);
// Drawing a Rectangle
Imgproc.rectangle (
matrix, //Matrix obj of the image
new Point(130, 50), //p1
new Point(300, 280), //p2
new Scalar(0, 0, 255), //Scalar object for color
5 //Thickness of the line
);
// Encoding the image
MatOfByte matOfByte = new MatOfByte();
Imgcodecs.imencode(".jpg", matrix, matOfByte);
// Storing the encoded Mat in a byte array
byte[] byteArray = matOfByte.toArray();
// Displaying the image
InputStream in = new ByteArrayInputStream(byteArray);
BufferedImage bufImage = ImageIO.read(in);
this.matrix = matrix;
// Creating the Writable Image
WritableImage writableImage = SwingFXUtils.toFXImage(bufImage, null);
return writableImage;
}
public static void main(String args[]) {
launch(args);
}
}
在執行上述程序時，您將得到以下輸出&負;
OpenCV - Drawing an Ellipse
可以使用imgproc類的方法rectangle（）在圖像上繪製橢圓。下面是這個方法的語法−
ellipse(img, box, color, thickness)
此方法接受以下參數&負;
mat−Amat表示要在其上繪製矩形的圖像的對象。
框−一個RotatedRect對象（橢圓內接在此矩形中。）
標量−A標量表示矩形顏色的對象。（BGR）
thickness−表示矩形厚度的整數;默認情況下，thickness的值爲1。
類的構造函數接受類的對象、類大小的對象和double類型的變量，如下所示。
RotatedRect(Point c, Size s, double a)
Example
下面的程序演示如何在圖像上繪製橢圓並使用JavaFX窗口顯示它。
import java.awt.image.BufferedImage;
import java.io.ByteArrayInputStream;
import java.io.InputStream;
import javax.imageio.ImageIO;
import javafx.application.Application;
import javafx.embed.swing.SwingFXUtils;
import javafx.scene.Group;
import javafx.scene.Scene;
import javafx.scene.image.ImageView;
import javafx.scene.image.WritableImage;
import javafx.stage.Stage;
import org.opencv.core.Core;
import org.opencv.core.Mat;
import org.opencv.core.MatOfByte;
import org.opencv.core.Point;
import org.opencv.core.RotatedRect;
import org.opencv.core.Scalar;
import org.opencv.core.Size;
import org.opencv.imgcodecs.Imgcodecs;
import org.opencv.imgproc.Imgproc;
public class DrawingEllipse extends Application {
Mat matrix = null;
@Override
public void start(Stage stage) throws Exception {
// Capturing the snapshot from the camera
DrawingEllipse obj = new DrawingEllipse();
WritableImage writableImage = obj.LoadImage();
// Setting the image view
ImageView imageView = new ImageView(writableImage);
// setting the fit height and width of the image view
imageView.setFitHeight(600);
imageView.setFitWidth(600);
// Setting the preserve ratio of the image view
imageView.setPreserveRatio(true);
// Creating a Group object
Group root = new Group(imageView);
// Creating a scene object
Scene scene = new Scene(root, 600, 400);
// Setting title to the Stage
stage.setTitle("Drawing Ellipse on the image");
// Adding scene to the stage
stage.setScene(scene);
// Displaying the contents of the stage
stage.show();
}
public WritableImage LoadImage() throws Exception {
// Loading the OpenCV core library
System.loadLibrary( Core.NATIVE_LIBRARY_NAME );
// Reading the Image from the file and storing it in to a Matrix object
String file ="E:/OpenCV/chap8/input.jpg";
Mat matrix = Imgcodecs.imread(file);
// Drawing an Ellipse
Imgproc.ellipse (
matrix, //Matrix obj of the image
new RotatedRect ( // RotatedRect(Point c, Size s, double a)
new Point(200, 150),
new Size(260, 180), 180
),
new Scalar(0, 0, 255), //Scalar object for color
10 //Thickness of the line
);
// Encoding the image
MatOfByte matOfByte = new MatOfByte();
Imgcodecs.imencode(".jpg", matrix, matOfByte);
// Storing the encoded Mat in a byte array
byte[] byteArray = matOfByte.toArray();
// Displaying the image
InputStream in = new ByteArrayInputStream(byteArray);
BufferedImage bufImage = ImageIO.read(in);
this.matrix = matrix;
// Creating the Writable Image
WritableImage writableImage = SwingFXUtils.toFXImage(bufImage, null);
return writableImage;
}
public static void main(String args[]) {
launch(args);
}
}
在執行上述程序時，您將得到以下輸出&負;
OpenCV - Drawing Polylines
You can draw Polylines on an image using the method polylines() of the imgproc class. 下面是這個方法的語法。
polylines(img, pts, isClosed, color, thickness)
此方法接受以下參數&負;
mat−Amat表示要在其上繪製多段線的圖像的對象。
pts−AList包含類型爲MatOfPoint的對象的對象。
isClosed−布爾型參數，指定多段線是否閉合。
標量−A標量表示多段線顏色的對象。（BGR）
厚度−表示多段線厚度的整數;默認情況下，厚度值爲1。
類的構造函數接受類的對象。
MatOfPoint(Point... a)
Example
下面的程序演示如何在圖像上繪製多段線並使用JavaFX窗口顯示它。
import java.awt.image.BufferedImage;
import java.io.ByteArrayInputStream;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.List;
import javax.imageio.ImageIO;
import javafx.application.Application;
import javafx.embed.swing.SwingFXUtils;
import javafx.scene.Group;
import javafx.scene.Scene;
import javafx.scene.image.ImageView;
import javafx.scene.image.WritableImage;
import javafx.stage.Stage;
import org.opencv.core.Core;
import org.opencv.core.Mat;
import org.opencv.core.MatOfByte;
import org.opencv.core.MatOfPoint;
import org.opencv.core.Point;
import org.opencv.core.Scalar;
import org.opencv.imgcodecs.Imgcodecs;
import org.opencv.imgproc.Imgproc;
public class DrawingPolyLines extends Application {
Mat matrix = null;
@Override
public void start(Stage stage) throws Exception {
// Capturing the snapshot from the camera
DrawingPolyLines obj = new DrawingPolyLines();
WritableImage writableImage = obj.LoadImage();
// Setting the image view
ImageView imageView = new ImageView(writableImage);
// setting the fit height and width of the image view
imageView.setFitHeight(600);
imageView.setFitWidth(600);
// Setting the preserve ratio of the image view
imageView.setPreserveRatio(true);
// Creating a Group object
Group root = new Group(imageView);
// Creating a scene object
Scene scene = new Scene(root, 600, 400);
// Setting title to the Stage
stage.setTitle("Drawing Polylines on the image");
// Adding scene to the stage
stage.setScene(scene);
// Displaying the contents of the stage
stage.show();
}
public WritableImage LoadImage() throws Exception {
// Loading the OpenCV core library
System.loadLibrary( Core.NATIVE_LIBRARY_NAME );
// Reading the Image from the file and storing it in to a Matrix object
String file ="E:/OpenCV/chap8/input.jpg";
Mat matrix = Imgcodecs.imread(file);
List<MatOfPoint> list = new ArrayList();
list.add(
new MatOfPoint (
new Point(75, 100), new Point(350, 100),
new Point(75, 150), new Point(350, 150),
new Point(75, 200), new Point(350, 200),
new Point(75, 250), new Point(350, 250)
)
);
// Drawing polylines
Imgproc.polylines (
matrix, // Matrix obj of the image
list, // java.util.List<MatOfPoint> pts
false, // isClosed
new Scalar(0, 0, 255), // Scalar object for color
2 // Thickness of the line
);
// Encoding the image
MatOfByte matOfByte = new MatOfByte();
Imgcodecs.imencode(".jpg", matrix, matOfByte);
// Storing the encoded Mat in a byte array
byte[] byteArray = matOfByte.toArray();
// Displaying the image
InputStream in = new ByteArrayInputStream(byteArray);
BufferedImage bufImage = ImageIO.read(in);
this.matrix = matrix;
// Creating the Writable Image
WritableImage writableImage = SwingFXUtils.toFXImage(bufImage, null);
return writableImage;
}
public static void main(String args[]) {
launch(args);
}
}
在執行上述程序時，您將得到以下輸出&負;
OpenCV - Drawing Convex Polylines
You can draw convex polylines on an image using the method fillconvexPoly() of the imgproc class. 下面是這個方法的語法。
fillConvexPoly(Mat img, MatOfPoint points, Scalar color)
此方法接受以下參數&負;
mat−Amat表示要在其上繪製凸多段線的圖像的對象。
點−AMatOfPoint表示要在其之間繪製凸多段線的點的對象。
標量−A標量表示凸多段線顏色的對象。（BGR）
類的構造函數接受類的對象。
MatOfPoint(Point... a)
Example
下面的程序演示如何在圖像上繪製凸多段線並使用JavaFX窗口顯示它。
import java.awt.image.BufferedImage;
import java.io.ByteArrayInputStream;
import java.io.InputStream;
import javax.imageio.ImageIO;
import javafx.application.Application;
import javafx.embed.swing.SwingFXUtils;
import javafx.scene.Group;
import javafx.scene.Scene;
import javafx.scene.image.ImageView;
import javafx.scene.image.WritableImage;
import javafx.stage.Stage;
import org.opencv.core.Core;
import org.opencv.core.Mat;
import org.opencv.core.MatOfByte;
import org.opencv.core.MatOfPoint;
import org.opencv.core.Point;
import org.opencv.core.Scalar;
import org.opencv.imgcodecs.Imgcodecs;
import org.opencv.imgproc.Imgproc;
public class FillConvexPoly extends Application {
Mat matrix = null;
@Override
public void start(Stage stage) throws Exception {
// Capturing the snapshot from the camera
FillConvexPoly obj = new FillConvexPoly();
WritableImage writableImage = obj.LoadImage();
// Setting the image view
ImageView imageView = new ImageView(writableImage);
// setting the fit height and width of the image view
imageView.setFitHeight(600);
imageView.setFitWidth(600);
//Setting the preserve ratio of the image view
imageView.setPreserveRatio(true);
// Creating a Group object
Group root = new Group(imageView);
// Creating a scene object
Scene scene = new Scene(root, 600, 400);
// Setting title to the Stage
stage.setTitle("Drawing convex Polylines (fill) on the image");
// Adding scene to the stage
stage.setScene(scene);
// Displaying the contents of the stage
stage.show();
}
public WritableImage LoadImage() throws Exception {
// Loading the OpenCV core library
System.loadLibrary( Core.NATIVE_LIBRARY_NAME );
// Reading the Image from the file and storing it in to a Matrix object
String file ="E:/OpenCV/chap8/input.jpg";
Mat matrix = Imgcodecs.imread(file);
MatOfPoint matOfPoint = new MatOfPoint (
new Point(75, 100), new Point(350, 100),
new Point(75, 150), new Point(350, 150),
new Point(75, 200), new Point(350, 200),
new Point(75, 250), new Point(350, 250)
);
// Drawing polylines
Imgproc.fillConvexPoly (
matrix, // Matrix obj of the image
matOfPoint, // java.util.List<MatOfPoint> pts
new Scalar(0, 0, 255) // Scalar object for color
);
// Encoding the image
MatOfByte matOfByte = new MatOfByte();
Imgcodecs.imencode(".jpg", matrix, matOfByte);
// Storing the encoded Mat in a byte array
byte[] byteArray = matOfByte.toArray();
// Displaying the image
InputStream in = new ByteArrayInputStream(byteArray);
BufferedImage bufImage = ImageIO.read(in);
this.matrix = matrix;
// Creating the Writable Image
WritableImage writableImage = SwingFXUtils.toFXImage(bufImage, null);
return writableImage;
}
public static void main(String args[]) {
launch(args);
}
}
在執行上述程序時，您將得到以下輸出&負;
OpenCV - Drawing Arrowed Lines
您可以使用imgproc類的arrowed line（）方法在圖像上繪製一條帶箭頭的線。下面是這個方法的語法−
arrowedLine(Mat img, Point pt1, Point pt2, Scalar color)
此方法接受以下參數&負;
mat−Amat表示要在其上繪製箭頭線的圖像的對象。
pt1和pt2−兩個點對象，表示要繪製箭頭線的點。
標量−A標量表示箭頭線顏色的對象。（BGR）
Example
下面的程序演示如何在圖像上繪製箭頭線並使用JavaFX窗口顯示它。
import java.awt.image.BufferedImage;
import java.io.ByteArrayInputStream;
import java.io.InputStream;
import javax.imageio.ImageIO;
import javafx.application.Application;
import javafx.embed.swing.SwingFXUtils;
import javafx.scene.Group;
import javafx.scene.Scene;
import javafx.scene.image.ImageView;
import javafx.scene.image.WritableImage;
import javafx.stage.Stage;
import org.opencv.core.Core;
import org.opencv.core.Mat;
import org.opencv.core.MatOfByte;
import org.opencv.core.Point;
import org.opencv.core.Scalar;
import org.opencv.imgcodecs.Imgcodecs;
import org.opencv.imgproc.Imgproc;
public class DrawingArrowedLine extends Application {
Mat matrix = null;
@Override
public void start(Stage stage) throws Exception {
// Capturing the snapshot from the camera
DrawingArrowedLine obj = new DrawingArrowedLine();
WritableImage writableImage = obj.LoadImage();
// Setting the image view
ImageView imageView = new ImageView(writableImage);
// setting the fit height and width of the image view
imageView.setFitHeight(600);
imageView.setFitWidth(600);
// Setting the preserve ratio of the image view
imageView.setPreserveRatio(true);
// Creating a Group object
Group root = new Group(imageView);
// Creating a scene object
Scene scene = new Scene(root, 600, 400);
// Setting title to the Stage
stage.setTitle("Drawing a line on the image");
// Adding scene to the stage
stage.setScene(scene);
// Displaying the contents of the stage
stage.show();
}
public WritableImage LoadImage() throws Exception {
// Loading the OpenCV core library
System.loadLibrary( Core.NATIVE_LIBRARY_NAME );
// Reading the Image from the file and storing it in to a Matrix object
String file ="C:/EXAMPLES/OpenCV/Aish.jpg";
Mat matrix = Imgcodecs.imread(file);
//Drawing a line
Imgproc.arrowedLine(
matrix, // Matrix obj of the image
new Point(10, 200), // p1
new Point(590, 200), // p2
new Scalar(0, 100, 255) // Scalar object for color
);
// arrowedLine(Mat img, Point pt1, Point pt2, Scalar color)
// Encoding the image
MatOfByte matOfByte = new MatOfByte();
Imgcodecs.imencode(".jpg", matrix, matOfByte);
// Storing the encoded Mat in a byte array
byte[] byteArray = matOfByte.toArray();
// Displaying the image
InputStream in = new ByteArrayInputStream(byteArray);
BufferedImage bufImage = ImageIO.read(in);
this.matrix = matrix;
// Creating the Writable Image
WritableImage writableImage = SwingFXUtils.toFXImage(bufImage, null);
return writableImage;
}
public static void main(String args[]) {
launch(args);
}
}
在執行上述程序時，您將得到以下輸出&負;
OpenCV - Adding Text
You can add text to an image using the method arrowedLine() of the imgproc class. 下面是這個方法的語法。
putText(img, text, org, fontFace, fontScale, Scalar color, int thickness)
此方法接受以下參數&負;
mat−Amat表示要添加文本的圖像的對象。
文本−A字符串表示要添加的文本的變量。
org−APoint表示圖像左下角文本字符串的對象。
字體−表示字體類型的整型變量。
font scale−double類型的變量，表示乘以字體特定基大小的比例因子。
scalar−Ascalar對象，表示要添加的文本的顏色。（BGR）
thickness−默認情況下，表示線條厚度的整數，thickness的值爲1。
Example
下面的程序演示如何將文本添加到圖像並使用JavaFX窗口顯示它。
import java.awt.image.BufferedImage;
import java.io.ByteArrayInputStream;
import java.io.InputStream;
import javax.imageio.ImageIO;
import javafx.application.Application;
import javafx.embed.swing.SwingFXUtils;
import javafx.scene.Group;
import javafx.scene.Scene;
import javafx.scene.image.ImageView;
import javafx.scene.image.WritableImage;
import javafx.stage.Stage;
import org.opencv.core.Core;
import org.opencv.core.Mat;
import org.opencv.core.MatOfByte;
import org.opencv.core.Point;
import org.opencv.core.Scalar;
import org.opencv.imgcodecs.Imgcodecs;
import org.opencv.imgproc.Imgproc;
public class AddingTextToImage extends Application {
Mat matrix = null;
@Override
public void start(Stage stage) throws Exception {
// Capturing the snapshot from the camera
AddingTextToImage obj = new AddingTextToImage();
WritableImage writableImage = obj.LoadImage();
// Setting the image view
ImageView imageView = new ImageView(writableImage);
// setting the fit height and width of the image view
imageView.setFitHeight(600);
imageView.setFitWidth(600);
// Setting the preserve ratio of the image view
imageView.setPreserveRatio(true);
// Creating a Group object
Group root = new Group(imageView);
// Creating a scene object
Scene scene = new Scene(root, 600, 400);
// Setting title to the Stage
stage.setTitle("Adding text to an image");
// Adding scene to the stage
stage.setScene(scene);
// Displaying the contents of the stage
stage.show();
}
public WritableImage LoadImage() throws Exception {
// Loading the OpenCV core library
System.loadLibrary( Core.NATIVE_LIBRARY_NAME );
// Reading the Image from the file and storing it in to a Matrix object
String file ="E:/OpenCV/chap8/input.jpg";
Mat matrix = Imgcodecs.imread(file);
// Adding Text
Imgproc.putText (
matrix, // Matrix obj of the image
"Ravivarma's Painting", // Text to be added
new Point(10, 50), // point
Core.FONT_HERSHEY_SIMPLEX , // front face
1, // front scale
new Scalar(0, 0, 0), // Scalar object for color
4 // Thickness
);
// Encoding the image
MatOfByte matOfByte = new MatOfByte();
Imgcodecs.imencode(".jpg", matrix, matOfByte);
// Storing the encoded Mat in a byte array
byte[] byteArray = matOfByte.toArray();
// Displaying the image
InputStream in = new ByteArrayInputStream(byteArray);
BufferedImage bufImage = ImageIO.read(in);
this.matrix = matrix;
//Creating the Writable Image
WritableImage writableImage = SwingFXUtils.toFXImage(bufImage, null);
return writableImage;
}
public static void main(String args[]) {
launch(args);
}
}
在執行上述程序時，您將得到以下輸出&負;
OpenCV - Blur (Averaging)
模糊（平滑）是降低圖像噪聲的常用圖像處理方法。這個過程去除圖像中的高頻內容，如邊緣，並使其平滑。
一般來說，模糊是通過低通濾波核卷積圖像（圖像的每個元素被添加到其局部鄰域，由核加權）來實現的。
Blur (Averaging)
在這個操作中，圖像被一個盒子過濾器卷積（標準化）。在這個過程中，圖像的中心元素被核心區域中所有像素的平均值所代替。
您可以使用imgproc類的blur（）方法對圖像執行此操作。下面是這個方法的語法−
blur(src, dst, ksize, anchor, borderType)
此方法接受以下參數&負;
src−AMat對象，表示此操作的源（輸入圖像）。
dst−AMat表示此操作的目標（輸出圖像）的對象。
ksize−ASize表示內核大小的對象。
錨點−整數類型的變量，表示錨點。
border type−整數類型的變量，表示要用於輸出的邊框類型。
Example
下面的程序演示如何對圖像執行平均（模糊）操作。
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");
}
}
假設下面是上面程序中指定的輸入圖像sample.jpg。
Output
在執行程序時，您將得到以下輸出&負;
Image Processed
如果您打開指定的路徑，您可以按以下方式觀察輸出圖像−
OpenCV - Gaussian Blur
在高斯模糊運算中，圖像被高斯濾波器卷積而不是盒濾波器卷積。高斯濾波器是一種去除高頻分量的低通濾波器。
您可以使用imgproc類的Gaussianblur（）方法對圖像執行此操作。下面是這個方法的語法−
GaussianBlur(src, dst, ksize, sigmaX)
此方法接受以下參數&負;
src−AMat對象，表示此操作的源（輸入圖像）。
dst−AMat表示此操作的目標（輸出圖像）的對象。
ksize−ASize表示內核大小的對象。
sigmaX−雙精度類型的變量，表示X方向上的高斯核標準差。
Example
下面的程序演示如何對圖像執行高斯模糊操作。
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");
}
}
假設下面是上面程序中指定的輸入圖像sample.jpg。
Output
在執行程序時，您將得到以下輸出&負;
Image Processed
如果您打開指定的路徑，您可以按以下方式觀察輸出圖像−
OpenCV - Median Blur
中值模糊操作類似於其他平均方法。這裡，圖像的中心元素被核心區域中所有像素的中值所代替。此操作在去除噪波的同時處理邊緣。
您可以使用imgproc類的medianBlur（）方法對圖像執行此操作。下面是這個方法的語法−
medianBlur(src, dst, ksize)
此方法接受以下參數&負;
src−AMat對象，表示此操作的源（輸入圖像）。
dst−AMat表示此操作的目標（輸出圖像）的對象。
ksize−ASize表示內核大小的對象。
Example
下面的程序演示如何對圖像執行中值模糊操作。
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");
}
}
假設下面是上面程序中指定的輸入圖像sample.jpg。
Output
在執行程序時，您將得到以下輸出&負;
Image Processed
如果您打開指定的路徑，您可以按以下方式觀察輸出圖像−
OpenCV - Bilateral Filter
圖像過濾允許您對圖像應用各種效果。在本章和隨後的三章中，我們將討論各種濾波器操作，如雙邊濾波器、盒濾波器、SQR盒濾波器和濾波器2d。
Bilateral Filter
The Bilateral Filter operation applies a bilateral image to a filter. You can perform this operation on an image using the medianBlur() method of the imgproc class. 下面是這個方法的語法。
bilateralFilter(src, dst, d, sigmaColor, sigmaSpace, borderType)
此方法接受以下參數&負;
src−AMat對象，表示此操作的源（輸入圖像）。
dst−AMat表示此操作的目標（輸出圖像）的對象。
d−整數類型的變量，表示像素鄰域的直徑。
sigma color−一個整數類型的變量，表示顏色空間中的過濾器sigma。
sigma space−一個整數類型的變量，表示坐標空間中的過濾器sigma。
borderType−表示所用邊框類型的整數對象。
Example
下面的程序演示如何對圖像執行雙邊過濾操作。
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");
}
}
假設下面是上述程序中指定的輸入圖像filter_input.jpg。
Output
在執行程序時，您將得到以下輸出&負;
Image Processed
如果您打開指定的路徑，您可以按以下方式觀察輸出圖像−
OpenCV - Box Filter
Box Filter操作類似於平均模糊操作;它將雙邊圖像應用於過濾器。在這裡，您可以選擇是否應規範化該框。
您可以使用imgproc類的boxFilter（）方法對圖像執行此操作。下面是這個方法的語法−
boxFilter(src, dst, ddepth, ksize, anchor, normalize, borderType)
此方法接受以下參數&負;
src−AMat對象，表示此操作的源（輸入圖像）。
dst−AMat表示此操作的目標（輸出圖像）的對象。
ddepth−整數類型的變量，表示輸出圖像的深度。
ksize−ASize表示模糊內核大小的對象。
錨點−整數類型的變量，表示錨點。
Normalize−類型爲boolean的變量，指定是否應規範內核。
borderType−表示所用邊框類型的整數對象。
Example
下面的程序演示如何對圖像執行Box Filter操作。
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");
}
}
假設下面是上述程序中指定的輸入圖像filter_input.jpg。
Output
在執行程序時，您將得到以下輸出&負;
Image Processed
如果您打開指定的路徑，您可以按以下方式觀察輸出圖像−
OpenCV - SQRBox Filter
您可以使用imgproc類的boxFilter（）方法對圖像執行SQRBox Filter操作。下面是這個方法的語法−
sqrBoxFilter(src, dst, ddepth, ksize)
此方法接受以下參數&負;
src−AMat對象，表示此操作的源（輸入圖像）。
dst−AMat表示此操作的目標（輸出圖像）的對象。
ddepth−整數類型的變量，表示輸出圖像的深度。
ksize−ASize表示模糊內核大小的對象。
Example
下面的程序演示如何對給定圖像執行Sqrbox篩選器操作。
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");
}
}
假設下面是上述程序中指定的輸入圖像filter_input.jpg。
Output
在執行程序時，您將得到以下輸出&負;
Image Processed
如果您打開指定的路徑，您可以按以下方式觀察輸出圖像−
OpenCV - Filter2D
Filter2D操作將圖像與內核卷積。您可以使用imgproc類的Filter2D（）方法對圖像執行此操作。下面是這個方法的語法−
filter2D(src, dst, ddepth, kernel)
此方法接受以下參數&負;
src−AMat對象，表示此操作的源（輸入圖像）。
dst−AMat表示此操作的目標（輸出圖像）的對象。
ddepth−整數類型的變量，表示輸出圖像的深度。
kernel−AMat表示卷積核的對象。
Example
下面的程序演示如何對圖像執行Filter2D操作。
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");
}
}
假設下面是上述程序中指定的輸入圖像filter_input.jpg。
Output
在執行程序時，您將得到以下輸出&負;
Image Processed
如果您打開指定的路徑，您可以按以下方式觀察輸出圖像−
OpenCV - Dilation
侵蝕和擴張是兩種形態操作。顧名思義，形態學操作是根據圖像的形狀來處理圖像的一組操作。
基於給定的輸入圖像，開發了一個「結構單元」。這可以在兩個過程中的任何一個中完成。它們的目的是消除噪音和解決缺陷，使圖像清晰。
Dilation
此過程遵循與特定形狀（如正方形或圓形）的某個核的卷積。這個內核有一個錨定點，它表示它的中心。
此內核重疊在圖片上以計算最大像素值。經過計算，圖片被替換爲中心的錨定。通過這個過程，明亮區域的面積會增大，因此圖像的大小也會增大。
例如，處於白色陰影或明亮陰影中的對象的大小會增大，而處於黑色陰影或深色陰影中的對象的大小會減小。
You can perform the dilation operation on an image using the dilate() method of the imgproc class. 下面是這個方法的語法。
dilate(src, dst, kernel)
此方法接受以下參數&負;
src−AMat對象，表示此操作的源（輸入圖像）。
dst−AMat表示此操作的目標（輸出圖像）的對象。
kernel−AMat表示內核的對象。
Example
您可以使用getStructuringElement（）方法準備內核矩陣。此方法接受表示變形類型的整數和大小類型的對象。
Imgproc.getStructuringElement(int shape, Size ksize);
下面的程序演示如何對給定的圖像執行膨脹操作。
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");
}
}
Input
假設下面是上面程序中指定的輸入圖像sample.jpg。
Output
在執行程序時，您將得到以下輸出&負;
Image Processed
如果您打開指定的路徑，您可以按以下方式觀察輸出圖像−
OpenCV - Erosion
侵蝕和膨脹是相當相似的過程。但是這裡計算的像素值是最小的而不是最大的。圖像將用該最小像素值替換定位點下的圖像。
通過這個過程，暗區域的面積會增大，亮區域會減小。例如，在深色或黑色陰影中對象的大小會增加，而在白色陰影或亮陰影中對象的大小會減小。
Example
您可以使用imgproc類的elegate（）方法對圖像執行此操作。下面是這個方法的語法−
erode(src, dst, kernel)
此方法接受以下參數&負;
src−AMat對象，表示此操作的源（輸入圖像）。
dst−AMat表示此操作的目標（輸出圖像）的對象。
kernel−AMat表示內核的對象。
您可以使用getStructuringElement（）方法準備內核矩陣。此方法接受表示變形類型的整數和大小類型的對象。
Imgproc.getStructuringElement(int shape, Size ksize);
以下程序演示如何對給定圖像執行侵蝕操作。
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");
}
}
假設下面是上面程序中指定的輸入圖像sample.jpg。
Output
在執行程序時，您將得到以下輸出&負;
Image Loaded
如果您打開指定的路徑，您可以按以下方式觀察輸出圖像−
OpenCV - Morphological Operations
在前面的章節中，我們討論了侵蝕和膨脹的過程。除此之外，OpenCV還有更多的形態轉換。類Imgproc方法的morphologyEx（）用於對給定圖像執行這些操作。
下面是這個方法的語法−
morphologyEx(src, dst, op, kernel)
此方法接受以下參數&負;
src−類的對象表示源（輸入）圖像。
dst−類的對象表示目標（輸出）圖像。
op−表示形態學操作類型的整數。
核矩陣。
Example
下面的程序演示如何使用OpenCV庫對圖像應用形態學操作。
import org.opencv.core.Core;
import org.opencv.core.CvType;
import org.opencv.core.Mat;
import org.opencv.imgcodecs.Imgcodecs;
import org.opencv.imgproc.Imgproc;
public class MorphologyExTest {
public static void main(String args[]) {
// Loading the OpenCV core library
System.loadLibrary( Core.NATIVE_LIBRARY_NAME );
// Reading the Image from the file and storing it in to a Matrix object
String file ="E:/OpenCV/chap12/morph_input.jpg";
Mat src = Imgcodecs.imread(file);
// Creating an empty matrix to store the result
Mat dst = new Mat();
// Creating kernel matrix
Mat kernel = Mat.ones(5,5, CvType.CV_32F);
// Applying Blur effect on the Image
Imgproc.morphologyEx(src, dst, Imgproc.MORPH_TOPHAT, kernel);
// Writing the image
Imgcodecs.imwrite("E:/OpenCV/chap12/morph_tophat.jpg", dst);
System.out.println("Image Processed");
}
}
假設下面是上面程序中指定的輸入圖像morph_input.jpg。
Output
在執行程序時，您將得到以下輸出&負;
Image Processed
如果您打開指定的路徑，您可以按以下方式觀察輸出圖像−
More Operations
除了在前面的示例中所演示的形態學操作之外，OpenCV還滿足各種其他類型的形態學。所有這些類型都由Imgproc類的預定義靜態欄位（固定值）表示。
您可以通過將它們各自的預定義值傳遞給morphologyEx（）方法的參數op來選擇所需的形態學類型。
// Applying Blur effect on the Image Imgproc.morphologyEx(src, dst, Imgproc.MORPH_TOPHAT, kernel);
以下是表示形態操作類型及其各自輸出的值。
| Operation and Description | Output |
|---|---|
| MORPH_BLACKHAT |  |
| MORPH_CLOSE |  |
| MORPH_CROSS |  |
| MORPH_DILATE |  |
| MORPH_ELLIPSE |  |
| MORPH_ERODE |  |
| MORPH_GRADIENT |  |
| MORPH_OPEN |  |
| MORPH_RECT |  |
| MORPH_TOPHAT |  |
OpenCV - Image Pyramids
金字塔是對圖像的一種操作，
首先使用特定的平滑濾波器（例如高斯、拉普拉斯）對輸入圖像進行平滑，然後對平滑後的圖像進行子採樣。
這個過程要重複多次。
在金字塔操作中，圖像的平滑度增加，解析度（大小）降低。
Pyramid Up
In Pyramid Up, the image is initially up-sampled and then blurred. You can perform Pyramid Up operation on an image using the pyrUP() method of the imgproc class. 下面是這個方法的語法−
pyrUp(src, dst, dstsize, borderType)
此方法接受以下參數&負;
src−類的對象表示源（輸入）圖像。
mat−表示目標（輸出）圖像的類對象。
size−類的對象，表示圖像要增加或減小的大小。
border type−一個整數類型的變量，表示要使用的邊框類型。
Example
下面的程序演示如何對圖像執行金字塔向上操作。
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");
}
}
假設下面是上面程序中指定的輸入圖像。
Output
在執行程序時，您將得到以下輸出&負;
Image Processed
如果您打開指定的路徑，您可以按以下方式觀察輸出圖像−
Pyramid Down
In Pyramid Down, the image is initially blurred and then down-sampled. You can perform Pyramid Down operation on an image using the pyrDown() method of the imgproc class. 下面是這個方法的語法−
pyrDown(src, dst, dstsize, borderType)
此方法接受以下參數&負;
src−類的對象表示源（輸入）圖像。
mat−表示目標（輸出）圖像的類對象。
size−類的對象，表示圖像要增加或減小的大小。
border type−一個整數類型的變量，表示要使用的邊框類型。
Example
下面的程序演示如何對圖像執行金字塔向下操作。
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");
}
}
假設下面是上面程序中指定的輸入圖像。
Output
在執行程序時，您將得到以下輸出&負;
Image Processed
如果您打開指定的路徑，您可以按以下方式觀察輸出圖像−
Mean Shift Filtering
在均值漂移金字塔運算中，對圖像進行均值漂移分割的初始步驟。
You can perform pyramid Mean Shift Filtering operation on an image using the pyrDown() method of the imgproc class. 下面是這個方法的語法。
pyrMeanShiftFiltering(src, dst, sp, sr)
此方法接受以下參數&負;
src−類的對象表示源（輸入）圖像。
mat−表示目標（輸出）圖像的類對象。
sp−雙精度類型的變量，表示空間窗口半徑。
sr−雙精度類型的變量，表示顏色窗口半徑。
Example
下面的程序演示如何對給定圖像執行均值漂移濾波操作。
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");
}
}
假設下面是上面程序中指定的輸入圖像。
Output
在執行程序時，您將得到以下輸出&負;
Image Processed
如果您打開指定的路徑，您可以按以下方式觀察輸出圖像−
OpenCV - Simple Threshold
閾值分割是一種圖像分割方法，一般用於生成二值圖像。閾值分爲簡單閾值和自適應閾值兩種。
Simple Thresholding
在簡單的閾值操作中，值大於指定閾值的像素被分配一個標準值。
You can perform simple threshold operation on an image using the method threshold() of the Imgproc class, 下面是這個方法的語法。
threshold(src, dst, thresh, maxval, type)
此方法接受以下參數&負;
src−類的對象表示源（輸入）圖像。
dst−類的對象表示目標（輸出）圖像。
thresh−表示閾值的雙精度變量。
maxval−一個雙精度變量，表示像素值大於閾值時要給定的值。
類型−一個整數類型的變量，表示要使用的閾值類型。
Example
下面的程序演示如何在OpenCV中對圖像執行簡單的閾值操作。
import org.opencv.core.Core;
import org.opencv.core.Mat;
import org.opencv.imgcodecs.Imgcodecs;
import org.opencv.imgproc.Imgproc;
public class Thresh {
public static void main(String args[]) {
// Loading the OpenCV core library
System.loadLibrary( Core.NATIVE_LIBRARY_NAME );
// Reading the Image from the file and storing it in to a Matrix object
String file ="E:/OpenCV/chap14/thresh_input.jpg";
Mat src = Imgcodecs.imread(file);
// Creating an empty matrix to store the result
Mat dst = new Mat();
Imgproc.threshold(src, dst, 50, 255, Imgproc.THRESH_BINARY);
// Writing the image
Imgcodecs.imwrite("E:/OpenCV/chap14/thresh_trunc.jpg", dst);
System.out.println("Image Processed");
}
}
假設下面是上述程序中指定的輸入圖像thresh_input.jpg。
Output
在執行程序時，您將得到以下輸出&負;
Image Processed
如果您打開指定的路徑，您可以按以下方式觀察輸出圖像−
Other types of simple thresholding
除了前面示例中演示的THRESH_BINARY操作之外，OpenCV還提供了各種其他類型的閾值操作。所有這些類型都由Imgproc類的預定義靜態欄位（固定值）表示。
通過將其各自的預定義值傳遞給threshold（）方法中名爲type的參數，可以選擇所需的閾值操作的類型。
Imgproc.threshold(src, dst, 50, 255, Imgproc.THRESH_BINARY);
下面是表示各種類型的閾值操作及其各自輸出的值。
| Operation and Description | Output |
|---|---|
| THRESH_BINARY |  |
| THRESH_BINARY_INV |  |
| THRESH_TRUNC |  |
| THRESH_TOZERO |  |
| THRESH_TOZERO_INV |  |
OpenCV - Adaptive Threshold
在簡單閾值化中，閾值是全局的，即對圖像中的所有像素都是相同的。自適應閾值是針對較小區域計算閾值的方法，因此，對於不同區域將有不同的閾值。
In OpenCV, you can perform Adaptive threshold operation on an image using the method adaptiveThreshold() of the Imgproc class. 下面是這個方法的語法。
adaptiveThreshold(src, dst, maxValue, adaptiveMethod, thresholdType, blockSize, C)
此方法接受以下參數&負;
src−類的對象表示源（輸入）圖像。
dst−類的對象表示目標（輸出）圖像。
maxValue−雙精度類型的變量，表示像素值大於閾值時要給定的值。
adaptive method−一個整數變量，表示要使用的自適應方法的類型。這將是以下兩個值之一
自適應閾值是鄰域面積的平均值。
自適應閾值是權重爲高斯窗口的鄰域值的加權和。
threshold type−整數類型的變量，表示要使用的閾值類型。
blockSize−整數類型的變量，表示用於計算閾值的像素鄰域的大小。
C−表示兩種方法中使用的常數的雙精度變量（從平均值或加權平均值中減去）。
Example
下面的程序演示如何在OpenCV中對圖像執行自適應閾值操作。在這裡，我們爲閾值方法選擇了類型二進位和類型自適應_THRESH_MEAN_C的自適應閾值。
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");
}
}
假設下面是上述程序中指定的輸入圖像thresh_input.jpg。
Output
在執行程序時，您將得到以下輸出&負;
Image Processed
如果您打開指定的路徑，您可以按以下方式觀察輸出圖像−
Other Types of Adaptive Thresholding
除了作爲自適應方法的自適應閾值平均值和作爲前一示例中演示的閾值類型的閾值二進位值之外，我們還可以選擇這兩個值的更多組合。
Imgproc.adaptiveThreshold(src, dst, 125, Imgproc.ADAPTIVE_THRESH_MEAN_C, Imgproc.THRESH_BINARY, 11, 12);
下面是表示參數adaptiveMethod和thresholdType及其各自輸出值的各種組合的值。
| adaptiveMethod / thresholdType | ADAPTIVE_THRESH_MEAN_C | ADAPTIVE_THRESH_GAUSSIAN_C: |
|---|---|---|
| THRESH_BINARY |  |
 |
| THRESH_BINARY_INV |  |
 |
OpenCV - Adding Borders
這一章教你如何蟾蜍邊界的形象。
The copyMakeBorder() Method
您可以使用名爲Core的類的方法copyMakeBorder（）將各種邊框添加到圖像中，該類屬於包org.opencv.Core。下面是此方法的語法。
copyMakeBorder(src, dst, top, bottom, left, right, borderType)
此方法接受以下參數&負;
src−類的對象表示源（輸入）圖像。
dst−類的對象表示目標（輸出）圖像。
top−整數類型的變量，表示圖像頂部邊框的長度。
bottom−整數類型的變量，表示圖像底部邊框的長度。
left−整數類型的變量，表示圖像左側邊框的長度。
right−整數類型的變量，表示圖像右側邊框的長度。
border type−整數類型的變量，表示要使用的邊框類型。
Example
下面的程序是一個示例，演示如何向給定圖像添加邊框。
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");
}
}
假設下面是上述程序中指定的輸入圖像thresh_input.jpg。
Output
在執行程序時，您將得到以下輸出&負;
Image Processed
如果您打開指定的路徑，您可以按以下方式觀察輸出圖像−
Other Types of Borders
除了上一個示例中演示的border type，border_CONSTANT之外，OpenCV還滿足各種其他類型的邊框。所有這些類型都由核心類的預定義靜態欄位（固定值）表示。
通過將其各自的預定義值傳遞給copyMakeBorder（）方法的名爲borderType的參數，可以選擇所需的閾值操作的類型。
Core.copyMakeBorder(src, dst, 20, 20, 20, 20, Core.BORDER_CONSTANT);
下面是表示各種邊界操作及其各自輸出的值。
| Operation and Description | Output |
|---|---|
| BORDER_CONSTANT |  |
| BORDER_ISOLATED |  |
| BORDER_DEFAULT |  |
| BORDER_REFLECT |  |
| BORDER_REFLECT_101 |  |
| BORDER_REFLECT101 |  |
| BORDER_REPLICATE |  |
| BORDER_WRAP |  |
OpenCV - Sobel Operator
Using the sobel operation, you can detect the edges of an image in both horizontal and vertical directions. You can apply sobel operation on an image using the method sobel(). 下面是這個方法的語法−
Sobel(src, dst, ddepth, dx, dy)
此方法接受以下參數&負;
src−類的對象表示源（輸入）圖像。
dst−類的對象表示目標（輸出）圖像。
ddepth−表示圖像深度的整數變量（-1）
dx−表示x-導數的整數變量。（0或1）
dy−表示y-導數的整數變量。（0或1）
Example
下面的程序演示如何對給定的圖像執行Sobel操作。
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");
}
}
假設下面是上面程序中指定的輸入圖像sobel_input.jpg。
Output
在執行程序時，您將得到以下輸出&負;
Image Processed
如果您打開指定的路徑，您可以按以下方式觀察輸出圖像−
sobel Variants
在將不同的值傳遞給最後一個參數（dx和dy）（介於0和1之間）時，您將得到不同的輸出&負;
// Applying sobel on the Image Imgproc.Sobel(src, dst, -1, 1, 1);
下表列出了Sobel（）方法的變量dx和dy及其各自輸出的各種值。
| X-derivative | Y-derivative | Output |
|---|---|---|
| 0 | 1 |  |
| 1 | 0 |  |
| 1 | 1 |  |
OpenCV - Scharr Operator
Scharr is also used to detect the second derivatives of an image in horizontal and vertical directions. You can perform scharr operation on an image using the method scharr(). 下面是這個方法的語法−
Scharr(src, dst, ddepth, dx, dy)
此方法接受以下參數&負;
src−類的對象表示源（輸入）圖像。
dst−類的對象表示目標（輸出）圖像。
ddepth−表示圖像深度的整數變量（-1）
dx−表示x-導數的整數變量。（0或1）
dy−表示y-導數的整數變量。（0或1）
Example
下面的程序演示如何將scharr應用於給定的圖像。
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");
}
}
假設下面是上面程序中指定的輸入圖像scharr_input.jpg。
Output
在執行它時，您將得到以下輸出&負;
Image Processed
如果您打開指定的路徑，您可以按以下方式觀察輸出圖像−
More scharr Derivatives
在將不同的值傳遞給最後一個參數（dx和dy）（介於0和1之間）時，您將得到不同的輸出&負;
// Applying scharr on the Image Imgproc.Scharr(src, dst, -1, 1, 1);
下表列出了方法scharr（）的變量dx和dy的各種值及其各自的輸出。
| X-derivative | Y-derivative | Output |
|---|---|---|
| 0 | 1 |  |
| 1 | 0 |  |
OpenCV - Laplacian Transformation
拉普拉斯算子也是一種導數算子，用來尋找圖像中的邊緣。它是一個二階導數掩模。在這個面具中，我們有兩個進一步的分類，一個是正拉普拉斯算子，另一個是負拉普拉斯算子。
與其他算子不同的是，拉普拉斯算子在任何特定方向上都不取邊，但在接下來的分類中它會取邊。
- Inward Edges
- Outward Edges
您可以使用imgproc類的Laplacian（）方法對圖像執行Laplacian Transform操作，下面是該方法的語法。
Laplacian(src, dst, ddepth)
此方法接受以下參數&負;
src−AMat對象，表示此操作的源（輸入圖像）。
dst−AMat表示此操作的目標（輸出圖像）的對象。
ddepth−整數類型的變量，表示目標圖像的深度。
Example
下面的程序演示如何對給定的圖像執行拉普拉斯變換操作。
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");
}
}
假設下面是上面程序中指定的輸入圖像laplacian_input.jpg。
Output
在執行程序時，您將得到以下輸出&負;
Image Processed
如果您打開指定的路徑，您可以按以下方式觀察輸出圖像−
OpenCV - Distance Transformation
距離變換運算符通常將二進位圖像作爲輸入。在該操作中，改變前景區域內的點的灰度強度，以使其各自的距離與最近的0值（邊界）保持距離。
You can apply distance transform in OpenCV using the method distanceTransform(). 下面是這個方法的語法。
distanceTransform(src, dst, distanceType, maskSize)
此方法接受以下參數&負;
src−類的對象表示源（輸入）圖像。
dst−類的對象表示目標（輸出）圖像。
distance type−整數類型的變量，表示要應用的距離轉換的類型。
mask size−一個整數類型的變量，表示要使用的掩碼大小。
Example
下面的程序演示如何對給定圖像執行距離轉換操作。
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");
}
}
假設下面是上面程序中指定的input imageinput.jpg。
Output
在執行程序時，您將得到以下輸出&負;
Image Processed
如果您打開指定的路徑，您可以按以下方式觀察輸出圖像−
Types of Distance Transform Operations
除了前面示例中演示的距離操作類型DIST_C之外，OpenCV還提供各種其他類型的距離轉換操作。所有這些類型都由Imgproc類的預定義靜態欄位（固定值）表示。
通過將其各自的預定義值傳遞給distance transform（）方法中名爲distance type的參數，可以選擇所需的距離變換操作的類型。
// Applying distance transform Imgproc.distanceTransform(mat, dst, Imgproc.DIST_C, 3);
下面是表示各種類型的距離變換操作及其各自輸出的值。
| Operation and Description | Output |
|---|---|
| DIST_C |  |
| DIST_L1 |  |
| DIST_L2 |  |
| DIST_LABEL_PIXEL |  |
| DIST_MASK_3 |  |
OpenCV - Using Camera
在本章中，我們將學習如何使用OpenCV使用系統攝像機捕捉幀。org.opencv.videoio包的video capture類包含使用相機捕獲視頻的類和方法。讓我們一步一步地學習如何捕捉幀−
Step 1: Load the OpenCV native library
在使用OpenCV庫編寫Java代碼時，首先需要使用load library（）加載OpenCV的本機庫。加載OpenCV本機庫，如下所示。
// Loading the core library System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
Step 2: Instantiate the video capture class
使用本教程前面提到的任何函數實例化Mat類。
// Instantiating the VideoCapture class (camera:: 0) VideoCapture capture = new VideoCapture(0);
Step 3: Read the frames
您可以使用VideoCapture類的read（）方法從相機讀取幀。此方法接受類Mat的對象來存儲讀取的幀。
// Reading the next video frame from the camera Mat matrix = new Mat(); capture.read(matrix);
Example
下面的程序演示如何使用camera捕獲一個幀並使用JavaFX窗口顯示它。它還保存捕獲的幀。
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);
}
}
Output
在執行程序時，您將得到以下輸出。
如果打開指定的路徑，可以看到保存爲jpg文件的同一幀。
OpenCV - Face Detection in a Picture
org.opencv.videoio包的video capture類包含使用系統攝像機捕獲視頻的類和方法。讓我們一步一步地學習怎麼做。
Step 1: Load the OpenCV native library
在使用OpenCV庫編寫Java代碼時，首先需要使用load library（）加載OpenCV的本機庫。加載OpenCV本機庫，如下所示。
// Loading the core library System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
Step 2: Instantiate the CascadeClassifier class
包org.opencv.objdetect的cascadescifier類用於加載分類器文件。通過傳遞xml文件lbpcascade_frontalface.xml來實例化這個類，如下所示。
// Instantiating the CascadeClassifier String xmlFile = "E:/OpenCV/facedetect/lbpcascade_frontalface.xml"; CascadeClassifier classifier = new CascadeClassifier(xmlFile);
Step 3: Detect the faces
可以使用名爲cascadescifier的類的方法detectMultiScale（）檢測圖像中的面。該方法接受包含輸入圖像的Mat類對象和MatOfRect類對象來存儲檢測到的面。
// Detecting the face in the snap MatOfRect faceDetections = new MatOfRect(); classifier.detectMultiScale(src, faceDetections);
Example
下面的程序演示如何檢測圖像中的人臉。
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");
}
}
假設下面是上面程序中指定的輸入圖像facedetection_input.jpg。
Output
在執行程序時，您將得到以下輸出&負;
Detected 3 faces Image Processed
如果您打開指定的路徑，您可以按以下方式觀察輸出圖像−
OpenCV - Face Detection using Camera
下面的程序演示如何使用系統攝像機檢測人臉，並使用JavaFX窗口顯示。
Example
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);
}
}
Output
在執行程序時，您將得到以下輸出。
如果打開指定的路徑，可以看到保存爲ajpgimage的同一快照。
OpenCV - Affine Translation
You can perform affine translation on an image using the warpAffine() method of the imgproc class. 下面是這個方法的語法−
Imgproc.warpAffine(src, dst, tranformMatrix, size);
此方法接受以下參數&負;
src−AMat對象，表示此操作的源（輸入圖像）。
dst−AMat表示此操作的目標（輸出圖像）的對象。
表示轉換矩陣的tranformMatrix對象。
size−整數類型的變量，表示輸出圖像的大小。
Example
下面的程序演示如何對給定的圖像應用仿射運算。
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");
}
}
假設下面是上面程序中指定的輸入圖像transform_input.jpg。
Output
在執行它時，您將得到以下輸出&負;
Image Processed
如果您打開指定的路徑，您可以按以下方式觀察輸出圖像−
OpenCV - Rotation
You can perform rotation operation on an image using the warpAffine() method of the imgproc class. 下面是這個方法的語法−
Imgproc.warpAffine(src, dst, rotationMatrix, size);
此方法接受以下參數&負;
src−AMat對象，表示此操作的源（輸入圖像）。
dst−AMat表示此操作的目標（輸出圖像）的對象。
旋轉矩陣−AMat表示旋轉矩陣的對象。
size−整數類型的變量，表示輸出圖像的大小。
Example
下面的程序演示如何旋轉圖像。
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");
}
}
假設下面是上面程序中指定的輸入圖像transform_input.jpg。
Output
在執行程序時，您將得到以下輸出&負;
Image Processed
如果您打開指定的路徑，您可以按以下方式觀察輸出圖像−
OpenCV - Scaling
You can perform scaling on an image using the resize() method of the imgproc class. 下面是這個方法的語法。
resize(Mat src, Mat dst, Size dsize, double fx, double fy, int interpolation)
此方法接受以下參數&負;
src−AMat對象，表示此操作的源（輸入圖像）。
dst−AMat表示此操作的目標（輸出圖像）的對象。
dsize−ASize表示輸出圖像大小的對象。
fx−雙精度類型的變量，表示沿水平軸的比例因子。
fy−雙精度類型的變量，表示沿垂直軸的比例因子。
插值−表示插值方法的整數變量。
Example
下面的程序演示如何對圖像應用縮放變換。
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");
}
}
假設下面是在上面的程序中指定的輸入圖像transform_input.jpg（size−Width:300px，height:300px）。
Output
在執行程序時，您將得到以下輸出&負;
Image Processed
如果打開指定的路徑，可以按如下方式觀察輸出圖像（大小：寬度：600px，高度：600px）−
OpenCV - Color Maps
In OpenCV, you can apply different color maps to an image using the method applyColorMap() of the class Imgproc. 下面是這個方法的語法−
applyColorMap(Mat src, Mat dst, int colormap)
它接受三個參數&負;
src−類的對象表示源（輸入）圖像。
dst−類的對象表示目標（輸出）圖像。
color map−一個整數類型的變量，表示要應用的顏色映射的類型。
Example
下面的程序演示如何將顏色映射應用於圖像。
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");
}
}
假設下面是上述程序中指定的輸入圖像color_input.jpg。
Output
在執行上述程序時，您將得到以下輸出&負;
Image Processed
如果您打開指定的路徑，您可以按以下方式觀察輸出圖像−
More Operations
除了前一個示例中演示的COLORMAP\u HOT之外，OpenCV還提供各種其他類型的顏色映射。所有這些類型都由Imgproc類的預定義靜態欄位（固定值）表示。
通過將其各自的預定義值傳遞給applyColorMap（）方法的名爲colormap的參數，可以選擇所需的colormap類型。
Imgproc.applyColorMap(src, dst, Imgproc.COLORMAP_HOT);
下面是表示各種類型的顏色映射及其各自輸出的值。
| Operation and Description | Output |
|---|---|
| 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 |  |
OpenCV - Canny Edge Detection
Canny邊緣檢測用於檢測圖像中的邊緣。它接受灰度圖像作爲輸入，採用多級算法。
您可以使用imgproc類的Canny（）方法對圖像執行此操作，以下是此方法的語法。
Canny(image, edges, threshold1, threshold2)
此方法接受以下參數&負;
image−AMat表示此操作的源（輸入圖像）的對象。
edges−AMat表示此操作的目標（邊）的對象。
threshold1−double類型的變量，表示滯後過程的第一個閾值。
threshold2−double類型的變量，表示滯後過程的第二個閾值。
Example
下面的程序是一個例子，演示如何對給定的圖像執行Canny邊緣檢測操作。
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");
}
}
假設下面是上面程序中指定的輸入圖像canny_input.jpg。
Output
在執行上述程序時，您將得到以下輸出&負;
Image Processed
如果您打開指定的路徑，您可以按以下方式觀察輸出圖像−
OpenCV - Hough Line Transform
You can detect the shape of a given image by applying the Hough Transform technique using the method HoughLines() of the Imgproc class. 下面是這個方法的語法。
HoughLines(image, lines, rho, theta, threshold)
此方法接受以下參數&負;
image−類的對象表示源（輸入）圖像。
lines−類的對象，存儲存儲行的參數（r，Φ）的向量。
rho−雙精度類型的變量，表示參數r的解析度（像素）。
theta−雙精度類型的變量，表示參數Φ的解析度（以弧度爲單位）。
threshold−一個整數類型的變量，表示「檢測」直線的最小交點數。
Example
下面的程序演示如何檢測給定圖像中的Hough線。
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");
}
}
假設下面是上面程序中指定的輸入圖像hough_input.jpg。
Output
在執行程序時，您將得到以下輸出&負;
143 1 Image Processed
如果您打開指定的路徑，您可以按以下方式觀察輸出圖像−
OpenCV - Histogram Equalization
圖像的直方圖顯示像素強度值的頻率。在圖像直方圖中，X軸顯示灰度強度，Y軸顯示這些強度的頻率。
Histogram equalization improves the contrast of an image, in order to stretch out the intensty range. You can equalize the histogram of a given image using the method equalizeHist() of the Imgproc class. 下面是這個方法的語法。
equalizeHist(src, dst)
此方法接受以下參數&負;
src−類的對象表示源（輸入）圖像。
dst−表示輸出的類對象。（均衡直方圖後得到的圖像）
Example
下面的程序演示如何均衡化給定圖像的直方圖。
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");
}
}
假設下面是上面程序中指定的輸入圖像histo_input.jpg。
Output
在執行程序時，您將得到以下輸出&負;
Image Processed
如果您打開指定的路徑，您可以按以下方式觀察輸出圖像−