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.imgcodecsorg.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 − 폴더 열기 OpenCVbuildjava. 여기에 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 하위 폴더로 이동 buildjava. 여기에 두 개의 폴더가 있습니다.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

지정된 경로를 열면 다음과 같이 출력 이미지를 관찰 할 수 있습니다.

이전 장에서 우리는 erosiondilation. 이 두 가지 외에도 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 수업.

각각의 사전 정의 된 값을 매개 변수에 전달하여 필요한 형태 유형을 선택할 수 있습니다. opmorphologyEx() 방법.

// 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 수업.

각각의 사전 정의 된 값을 다음과 같은 매개 변수에 전달하여 필요한 임계 값 작업의 유형을 선택할 수 있습니다. typethreshold() 방법.

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의 이미지에서 적응 임계 값 연산을 수행하는 방법을 보여줍니다. 여기서 우리는 유형의 적응 형 임계 값을 선택합니다.binaryADAPTIVE_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);

    다음은 매개 변수 값의 다양한 조합을 나타내는 값입니다. adaptiveMethodthresholdType 및 각각의 출력.

    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 클래스의 미리 정의 된 정적 필드 (고정 값)로 표시됩니다.

    각각의 사전 정의 된 값을 다음과 같은 매개 변수에 전달하여 필요한 임계 값 작업의 유형을 선택할 수 있습니다. borderTypecopyMakeBorder() 방법.

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

    다음 표는 변수에 대한 다양한 값을 나열합니다. dxdy 방법의 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);

    다음은 변수에 대한 다양한 값을 나열하는 표입니다. dxdy 방법의 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 클래스의 사전 정의 된 정적 필드 (고정 값)로 표시됩니다.

각각의 사전 정의 된 값을 다음과 같은 매개 변수에 전달하여 필요한 거리 변환 작업의 유형을 선택할 수 있습니다. distanceTypedistanceTransform() 방법.

// 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 클래스의 사전 정의 된 정적 필드 (고정 값)로 표시됩니다.

각각의 사전 정의 된 값을 다음과 같은 매개 변수에 전달하여 필요한 컬러 맵 유형을 선택할 수 있습니다. colormapapplyColorMap() 방법.

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

지정된 경로를 열면 다음과 같이 출력 이미지를 관찰 할 수 있습니다.