OpenCV-퀵 가이드
OpenCV는 실시간으로 개발할 수있는 크로스 플랫폼 라이브러리입니다. computer vision applications. 주로 얼굴 감지 및 물체 감지와 같은 기능을 포함하여 이미지 처리, 비디오 캡처 및 분석에 중점을 둡니다.
"컴퓨터 비전"이라는 용어를 정의하여 장을 시작하겠습니다.
컴퓨터 시각 인식
Computer Vision은 장면에있는 구조의 속성 측면에서 2D 이미지에서 3D 장면을 재구성, 중단 및 이해하는 방법을 설명하는 분야로 정의 할 수 있습니다. 컴퓨터 소프트웨어와 하드웨어를 사용하여 인간의 시각을 모델링하고 복제하는 것을 다룹니다.
Computer Vision은 다음 분야와 크게 겹칩니다.
Image Processing − 이미지 조작에 중점을 둡니다.
Pattern Recognition − 패턴 분류를위한 다양한 기법을 설명합니다.
Photogrammetry − 이미지에서 정확한 측정 값을 얻는 것과 관련이 있습니다.
컴퓨터 비전 대 이미지 처리
Image processing이미지 대 이미지 변환을 다룹니다. 이미지 처리의 입력과 출력은 모두 이미지입니다.
Computer vision이미지에서 물리적 객체에 대한 명시적이고 의미있는 설명을 구성하는 것입니다. 컴퓨터 비전의 출력은 3D 장면의 구조에 대한 설명 또는 해석입니다.
컴퓨터 비전의 응용
여기에서는 Computer Vision이 많이 사용되는 주요 도메인 몇 가지를 나열했습니다.
로봇 공학 응용
현지화-자동으로 로봇 위치 결정
Navigation
장애물 회피
조립 (페그 인 홀, 용접, 도장)
조작 (예 : PUMA 로봇 조작기)
HRI (Human Robot Interaction)-사람과 상호 작용하고 서비스를 제공하는 지능형 로봇
의학 응용
- 분류 및 검출 (예 : 병변 또는 세포 분류 및 종양 검출)
- 2D / 3D 분할
- 3D 인간 장기 재건 (MRI 또는 초음파)
- 비전 유도 로봇 수술
산업 자동화 애플리케이션
- 산업 검사 (결함 감지)
- Assembly
- 바코드 및 포장 라벨 판독
- 개체 정렬
- 문서 이해 (예 : OCR)
보안 애플리케이션
생체 인식 (홍채, 지문, 얼굴 인식)
Surveillance-특정 의심스러운 활동 또는 행동 감지
교통 신청
- 자율 주행 차
- 안전 (예 : 운전자 경계 모니터링)
OpenCV 라이브러리의 특징
OpenCV 라이브러리를 사용하면 다음을 수행 할 수 있습니다.
이미지 읽기 및 쓰기
비디오 캡처 및 저장
이미지 처리 (필터, 변환)
기능 감지 수행
동영상이나 이미지에서 얼굴, 눈, 자동차와 같은 특정 물체를 감지합니다.
동영상을 분석합니다. 즉, 동영상의 움직임을 추정하고 배경을 빼고 동영상 속의 물체를 추적합니다.
OpenCV는 원래 C ++로 개발되었습니다. 그 외에도 Python 및 Java 바인딩이 제공되었습니다. OpenCV는 Windows, Linux, OSx, FreeBSD, Net BSD, Open BSD 등과 같은 다양한 운영 체제에서 실행됩니다.
이 튜토리얼은 Java 바인딩을 사용하는 예제와 함께 OpenCV의 개념을 설명합니다.
OpenCV 라이브러리 모듈
다음은 OpenCV 라이브러리의 주요 라이브러리 모듈입니다.
핵심 기능
이 모듈은 OpenCV 애플리케이션을 빌드하는 데 사용되는 Scalar, Point, Range 등과 같은 기본 데이터 구조를 다룹니다. 이 외에도 다차원 배열도 포함합니다.Mat, 이미지를 저장하는 데 사용됩니다. OpenCV의 Java 라이브러리에서이 모듈은 이름이있는 패키지로 포함됩니다.org.opencv.core.
이미지 처리
이 모듈은 이미지 필터링, 기하학적 이미지 변환, 색 공간 변환, 히스토그램 등과 같은 다양한 이미지 처리 작업을 다룹니다. OpenCV의 Java 라이브러리에서이 모듈은 이름이있는 패키지로 포함됩니다. org.opencv.imgproc.
비디오
이 모듈은 모션 추정, 배경 빼기 및 객체 추적과 같은 비디오 분석 개념을 다룹니다. OpenCV의 Java 라이브러리에서이 모듈은 이름이있는 패키지로 포함됩니다.org.opencv.video.
비디오 I / O
이 모듈은 OpenCV 라이브러리를 사용하여 비디오 캡처 및 비디오 코덱을 설명합니다. OpenCV의 Java 라이브러리에서이 모듈은 이름이있는 패키지로 포함됩니다.org.opencv.videoio.
calib3d
이 모듈에는 기본 다중 뷰 지오메트리 알고리즘, 단일 및 스테레오 카메라 보정, 객체 포즈 추정, 스테레오 대응 및 3D 재구성 요소와 관련된 알고리즘이 포함됩니다. OpenCV의 Java 라이브러리에서이 모듈은 이름이있는 패키지로 포함됩니다.org.opencv.calib3d.
기능 2d
이 모듈에는 기능 감지 및 설명의 개념이 포함되어 있습니다. OpenCV의 Java 라이브러리에서이 모듈은 이름이있는 패키지로 포함됩니다.org.opencv.features2d.
Objdetect
이 모듈에는 얼굴, 눈, 머그, 사람, 자동차 등과 같은 사전 정의 된 클래스의 개체 및 인스턴스 감지가 포함됩니다. OpenCV의 Java 라이브러리에서이 모듈은 이름이있는 패키지로 포함됩니다. org.opencv.objdetect.
하이 구이
이것은 간단한 UI 기능을 갖춘 사용하기 쉬운 인터페이스입니다. OpenCV의 Java 라이브러리에서이 모듈의 기능은 두 개의 서로 다른 패키지에 포함되어 있습니다.org.opencv.imgcodecs 과 org.opencv.videoio.
OpenCV의 간략한 역사
OpenCV는 처음에 CPU 집약적 인 애플리케이션을 조언하기위한 인텔 연구 이니셔티브였습니다. 1999 년에 공식적으로 출시되었습니다.
- 2006 년에 첫 번째 주요 버전 인 OpenCV 1.0이 출시되었습니다.
- 2009 년 10 월 두 번째 주요 버전 인 OpenCV 2가 출시되었습니다.
- 2012 년 8 월에 OpenCV는 비영리 단체 인 OpenCV.org에서 가져 왔습니다.
이 장에서는 시스템에 OpenCV를 설치하고 환경을 설정하는 방법을 배웁니다.
OpenCV 설치
먼저 시스템에 OpenCV를 다운로드해야합니다. 아래 단계를 따르십시오.
Step 1 − 홈페이지 열기 OpenCV 다음 링크를 클릭하여 : http://opencv.org/ 클릭하면 아래와 같은 홈페이지가 나타납니다.
Step 2 − 이제 Downloads위의 스크린 샷에서 강조 표시된 링크. 클릭하면 OpenCV의 다운로드 페이지로 이동합니다.
Step 3 − 위 스크린 샷에서 강조 표시된 링크를 클릭하면 opencv-3.1.0.exe다운로드됩니다. 이 파일을 추출하여 폴더를 생성하십시오.opencv 다음 스크린 샷과 같이 시스템에서.
Step 4 − 폴더 열기 OpenCV → build → java. 여기에 OpenCV의 jar 파일이 있습니다.opencv-310.jar. 나중에 사용할 수 있도록이 파일을 별도의 폴더에 저장하십시오.
Eclipse 설치
필수 JAR 파일을 다운로드 한 후이 JAR 파일을 Eclipse 환경에 임베드해야합니다. 이러한 JAR 파일에 대한 빌드 경로를 설정하고 다음을 사용하여이를 수행 할 수 있습니다.pom.xml.
빌드 경로 설정
다음은 Eclipse에서 OpenCV를 설정하는 단계입니다.
Step 1− 시스템에 Eclipse를 설치했는지 확인하십시오. 그렇지 않은 경우 시스템에 Eclipse를 다운로드하여 설치하십시오.
Step 2 − Eclipse를 열고 File, New를 클릭하고 다음 스크린 샷과 같이 새 프로젝트를 엽니 다.
Step 3 − 프로젝트를 선택하면 New Project마법사. 이 마법사에서 Java 프로젝트를 선택하고Next 다음 스크린 샷과 같이 버튼을 클릭합니다.
Step 4 − 계속 진행하면 다음 페이지로 이동합니다. New Java Project wizard. 새 프로젝트를 생성하고Next, 다음 스크린 샷에 표시된대로.
Step 5− 새 프로젝트를 생성 한 후 마우스 오른쪽 버튼으로 클릭합니다. 고르다Build Path 클릭 Configure Build Path… 다음 스크린 샷에 표시된대로.
Step 6 − 클릭시 Build Path 옵션으로 이동합니다. Java Build Path wizard. 클릭Add External JARs 다음 스크린 샷과 같이 버튼을 클릭합니다.
Step 7 − 파일을 저장 한 경로를 선택하십시오 opencv-310.jar.
Step 8 − 클릭시 Open 위 스크린 샷의 버튼을 클릭하면 해당 파일이 라이브러리에 추가됩니다.
Step 9 − 클릭시 OK, 필요한 JAR 파일을 현재 프로젝트에 성공적으로 추가하고 참조 라이브러리를 확장하여 추가 된 라이브러리를 확인할 수 있습니다.
네이티브 라이브러리의 경로 설정
JAR 파일 외에도 OpenCV의 네이티브 라이브러리 (DLL 파일) 경로를 설정해야합니다.
Location of DLL files − 다음의 설치 폴더를 엽니 다. OpenCV 하위 폴더로 이동 build → java. 여기에 두 개의 폴더가 있습니다.x64 (64 비트) 및 x86 (32 비트) dll OpenCV의 파일.
운영 체제에 적합한 각 폴더를 열면 dll 다음 스크린 샷에 표시된대로 파일.
이제 아래 단계에 따라이 파일의 경로도 설정하십시오.
Step 1− 다시 한 번 JavaBuildPath 창을 엽니 다. 여기에서 추가 된 JAR 파일과JRE System Library.
Step 2 − 확장하면 시스템 라이브러리와 Native library location, 다음 스크린 샷에 강조 표시되어 있습니다.
Step 3 − 두 번 클릭 Native library location. 여기에서Native Library Folder Configuration window 아래 그림과 같이.
여기에서 버튼을 클릭하세요 External Folder… 위치를 선택하십시오 dll 시스템의 파일.
이미지를 캡처하기 위해 카메라 및 스캐너와 같은 장치를 사용합니다. 이러한 장치는 이미지의 숫자 값 (예 : 픽셀 값)을 기록합니다. OpenCV는 디지털 이미지를 처리하는 라이브러리이므로 처리를 위해 이러한 이미지를 저장해야합니다.
그만큼 MatOpenCV 라이브러리의 클래스는 이미지의 값을 저장하는 데 사용됩니다. n 차원 배열을 나타내며 회색조 또는 컬러 이미지, 복셀 볼륨, 벡터 필드, 포인트 클라우드, 텐서, 히스토그램 등의 이미지 데이터를 저장하는 데 사용됩니다.
이 클래스는 두 개의 데이터 부분으로 구성됩니다. header 그리고 pointer
Header − 크기, 저장에 사용 된 방법 및 행렬의 주소 (크기가 일정 함)와 같은 정보를 포함합니다.
Pointer − 이미지의 픽셀 값을 저장합니다 (변함 유지).
매트 클래스
OpenCV Java 라이브러리는이 클래스에 동일한 이름 (Mat) 패키지 내 org.opencv.core.
생성자
OpenCV Java 라이브러리의 Mat 클래스에는 Mat 개체를 구성 할 수있는 다양한 생성자가 있습니다.
| S. 아니 | 생성자 및 설명 |
|---|---|
| 1 | Mat() 대부분의 경우 매개 변수가없는 기본 생성자입니다. 이를 생성자에 사용하여 빈 행렬을 만들고 다른 OpenCV 메서드에 전달합니다. |
| 2 | Mat(int rows, int cols, int type) 이 생성자는 2D 배열의 행 및 열 수와 배열 유형 (데이터 저장에 사용됨)을 나타내는 정수 유형의 세 매개 변수를받습니다. |
| 삼 | Mat(int rows, int cols, int type, Scalar s) 이전의 매개 변수를 포함하여이 생성자는 추가적으로 Scalar 클래스의 객체를 매개 변수로 허용합니다. |
| 4 | Mat(Size size, int type) 이 생성자는 행렬의 크기를 나타내는 객체와 데이터를 저장하는 데 사용되는 배열의 유형을 나타내는 정수라는 두 개의 매개 변수를받습니다. |
| 5 | Mat(Size size, int type, Scalar s) 이전의 매개 변수를 포함하여이 생성자는 추가적으로 Scalar 클래스의 객체를 매개 변수로 허용합니다. |
| 6 | Mat(long addr) |
| 7 | Mat(Mat m, Range rowRange) 이 생성자는 다른 행렬의 객체와 새 행렬을 만드는 데 사용할 행 범위를 나타내는 Range 클래스의 객체를받습니다. |
| 8 | Mat(Mat m, Range rowRange, Range colRange) 이전 매개 변수를 포함하여이 생성자는 클래스의 객체를 추가로받습니다. 열 범위를 나타내는 범위입니다. |
| 9 | Mat(Mat m, Rect roi) 이 생성자는 두 개의 객체를받습니다. 하나는 다른 행렬을 나타내고 다른 하나는 Region O에프 Interest. |
Note −
배열 유형. CV_8UC1, ..., CV_64FC4를 사용하여 1-4 개의 채널 행렬을 생성하거나 CV_8UC (n), ..., CV_64FC (n)을 사용하여 다중 채널 (최대 CV_CN_MAX 채널) 행렬을 생성합니다.
행렬의 유형은 클래스의 다양한 필드로 표현되었습니다. CvType 패키지에 속하는 org.opencv.core.
방법 및 설명
다음은 Mat 클래스에서 제공하는 몇 가지 메서드입니다.
| S. 아니 | 방법 및 설명 |
|---|---|
| 1 | Mat col(int x) 이 메서드는 열의 인덱스를 나타내는 정수 매개 변수를 받아들이고 해당 열을 검색하고 반환합니다. |
| 2 | Mat row(int y) 이 메서드는 행의 인덱스를 나타내는 정수 매개 변수를 받아들이고 해당 행을 검색하고 반환합니다. |
| 삼 | int cols() 이 메서드는 행렬의 열 수를 반환합니다. |
| 4 | int rows() 이 메서드는 행렬의 행 수를 반환합니다. |
| 5 | Mat setTo(Mat value) 이 메서드는 Mat 유형을 지정하고 배열 요소를 지정된 값으로 설정합니다. |
| 6 | Mat setTo(Scalar s) 이 메서드는 Scalar 유형을 지정하고 배열 요소를 지정된 값으로 설정합니다. |
행렬 생성 및 표시
이 섹션에서는 첫 번째 OpenCV 예제에 대해 설명합니다. 간단한 OpenCV 매트릭스를 만들고 표시하는 방법을 살펴 보겠습니다.
다음은 OpenCV에서 행렬을 만들고 표시하기 위해 따라야 할 단계입니다.
1 단계 : OpenCV 네이티브 라이브러리로드
OpenCV 라이브러리를 사용하여 Java 코드를 작성하는 동안해야 할 첫 번째 단계는 다음을 사용하여 OpenCV의 기본 라이브러리를로드하는 것입니다. loadLibrary(). 아래와 같이 OpenCV 네이티브 라이브러리를로드합니다.
//Loading the core library
System.loadLibrary(Core.NATIVE_LIBRARY_NAME);2 단계 : Mat 클래스 인스턴스화
앞서이 장에서 언급 한 함수를 사용하여 Mat 클래스를 인스턴스화합니다.
//Creating a matrix
Mat matrix = new Mat(5, 5, CvType.CV_8UC1, new Scalar(0));3 단계 : 방법을 사용하여 행렬 채우기
인덱스 값을 메소드에 전달하여 행렬의 특정 행 / 열을 검색 할 수 있습니다. row()/col().
그리고 다음의 변형을 사용하여 이러한 값을 설정할 수 있습니다. setTo() 행동 양식.
//Retrieving the row with index 0
Mat row0 = matrix.row(0);
//setting values of all elements in the row with index 0
row0.setTo(new Scalar(1));
//Retrieving the row with index 3
Mat col3 = matrix.col(3);
//setting values of all elements in the row with index 3
col3.setTo(new Scalar(3));Example
다음 프로그램 코드를 사용하여 OpenCV 라이브러리를 사용하여 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]JavaSE API를 사용하여 이미지로드
그만큼 BufferedImage 의 클래스 java.awt.image.BufferedImage 패키지는 이미지를 저장하는 데 사용되며 ImageIO 패키지 클래스 import javax.imageio 이미지를 읽고 쓰는 방법을 제공합니다.
Example
다음 프로그램 코드를 사용하여 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지정된 경로를 열면 다음과 같이 저장된 이미지를 볼 수 있습니다.
그만큼 Imgcodecs 패키지 클래스 org.opencv.imgcodecs이미지를 읽고 쓰는 방법을 제공합니다. OpenCV를 사용하면 이미지를 읽고 매트릭스에 저장할 수 있습니다 (필요한 경우 매트릭스에서 변환 수행). 나중에 처리 된 행렬을 파일에 쓸 수 있습니다.
그만큼 read() 의 방법 Imgcodecs클래스는 OpenCV를 사용하여 이미지를 읽는 데 사용됩니다. 다음은이 메서드의 구문입니다.
imread(filename)그것은 인수를 받아 들인다 (filename), 읽을 파일의 경로를 나타내는 문자열 유형의 변수입니다.
다음은 OpenCV 라이브러리를 사용하여 Java에서 이미지를 읽기 위해 따라야 할 단계입니다.
1 단계 : OpenCV 네이티브 라이브러리로드
OpenCV 네이티브 라이브러리를로드하려면 load() 방법은 아래와 같습니다.
//Loading the core library
System.loadLibrary(Core.NATIVE_LIBRARY_NAME);2 단계 : Imgcodecs 클래스 인스턴스화
인스턴스화 Imgcodecs 수업.
//Instantiating the Imgcodecs class
Imgcodecs imageCodecs = new Imgcodecs();3 단계 : 이미지 읽기
방법을 사용하여 이미지 읽기 imread(). 이 메서드는 이미지의 경로를 나타내는 문자열 인수를 받아들이고 다음과 같이 읽은 이미지를 반환합니다.Mat 목적.
//Reading the Image from the file
Mat matrix = imageCodecs.imread(Path of the image);예
다음 프로그램 코드는 read an image 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그만큼 write() 의 방법 Imgcodecs클래스는 OpenCV를 사용하여 이미지를 작성하는 데 사용됩니다. 이미지를 작성하려면 이전 예제의 처음 세 단계를 반복하십시오.
이미지를 작성하려면 다음을 호출해야합니다. imwrite() 의 방법 Imgcodecs 수업.
다음은이 메서드의 구문입니다.
imwrite(filename, mat)이 방법은 다음 매개 변수를 허용합니다.
filename − A String 파일을 저장할 경로를 나타내는 변수입니다.
mat − A Mat 기록 할 이미지를 나타내는 객체입니다.
예
다음 프로그램은 write an image 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 Java 라이브러리를 사용하여 이미지를 읽고 저장하는 방법에 대해 논의했습니다. 또한 AWT / Swings 및 JavaFX와 같은 GUI 라이브러리를 사용하여로드 된 이미지를 별도의 창에 표시 할 수도 있습니다.
매트를 버퍼 이미지로 변환
이미지를 읽기 위해 우리는 방법을 사용합니다 imread(). 이 메서드는 다음 형식으로 읽은 이미지를 반환합니다.Matrix. 그러나이 이미지를 GUI 라이브러리 (AWT / Swings 및 JavaFX)와 함께 사용하려면 클래스의 객체로 변환해야합니다.BufferedImage 패키지의 java.awt.image.BufferedImage.
다음은 변환하는 단계입니다. Mat OpenCV의 대상 BufferedImage 목적.
1 단계 : Mat를 MatOfByte로 인코딩
우선, 행렬을 바이트 행렬로 변환해야합니다. 방법을 사용하여 할 수 있습니다.imencode() 수업의 Imgcodecs. 다음은이 메서드의 구문입니다.
imencode(ext, image, matOfByte);이 방법은 다음 매개 변수를 허용합니다.
Ext − 이미지 형식 (.jpg, .png 등)을 지정하는 문자열 매개 변수
image − 이미지의 매트 개체
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);2 단계 : MatOfByte 객체를 바이트 배열로 변환
변환 MatOfByte 메소드를 사용하여 객체를 바이트 배열로 toArray().
byte[] byteArray = matOfByte.toArray();3 단계 : InputStream 개체 준비
이전 단계에서 생성 한 바이트 배열을 생성자에 전달하여 InputStream 객체를 준비합니다. ByteArrayInputStream 수업.
//Preparing the InputStream object
InputStream in = new ByteArrayInputStream(byteArray);4 단계 : InputStream 개체 준비
이전 단계에서 만든 입력 스트림 개체를 read() 의 방법 ImageIO수업. 이것은 BufferedImage 객체를 반환합니다.
//Preparing the BufferedImage
BufferedImage bufImage = ImageIO.read(in);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);Example
다음 프로그램 코드는 read 이미지와 display OpenCV 라이브러리를 사용하여 스윙 창을 통해.
import java.awt.image.BufferedImage;
import java.io.ByteArrayInputStream;
import java.io.InputStream;
import javax.imageio.ImageIO;
import javax.swing.ImageIcon;
import javax.swing.JFrame;
import javax.swing.JLabel;
import org.opencv.core.Core;
import org.opencv.core.Mat;
import org.opencv.core.MatOfByte;
import org.opencv.imgcodecs.Imgcodecs;
public class DisplayingImagesUsingSwings {
public static void main(String args[]) throws Exception {
//Loading the OpenCV core library
System.loadLibrary( Core.NATIVE_LIBRARY_NAME );
//Reading the Image from the file and storing it in to a Matrix object
String file = "C:/EXAMPLES/OpenCV/sample.jpg";
Mat image = Imgcodecs.imread(file);
//Encoding the image
MatOfByte matOfByte = new MatOfByte();
Imgcodecs.imencode(".jpg", image, matOfByte);
//Storing the encoded Mat in a byte array
byte[] byteArray = matOfByte.toArray();
//Preparing the Buffered Image
InputStream in = new ByteArrayInputStream(byteArray);
BufferedImage bufImage = ImageIO.read(in);
//Instantiate JFrame
JFrame frame = new JFrame();
//Set Content to the JFrame
frame.getContentPane().add(new JLabel(new ImageIcon(bufImage)));
frame.pack();
frame.setVisible(true);
System.out.println("Image Loaded");
}
}위의 프로그램을 실행하면 다음과 같은 출력이 나타납니다.
Image Loaded그 외에도 다음과 같이로드 된 이미지를 표시하는 창을 볼 수 있습니다.
JavaFX를 사용하여 이미지 표시
JavaFX를 사용하여 이미지를 표시하려면 먼저 imread() 방법으로 변환 BufferedImage. 그런 다음 아래와 같이 BufferedImage를 WritableImage로 변환합니다.
WritableImage writableImage = SwingFXUtils.toFXImage(bufImage, null);이것을 통과 WritableImage 객체의 생성자에 ImageView 수업.
ImageView imageView = new ImageView(writableImage);Example
다음 프로그램 코드는 방법을 보여줍니다. read 이미지와 display 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는 컬러, 바이너리, 그레이 스케일 등과 같은 다양한 유형의 이미지를 지원합니다. imread() 방법 및 사전 정의 된 필드 Imgcodecs 클래스에서 주어진 이미지를 다른 유형으로 읽을 수 있습니다.
imread () 메서드 (IMREAD_XXX)의 플래그 매개 변수
이전 장에서 우리는 imread() 의 방법 Imgcodecs수업. 읽을 이미지의 위치를 나타내는 문자열 인수를받습니다.
imread(filename)그만큼 imread() 메서드에는 다른 구문이 있습니다.
imread(filename, int flags)이 구문은 두 개의 매개 변수를 허용합니다.
filename − 인수를받습니다. (filename), 읽을 파일의 경로를 나타내는 문자열 유형의 변수입니다.
flags− 미리 정의 된 플래그 값을 나타내는 정수 값. 각 값에 대해 주어진 이미지를 특정 유형 (회색조 색상 등)으로 읽습니다.
다음은에서 제공되는 다양한 필드를 나열한 표입니다. Imgproc 이 매개 변수에 대한 값으로 클래스.
| S. 아니 | 필드 및 설명 |
|---|---|
| 1 | IMREAD_COLOR 플래그가이 값으로 설정되면로드 된 이미지가 3 채널 BGR (청록색 빨강) 컬러 이미지로 변환됩니다. |
| 2 | IMREAD_GRAYSCALE 플래그가이 값으로 설정되면로드 된 이미지가 단일 채널 회색조 이미지로 변환됩니다. |
| 삼 | IMREAD_LOAD_GDAL 플래그가이 값으로 설정되면 다음을 사용하여 이미지를로드 할 수 있습니다. gdal 운전사. |
| 4 | IMREAD_ANYCOLOR 플래그가이 값으로 설정되면 가능한 모든 색상 형식으로 이미지를 읽습니다. |
| 5 | IMREAD_REDUCED_COLOR_2 IMREAD_REDUCED_COLOR_4 IMREAD_REDUCED_COLOR_8 플래그가이 값으로 설정되어있는 경우, 화상은 3 채널 BGR으로 판독되고, 화상의 크기는 ¼, ½로 감소 번째 또는 ⅛ 번째 사용 된 필드에 대한 상기 이미지의 원래 크기. |
| 6 | IMREAD_REDUCED_GRAYSCALE_2 IMREAD_REDUCED_GRAYSCALE_4 IMREAD_REDUCED_GRAYSCALE_8 플래그가이 값으로 설정 될 경우, 이미지는 단일 채널 계조 화상으로서 판독하고, 화상의 크기는 ¼, ½로 감소 번째 또는 ⅛ 번째 필드에 대한 상기 화상의 원래 크기의 사용 . |
| 7 | IMREAD_UNCHANGED 플래그가이 값으로 설정되면로드 된 이미지가있는 그대로 반환됩니다. |
다음 프로그램은 컬러 이미지를 그레이 스케일로 읽고 JavaFX 창을 사용하여 표시하는 방법을 보여줍니다. 여기에서는 플래그를 전달하여 이미지를 읽었습니다.IMREAD_GRAYSCALE 컬러 이미지의 경로를 포함하는 문자열과 함께.
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);
}
}입력 이미지
다음이 입력 이미지라고 가정합니다. sample.jpg 위의 프로그램에서 지정합니다.
출력 이미지
프로그램을 실행하면 다음과 같은 출력이 표시됩니다.
다음 프로그램은 컬러 이미지를 BGR 형 이미지로 읽어서 JavaFX 창을 이용하여 표시하는 방법을 보여줍니다. 여기에서는 플래그를 전달하여 이미지를 읽었습니다.IMREAD_COLOR 방법에 imread() 컬러 이미지의 경로를 포함하는 문자열과 함께.
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);
}
}입력 이미지
다음이 입력 이미지라고 가정합니다. sample.jpg 위의 프로그램에서 지정합니다.
출력 이미지
프로그램을 실행하면 다음과 같은 출력이 표시됩니다.
이전 장에서 입력 이미지를 다른 유형 (이진, 회색조, BGR 등)으로 읽는 방법에 대해 논의했습니다. 이 장에서는 한 유형의 이미지를 다른 유형으로 변환하는 방법을 배웁니다.
명명 된 클래스 Imgproc 패키지의 org.opencv.imgproc 이미지를 한 색상에서 다른 색상으로 변환하는 방법을 제공합니다.
컬러 이미지를 그레이 스케일로 변환
명명 된 메서드 cvtColor()컬러 이미지를 그레이 스케일로 변환하는 데 사용됩니다. 다음은이 메서드의 구문입니다.
cvtColor(Mat src, Mat dst, int code)이 방법은 다음 매개 변수를 허용합니다.
src − 소스를 나타내는 행렬.
dst − 목적지를 나타내는 행렬.
code − 변환 유형을 나타내는 정수 코드 (예 : RGB에서 그레이 스케일로).
코드를 전달하여 컬러 이미지를 그레이 스케일로 변환 할 수 있습니다. Imgproc.COLOR_RGB2GRAY 소스 및 대상 행렬과 함께 cvtColor() 방법.
예
다음 프로그램은 컬러 이미지를 그레이 스케일 이미지로 읽고 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);
}
}입력 이미지
다음이 입력 이미지라고 가정합니다. sample.jpg 위의 프로그램에서 지정합니다.
출력 이미지
프로그램을 실행하면 다음과 같은 출력이 표시됩니다.
호출 된 메서드 threshold()회색조 이미지를 이진 이미지로 변환하는 데 사용됩니다. 다음은이 메서드의 구문입니다.
threshold(Mat src, Mat dst, double thresh, double maxval, int type)이 방법은 다음 매개 변수를 허용합니다.
mat − A Mat 입력 이미지를 나타내는 개체입니다.
dst − A Mat 출력 이미지를 나타내는 객체입니다.
thresh − 임계 값을 나타내는 정수.
maxval − THRESH_BINARY 및 THRESH_BINARY_INV 임계 값 유형과 함께 사용할 최대 값을 나타내는 정수.
type − 변환 유형을 나타내는 정수 코드 (예 : RGB에서 그레이 스케일로).
코드를 전달하여 회색조 이미지를 이진 이미지로 변환 할 수 있습니다. Imgproc.THRESH_BINARY 나머지 매개 변수에 대한 값과 함께.
예
다음 프로그램은 컬러 이미지를 바이너리 이미지로 읽고 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);
}
}입력 이미지
다음이 입력 이미지라고 가정합니다. sample.jpg 위의 프로그램에서 지정합니다.
출력 이미지
프로그램을 실행하면 다음과 같은 출력이 표시됩니다.
이전 장에서 언급 한 동일한 방법을 사용하여 회색조 이미지를 이진 이미지로 변환 할 수 있습니다. 이 프로그램에 대한 입력으로 그레이 스케일 이미지의 경로를 전달하기 만하면됩니다.
예
다음 프로그램은 회색조 이미지를 바이너리 이미지로 읽고 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);
}
}입력 이미지
다음이 입력 이미지라고 가정합니다. sample.jpg 위의 프로그램에서 지정합니다.
출력 이미지
프로그램을 실행하면 다음과 같은 출력이 표시됩니다.
원, 직사각형, 선, 타원, 폴리 라인, 볼록, 폴리 라인, 폴리 라인 등 다양한 모양을 이미지에 각각의 방법을 사용하여 그릴 수 있습니다. org.opencv.imgproc 꾸러미.
방법을 사용하여 이미지에 원을 그릴 수 있습니다. circle() 의 imgproc수업. 다음은이 방법의 구문입니다-
circle(img, center, radius, color, thickness)이 방법은 다음 매개 변수를 허용합니다.
mat − A Mat 원이 그려 질 이미지를 나타내는 객체입니다.
point − A Point 원의 중심을 나타내는 개체입니다.
radius − 유형의 변수 integer 원의 반경을 나타냅니다.
scalar − A Scalar원의 색상을 나타내는 객체입니다. (BGR)
thickness − 안 integer원의 두께를 나타냅니다. 기본적으로 두께 값은 1입니다.
예
다음 프로그램은 이미지에 원을 그리고 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);
}
}위의 프로그램을 실행하면 다음과 같은 출력이 나타납니다.
방법을 사용하여 이미지에 선을 그릴 수 있습니다. line() 의 imgproc수업. 다음은이 메서드의 구문입니다.
line(img, pt1, pt2, color, thickness)이 방법은 다음 매개 변수를 허용합니다.
mat − A Mat 선을 그릴 이미지를 나타내는 객체입니다.
pt1 and pt2 − 두 Point 선을 그릴 지점을 나타내는 개체입니다.
scalar − A Scalar원의 색상을 나타내는 객체입니다. (BGR)
thickness− 선의 두께를 나타내는 정수. 기본적으로 두께 값은 1입니다.
예
다음 프로그램은 이미지에 선을 그리고 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);
}
}위의 프로그램을 실행하면 다음과 같은 출력이 나타납니다.
방법을 사용하여 이미지에 직사각형을 그릴 수 있습니다. rectangle() 의 imgproc수업. 다음은이 방법의 구문입니다-
rectangle(img, pt1, pt2, color, thickness)이 방법은 다음 매개 변수를 허용합니다.
mat − A Mat 직사각형이 그려 질 이미지를 나타내는 객체.
pt1 and pt2 − 두 Point 그릴 직사각형의 꼭지점을 나타내는 객체.
scalar − A Scalar직사각형의 색상을 나타내는 객체입니다. (BGR)
thickness− 직사각형의 두께를 나타내는 정수. 기본적으로 두께 값은 1입니다.
예
다음 예제는 이미지에 직사각형을 그리고 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);
}
}위의 프로그램을 실행하면 다음과 같은 출력이 나타납니다.
방법을 사용하여 이미지에 타원을 그릴 수 있습니다. rectangle() 의 imgproc수업. 다음은이 방법의 구문입니다-
ellipse(img, box, color, thickness)이 방법은 다음 매개 변수를 허용합니다.
mat − A Mat Rectangle이 그려 질 이미지를 나타내는 객체입니다.
box − RotatedRect 객체 (타원은이 직사각형에 새겨 져 있습니다.)
scalar − A ScalarRectangle의 색상을 나타내는 객체입니다. (BGR)
thickness− Rectangle의 두께를 나타내는 정수. 기본적으로 두께 값은 1입니다.
생성자 RotatedRect 클래스는 클래스의 객체를받습니다. Point, Size 클래스의 객체 및 double 유형의 변수입니다.
RotatedRect(Point c, Size s, double a)예
다음 프로그램은 이미지에 타원을 그리고 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);
}
}위의 프로그램을 실행하면 다음과 같은 출력이 나타납니다.
방법을 사용하여 이미지에 폴리 라인을 그릴 수 있습니다. polylines() 의 imgproc수업. 다음은이 메서드의 구문입니다.
polylines(img, pts, isClosed, color, thickness)이 방법은 다음 매개 변수를 허용합니다.
mat − A Mat 폴리 라인이 그려 질 이미지를 나타내는 객체입니다.
pts − A List 유형의 개체를 보유하는 개체 MatOfPoint.
isClosed − 폴리 라인이 닫힌 날씨를 지정하는 부울 유형의 매개 변수.
scalar − A Scalar폴리 라인의 색상을 나타내는 객체입니다. (BGR)
thickness− 폴리 라인의 두께를 나타내는 정수. 기본적으로 두께 값은 1입니다.
생성자 MatOfPoint 클래스는 클래스의 객체를받습니다. Point.
MatOfPoint(Point... a)예
다음 프로그램은 이미지에 폴리 라인을 그리고 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);
}
}위의 프로그램을 실행하면 다음과 같은 출력이 나타납니다.
방법을 사용하여 이미지에 볼록한 폴리 라인을 그릴 수 있습니다. fillconvexPoly() 의 imgproc수업. 다음은이 메서드의 구문입니다.
fillConvexPoly(Mat img, MatOfPoint points, Scalar color)이 방법은 다음 매개 변수를 허용합니다.
mat − A Mat 볼록 폴리 라인을 그릴 이미지를 나타내는 객체입니다.
points − A MatOfPoint 볼록 폴리 라인이 그려 질 지점을 나타내는 객체입니다.
scalar − A Scalar볼록한 폴리 라인의 색상을 나타내는 객체입니다. (BGR)
생성자 MatOfPoint 클래스는 클래스의 객체를받습니다. Point.
MatOfPoint(Point... a)예
다음 프로그램은 이미지에 볼록 폴리 라인을 그리고 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);
}
}위의 프로그램을 실행하면 다음과 같은 출력이 나타납니다.
방법을 사용하여 이미지에 화살표 선을 그릴 수 있습니다. arrowedLine() 의 imgproc수업. 다음은이 방법의 구문입니다-
arrowedLine(Mat img, Point pt1, Point pt2, Scalar color)이 방법은 다음 매개 변수를 허용합니다.
mat − A Mat 화살표 선이 그려 질 이미지를 나타내는 객체입니다.
pt1 and pt2 − 두 Point 화살표 선이 그려 질 지점을 나타내는 객체.
scalar − A Scalar화살표 선의 색상을 나타내는 객체입니다. (BGR)
예
다음 프로그램은 이미지에 화살표 선을 그리고 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);
}
}위의 프로그램을 실행하면 다음과 같은 출력이 나타납니다.
방법을 사용하여 이미지에 텍스트를 추가 할 수 있습니다. arrowedLine() 의 imgproc수업. 다음은이 메서드의 구문입니다.
putText(img, text, org, fontFace, fontScale, Scalar color, int thickness)이 방법은 다음 매개 변수를 허용합니다.
mat − A Mat 텍스트가 추가 될 이미지를 나타내는 객체입니다.
text − A string 추가 할 텍스트를 나타내는 변수입니다.
org − A Point 이미지의 왼쪽 하단 모서리 텍스트 문자열을 나타내는 객체입니다.
fontFace − 글꼴 유형을 나타내는 정수 유형의 변수.
fontScale − 글꼴 별 기본 크기를 곱한 배율을 나타내는 double 유형의 변수.
scalar − A Scalar추가 할 텍스트의 색상을 나타내는 객체입니다. (BGR)
thickness − 기본적으로 선의 두께를 나타내는 정수이며 두께 값은 1입니다.
예
다음 프로그램은 이미지에 텍스트를 추가하고 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);
}
}위의 프로그램을 실행하면 다음과 같은 출력이 나타납니다.
블러 링 (스무딩)은 이미지 노이즈를 줄이기 위해 일반적으로 사용되는 이미지 처리 작업입니다. 이 프로세스는 이미지에서 가장자리와 같은 고주파 콘텐츠를 제거하고 매끄럽게 만듭니다.
일반적으로 블러 링은 저역 통과 필터 커널을 통해 이미지를 컨 볼빙 (이미지의 각 요소가 로컬 인접 요소에 추가되고 커널에 의해 가중치가 부여됨)함으로써 달성됩니다.
흐림 (평균)
이 작업 동안 이미지는 상자 필터 (정규화)로 컨볼 루션됩니다. 이 과정에서 이미지의 중심 요소는 커널 영역에있는 모든 픽셀의 평균으로 대체됩니다.
다음 방법을 사용하여 이미지에서이 작업을 수행 할 수 있습니다. blur() 의 imgproc수업. 다음은이 방법의 구문입니다-
blur(src, dst, ksize, anchor, borderType)이 방법은 다음 매개 변수를 허용합니다.
src − A Mat 이 작업의 소스 (입력 이미지)를 나타내는 개체입니다.
dst − A Mat 이 작업의 대상 (출력 이미지)을 나타내는 개체입니다.
ksize − A Size 커널의 크기를 나타내는 객체입니다.
anchor − 앵커 포인트를 나타내는 정수 유형의 변수.
borderType − 출력에 사용될 테두리의 유형을 나타내는 정수 유형의 변수.
예
다음 프로그램은 이미지에서 평균화 (흐림) 작업을 수행하는 방법을 보여줍니다.
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 위의 프로그램에서 지정합니다.
산출
프로그램을 실행하면 다음과 같은 출력이 표시됩니다.
Image Processed지정된 경로를 열면 다음과 같이 출력 이미지를 관찰 할 수 있습니다.
가우시안 흐림 작업에서 이미지는 상자 필터 대신 가우스 필터로 컨볼 루션됩니다. 가우시안 필터는 고주파 성분이 감소되는 저역 통과 필터입니다.
다음을 사용하여 이미지에서이 작업을 수행 할 수 있습니다. Gaussianblur() 의 방법 imgproc수업. 다음은이 방법의 구문입니다-
GaussianBlur(src, dst, ksize, sigmaX)이 방법은 다음 매개 변수를 허용합니다.
src − A Mat 이 작업의 소스 (입력 이미지)를 나타내는 개체입니다.
dst − A Mat 이 작업의 대상 (출력 이미지)을 나타내는 개체입니다.
ksize − A Size 커널의 크기를 나타내는 객체입니다.
sigmaX − X 방향의 가우스 커널 표준 편차를 나타내는 double 유형의 변수.
예
다음 프로그램은 이미지에서 가우시안 블러 작업을 수행하는 방법을 보여줍니다.
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 위의 프로그램에서 지정합니다.
산출
프로그램을 실행하면 다음과 같은 출력이 표시됩니다.
Image Processed지정된 경로를 열면 다음과 같이 출력 이미지를 관찰 할 수 있습니다.
중앙값 흐림 작업은 다른 평균화 방법과 유사합니다. 여기서 이미지의 중심 요소는 커널 영역에있는 모든 픽셀의 중앙값으로 대체됩니다. 이 작업은 노이즈를 제거하면서 가장자리를 처리합니다.
다음을 사용하여 이미지에서이 작업을 수행 할 수 있습니다. medianBlur() 의 방법 imgproc수업. 다음은이 방법의 구문입니다-
medianBlur(src, dst, ksize)이 방법은 다음 매개 변수를 허용합니다.
src − A Mat 이 작업의 소스 (입력 이미지)를 나타내는 개체입니다.
dst − A Mat 이 작업의 대상 (출력 이미지)을 나타내는 개체입니다.
ksize − A Size 커널의 크기를 나타내는 객체입니다.
예
다음 프로그램은 이미지에서 중앙값 흐림 작업을 수행하는 방법을 보여줍니다.
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 위의 프로그램에서 지정합니다.
산출
프로그램을 실행하면 다음과 같은 출력이 표시됩니다.
Image Processed지정된 경로를 열면 다음과 같이 출력 이미지를 관찰 할 수 있습니다.
이미지 필터링을 사용하면 이미지에 다양한 효과를 적용 할 수 있습니다. 이 장과 다음 세 장에서는 Bilateral Filter, Box Filter, SQR Box Filter 및 Filter2D와 같은 다양한 필터 작업에 대해 설명합니다.
양방향 필터
양방향 필터 작업은 필터에 양방향 이미지를 적용합니다. 다음을 사용하여 이미지에서이 작업을 수행 할 수 있습니다.medianBlur() 의 방법 imgproc수업. 다음은이 메서드의 구문입니다.
bilateralFilter(src, dst, d, sigmaColor, sigmaSpace, borderType)이 방법은 다음 매개 변수를 허용합니다.
src − A Mat 이 작업의 소스 (입력 이미지)를 나타내는 개체입니다.
dst − A Mat 이 작업의 대상 (출력 이미지)을 나타내는 개체입니다.
d − 픽셀 이웃의 직경을 나타내는 정수 유형의 변수.
sigmaColor − 색 공간에서 필터 시그마를 나타내는 정수 유형의 변수.
sigmaSpace − 좌표 공간에서 필터 시그마를 나타내는 정수 유형의 변수.
borderType − 사용 된 테두리 유형을 나타내는 정수 개체.
예
다음 프로그램은 이미지에서 양방향 필터 작업을 수행하는 방법을 보여줍니다.
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 위의 프로그램에서 지정합니다.
산출
프로그램을 실행하면 다음과 같은 출력이 표시됩니다.
Image Processed지정된 경로를 열면 다음과 같이 출력 이미지를 관찰 할 수 있습니다.
박스 필터 작업은 평균화 흐림 작업과 유사합니다. 필터에 양방향 이미지를 적용합니다. 여기에서 상자를 정규화할지 여부를 선택할 수 있습니다.
다음을 사용하여 이미지에서이 작업을 수행 할 수 있습니다. boxFilter() 의 방법 imgproc수업. 다음은이 방법의 구문입니다-
boxFilter(src, dst, ddepth, ksize, anchor, normalize, borderType)이 방법은 다음 매개 변수를 허용합니다.
src − A Mat 이 작업의 소스 (입력 이미지)를 나타내는 개체입니다.
dst − A Mat 이 작업의 대상 (출력 이미지)을 나타내는 개체입니다.
ddepth − 출력 이미지의 깊이를 나타내는 정수 유형의 변수.
ksize − A Size 블러 링 커널의 크기를 나타내는 객체입니다.
anchor − 앵커 포인트를 나타내는 정수 유형의 변수.
Normalize − 커널이 정규화되어야하는 날씨를 지정하는 부울 유형의 변수.
borderType − 사용 된 테두리 유형을 나타내는 정수 개체.
예
다음 프로그램은 이미지에서 상자 필터 작업을 수행하는 방법을 보여줍니다.
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 위의 프로그램에서 지정합니다.
산출
프로그램을 실행하면 다음과 같은 출력이 표시됩니다.
Image Processed지정된 경로를 열면 다음과 같이 출력 이미지를 관찰 할 수 있습니다.
다음을 사용하여 이미지에서 SQRBox 필터 작업을 수행 할 수 있습니다. boxFilter() 의 방법 imgproc수업. 다음은이 방법의 구문입니다-
sqrBoxFilter(src, dst, ddepth, ksize)이 방법은 다음 매개 변수를 허용합니다.
src − A Mat 이 작업의 소스 (입력 이미지)를 나타내는 개체입니다.
dst − A Mat 이 작업의 대상 (출력 이미지)을 나타내는 개체입니다.
ddepth − 출력 이미지의 깊이를 나타내는 정수 유형의 변수.
ksize − A Size 블러 링 커널의 크기를 나타내는 객체입니다.
예
다음 프로그램은 주어진 이미지에서 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 위의 프로그램에서 지정합니다.
산출
프로그램을 실행하면 다음과 같은 출력이 표시됩니다.
Image Processed지정된 경로를 열면 다음과 같이 출력 이미지를 관찰 할 수 있습니다.
Filter2D 작업은 커널과 이미지를 컨볼 루션합니다. 다음을 사용하여 이미지에서이 작업을 수행 할 수 있습니다.Filter2D() 의 방법 imgproc수업. 다음은이 방법의 구문입니다-
filter2D(src, dst, ddepth, kernel)이 방법은 다음 매개 변수를 허용합니다.
src − A Mat 이 작업의 소스 (입력 이미지)를 나타내는 개체입니다.
dst − A Mat 이 작업의 대상 (출력 이미지)을 나타내는 개체입니다.
ddepth − 출력 이미지의 깊이를 나타내는 정수 유형의 변수.
kernel − A Mat 컨볼 루션 커널을 나타내는 객체입니다.
예
다음 프로그램은 이미지에서 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 위의 프로그램에서 지정합니다.
산출
프로그램을 실행하면 다음과 같은 출력이 표시됩니다.
Image Processed지정된 경로를 열면 다음과 같이 출력 이미지를 관찰 할 수 있습니다.
침식과 팽창은 형태 학적 작업의 두 가지 유형입니다. 이름에서 알 수 있듯이 형태 적 작업은 이미지를 모양에 따라 처리하는 작업 집합입니다.
주어진 입력 이미지를 기반으로 "구조적 요소"가 개발됩니다. 이는 두 절차 중 하나에서 수행 할 수 있습니다. 이는 노이즈를 제거하고 결함을 해결하여 이미지를 선명하게 만드는 데 목적이 있습니다.
팽창
이 절차는 정사각형 또는 원과 같은 특정 모양의 일부 커널과 컨볼 루션을 따릅니다. 이 커널에는 중심을 나타내는 앵커 포인트가 있습니다.
이 커널은 최대 픽셀 값을 계산하기 위해 그림 위에 겹쳐집니다. 계산 후 그림은 중앙의 앵커로 대체됩니다. 이 절차를 사용하면 밝은 영역의 크기가 커져 이미지 크기가 커집니다.
예를 들어, 흰색 음영 또는 밝은 음영의 개체 크기는 증가하고 검은 음영 또는 어두운 음영의 개체 크기는 감소합니다.
다음을 사용하여 이미지에서 확장 작업을 수행 할 수 있습니다. dilate() 의 방법 imgproc수업. 다음은이 메서드의 구문입니다.
dilate(src, dst, kernel)이 방법은 다음 매개 변수를 허용합니다.
src − A Mat 이 작업의 소스 (입력 이미지)를 나타내는 개체입니다.
dst − A Mat 이 작업의 대상 (출력 이미지)을 나타내는 개체입니다.
kernel − A Mat 커널을 나타내는 객체.
예
다음을 사용하여 커널 매트릭스를 준비 할 수 있습니다. getStructuringElement()방법. 이 메소드는 다음을 나타내는 정수를받습니다.morph_rect 유형 및 유형의 객체 Size.
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");
}
}입력
다음이 입력 이미지라고 가정합니다. sample.jpg 위의 프로그램에서 지정합니다.
산출
프로그램을 실행하면 다음과 같은 출력이 표시됩니다.
Image Processed지정된 경로를 열면 다음과 같이 출력 이미지를 관찰 할 수 있습니다.
침식은 팽창과 매우 유사한 과정입니다. 그러나 여기서 계산 된 픽셀 값은 확장에서 최대가 아니라 최소입니다. 이미지는 앵커 포인트 아래의 최소 픽셀 값으로 대체됩니다.
이 절차를 사용하면 어두운 영역의 크기가 커지고 밝은 영역이 줄어 듭니다. 예를 들어, 어두운 그늘이나 검은 그늘에있는 물체의 크기는 증가하고 흰색 또는 밝은 그늘에 감소합니다.
예
다음을 사용하여 이미지에서이 작업을 수행 할 수 있습니다. erode() 의 방법 imgproc수업. 다음은이 방법의 구문입니다-
erode(src, dst, kernel)이 방법은 다음 매개 변수를 허용합니다.
src − A Mat 이 작업의 소스 (입력 이미지)를 나타내는 개체입니다.
dst − A Mat 이 작업의 대상 (출력 이미지)을 나타내는 개체입니다.
kernel − A Mat 커널을 나타내는 객체.
다음을 사용하여 커널 매트릭스를 준비 할 수 있습니다. getStructuringElement()방법. 이 메소드는 다음을 나타내는 정수를받습니다.morph_rect 유형 및 유형의 객체 Size.
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 위의 프로그램에서 지정합니다.
산출
프로그램을 실행하면 다음과 같은 출력이 표시됩니다.
Image Loaded지정된 경로를 열면 다음과 같이 출력 이미지를 관찰 할 수 있습니다.
이전 장에서 우리는 erosion 과 dilation. 이 두 가지 외에도 OpenCV에는 더 많은 형태 적 변형이 있습니다. 그만큼morphologyEx() 수업 방법의 Imgproc 주어진 이미지에서 이러한 작업을 수행하는 데 사용됩니다.
다음은이 방법의 구문입니다-
morphologyEx(src, dst, op, kernel)이 방법은 다음 매개 변수를 허용합니다.
src − 클래스의 대상 Mat 소스 (입력) 이미지를 나타냅니다.
dst − 클래스의 대상 Mat 대상 (출력) 이미지를 나타냅니다.
op − 형태 적 연산의 유형을 나타내는 정수.
kernel − 커널 행렬.
예
다음 프로그램은 형태 학적 작업을 적용하는 방법을 보여줍니다. "top-hat" 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 위의 프로그램에서 지정합니다.
산출
프로그램을 실행하면 다음과 같은 출력이 표시됩니다.
Image Processed지정된 경로를 열면 다음과 같이 출력 이미지를 관찰 할 수 있습니다.
더 많은 작업
형태 학적 작업 외에 TOPHAT, 이전에 설명 example, OpenCV는 다양한 다른 유형의 형태를 제공합니다. 이러한 유형은 모두 미리 정의 된 정적 필드 (고정 값)로 표시됩니다.Imgproc 수업.
각각의 사전 정의 된 값을 매개 변수에 전달하여 필요한 형태 유형을 선택할 수 있습니다. op 의 morphologyEx() 방법.
// Applying Blur effect on the Image
Imgproc.morphologyEx(src, dst, Imgproc.MORPH_TOPHAT, kernel);다음은 형태 학적 연산의 유형과 각각의 출력을 나타내는 값입니다.
| 작동 및 설명 | 산출 |
|---|---|
| MORPH_BLACKHAT |
|
| MORPH_CLOSE |
|
| MORPH_CROSS |
|
| MORPH_DILATE |
|
| MORPH_ELLIPSE |
|
| MORPH_ERODE |
|
| MORPH_GRADIENT |
|
| MORPH_OPEN |
|
| MORPH_RECT |
|
| MORPH_TOPHAT |
|
피라미드는 이미지에 대한 작업입니다.
입력 이미지는 처음에 특정 스무딩 필터 (예 : Gaussian, Laplacian)를 사용하여 스무딩 된 다음 스무딩 된 이미지가 서브 샘플링됩니다.
이 과정은 여러 번 반복됩니다.
피라미드 작업 중에는 이미지의 부드러움이 증가하고 해상도 (크기)가 감소합니다.
피라미드 위로
Pyramid Up에서 이미지는 처음에 업 샘플링 된 다음 흐리게 처리됩니다. 다음을 사용하여 이미지에 대해 Pyramid Up 작업을 수행 할 수 있습니다.pyrUP() 의 방법 imgproc수업. 다음은이 방법의 구문입니다-
pyrUp(src, dst, dstsize, borderType)이 방법은 다음 매개 변수를 허용합니다.
src − 클래스의 대상 Mat 소스 (입력) 이미지를 나타냅니다.
mat − 클래스의 대상 Mat 대상 (출력) 이미지를 나타냅니다.
size − 클래스의 대상 Size 이미지를 늘리거나 줄일 크기를 나타냅니다.
borderType − 사용할 테두리 유형을 나타내는 정수 유형의 변수.
예
다음 프로그램은 이미지에서 Pyramid Up 작업을 수행하는 방법을 보여줍니다.
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");
}
}다음이 입력 이미지라고 가정합니다. pyramid_input.jpg 위의 프로그램에서 지정합니다.
산출
프로그램을 실행하면 다음과 같은 출력이 표시됩니다.
Image Processed지정된 경로를 열면 다음과 같이 출력 이미지를 관찰 할 수 있습니다.
아래로 피라미드
Pyramid Down에서는 이미지가 처음에 흐릿한 다음 다운 샘플링됩니다. 다음을 사용하여 이미지에 대해 아래로 피라미드 작업을 수행 할 수 있습니다.pyrDown() 의 방법 imgproc수업. 다음은이 방법의 구문입니다-
pyrDown(src, dst, dstsize, borderType)이 방법은 다음 매개 변수를 허용합니다.
src − 클래스의 대상 Mat 소스 (입력) 이미지를 나타냅니다.
mat − 클래스의 대상 Mat 대상 (출력) 이미지를 나타냅니다.
size − 클래스의 대상 Size 이미지를 늘리거나 줄일 크기를 나타냅니다.
borderType − 사용할 테두리 유형을 나타내는 정수 유형의 변수.
예
다음 프로그램은 이미지에서 아래로 피라미드 작업을 수행하는 방법을 보여줍니다.
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");
}
}다음이 입력 이미지라고 가정합니다. pyramid_input.jpg 위의 프로그램에서 지정합니다.
산출
프로그램을 실행하면 다음과 같은 출력이 표시됩니다.
Image Processed지정된 경로를 열면 다음과 같이 출력 이미지를 관찰 할 수 있습니다.
평균 이동 필터링
평균 이동 피라미드 연산에서는 이미지의 평균 이동 분할의 초기 단계가 수행됩니다.
다음을 사용하여 이미지에 피라미드 평균 이동 필터링 작업을 수행 할 수 있습니다. pyrDown() 의 방법 imgproc수업. 다음은이 메서드의 구문입니다.
pyrMeanShiftFiltering(src, dst, sp, sr)이 방법은 다음 매개 변수를 허용합니다.
src − 클래스의 대상 Mat 소스 (입력) 이미지를 나타냅니다.
mat − 클래스의 대상 Mat 대상 (출력) 이미지를 나타냅니다.
sp − 공간 창 반경을 나타내는 double 유형의 변수.
sr − 색상 창 반경을 나타내는 double 유형의 변수.
예
다음 프로그램은 주어진 이미지에 대해 평균 이동 필터링 작업을 수행하는 방법을 보여줍니다.
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");
}
}다음이 입력 이미지라고 가정합니다. pyramid_input.jpg 위의 프로그램에서 지정합니다.
산출
프로그램을 실행하면 다음과 같은 출력이 표시됩니다.
Image Processed지정된 경로를 열면 다음과 같이 출력 이미지를 관찰 할 수 있습니다.
임계 값은 이미지 분할 방법이며 일반적으로 이진 이미지를 만드는 데 사용됩니다. 임계 값은 단순 임계 값과 적응 형 임계 값의 두 가지 유형입니다.
단순 임계 값
단순 임계 값 작업에서 값이 지정된 임계 값보다 큰 픽셀에는 표준 값이 할당됩니다.
방법을 사용하여 이미지에 대해 간단한 임계 값 연산을 수행 할 수 있습니다. threshold() 의 Imgproc class, 다음은이 메서드의 구문입니다.
threshold(src, dst, thresh, maxval, type)이 방법은 다음 매개 변수를 허용합니다.
src − 클래스의 대상 Mat 소스 (입력) 이미지를 나타냅니다.
dst − 클래스의 대상 Mat 대상 (출력) 이미지를 나타냅니다.
thresh − 임계 값을 나타내는 이중 유형의 변수.
maxval − 픽셀 값이 임계 값보다 크면 주어질 값을 나타내는 이중 유형의 변수.
type − 사용할 임계 값 유형을 나타내는 정수 유형의 변수.
예
다음 프로그램은 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 위의 프로그램에서 지정합니다.
산출
프로그램을 실행하면 다음과 같은 출력이 표시됩니다.
Image Processed지정된 경로를 열면 다음과 같이 출력 이미지를 관찰 할 수 있습니다.
다른 유형의 단순 임계 값
여기에 덧붙여 THRESH_BINARY이전 예제에서 설명한 작업 인 OpenCV는 다양한 다른 유형의 임계 값 작업을 제공합니다. 이러한 유형은 모두 미리 정의 된 정적 필드 (고정 값)로 표시됩니다.Imgproc 수업.
각각의 사전 정의 된 값을 다음과 같은 매개 변수에 전달하여 필요한 임계 값 작업의 유형을 선택할 수 있습니다. type 의 threshold() 방법.
Imgproc.threshold(src, dst, 50, 255, Imgproc.THRESH_BINARY);다음은 다양한 유형의 임계 값 작업과 해당 출력을 나타내는 값입니다.
| 작동 및 설명 | 산출 |
|---|---|
| THRESH_BINARY |
|
| THRESH_BINARY_INV |
|
| THRESH_TRUNC |
|
| THRESH_TOZERO |
|
| THRESH_TOZERO_INV |
|
에 simple thresholding, 임계 값은 전역입니다. 즉, 이미지의 모든 픽셀에 대해 동일합니다. Adaptive thresholding 임계 값이 작은 지역에 대해 계산되는 방법이므로 지역마다 다른 임계 값이 있습니다.
OpenCV에서는 다음 방법을 사용하여 이미지에 적응 임계 값 작업을 수행 할 수 있습니다. adaptiveThreshold() 의 Imgproc수업. 다음은이 메서드의 구문입니다.
adaptiveThreshold(src, dst, maxValue, adaptiveMethod, thresholdType, blockSize, C)이 방법은 다음 매개 변수를 허용합니다.
src − 클래스의 대상 Mat 소스 (입력) 이미지를 나타냅니다.
dst − 클래스의 대상 Mat 대상 (출력) 이미지를 나타냅니다.
maxValue − 픽셀 값이 임계 값보다 크면 주어질 값을 나타내는 이중 유형의 변수.
adaptiveMethod− 사용할 적응 방법을 나타내는 유형의 정수 변수. 다음 두 값 중 하나입니다.
ADAPTIVE_THRESH_MEAN_C − 임계 값은 주변 지역의 평균입니다.
ADAPTIVE_THRESH_GAUSSIAN_C − 임계 값은 가중치가 가우스 윈도우 인 인접 값의 가중치 합입니다.
thresholdType − 사용할 임계 값 유형을 나타내는 정수 유형의 변수.
blockSize − 임계 값을 계산하는 데 사용되는 픽셀 이웃의 크기를 나타내는 정수 유형의 변수.
C − 두 방법에서 사용되는 상수를 나타내는 이중 유형의 변수 (평균 또는 가중 평균에서 뺀 값).
예
다음 프로그램은 OpenCV의 이미지에서 적응 임계 값 연산을 수행하는 방법을 보여줍니다. 여기서 우리는 유형의 적응 형 임계 값을 선택합니다.binary 과 ADAPTIVE_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 위의 프로그램에서 지정합니다.
산출
프로그램을 실행하면 다음과 같은 출력이 표시됩니다.
Image Processed지정된 경로를 열면 다음과 같이 출력 이미지를 관찰 할 수 있습니다.
다른 유형의 적응 임계 값
여기에 덧붙여 ADAPTIVE_THRESH_MEAN_C 적응 방법으로 THRESH_BINARY 이전 예에서 설명한 것처럼 임계 값 유형으로이 두 값의 더 많은 조합을 선택할 수 있습니다.
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 |
|
|
이 장에서는 두꺼비가 이미지에 테두리를 지정하는 방법을 설명합니다.
copyMakeBorder () 메서드
방법을 사용하여 이미지에 다양한 테두리를 추가 할 수 있습니다. copyMakeBorder() 패키지에 속하는 Core라는 클래스의 org.opencv.core. 다음은이 메서드의 구문입니다.
copyMakeBorder(src, dst, top, bottom, left, right, borderType)이 방법은 다음 매개 변수를 허용합니다.
src − 클래스의 대상 Mat 소스 (입력) 이미지를 나타냅니다.
dst − 클래스의 대상 Mat 대상 (출력) 이미지를 나타냅니다.
top − 이미지 상단의 테두리 길이를 나타내는 정수 유형의 정수 변수.
bottom − 이미지 하단의 테두리 길이를 나타내는 정수 유형의 정수 변수.
left − 이미지 왼쪽 테두리의 길이를 나타내는 정수 유형의 정수 변수.
right − 이미지 오른쪽 테두리의 길이를 나타내는 정수 유형의 정수 변수.
borderType − 사용할 테두리의 유형을 나타내는 정수 유형의 변수.
예
다음 프로그램은 주어진 이미지에 테두리를 추가하는 방법을 보여주는 예제입니다.
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 위의 프로그램에서 지정합니다.
산출
프로그램을 실행하면 다음과 같은 출력이 표시됩니다.
Image Processed지정된 경로를 열면 다음과 같이 출력 이미지를 관찰 할 수 있습니다.
다른 유형의 테두리
테두리 유형 외에도 BORDER_CONSTANT이전 예제에서 보여준 OpenCV는 다양한 다른 유형의 테두리를 제공합니다. 이러한 모든 유형은 Core 클래스의 미리 정의 된 정적 필드 (고정 값)로 표시됩니다.
각각의 사전 정의 된 값을 다음과 같은 매개 변수에 전달하여 필요한 임계 값 작업의 유형을 선택할 수 있습니다. borderType 의 copyMakeBorder() 방법.
Core.copyMakeBorder(src, dst, 20, 20, 20, 20, Core.BORDER_CONSTANT);다음은 다양한 유형의 테두리 작업과 해당 출력을 나타내는 값입니다.
| 작동 및 설명 | 산출 |
|---|---|
| BORDER_CONSTANT |
|
| BORDER_ISOLATED |
|
| BORDER_DEFAULT |
|
| BORDER_REFLECT |
|
| BORDER_REFLECT_101 |
|
| BORDER_REFLECT101 |
|
| BORDER_REPLICATE |
|
| BORDER_WRAP |
|
사용 sobel operation, 수평 및 수직 방향으로 이미지의 가장자리를 감지 할 수 있습니다. 방법을 사용하여 이미지에 소벨 연산을 적용 할 수 있습니다.sobel(). 다음은이 방법의 구문입니다-
Sobel(src, dst, ddepth, dx, dy)이 방법은 다음 매개 변수를 허용합니다.
src − 클래스의 대상 Mat 소스 (입력) 이미지를 나타냅니다.
dst − 클래스의 대상 Mat 대상 (출력) 이미지를 나타냅니다.
ddepth − 이미지의 깊이를 나타내는 정수 변수 (-1)
dx− x 미분을 나타내는 정수 변수. (0 또는 1)
dy− y 미분을 나타내는 정수 변수. (0 또는 1)
예
다음 프로그램은 주어진 이미지에서 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 위의 프로그램에서 지정합니다.
산출
프로그램을 실행하면 다음과 같은 출력이 표시됩니다.
Image Processed지정된 경로를 열면 다음과 같이 출력 이미지를 관찰 할 수 있습니다.
소벨 변형
마지막에 다른 값을 매개 변수 (dx 및 dy) (0 및 1)에 전달하면 다른 출력을 얻을 수 있습니다.
// Applying sobel on the Image
Imgproc.Sobel(src, dst, -1, 1, 1);다음 표는 변수에 대한 다양한 값을 나열합니다. dx 과 dy 방법의 Sobel() 및 각각의 출력.
| X 파생 | Y 파생 | 산출 |
|---|---|---|
| 0 | 1 |
|
| 1 | 0 |
|
| 1 | 1 |
|
Scharr는 또한 수평 및 수직 방향에서 이미지의 2 차 미분을 감지하는 데 사용됩니다. 방법을 사용하여 이미지에 대해 scharr 작업을 수행 할 수 있습니다.scharr(). 다음은이 방법의 구문입니다-
Scharr(src, dst, ddepth, dx, dy)이 방법은 다음 매개 변수를 허용합니다.
src − 클래스의 대상 Mat 소스 (입력) 이미지를 나타냅니다.
dst − 클래스의 대상 Mat 대상 (출력) 이미지를 나타냅니다.
ddepth − 이미지의 깊이를 나타내는 정수 변수 (-1)
dx− x 미분을 나타내는 정수 변수. (0 또는 1)
dy− y 미분을 나타내는 정수 변수. (0 또는 1)
예
다음 프로그램은 주어진 이미지에 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 위의 프로그램에서 지정합니다.
산출
실행하면 다음과 같은 출력이 표시됩니다.
Image Processed지정된 경로를 열면 다음과 같이 출력 이미지를 관찰 할 수 있습니다.
더 많은 scharr 파생 상품
마지막에 다른 값을 매개 변수 (dx 및 dy) (0 및 1)에 전달하면 다른 출력을 얻을 수 있습니다.
// Applying scharr on the Image
Imgproc.Scharr(src, dst, -1, 1, 1);다음은 변수에 대한 다양한 값을 나열하는 표입니다. dx 과 dy 방법의 scharr() 및 각각의 출력.
| X 파생 | Y 파생 | 산출 |
|---|---|---|
| 0 | 1 |
|
| 1 | 0 |
|
라플라시안 연산자는 또한 이미지에서 가장자리를 찾는 데 사용되는 미분 연산자입니다. 2 차 미분 마스크입니다. 이 마스크에는 두 가지 추가 분류가 있는데 하나는 Positive Laplacian Operator이고 다른 하나는 Negative Laplacian Operator입니다.
다른 연산자와 달리 Laplacian은 특정 방향으로 모서리를 제거하지 않았지만 다음 분류에서 모서리를 제거합니다.
- 안쪽 가장자리
- 바깥 쪽 가장자리
수행 할 수 있습니다 Laplacian Transform 사용하여 이미지 작업 Laplacian() 의 방법 imgproc 다음은이 메서드의 구문입니다.
Laplacian(src, dst, ddepth)이 방법은 다음 매개 변수를 허용합니다.
src − A Mat 이 작업의 소스 (입력 이미지)를 나타내는 개체입니다.
dst − A Mat 이 작업의 대상 (출력 이미지)을 나타내는 개체입니다.
ddepth − 대상 이미지의 깊이를 나타내는 정수 유형의 변수.
예
다음 프로그램은 주어진 이미지에서 라플라스 변환 작업을 수행하는 방법을 보여줍니다.
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 위의 프로그램에서 지정합니다.
산출
프로그램을 실행하면 다음과 같은 출력이 표시됩니다.
Image Processed지정된 경로를 열면 다음과 같이 출력 이미지를 관찰 할 수 있습니다.
그만큼 distance transform연산자는 일반적으로 이진 이미지를 입력으로 사용합니다. 이 작업에서 전경 영역 내부 포인트의 그레이 레벨 강도는 가장 가까운 0 값 (경계)에서 각각의 거리를 멀어지게 변경됩니다.
방법을 사용하여 OpenCV에서 거리 변환을 적용 할 수 있습니다. distanceTransform(). 다음은이 메서드의 구문입니다.
distanceTransform(src, dst, distanceType, maskSize)이 방법은 다음 매개 변수를 허용합니다.
src − 클래스의 대상 Mat 소스 (입력) 이미지를 나타냅니다.
dst − 클래스의 대상 Mat 대상 (출력) 이미지를 나타냅니다.
distanceType − 적용 할 거리 변환의 유형을 나타내는 정수 유형의 변수.
maskSize − 사용할 마스크 크기를 나타내는 정수 유형의 변수.
예
다음 프로그램은 주어진 이미지에서 거리 변환 작업을 수행하는 방법을 보여줍니다.
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.jpg 위의 프로그램에서 지정합니다.
산출
프로그램을 실행하면 다음과 같은 출력이 표시됩니다.
Image Processed지정된 경로를 열면 다음과 같이 출력 이미지를 관찰 할 수 있습니다.
거리 변환 작업의 유형
거리 작동 유형에 추가 DIST_C이전 예제에서 설명한 OpenCV는 다양한 다른 유형의 거리 변환 작업을 제공합니다. 이러한 모든 유형은 Imgproc 클래스의 사전 정의 된 정적 필드 (고정 값)로 표시됩니다.
각각의 사전 정의 된 값을 다음과 같은 매개 변수에 전달하여 필요한 거리 변환 작업의 유형을 선택할 수 있습니다. distanceType 의 distanceTransform() 방법.
// Applying distance transform
Imgproc.distanceTransform(mat, dst, Imgproc.DIST_C, 3);다음은 다양한 유형을 나타내는 값입니다. distanceTransform 작업 및 각각의 출력.
| 작동 및 설명 | 산출 |
|---|---|
| DIST_C |
|
| DIST_L1 |
|
| DIST_L2 |
|
| DIST_LABEL_PIXEL |
|
| DIST_MASK_3 |
|
이 장에서는 OpenCV를 사용하여 시스템 카메라를 사용하여 프레임을 캡처하는 방법을 배웁니다. 그만큼VideoCapture 의 클래스 org.opencv.videoio패키지에는 카메라를 사용하여 비디오를 캡처하는 클래스와 메서드가 포함되어 있습니다. 단계별로 프레임 캡처 방법을 배워 보겠습니다.
1 단계 : OpenCV 네이티브 라이브러리로드
OpenCV 라이브러리를 사용하여 Java 코드를 작성하는 동안해야 할 첫 번째 단계는 다음을 사용하여 OpenCV의 기본 라이브러리를로드하는 것입니다. loadLibrary(). 아래와 같이 OpenCV 네이티브 라이브러리를로드합니다.
// Loading the core library
System.loadLibrary(Core.NATIVE_LIBRARY_NAME);2 단계 : 비디오 캡처 클래스 인스턴스화
이전에이 튜토리얼에서 언급 한 함수를 사용하여 Mat 클래스를 인스턴스화합니다.
// Instantiating the VideoCapture class (camera:: 0)
VideoCapture capture = new VideoCapture(0);3 단계 : 프레임 읽기
카메라에서 프레임을 읽을 수 있습니다. read() 의 방법 VideoCapture수업. 이 메소드는 클래스의 객체를받습니다.Mat 프레임 읽기를 저장합니다.
// Reading the next video frame from the camera
Mat matrix = new Mat();
capture.read(matrix);예
다음 프로그램은 카메라를 사용하여 프레임을 캡처하고 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);
}
}산출
프로그램을 실행하면 다음과 같은 출력이 표시됩니다.
지정된 경로를 열면 jpg 파일로 저장된 동일한 프레임을 볼 수 있습니다.
그만큼 VideoCapture 의 클래스 org.opencv.videoio패키지에는 시스템 카메라를 사용하여 비디오를 캡처하는 클래스와 메서드가 포함되어 있습니다. 단계별로 가서 어떻게하는지 배우자.
1 단계 : OpenCV 네이티브 라이브러리로드
OpenCV 라이브러리를 사용하여 Java 코드를 작성하는 동안해야 할 첫 번째 단계는 다음을 사용하여 OpenCV의 기본 라이브러리를로드하는 것입니다. loadLibrary(). 아래와 같이 OpenCV 네이티브 라이브러리를로드합니다.
// Loading the core library
System.loadLibrary(Core.NATIVE_LIBRARY_NAME);2 단계 : CascadeClassifier 클래스 인스턴스화
그만큼 CascadeClassifier 패키지 클래스 org.opencv.objdetect분류 자 파일을로드하는 데 사용됩니다. 전달하여이 클래스를 인스턴스화하십시오.xml 파일 lbpcascade_frontalface.xml 아래 그림과 같이.
// Instantiating the CascadeClassifier
String xmlFile = "E:/OpenCV/facedetect/lbpcascade_frontalface.xml";
CascadeClassifier classifier = new CascadeClassifier(xmlFile);3 단계 : 얼굴 감지
방법을 사용하여 이미지에서 얼굴을 감지 할 수 있습니다. detectMultiScale() 명명 된 클래스의 CascadeClassifier. 이 메소드는 클래스의 객체를받습니다.Mat 입력 이미지와 클래스의 객체 보유 MatOfRect 감지 된 얼굴을 저장합니다.
// Detecting the face in the snap
MatOfRect faceDetections = new MatOfRect();
classifier.detectMultiScale(src, faceDetections);예
다음 프로그램은 이미지에서 얼굴을 감지하는 방법을 보여줍니다.
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 위의 프로그램에서 지정합니다.
산출
프로그램을 실행하면 다음과 같은 출력이 표시됩니다.
Detected 3 faces
Image Processed지정된 경로를 열면 다음과 같이 출력 이미지를 관찰 할 수 있습니다.
다음 프로그램은 시스템 카메라를 사용하여 얼굴을 감지하고 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.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);
}
}산출
프로그램을 실행하면 다음과 같은 출력이 표시됩니다.
지정된 경로를 열면 동일한 스냅 샷이 jpg 영상.
수행 할 수 있습니다 affine translation 사용하여 이미지에 warpAffine()imgproc 클래스의 메서드. 다음은이 방법의 구문입니다-
Imgproc.warpAffine(src, dst, tranformMatrix, size);이 방법은 다음 매개 변수를 허용합니다.
src − A Mat 이 작업의 소스 (입력 이미지)를 나타내는 개체입니다.
dst − A Mat 이 작업의 대상 (출력 이미지)을 나타내는 개체입니다.
tranformMatrix − A Mat 변환 행렬을 나타내는 개체입니다.
size − 출력 이미지의 크기를 나타내는 정수 유형의 변수.
예
다음 프로그램은 주어진 이미지에 아핀 연산을 적용하는 방법을 보여줍니다.
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 위의 프로그램에서 지정합니다.
산출
실행하면 다음과 같은 출력이 표시됩니다.
Image Processed지정된 경로를 열면 다음과 같이 출력 이미지를 관찰 할 수 있습니다.
당신은 할 수 있습니다 perform rotation 사용하여 이미지 작업 warpAffine() 의 방법 imgproc수업. 다음은이 방법의 구문입니다-
Imgproc.warpAffine(src, dst, rotationMatrix, size);이 방법은 다음 매개 변수를 허용합니다.
src − A Mat 이 작업의 소스 (입력 이미지)를 나타내는 개체입니다.
dst − A Mat 이 작업의 대상 (출력 이미지)을 나타내는 개체입니다.
rotationMatrix − A Mat 회전 행렬을 나타내는 객체입니다.
size − 출력 이미지의 크기를 나타내는 정수 유형의 변수.
예
다음 프로그램은 이미지를 회전하는 방법을 보여줍니다.
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 위의 프로그램에서 지정합니다.
산출
프로그램을 실행하면 다음과 같은 출력이 표시됩니다.
Image Processed지정된 경로를 열면 다음과 같이 출력 이미지를 관찰 할 수 있습니다.
수행 할 수 있습니다 scaling 사용하여 이미지에 resize() 의 방법 imgproc수업. 다음은이 메서드의 구문입니다.
resize(Mat src, Mat dst, Size dsize, double fx, double fy, int interpolation)이 방법은 다음 매개 변수를 허용합니다.
src − A Mat 이 작업의 소스 (입력 이미지)를 나타내는 개체입니다.
dst − A Mat 이 작업의 대상 (출력 이미지)을 나타내는 개체입니다.
dsize − A Size 출력 이미지의 크기를 나타내는 개체입니다.
fx − 수평 축을 따라 배율을 나타내는 double 유형의 변수.
fy − 수직 축을 따라 배율을 나타내는 double 유형의 변수.
Interpolation − 보간 방법을 나타내는 정수 변수.
예
다음 프로그램은 신청 방법을 보여줍니다 scale transformation 이미지에.
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 위 프로그램에서 지정합니다 (크기-폭 : 300px 및 높이 : 300px).
산출
프로그램을 실행하면 다음과 같은 출력이 표시됩니다.
Image Processed지정된 경로를 열면 다음과 같이 출력 이미지를 볼 수 있습니다. (size − Width : 600px, height : 600px) −
OpenCV에서는 방법을 사용하여 이미지에 다른 색상 맵을 적용 할 수 있습니다. applyColorMap() 수업의 Imgproc. 다음은이 방법의 구문입니다-
applyColorMap(Mat src, Mat dst, int colormap)세 가지 매개 변수를받습니다.
src − 클래스의 대상 Mat 소스 (입력) 이미지를 나타냅니다.
dst − 클래스의 대상 Mat 대상 (출력) 이미지를 나타냅니다.
colormap − 적용 할 컬러 맵의 유형을 나타내는 정수 유형의 변수.
예
다음 프로그램은 신청 방법을 보여줍니다 color map 이미지에.
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 위의 프로그램에서 지정합니다.
산출
위의 프로그램을 실행하면 다음과 같은 출력이 나타납니다.
Image Processed지정된 경로를 열면 다음과 같이 출력 이미지를 관찰 할 수 있습니다.
더 많은 작업
이외에 COLORMAP_HOT이전 예제에서 보여준 OpenCV는 다양한 다른 유형의 색상 맵을 제공합니다. 이러한 모든 유형은 Imgproc 클래스의 사전 정의 된 정적 필드 (고정 값)로 표시됩니다.
각각의 사전 정의 된 값을 다음과 같은 매개 변수에 전달하여 필요한 컬러 맵 유형을 선택할 수 있습니다. colormap 의 applyColorMap() 방법.
Imgproc.applyColorMap(src, dst, Imgproc.COLORMAP_HOT);다음은 다양한 유형의 색상 맵과 해당 출력을 나타내는 값입니다.
| 작동 및 설명 | 산출 |
|---|---|
| COLORMAP_AUTUMN |
|
| COLORMAP_BONE |
|
| COLORMAP_COOL |
|
| COLORMAP_HOT |
|
| COLORMAP_HSV |
|
| COLORMAP_JET |
|
| COLORMAP_OCEAN |
|
| COLORMAP_PARULA |
|
| COLORMAP_PINK |
|
| COLORMAP_RAINBOW |
|
| COLORMAP_SPRING |
|
| COLORMAP_SUMMER |
|
| COLORMAP_WINTER |
|
Canny Edge Detection은 이미지의 가장자리를 감지하는 데 사용됩니다. 회색조 이미지를 입력으로 받아들이고 다단계 알고리즘을 사용합니다.
다음을 사용하여 이미지에서이 작업을 수행 할 수 있습니다. Canny() 의 방법 imgproc 다음은이 메서드의 구문입니다.
Canny(image, edges, threshold1, threshold2)이 방법은 다음 매개 변수를 허용합니다.
image − A Mat 이 작업의 소스 (입력 이미지)를 나타내는 개체입니다.
edges − A Mat 이 작업의 대상 (에지)을 나타내는 개체입니다.
threshold1 − 히스테리시스 절차에 대한 첫 번째 임계 값을 나타내는 double 유형의 변수.
threshold2 − 히스테리시스 절차에 대한 두 번째 임계 값을 나타내는 double 유형의 변수.
예
다음 프로그램은 주어진 이미지에서 Canny Edge Detection 작업을 수행하는 방법을 보여주는 예제입니다.
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 위의 프로그램에서 지정합니다.
산출
위의 프로그램을 실행하면 다음과 같은 출력이 나타납니다.
Image Processed지정된 경로를 열면 다음과 같이 출력 이미지를 관찰 할 수 있습니다.
다음을 적용하여 주어진 이미지의 모양을 감지 할 수 있습니다. Hough Transform technique 방법 사용 HoughLines() 의 Imgproc수업. 다음은이 메서드의 구문입니다.
HoughLines(image, lines, rho, theta, threshold)이 방법은 다음 매개 변수를 허용합니다.
image − 클래스의 대상 Mat 소스 (입력) 이미지를 나타냅니다.
lines − 클래스의 대상 Mat 라인의 매개 변수 (r, Φ)를 저장하는 벡터를 저장합니다.
rho − 매개 변수 r의 해상도를 픽셀 단위로 나타내는 double 유형의 변수.
theta − 매개 변수 Φ의 해상도를 라디안 단위로 나타내는 double 유형의 변수.
threshold − 라인을 "감지"하기위한 최소 교차 수를 나타내는 정수 유형의 변수.
예
다음 프로그램은 주어진 이미지에서 허프 라인을 감지하는 방법을 보여줍니다.
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 위의 프로그램에서 지정합니다.
산출
프로그램을 실행하면 다음과 같은 출력이 표시됩니다.
143
1
Image Processed지정된 경로를 열면 다음과 같이 출력 이미지를 관찰 할 수 있습니다.
그만큼 histogram이미지는 픽셀의 강도 값의 빈도를 보여줍니다. 이미지 히스토그램에서 X 축은 그레이 레벨 강도를 나타내고 Y 축은 이러한 강도의 빈도를 나타냅니다.
Histogram equalization강도 범위를 늘리기 위해 이미지의 대비를 향상시킵니다. 다음 방법을 사용하여 주어진 이미지의 히스토그램을 균등화 할 수 있습니다.equalizeHist() 의 Imgproc수업. 다음은이 메서드의 구문입니다.
equalizeHist(src, dst)이 방법은 다음 매개 변수를 허용합니다.
src − 클래스의 대상 Mat 소스 (입력) 이미지를 나타냅니다.
dst − 클래스의 대상 Mat출력을 나타냅니다. (히스토그램을 균등화 한 후 얻은 이미지)
예
다음 프로그램은 주어진 이미지의 히스토그램을 균일화하는 방법을 보여줍니다.
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 위의 프로그램에서 지정합니다.
산출
프로그램을 실행하면 다음과 같은 출력이 표시됩니다.
Image Processed지정된 경로를 열면 다음과 같이 출력 이미지를 관찰 할 수 있습니다.
