OpenCV

OpenCV

OpenCV
컴퓨터 비전 애플리케이션을 개발하기 위한 오픈소스 라이브러리.

[구성]
build/include : 헤더파일들이 들어있는 디렉터리. (.hpp, .h)
build/install/x64/vc14/lib : x64환경 Visual Studio 2015용(vc14) OpenCV Debug/Release 라이브러리 파일들이 들어있는 디렉터리 (.lib)
build/install/x64/vc14/bin : x64환경 Visual Studio 2015용(vc14) OpenCV Debug/Release 동적 연결 라이브러리 파일들이 들어있는 디렉터리 (.dll)
ovencv_world_341d.dll -> d는 debug용 파일 (이 파일은 하나로 모아둔 dll 파일 [설치법]4.에서BUILD_OPENCV_WORLD )
build\etc : haarcascades, lbpcascades XML 파일들이 들어있는 디렉터리 (.xml)

[모듈]
opencv_core 모듈 : 라이브러리의 핵심기능이 들어 있다.
opencv_impproc 모듈 : 주요 영상처리 함수 포함.
opencv_highgui 모듈 : 영상과 비디오 읽기/쓰기 함수 제공. 몇 가지 사용자 인터페이스 제공.
특정 모듈을 사용하려면 최상위 헤더파일을 include 해야한다.

[설치법]
영상(컴퓨터 비전)  라이브러리이기에 공간은 적어도 20GB 비워 놓아야 한다.
작업시간 최소 2시간
1. opencv.org 에서 최신버전 다운 후 압축풀기 ex) C:\opencv-3.4.1 이런식으로
2. 최첨단 알고리즘을 활용하기위해 추가 모듈 설치 github.com/opencv/opencv_contrib에서
zip파일 다운 후 압축해제 opencv_contrib-master\modules를 contrib로 폴더명 변경 후 ex) opencv-3.4.1/opencv/sources에 넣는다. (나머진 필요없음.)
3. 오픈소스 소프트웨어 도구 CMake 다운. cmake.org .msi 설치형으로 받아서 Add CMake to the system PATH for all users 체크 (안해도 된다.)
설치 위치는 상관없다. ex) C:\Program Files\CMake\
CMake GUI를 사용해서 opencv 라이브러리소스와 바이너리있는 폴더지정
Where is the source code -> ex) C:\opencv-3.4.1\sources
Where to build the binaries -> ex) C:\opencv-3.4.1\build
4. Tools -> Configure 현재 설치된 컴파일러 선택! ex) Visual Studio 14 2015 Win64 Finish버튼 누른다.
만약 잘못 눌러서 에러 발생시 File -> Delete Cache하고 다시 4. 시도한다.
OPENCV_EXTRA_MODULES_PATH의 VALUE에 2.에서 다운받았던 추가 모듈 지정 ex) C:/opencv-3.4.1\sources\contrib
Configure 버튼 클릭
예제를 보기 위해선 BUILD_OPENCV_EXAMPLE 체크
상업,배포용이 아닌경우 DLL을 하나로 통합해주는 BUILD_OPENCV_WORLD 체크
CUDA 설정 엄청난 빌드시간이 걸릴 수 있으나 실험용으로 쓸 것이면 체크 관련된 것 전부 언체크 (난 다 언체크)
Python, C 예제 보려면 INSTALL_C_EXAMPLES(난 언체크), INSTALL_PYTHON_EXAMPLES 체크
OPENCV에서 OPENGL을 사용하는 코드를 작성할 경우 WITH_OPENGL 체크
C++11버전 지원 Enable_CXX11 체크
자바스크립트 지원 Build opencv_js 체크
OPENCV 문서 지원 DOCS 체크
모든 항목이 빨간색이 사라질 때까지 Configure 버튼 누른다. (2-3번)
5. 라이브러리를 컴파일 할 수 있게 하는 프로젝트 파일 생성. Generate 버튼 클릭
6. 프로젝트 파일 실행 후 Build하기. Open Project버튼 클릭 or ex)Visual Studio라면 opencv-3.4.1\build\OpenCV.sln을 연다.
빌드>솔루션 빌드 Release 와 Debug 각각 빌드. ALL BUILD 작업. 그 후에 .dll과 .lib파일을 특정폴더에 모아두는 INSTALL 빌드 작업.
INSTALL 프로젝트(CMakeTargets아래)를 선택하고 마우스 오른쪽 Build, Release 와 Debug 각각 빌드.
성공 시 install 디렉토리 생성 ex) C:\opencv-3.4.1\build\install
install 디렉토리에 애플리케이션에 링크해야하는 OpenCV 라이브러리의 모든 바이너리 파일들, 런타임에서 호출가능하능한 동적라이브러리 파일들이 들어있음.
리눅스 환경이라면 sudo make INSTALL이나 apt-get
맥OS에선 홈브루 패키지 관리자 사용. brew install opencv3 -with-contrib 입력
7. 끝

+ VTK 추가소프트웨어 설치
cv::viz 모듈 : 영상으로 부터 장면의 3D 정보를 재구성하기 위해 사용한다. 장면 객체와 카메라를 시각화해주는 함수 제공.
다른 오픈소스 라이브러리 VTK위에서 빌드된 것이므로 OpenCV를 컴파일하기 전에 시스템에 VTK를 설치해야한다.


[세팅]
1. 새 솔루션, 프로젝트 생성, C++ 콘솔 애플리케이션 생성(vc-15에서 Window 데스크톱 마법사 실행). 자신의 컴퓨터의 [플렛폼]에 맞게 설정 [x84] <-> [x64].
2. 프로젝트 속성에서 [구성]-> [모든구성]으로 변경 한번에 Debug/Release설정을 위해 그리고 [C/C++] 선택 후, 추가 포함 디렉터리 build\include 추가
ex) C:\opencv-3.4.1\build\include 
3. [링커]선택 후, [추가 라이브러리 디렉터리] 에 OpenCV 라이브러리 lib 파일 위치 입력 build\install\x64(or x84)\vc??\lib
ex) C:\opencv-3.4.1\build\install\x64\vc14\lib
4. [구성속성] -> [디버깅]선택 후, [환경] 에 OpenCV 라이브러리 dll 파일 위치 입력
ex) PATH=C:\opencv-3.4.1\build\install\x64\vc14\bin;%PATH%
5. 확인 누르고 [구성]-> [활성(Debug)] 선택, [링커]-> [입력] -> [추가종속성] 에 opencv_world버전d.lib 추가 //이 작업은 ".hpp" <.hpp> 되게 하는것
ex) opencv_world341d.lib;
6. [구성]-> [활성(Release)] 선택, [링커]-> [입력] -> [추가종속성] 에 opencv_world버전.lib 추가 //이 작업은 ".hpp" <.hpp> 되게 하는것
ex) opencv_world341.lib;
7. 확인 누르고 끝 만약, cmd에서 사용하려면 환경변수에 추가 C:\opencv-3.4.1\build\install\x64\vc15\bin;


[기초]

1. 영상을 불러오고 띄우고 저장하기 [Playing with Images]
- Depth는 Pixel를 표현하는 Date Type(자료형)이며 정확히는 Channel당 bit수 다.
  COLOR(컬러 영상)이면 3채널에 채널당 8비트이므로 Depth는 3*8=24비트이다.
- cv::Point 구조체는 특정 점을 표현할 때 사용한다. (x, y)로 구성
- cv::Scalar 구조체는 컬러 값을 지정할 때 사용한다. (b, g, r)로 구성 BGR순서 Blue, Green, Red순
- cv::Size 구조체는 특정 사이즈를 표현할 때 사용한다. (가로길이cols, 세로길이rows)로 구성 ( <-> 다른 것과 역이라는 것 생각하기 보통 세로,가로 )
- cv::Rect 구조체는 사각형을 표현할 때 사용한다. (x, y, width, height)로 구성
- cv::Range 구조체는 범위를 표현할 때 사용한다. (2차원 직선), (start, end)로 구성
- 영상은 행렬이다.
- 입력배열/출력배열(1cv::InputArray, cv::OutputArray)는 OpenCV에서 배열 개념을 일반화하기 위해 도입한 Proxy Class(프록시 클래스)이다.
  이것의 장점은 함수가 데이터의 구조체를 수정하지 않는것을 보장한다.
  cv::Mat 뿐만 아니라 std::vector(단, 클래스내부or 함수 내부에서 사용해선 안됨), cv::Scalar, cv::Vec을 사용할 수 있다.
  ex) 2개의 값을 갖는 이진영상으로 변환하는 cv::threshold() 함수를 다음과 같이 쓸 수 있다.
      std::vector<double> src = ~
      cv::Mat dst;
      cv::threshold(src, dst, 128, 255, cv::THRESH_BINARY);
- cv::Matx 템플릿 클래스와 서브 클래스는 작은 행렬을 다룰 때 사용할 수 있다.
  ex) double의 3X3 행렬과 3원소 백터의 곱
      cv::Matx33d matrix(3.0, 2.0, 1.0,
      			 2,0, 1.0, 3.0,
			 1.0, 2.0, 3.0);
			 
      cv::Matx31d vector(5.0, 1.0, 3.0);
      cv::Matx31d result = matrix * vector;
- ROI(Region Of Interest) = 관심 영역 : 영상편집의 마스크 기능처럼, 영상의 일부에만 처리 함수를 적용해야 할 때 영상에서 부분영역을 정의한 후,
  일반 영상으로 간주해 다루는 훌륭한 매커니즘을 가지고 있다. 부모 영상과 동일한 데이터 버퍼를 가리키며, 핵심은 ROI좌표를 지정한 헤더를 가진 cv::Mat 객체이다.
  반드시, copyTo()나 clone()같이 깊은복사로 이미지를 붙여넣어야한다.
  마스크로 쓸 Mat는 얇은복사 해야하며(이미지 추가 할 때는 똑같이 깊은복사), 마스크는 8비트 영상이여야하며, 0인 부분을 투명하게 한다. 마스크적용할추가이미지.copyTo(ROI, 마스크용Mat);
  1) cv::Rect 사용하기
  ex) cv::Mat imageROI(image, cv::Rect(image.cols - logo.cols, image.rows - logo.rows, logo.cols, logo.rows));
  ex) cv::Mat imageROI = image(cv::Rect(image.cols - logo.cols, image.rows - logo.rows, logo.cols, logo.rows));
  ex) cv::Rect r(image.cols - logo.cols, image.rows - logo.rows, logo.cols, logo.rows); cv::Mat imageROI= image(r);
  2) cv::Range 사용하기
  ex) cv::Mat imageROI = image(cv::Range(image.rows-logo.rows,image.rows), cv::Range(image.cols-logo.cols,image.cols));
  3) mask 사용하기 
  ex) cv::Mat mask(logo);
      logo.copyTo(imageROI, mask);
  
<코드 1 - 영상을 불러오고 띄우고 저장하기>
#include <opencv2/core.hpp>
#include <opencv2/highgui.hpp>
#include <opencv2/imgproc.hpp>
#include <iostream>


void onMouse(int event, int x, int y, int flags, void* param) {
	cv::Mat *im = reinterpret_cast<cv::Mat*>(param);

	switch (event)
	{
		case CV_EVENT_LBUTTONDOWN:
			std::cout << "at (" << x << ", " << y << ") value is: " << static_cast<int>(im->at<uchar>(cv::Point(x, y))) << std::endl;
			break;
	}
}

int main()
{
	cv::namedWindow("Original Image");


	cv::Mat image = cv::imread("images/puppy.bmp",CV_LOAD_IMAGE_GRAYSCALE);
	std::cout << "This image is " << image.rows << "x" << image.cols << std::endl;
	std::cout << "This image has " << image.channels() << " channel(s)" << std::endl;

	cv::circle(image, cv::Point(155, 100), 65, 0, 3);

	cv::putText(image, "This is a dog.", cv::Point(40, 200), cv::FONT_HERSHEY_PLAIN, 2.0, 255, 2);


	cv::imshow("Original Image", image);

	cv::setMouseCallback("Original Image", onMouse, reinterpret_cast<void*>(&image));

	cv::namedWindow("ABC");

	cv::flip(image, image, 1);
	cv::imshow("ABC", image);

	cv::waitKey(0);

	cv::imwrite("resultTest01.png", image);

	return 0;
}

<코드 2 - cv::Mat 데이터 구조체 살펴보기>
#include <opencv2/core.hpp>
#include <opencv2/highgui.hpp>
#include <iostream>

cv::Mat function() {
	//영상생성
	cv::Mat ima(500, 500, CV_8U,50);
	//생성된 영상 반환
	return ima;
}

int main()
{
	//240행과 320열로 구성된 새로운 영상 생성
	cv::Mat image1(240, 320, CV_8U, 100);
	//또는
	//cv::Mat image1(240, 320, CV_8U, cv::Scalar(100));

	cv::imshow("Image", image1); //영상보기
	
	std::cout << "image1's size is " << image1.size<< std::endl;
	cv::waitKey(0); //키 입력 기다리기

	//새로운 영상을 재할당
	image1.create(200, 200, CV_8U);
	image1 = 200;

	cv::imshow("Image", image1); //영상보기
	cv::waitKey(0); //키 입력 기다리기

	//빨간색 영상 생성
	//채널 순서는 BGR 임
	cv::Mat image2(240, 320, CV_8UC3, cv::Scalar(0, 0, 255));

	//또는
	//cv::Mat image2(cv::Size(320,240),CV_8UC3);
	//image2 = cv::Scalar(0,0,255);

	cv::imshow("Image", image2); //영상보기
	cv::waitKey(0); //키 입력 기다리기

	//영상읽기
	cv::Mat image3 = cv::imread("images/puppy.bmp");

	//모든 영상은 동일한 데이터 블록을 가리킴
	cv::Mat image4(image3);
	image1 = image3;

	//이런 영상은 원시 영상의 새로운 복사본임
	image3.copyTo(image2);
	cv::Mat image5 = image3.clone();

	//테스트하기 위해 영상을 변환
	cv::flip(image3, image3, 1);

	//처리에 영향을 받은 영상이 어떤지 확인
	cv::imshow("Image 3", image3);
	cv::imshow("Image 1", image1);
	cv::imshow("Image 2", image2);
	cv::imshow("Image 4", image4);
	cv::imshow("Image 5", image5);
	cv::waitKey(0);

	//function 함수로부터 그레이레벨 영상 얻기
	cv::Mat gray = function();

	cv::imshow("Image", gray); //영상보기
	cv::waitKey(0); //키 입력 기다리기

	//영상을 그레이스케일로 읽기
	image1 = cv::imread("images/puppy.bmp", CV_LOAD_IMAGE_GRAYSCALE);
	image1.convertTo(image2, CV_32F, 1/255.0, 0.0);

	cv::imshow("Image", image2);  //영상보기
	cv::waitKey(0); //키 입력 기다리기

	//행렬 Matx 클래스 예제
	cv::Matx33d matrix(3.0, 2.0, 1.0,
		2.0, 1.0, 3.0,
		1.0, 2.0, 3.0);

	cv::Matx31d vector(5.0, 1.0, 3.0);

	cv::Matx31d result = matrix * vector;

	std::cout << result;
	cv::waitKey(0);

	return 0;
}

<코드 3 - 관심 영역 정의>
#include <opencv2/core.hpp>
#include <opencv2/highgui.hpp>
#include <iostream>

int main()
{
	cv::namedWindow("Image");

	cv::Mat image = cv::imread("images/puppy.bmp");

	cv::Mat logo = cv::imread("images/smalllogo.png");

	//영상의 오른쪽 하단에서 영상 ROI 정의, Rect(x,y,width,height)
	cv::Mat imageROI(image, cv::Rect(image.cols - logo.cols, image.rows - logo.rows, logo.cols, logo.rows));

	//로고삽입
	logo.copyTo(imageROI);

	cv::imshow("Image",image);
	cv::waitKey();
	
	//새로운 이미지 합성을 위해 다시로드
	image = cv::imread("images/puppy.bmp");

	//다른방법으로 왼쪽아래에 영상 ROI 정의
	imageROI = image(cv::Range(image.rows - logo.rows, image.rows), cv::Range(0, logo.cols));

	//이번엔 마스크로 쓸 이미지 얇은복사, 마스크는 8비트 영상이여야하며, 0인 부분을 투명하게 한다.
	cv::Mat mask(logo);

	logo.copyTo(imageROI, mask);

	cv::imshow("Image2", image);
	cv::waitKey();
}

2. 화소 다루기 [Manipulating the Pixels]
- 화소(Pixel)는 행렬의 각 원소.
- 원소가 단일 수치 값이거나 다중 채널 영상인 경우, 값이 백터일 수 있다.
- salt-and-pepper noise는 흰색(0), 검은색(255)을 번갈아 가며 넣는 노이즈를 뜻한다.
- impulse noise는 흰색(0)이나 검은색(255) 한가지만 넣는 노이즈를 말한다.
- cv::Vec!? (= cv::Vec<T,N>) 구조체는 특정개수의 원소의 집합, 백터형을 표현할 때 사용한다. (!에 원소의 개수 2,3,4 등) (?에 b = byte, l = long, f = float, d = double, s = short 등)
- CV_Assert(expr) 매크로 : expr 조건식이 거짓이면 예외를 발생시킨다.
  ex) CV_Assert(image.type() == CV_8UC1); // 그레이레벨이 아닐경우 예외처리
- 행 마다 원소의 개수가 다를 수 있다. 중복되는 원소는 포함되지 않기에(?)
- 컬러 감소 작업 : CV_8U3C의 컬러의 총 개수는 256*256*256 = 약 1,600만 컬러 이상이다. 따라서 분석복잡도를 줄이기 위해 컬러 감소 알고리즘들이 존재한다.
  1) 가장 간단한 기본 컬러 감소 알고리즘 : N이 감소인자이면 영상의 각 화소와 해당 화소의 각 채널을 N으로 나눈다.(정수로 나누기에 나머지를 잃는다.) 그런다음 N을 곱하고(N의 배수로 만들어주는 작업) N/2를 더해 중간값으로 보정한다.
     결국 256/N * 256/N * 256/N 인 컬러 개수로 줄일 수 있다.
     식 : data/N*N + N/2
  2) 비슷하지만 다른 알고리즘1 : 나머지 연산자를 사용한 알고리즘.
     식 : data - data%N + N/2
  3) 비슷하지만 다른 효율적인 알고리즘2 : 비트별 연산자를 사용한 알고리즘. pow(2,n)으로 제한했을 때 화소 값의 첫번 째 n비트를 마스킹하면 div의 가장 가까운 낮은 배수를 제공한다. 다른 알고리즘보다 효율적이다.
     식 : mask = 0xFF<<(logN/log2), data &= mask and data |= div>>1 
- 영상처리에서는 일반적으로 이웃하는 화소 값에 기반을 두고 각 화소 위치의 값을 계산하는 처리 함수를 사용한다. = 이웃 접근으로 영상 조회
- 영상을 선명하게 만드는 처리 함수는 라플라시안 연산자(6강)에 기반을 둔다. 영상에 라플라시안을 빼면 영상 에지가 두드러지게 돼 결국 선명한 영상을 얻게된다.
- 선명화 처리, 샤프닝 : sharpened_pixel = 5*current - left - right - up - down; 3개의 포인터를 사용한다. 현재 행, 위 행, 아래 행
                      화소 계산 시 이웃에 접근해야 하므로 첫 행,열과 마지막 행,열의 값을 계산하는 것은 불가능하다.
  1) 기본적인 방법: 포인터를 생성해서 계산하기. 검은 테두리가 생긴다. 검은 테두리를 제거하는 알고리즘들도 있다.
  2) 커널 행렬, 커널은 원하는 결과를 얻기 위해 계산에 관련된 화소를 조합하는 방법을 기술하는 것이다.
  [ 0 -1 0 ]
  [-1 5 -1 ]
  [ 0 -1 0 ]
  별 다른 언급이 없는경우 현재의 화소는 커널의 중심, 커널의 크기는 이웃의 크기이며, 커널은 영상에 적용하는 필터를 정의한다.(곱한다) 
  cv::filter2D 와 커널행렬을 사용해서 처리할 수 있다. 검은 테두리가 생기지 않는다. 큰 커널일 경우 더욱 유리하다.
  3) Iterator반복자를 사용하는 방법 : 반복자를 포인터선언처럼해서 처리한다. 검은 테두리가 생기며 흑백만 가능하다.
    ex)
    	//그레이레벨 이미지여야함.
	CV_Assert(image.type() == CV_8UC1);

	//반복자들을 1행으로 초기화
	cv::Mat_<uchar>::const_iterator it = image.begin<uchar>() + image.cols;
	cv::MatConstIterator_<uchar> itend = image.end<uchar>() - image.cols;
	cv::Mat_<uchar>::const_iterator itup = image.begin<uchar>();
	cv::MatConstIterator_<uchar> itdown = image.begin<uchar>() + 2*image.cols;

	//재할당 필요성을 위해
	result.create(image.size(), image.type());
	//output 반복자 설정
	cv::Mat_<uchar>::iterator itout = result.begin<uchar>() + result.cols;

	for (; it != itend; ++it, ++itout, ++itup, ++itdown) {
		*itout = cv::saturate_cast<uchar>(*it * 5 - *(it - 1) - *(it + 1) - *itup - *itdown);
	}

	//처리하지 않은 영역 0으로
	result.row(0).setTo(cv::Scalar(0));
	result.row(result.rows - 1).setTo(cv::Scalar(0));
	result.col(0).setTo(cv::Scalar(0));
	result.col(result.cols - 1).setTo(cv::Scalar(0));
- 영상의 산술 연산 : 연산자로도 가능하고 각종 산술 함수를 사용해서 특정 영상의 화소값을 산술 할 수 있다.
  모든 산술 연산자는 결과가 입력 타입의 범위 안에 있다는 것을 보장하기 위해 항상 saturate_cast() 함수를 호출한다.
    ex) result = 0.7* image1 + 0.9*image2; //가중치를 둔 ADD를 연산자로 연산한 것
    ex) cv::addWeighted(image1, 0.7, image2, 0.9, 0., result); //위와 같은 코드
  연산자의 종류 add, subtract, absdiff, multiply, divide, bitwise_and, bitwise_or, bitwise_xor, bitwise_not, min, max, sqrt, pow, abs, cuberoot, exp, log 등등.
  그 외 수학함수 역행렬 m1.inv(), 전치 mt1.t(), 행렬식 m1.determinant(), 행렬식 v1.norm(), 외적 v1.cross(v2), 내적 v1.dot(v2)
  칼라감소 알고리즘 산술 연산자로 간결하게 작성한 예시) image = (image & cv::Scalar(mask, mask, mask)) + cv::Scalar(div / 2, div / 2, div / 2);
- 영상 채널 분리/결합 : 각 채널을 따로 처리할 때 사용한다. cv::split(분리할, 분리된) 과 cv::merge(합칠,합쳐진)로 가능하다.
    ex) // 3개의 Mat로 이뤄진 Vector 선언
	std::vector<cv::Mat> planes;
	// 3채널 이미지의 채널을 모두 나눠 3개의 이미지로 split함수
	cv::split(image1, planes);
	// 블루채널에 ADD하기
	planes[0] += image2;
	// 다시 3채널 합쳐서 하나의 3채널 이미지로
	cv::merge(planes, result);
- 영상 재매핑 : 영상의 화소를 옮겨 영상의 모습을 변경하는 방법으로, 화소 값을 바꾸지 않는 대신 화소의 위치를 재매핑한다. 특수한 효과나 영상 왜곡을 보정할 때 매우 유용하다.
               remap함수를 사용하려면 재매핑 맵을 먼저 정의해야 한다. 그런다음 입력영상에 맵을 적용한다. 
	       역방향매핑이라고 하는데 변환이 새로운 영상의 화소를 원본 영상에 재매핑하는 방법을 기술하기 때문이다.
	       실제화소 사이에 있는 가상화소의 값을 보간할 수 있는 방법이 5번째 인자 보간방법에 의해 정해진다. (*화소 보간은 6에서 더 자세하게)
 
<코드 1 - 화소 값에 접근하기/ 노이즈 만들기>
#include <opencv2/core.hpp>
#include <opencv2/highgui.hpp>
#include <random>

void salt(cv::Mat image, int n) {

	//C++11 난수생성기
	std::default_random_engine generator;
	std::uniform_int_distribution<int> randomRow(0, image.rows - 1);
	std::uniform_int_distribution<int> randomCol(0, image.cols - 1);

	int i, j;

	for (int k = 0; k < n; k++)
	{
		//무작위 영상 좌표
		i = randomCol(generator);
		j = randomRow(generator);

		//그레이레벨 영상 CV_8U 말고 CV_8UC1이라고 표현가능
		if (image.type() == CV_8UC1) {
			image.at<uchar>(j, i) = 255;
		}
		else if (image.type() == CV_8UC3) {
			//3채널 이기에 Vec3b 를 사용. b는 byte uchar형을 의미
			image.at<cv::Vec3b>(j, i)[0] = 255;
			image.at<cv::Vec3b>(j, i)[1] = 255;
			image.at<cv::Vec3b>(j, i)[2] = 255;

			// 이렇게 쓸수도 있다.
			// image.at<cv::Vec3b>(j, i) = cv::Vec3b(255, 255, 255);
		}
	}
}

void salt2(cv::Mat image, int n)
{
	CV_Assert(image.type() == CV_8UC1);

	//C++11 난수생성기
	std::default_random_engine generator;
	std::uniform_int_distribution<int> randomRow(0, image.rows - 1);
	std::uniform_int_distribution<int> randomCol(0, image.cols - 1);

	//cv::Mat_ 템플릿클래스 사용
	//서브 클래스로 생성
	cv::Mat_<uchar> img1(image);

	//참조형으로 사용하는 법
	cv::Mat_<uchar>& img2= reinterpret_cast<cv::Mat_<uchar>&>(image);

	int i, j;
	for (int k = 0; k < n; k++)
	{
		i = randomCol(generator);
		j = randomRow(generator);

		img1(j, i) = 255;
	}
}

int main()
{
	cv::namedWindow("Image");
	
	cv::Mat image = cv::imread("../images/boldt.jpg",1);

	salt(image, 3000);

	cv::imshow("Image", image);
	cv::waitKey();

	image = cv::imread("../images/boldt.jpg", 0);

	salt2(image, 500);

	cv::imshow("Image", image);
	cv::waitKey();

	return 0;
}

<코드 2 - 포인터로 영상 조회/ 칼라 감소 알고리즘>
#include <opencv2/core.hpp>
#include <opencv2/highgui.hpp>
#include <iostream>

//기본
void colorReduce(cv::Mat image, int div = 64)
{
	int nl = image.rows; // 행의 개수
	int nc = image.cols * image.channels(); // 각 행의 원소(channel) 총 개수

	for (int j = 0; j < nl; j++)
	{
		uchar* data = image.ptr<uchar>(j);
		for (int i = 0; i < nc; i++)
		{
			data[i] = data[i] / div * div + div / 2;
		}
	}
}

//다른방법1
void colorReduce1(cv::Mat image, int div = 64) 
{
	int nl = image.rows; 
	int nc = image.cols * image.channels(); 
	uchar div2 = div >> 1; // div2 = div/2

	for (int j = 0; j<nl; j++) {
		uchar* data = image.ptr<uchar>(j);
		for (int i = 0; i<nc; i++)
		{
			*data++ = *data / div * div + div2; // 포인터산술을 이용한 방법이다. 이렇게도 사용가능
		} 
	}
}

//다른방법2
void colorReduce2(cv::Mat image, int div = 64) 
{
	int nl = image.rows;
	int nc = image.cols * image.channels();
	uchar div2 = div >> 1; // div2 = div/2

	for (int j = 0; j<nl; j++) {
		uchar* data = image.ptr<uchar>(j);
		for (int i = 0; i<nc; i++)
		{
			int v = *data;
			*data++ = v - v % div + div2; // 나머지연산자+포인터산술을 이용한 방법이다. 이렇게도 사용가능
		}
	}
}

//다른방법3
void colorReduce3(cv::Mat image, int div = 64) 
{
	int nl = image.rows;
	int nc = image.cols * image.channels();
	int n = static_cast<int>(log(static_cast<double>(div)) / log(2.0) + 0.5); // + 0.5는 반올림 logA/logB = log_B A와같음 log_2 2^6 = 6.0
	//화소 값을 반올림하기 위해 사용하는 마스크
	uchar mask = 0xFF << n; // e.g. for div=16, mask= 0xF0
	uchar div2 = 1 << (n - 1); // div2 = div/2 (단 div는 2^n)


	for (int j = 0; j<nl; j++) {
		uchar* data = image.ptr<uchar>(j);
		for (int i = 0; i<nc; i++)
		{
			*data &= mask;     // 마스킹하는 and비트연산
			*data++ |= div2;   // or비트연산으로 div/2 더하기
			//*data++ += div2;   // div/2 더하기
		}
	}
}

//다른방법3-2 저수준 포인터 산술 오류가 발생하기 쉬우므로 추천하는 방법이 아님
void colorReduce4(cv::Mat image, int div = 64) 
{
	int nl = image.rows;
	int nc = image.cols * image.channels();
	int n = static_cast<int>(log(static_cast<double>(div)) / log(2.0) + 0.5); // + 0.5는 반올림 logA/logB = log_B A와같음 log_2 2^6 = 6.0
	int step = image.step;	//유효너비를 바이트단위(=uchar)로 저장
	//화소 값을 반올림하기 위해 사용하는 마스크
	uchar mask = 0xFF << n; // e.g. for div=16, mask= 0xF0
	uchar div2 = 1 << (n - 1); // div2 = div/2 (단 div는 2^n)

	uchar* data = image.data; // 데이터블록의 첫 지점 가져오기
	for (int j = 0; j<nl; j++) {
		for (int i = 0; i<nc; i++)
		{
			*(data+i) &= mask;     // 마스킹하는 and비트연산
			*(data+i) += div2;   // div/2 더하기
			//*(data+i) |= div2;   // or비트연산으로 div/2 더하기
			//std::cout<<*(data+i)<<std::endl;
		}
		data += step; // 다음 행 주소가져오기
	}
}

//다른방법3-3 행의 원소개수를 재계산해서 하는방법 느리다. 이렇게해선 안되는 예
void colorReduce5(cv::Mat image, int div = 64) 
{
	int nl = image.rows;
	int n = static_cast<int>(log(static_cast<double>(div)) / log(2.0) + 0.5); // + 0.5는 반올림 logA/logB = log_B A와같음 log_2 2^6 = 6.0
	//화소 값을 반올림하기 위해 사용하는 마스크
	uchar mask = 0xFF << n; // e.g. for div=16, mask= 0xF0
	uchar div2 = 1 << (n - 1); // div2 = div/2 (단 div는 2^n)


	for (int j = 0; j<nl; j++) {
		uchar* data = image.ptr<uchar>(j);
		//행의 원소개수를 재개산 비효율적인 코드
		for (int i = 0; i<image.cols * image.channels(); i++)
		{
			*data &= mask;     // 마스킹하는 and비트연산
			*data++ += div2;   // div/2 더하기
		}
	}
}

//인풋,아웃풋 모델
void colorReduceIO(const cv::Mat &image, cv::Mat &result, int div = 64) 
{
	int nl = image.rows;
	int nc = image.cols; 
	int nchannels = image.channels();

	//만약 아웃풋 모델의 크기와 타입이 인풋 모델과 다를 경우 수정
	result.create(image.rows, image.cols, image.type());

	for (int j = 0; j<nl; j++) {
		//인풋, 아웃풋 모델의 행 주소 가져오기
		const uchar* data_in = image.ptr<uchar>(j);
		uchar* data_out = result.ptr<uchar>(j);

		for (int i = 0; i<nc*nchannels; i++) {
			data_out[i] = data_in[i] / div * div + div / 2;
		}
	}
}

//다른방법3-4 만약 추가화소가 없는경우 직렬로 계산 반복문 j를 무효화 함 2차-> 1차 더 효율성을 높임
void colorReduce6(cv::Mat image, int div = 64) 
{
	int nl = image.rows;
	int nc = image.cols * image.channels();

	if (image.isContinuous()) {
		nc = nc*nl;
		nl = 1;
	}
	int n = static_cast<int>(log(static_cast<double>(div)) / log(2.0) + 0.5);
	uchar mask = 0xFF << n;
	uchar div2 = div >> 1;

	for (int j = 0; j < nl; j++)
	{
		uchar *data = image.ptr<uchar>(j);
		for (int i = 0; i < nc; i++) {
			*data &= mask;
			*data++ += div2;
		}
	}
}

//다른방법3-5 reshape함수로 메모리복사나 다시할당없이 차원 수를 변경
void colorReduce7(cv::Mat image, int div = 64)
{
	if (image.isContinuous()) {
		image.reshape(1, 1);
	}

	int nl = image.rows;
	int nc = image.cols * image.channels();

	int n = static_cast<int>(log(static_cast<double>(div)) / log(2.0) + 0.5);
	uchar mask = 0xFF << n;
	uchar div2 = div >> 1;

	for (int j = 0; j < nl; j++)
	{
		uchar *data = image.ptr<uchar>(j);
		for (int i = 0; i < nc; i++) {
			*data &= mask;
			*data++ += div2;
		}
	}
}

//다른방법4 알고리즘형태는 기본과 같으나 Iterator 반복자를 사용해 조회
void colorReduce8(cv::Mat image, int div = 64)
{
	cv::MatIterator_<cv::Vec3b> it = image.begin<cv::Vec3b>();
	cv::Mat_<cv::Vec3b>::iterator itend = image.end<cv::Vec3b>(); //위 아래 선언 같은 의미
	uchar div2 = div >> 1;

	for (; it != itend; it++)
	{
		(*it)[0] = (*it)[0] / div * div + div2;
		(*it)[1] = (*it)[1] / div * div + div2;
		(*it)[2] = (*it)[2] / div * div + div2;
	}
}

//다른방법4-2 반복자 한번에 표현 
void colorReduce9(cv::Mat image, int div = 64)
{
	cv::MatIterator_<cv::Vec3b> it = image.begin<cv::Vec3b>();
	cv::MatIterator_<cv::Vec3b> itend = image.end<cv::Vec3b>();

	const cv::Vec3b div2(div/2,div/2,div/2);

	for (; it != itend; it++)
	{
		*it = *it / div * div + div2;
	}
}

//다른방법4-3 반복자 바이너리 마스크
void colorReduce10(cv::Mat image, int div = 64)
{
	int n = static_cast<int>(log(static_cast<double>(div)) / log(2.0) + 0.5);
	uchar mask = 0xFF << n;
	uchar div2 = div >> 1;

	cv::Mat_<cv::Vec3b>::iterator it = image.begin<cv::Vec3b>();
	cv::Mat_<cv::Vec3b>::iterator itend = image.end<cv::Vec3b>();

	for (; it != itend; it++)
	{
		(*it)[0] &= mask;
		(*it)[0] += div2;
		(*it)[1] &= mask;
		(*it)[1] += div2;
		(*it)[2] &= mask;
		(*it)[2] += div2;
	}
}

//다른방법4-4 Mat_ 생성 시 <type> 생략가능
void colorReduce11(cv::Mat image, int div = 64)
{
	cv::Mat_<cv::Vec3b> cimage = image;
	cv::Mat_<cv::Vec3b>::iterator it = cimage.begin();
	cv::Mat_<cv::Vec3b>::iterator itend = cimage.end();
	uchar div2 = div >> 1;

	for (; it != itend; it++)
	{
		(*it)[0] = (*it)[0] / div * div + div2;
		(*it)[1] = (*it)[1] / div * div + div2;
		(*it)[2] = (*it)[2] / div * div + div2;
	}
}

//다른방법5 at매소드 사용하기 비추
void colorReduce12(cv::Mat image, int div = 64)
{
	int nl = image.rows;
	int nc = image.cols;
	uchar div2 = div >> 1;

	for (int j = 0; j<nl; j++) {
		for (int i = 0; i<nc; i++) {
			image.at<cv::Vec3b>(j, i)[0] = image.at<cv::Vec3b>(j, i)[0] / div * div + div2;
			image.at<cv::Vec3b>(j, i)[1] = image.at<cv::Vec3b>(j, i)[1] / div * div + div2;
			image.at<cv::Vec3b>(j, i)[2] = image.at<cv::Vec3b>(j, i)[2] / div * div + div2;
		}
	}
}

//다른방법6 Scalar와 mask 사용해서 비트연산 가장 빠른방법
void colorReduce13(cv::Mat image, int div = 64)
{
	int n = static_cast<int>(log(static_cast<double>(div)) / log(2.0) + 0.5);
	uchar mask = 0xFF << n;
				
	image = (image & cv::Scalar(mask, mask, mask)) + cv::Scalar(div / 2, div / 2, div / 2);
}

//다른방법7 LUT(Look-up-table) 6강의 내용을 이용한 방법
void colorReduce14(cv::Mat image, int div = 64)
{
	cv::Mat lookup(1, 256, CV_8U);

	for (int i = 0; i<256; i++)
	{
		lookup.at<uchar>(i) = i / div * div + div / 2;
	}
	cv::LUT(image, lookup, image);
}

#define NTESTS 15
#define NITERATIONS 10

int main()
{
	cv::Mat image = cv::imread("../images/boldt.jpg");

	int64 start = cv::getTickCount();
	colorReduce(image, 64);
	double duration = (cv::getTickCount() - start) / cv::getTickFrequency();

	std::cout << "Duration= " << duration << "secs" << std::endl;
	cv::namedWindow("Image");
	cv::imshow("Image", image);

	cv::waitKey();

	image = cv::imread("../images/boldt.jpg");
	cv::Mat complete;
	start = cv::getTickCount();
	colorReduceIO(image, complete, 64);
	duration = (cv::getTickCount() - start) / cv::getTickFrequency();

	std::cout << "Duration= " << duration << "secs" << std::endl;
	cv::namedWindow("ImageIO");
	cv::imshow("ImageIO", complete);

	cv::waitKey();

	int64 t[NTESTS], tinit;

	for (int i = 0; i<NTESTS; i++)
		t[i] = 0;

	cv::Mat images[NTESTS];
	cv::Mat result;

	typedef void(*FunctionPointer)(cv::Mat, int);
	FunctionPointer functions[NTESTS] = { colorReduce, colorReduce1, colorReduce2, colorReduce3, colorReduce4,
		colorReduce5, colorReduce6, colorReduce7, colorReduce8, colorReduce9,
		colorReduce10, colorReduce11, colorReduce12, colorReduce13, colorReduce14 };

	int n = NITERATIONS;
	for (int k = 0; k<n; k++) {

		std::cout << k << " of " << n << std::endl;

		for (int c = 0; c < NTESTS; c++) {

			images[c] = cv::imread("../images/boldt.jpg");

			tinit = cv::getTickCount();
			functions[c](images[c], 64);
			t[c] += cv::getTickCount() - tinit;

			std::cout << ".";
		}

		std::cout << std::endl;
	}

	std::string descriptions[NTESTS] = {
		"original version:",
		"with dereference operator:",
		"using modulo operator:",
		"using a binary mask:",
		"direct ptr arithmetic:",
		"row size recomputation:",
		"continuous image:",
		"reshape continuous image:",
		"with iterators:",
		"Vec3b iterators:",
		"iterators and mask:",
		"iterators from Mat_:",
		"at method:",
		"overloaded operators:",
		"look-up table:",
	};

	for (int i = 0; i < NTESTS; i++)
	{
		cv::namedWindow(descriptions[i]);
		cv::imshow(descriptions[i], images[i]);
	}

	std::cout << std::endl << "-------------------------------------------" << std::endl << std::endl;
	for (int i = 0; i < NTESTS; i++)
	{
		std::cout << i << ". " << descriptions[i] << 1000.*t[i] / cv::getTickFrequency() / n << "ms" << std::endl;
	}

	cv::waitKey();
	return 0;
}

<코드 3 - 이웃 접근으로 영상 조회>
#include <iostream>
#include <opencv2/core.hpp>
#include <opencv2/highgui.hpp>
#include <opencv2/imgproc.hpp>

void sharpen(const cv::Mat &image, cv::Mat &result)
{
	//Mat 함수 재할당이 필요할 경우를 위해서
	result.create(image.size(), image.type());
	int nchannals = image.channels(); //채널 개수 얻기

	//모든 행 대상(처음과 마지막 제외)
	for (int j = 1; j < image.rows - 1; j++)
	{
		const uchar* previous = image.ptr<const uchar>(j - 1); //이전 행
		const uchar* current = image.ptr<const uchar>(j); //현재 행
		const uchar* next = image.ptr<const uchar>(j + 1); //다음 행

		uchar* output = result.ptr<uchar>(j); //결과 행
		
		for (int i = nchannals; i < (image.cols - 1)*nchannals; i++)
		{
			//선명화 연산자 적용
			*output++ = cv::saturate_cast<uchar>(5 * current[i] - current[i - nchannals] - current[i + nchannals] - previous[i] - next[i]);

			//처리하지 않은 화소를 0으로 설정
			result.row(0).setTo(cv::Scalar(0));
			result.row(result.rows - 1).setTo(cv::Scalar(0));
			result.col(0).setTo(cv::Scalar(0));
			result.col(result.cols - 1).setTo(cv::Scalar(0));
		}
	}
}

void sharpen2D(const cv::Mat &image, cv::Mat &result)
{
	//커널 생성(모든 항목을 0으로 초기화)
	cv::Mat kernel(3, 3, CV_32F, cv::Scalar(0));

	//커널 값을 할당
	kernel.at<float>(1, 1) = 5.0;
	kernel.at<float>(0, 1) = -1.0;
	kernel.at<float>(2, 1) = -1.0;
	kernel.at<float>(1, 0) = -1.0;
	kernel.at<float>(1, 2) = -1.0;

	//영상 필터링
	cv::filter2D(image, result, image.depth(), kernel);
}

void sharpenIterator(const cv::Mat &image, cv::Mat &result)
{
	//그레이레벨 이미지여야함.
	CV_Assert(image.type() == CV_8UC1);

	//반복자들을 1행으로 초기화
	cv::Mat_<uchar>::const_iterator it = image.begin<uchar>() + image.cols;
	cv::MatConstIterator_<uchar> itend = image.end<uchar>() - image.cols;
	cv::Mat_<uchar>::const_iterator itup = image.begin<uchar>();
	cv::MatConstIterator_<uchar> itdown = image.begin<uchar>() + 2*image.cols;

	//재할당 필요성을 위해
	result.create(image.size(), image.type());
	//output 반복자 설정
	cv::Mat_<uchar>::iterator itout = result.begin<uchar>() + result.cols;

	for (; it != itend; ++it, ++itout, ++itup, ++itdown) {
		*itout = cv::saturate_cast<uchar>(*it * 5 - *(it - 1) - *(it + 1) - *itup - *itdown);
	}

	//처리하지 않은 영역 0으로
	result.row(0).setTo(cv::Scalar(0));
	result.row(result.rows - 1).setTo(cv::Scalar(0));
	result.col(0).setTo(cv::Scalar(0));
	result.col(result.cols - 1).setTo(cv::Scalar(0));
}

int main()
{
	cv::Mat image = cv::imread("../images/boldt.jpg");
	if (!image.data)
		return 0;

	cv::Mat result;

	double time = static_cast<double>(cv::getTickCount());
	sharpen(image, result);
	time = (static_cast<double>(cv::getTickCount()) - time) / cv::getTickFrequency();
	std::cout << "time= " << time << std::endl;

	cv::namedWindow("Image");
	cv::imshow("Image", result);

	cv::waitKey();

	image = cv::imread("../images/boldt.jpg");

	time = static_cast<double>(cv::getTickCount());
	sharpen2D(image, result);
	time = (static_cast<double>(cv::getTickCount()) - time) / cv::getTickFrequency();
	std::cout << "time 2D= " << time << std::endl;

	cv::namedWindow("Image 2D");
	cv::imshow("Image 2D", result);

	cv::waitKey();

	image = cv::imread("../images/boldt.jpg", 0);

	time = static_cast<double>(cv::getTickCount());
	sharpenIterator(image, result);
	time = (static_cast<double>(cv::getTickCount()) - time) / cv::getTickFrequency();
	std::cout << "time 3= " << time << std::endl;

	cv::namedWindow("Sharpened Image");
	cv::imshow("Sharpened Image", result);

	cv::waitKey();

	return 0;
}

<코드 4 - 간단한 산술 연산 수행>
#include <vector>
#include <opencv2/core.hpp>
#include <opencv2/highgui.hpp>

int main()
{
	cv::Mat image1;
	cv::Mat image2;

	image1 = cv::imread("../images/boldt.jpg");
	image2 = cv::imread("../images/rain.jpg");

	if (!image1.data)
		return 0;
	if (!image2.data)
		return 0;

	cv::namedWindow("Image 1");
	cv::imshow("Image 1", image1);
	cv::namedWindow("Image 2");
	cv::imshow("Image 2", image2);

	cv::Mat result;
	//그냥 더하는게 아닌 가중합 addWeighted 가중치를 둬서 합치는거라 더 자연스러움
	cv::addWeighted(image1, 0.7, image2, 0.9, 0., result);

	cv::namedWindow("result");
	cv::imshow("result", result);

	// 연산자를 사용해서 ADD하기
	result = 0.7* image1 + 0.9*image2;

	cv::namedWindow("Result with operators");
	cv::imshow("Result with operators", result);

	image2 = cv::imread("../images/rain.jpg", 0);

	// 3개의 Mat로 이뤄진 Vector 선언
	std::vector<cv::Mat> planes;
	// 3채널 이미지의 채널을 모두 나눠 3개의 이미지로 split함수
	cv::split(image1, planes);
	// 블루채널에 ADD하기
	planes[0] += image2;
	// 다시 3채널 합쳐서 하나의 3채널 이미지로
	cv::merge(planes, result);
 
	cv::namedWindow("Result on blue channel");
	cv::imshow("Result on blue channel", result);

	cv::waitKey();

	return 0;
}

<코드 5 - 영상 재매핑>
#include <opencv2/core.hpp>
#include <opencv2/highgui.hpp>
#include <opencv2/imgproc.hpp>


//물결 효과를 생성하기 위한 영상 재매핑
void wave(const cv::Mat &image, cv::Mat &result)
{
	//맵 역할
	cv::Mat srcX(image.rows, image.cols, CV_32F);
	cv::Mat srcY(image.rows, image.cols, CV_32F);

	//매핑 생성
	for (int i = 0; i < image.rows; i++) {
		for (int j = 0; j < image.cols; j++) {

			//화소 (i, j)의 새로운 위치
			srcX.at<float>(i, j) = j; //열은 그대로 유지
			srcY.at<float>(i, j) = i + 5 * sin(j / 10.0); //원래있던 i행의 화소를 바로 사인 곡선에 따라 옮긴다.

			//수평으로 뒤집기
			//srcX.at<float>(i,j)= image.cols-j-1;
			//srcY.at<float>(i,j)= i;
		}
	}

	//매핑 적용
	cv::remap(image, result, srcX, srcY, CV_INTER_LINEAR); //마지막 인수 보간하는 함수로 선형보간 적용함.
}

int main()
{
	cv::Mat image = cv::imread("../images/boldt.jpg", 1);
	if (!image.data) return 0;

	cv::namedWindow("Image");
	cv::imshow("Image", image);

	cv::Mat result;
	wave(image, result);

	cv::namedWindow("Remapped image");
	cv::imshow("Remapped image", result);

	cv::waitKey();
	return 0;
}

3. 영상의 컬러 처리 [Processing Images with Classes]
- 코드에 주석으로 설명을 다는 식으로 정리.
- Lab 색 공간 : https://ko.wikipedia.org/wiki/Lab_%EC%83%89_%EA%B3%B5%EA%B0%84
- 첫번 째 코드는 영상의 모든화소를 확인해 특정 유사한 컬러를 찾는 간단한 컬러 비교 알고리즘 클래스를 만드는 것인데, [전략 디자인 패턴]을 사용한다.
- 두번 째 코드는 정지영상에서 전경 객체를 추출하고 싶을 때 사용하기에 가장 좋은 알고리즘 함수로 계산적으로 워터쉐드보다 비싸지만 정확하다.
  부분 레이블링에 기반을 두고 전체 영상에 대한 전경/배경 영상 분할을 결정한다. 여기서는 전경을 포함한 사각형을 사용해 전경/배경을 레이블링한다.
- 세번 째 코드는 첫번 째 코드안에 있다. CIE L*a*b에 대한 코드로 RGB 컬러 공간은 빨강,초록,파랑의 가산 원색을 사용하는데 기반을 두고 있으나,
  디지털 영상의 기본 컬러공간이며 거리 간의 거리를 계산하는 것이 주어진 두 컬러 간의 유사도를 측정하는 가장 좋은방법이 아니다. 왜냐하면 RGB는 지각적으로는 균등한 컬러 공간이 아니기 때문에 주어진 거리에서 두 컬러가 아주 비슷하게 보이는 반면
  동일한 거리로 격리된 두 컬러가 매우 다르게 보일 수 있기 때문이다. 이런 문제를 해결하기 위해 지각적으로 균등한 속성을 갖는 다른 컬러 표현을 도입한 것 중에 하나가 CIE L*a*b 컬러 모델이다.
  1. CIE L*a*b
  Lab을 사용하면 영상 화소와 대상 컬러 간의 유클리디안 거리는 두 컬러 간의 시각적 유사도 측정에 의미가 있게 될 수 있다.
  Lab으로 작업하기 위해 이전 코드를 수정한 것이 첫 번째 코드를 수정한 내용이다.
  화소의 각 밝기를 나타내는 L채널은 0-100사이, a b채널은 색도(chromaticity) 성분에 대응하고 값의 범위는 -127~128 사이에 있다.
  2. YCrCb
  jPEG 압축에서 사용되는 컬러공간은 'YCrCb' 이다.
  3. CIE L*u*v
  CIE L*u*v 컬러 공간은 색도 채널에 대한 다른 표현을 한다. RGB 컬러 영역을 왜곡하기 때문에 변환시 비선형(비용이 많이 들 수 있다.)계산을 해야한다.
  4. CIE XYZ
  CIE XYZ 컬러 공간은 장치에 독립적인 방식으로 지각할 수 있는 모든 컬러를 표현하기 위해 사용되는 표준 컬러공간이다. Luv 와 Lab 공간의 계산 과정에서 XYZ 컬러 공간을 중간 표현으로 사용한다. RGB와 XYZ 컬러 공간 간의 변환은 비선형 계산이다.
  Y채널이 영상의 그레이레벨 버전에 대응한다는 특징을 가지고 있다.
  5. HSV, HLS
  HSV나 HLS는 컬러를 색상 성분과 채도 성분을 비롯해 명도나 광도 성분을 분해 할 수 있다는 특징을 가지고 있다. 인간이 컬러를 설명하기 위한 매우 자연스러운 방식이기도 하다.
  6. Gray
  컬러영상을 그레이레벨 명암으로 변환할 수도 있다. 결과는 1채널 영상이 된다. cv::cvtColor(color, gray, CV_BGR2GRAY);
- 네번 째 코드는 색상, 채도, 밝기 개념에 기반을 둔 현상적 컬러 공간을 통해 컬러를 묘사하는 수단인 색상, 채도, 밝기의 개념을 살펴보는 코드다.
  HSV 컬러 공간 구현에서는
  명도를 세 가지 BGR 성분의 최댓값으로 정의한다. 이는 밝기 개념을 지나치게 단순화한 구현이다.
  채도 계산 방법 S = ((max(R,G,B)-min(R,G,B))/max(R,G,B) 사실 채도는 BGR 값의 최댓값과 최솟값의 상대적인 차이만 측정하기 때문에 (1,0,0)과 같은 경우 검게 보여도 채도가 1이다. 어두운 영역에서의 채도를 신뢰할 수 없고, 고려도 하지 않아야한다.
  색상은 0-360사이의 각도 값으로 표현하며, 빨간색은 0도다. 단, 8비트 영상일경우 255가 최대이기에 각도 값을 반으로 나눈다. 0-180
  HSB 컬러 공간은 각 점이 내부에 특정한 컬러에 대응하는 원추로 자주 표현된다.
  각이 진 위치는 컬러의 색상(H)에 대응하고, 채도는 중심 축으로부터의 거리(S)이며, 밝기는 높이(B)로 주어진다. 원추의 꼭대기는 색상과 채도가 정의되지 않은 검은색에 대응한다.
  색상 채도(HS)를 사용해 피부색 검출 테스트로 마무리 한다.

<코드 1 - 전략 패턴을 이용한 컬러 비교 (3개의 파일)>
================ 1 ch03-1.cpp ==================
#include <opencv2/core.hpp>
#include <opencv2/highgui.hpp>

#include "colordetector.h"

int main()
{
	//1. 영상처리기 객체 생성
	ColorDetector cdetect;

	//2. 입력영상 읽기
	cv::Mat image = cv::imread("../images/boldt.jpg");
	if (image.empty()) return 0;
	cv::namedWindow("Original Image");
	cv::imshow("Original Image", image);

	//3. 입력파라미터 설정
	cdetect.setTargetColor(230, 190, 130); //푸른 하늘찾기

	//4. 영상을 처리 한 후 결과를 창에 띄움
	cv::Mat result = cdetect.process(image);
	cv::namedWindow("result");
	cv::imshow("result", result);

	//or 함수자 사용하기
	//여기서 거리는 Lab 컬러 공간으로 측정된다.
	ColorDetector colordetector(230, 190, 130,	//색
									45, true);	//Lab 경계선
	result = colordetector(image);
	cv::namedWindow("result (functor)");
	cv::imshow("result (functor)", result);

	//floodFill 함수 테스트
	cv::floodFill(image,			//입력/결과 영상
		cv::Point(100, 50),			//초기 점
		cv::Scalar(255, 255, 255),	//다시 그린 컬러
		(cv::Rect*)0,				//다시 그린 집합의 경계 사각형
		cv::Scalar(35, 35, 35),		//낮은 차이 경계값
		cv::Scalar(35, 35, 35),		//높은 차이 경계값
		cv::FLOODFILL_FIXED_RANGE);	//시드 화소와 비교할 화소

	result = colordetector(image);
	cv::namedWindow("Flood Fill result");
	cv::imshow("Flood Fill result", image);

	//색 공간의 속성들을 보여주기 위해 단순한 영상 생성
	cv::Mat colors(100, 300, CV_8UC3, cv::Scalar(100, 200, 150));
	cv::Mat range = colors.colRange(0, 100);
	range = range + cv::Scalar(10, 10, 10);

	cv::namedWindow("3 colors");
	cv::imshow("3 colors", colors);

	cv::waitKey();

	range = colors.colRange(200, 300);
	range = range + cv::Scalar(-10, -10, 10);

	cv::imshow("3 colors", colors);

	cv::Mat labImage(100, 300, CV_8UC3, cv::Scalar(100, 200, 150));
	cv::cvtColor(labImage, labImage, CV_BGR2Lab);
	range = labImage.colRange(0, 100);
	range = range + cv::Scalar(10, 10, 10);

	cv::namedWindow("3 colors (Lab)");
	cv::imshow("3 colors (Lab)", labImage);

	cv::waitKey();

	range = labImage.colRange(200, 300);
	range = range + cv::Scalar(-10, -10, 10);
	cv::imshow("3 colors (Lab)", labImage);

	cv::waitKey();

	cv::cvtColor(labImage, labImage, CV_BGR2Lab);
	cv::imshow("3 colors (Lab)", labImage);

	//밝기(명도) vs 휘도
	cv::Mat grayLevels(100, 256, CV_8UC3);
	for (int i = 0; i < 256; i++) {
		grayLevels.col(i) = cv::Scalar(i, i, i);
	}
	
	range = grayLevels.rowRange(50, 100);
	cv::Mat channels[3];
	cv::split(range, channels);
	channels[1] = 128;
	channels[2] = 128;
	cv::merge(channels, 3, range);
	cv::cvtColor(range, range, CV_Lab2BGR);

	cv::namedWindow("Luminance vs Brightness");
	cv::imshow("Luminance vs Brightness", grayLevels);

	cv::waitKey();

	return 0;
}

================ 2 colordetector.h ==================
#if !defined COLORDETECT
#define COLORDETECT

#include <opencv2/core.hpp>
#include <opencv2/imgproc.hpp>

class ColorDetector {

private:

	//최소 허용거리
	int maxDist;

	//대상 컬러
	cv::Vec3b target;

	//변환된 영상의 색을 포함한 영상
	cv::Mat converted;
	bool useLab;

	//결과 이진 맵을 포함하는 영상
	cv::Mat result;

public:

	//빈 생성자
	//여기서 기본 파라미터 초기화
	ColorDetector() : maxDist(100), target(0, 0, 0), useLab(false) {}

	//Lab 컬러 공간 예제를 위한 추가 생성자
	ColorDetector(bool useLab) : maxDist(100), target(0,0,0), useLab(useLab) {}

	//완전 생성자
	ColorDetector(uchar blue, uchar green, uchar red, int maxDist = 100, bool useLab= false) : maxDist(maxDist), useLab(useLab) {

		//대상 컬러
		setTargetColor(blue, green, red);
	}

	//대상 컬러로부터의 거리 계산
	int getDistanceToTargetColor(const cv::Vec3b& color) const {
		return getColorDistance(color, target);
	}

	//두 컬러 간의 도시 블럭 거리 계산
	int getColorDistance(const cv::Vec3b& color1, const cv::Vec3b& color2) const {
		return abs(color1[0] - color2[0]) + abs(color1[1] - color2[1]) + abs(color1[2] - color2[2]);

		//Or: 유클리디안 놈을 계산하는 함수 norm() 뺄샘결과가 int형이라 Vec3i 사용
		//return static_cast<int>(cv::norm<int,3>(cv::Vec3i(color[0]-color2[0],color[1]-color2[1],color[2]-color2[2])));

		//Or: 이렇게 쓰면 틀린 예 return static_cast<int>(cv::norm<uchar,3>(color-target)); 산술연산함수를 사용한 예는 아래와 같다. 
		//cv::Vec3b dist;
		//cv::absdiff(color,color2,dist);
		//return cv::sum(dist)[0];
	}

	//영상를 처리한다. 한개의 채널을 가진 이진 영상을 반환함.
	cv::Mat process(const cv::Mat &image);

	cv::Mat operator()(const cv::Mat &image) {

		cv::Mat input;

		if (useLab) {
			cv::cvtColor(image, input, CV_BGR2Lab);
		}
		else {
			input = image;
		}

		cv::Mat output;

		//대상 컬러와 절대차 계산
		cv::absdiff(input, cv::Scalar(target), output);

		//채널을 세 영상으로 분리
		std::vector<cv::Mat> images;
		cv::split(output, images);

		//새 채널을 더함(여기서 saturation(saturate_cast)가 발생할 수 있음
		output = images[0] + images[1] + images[2];

		//경계값 허용
		cv::threshold(output, //입력영상
			output, //결과영상
			maxDist, //경계값(256미만이여야 함)
			255, //최댓값
			cv::THRESH_BINARY_INV); //경계화 모드, 경계값보다 같거나 작으면 정의된 최댓값을 할당하는 반전모드 그 외에 THRESH_BINARY=0, THRESH_TOZERO 등이 있다. 

		return output;
	}


	//getters and setters

	//컬러 거리 경계값 설정
	//경계 값은 양수이어야 하며, 아니라면 거리 경계 값을 0으로 설정
	void setColorDistanceThreshold(int distance) {

		if (distance < 0) distance = 0;

		maxDist = distance;
	}

	//컬러 거리 경계 값 얻기
	int getColorDistanceThreshold() const {
		return maxDist;
	}

	//검출할 컬러 설정
	void setTargetColor(uchar blue, uchar green, uchar red) {
		
		//BGR 순서
		target = cv::Vec3b(blue, green, red);

		if (useLab) {
			//임시 1 픽셀 영상 생성
			cv::Mat tmp(1, 1, CV_8UC3);
			tmp.at<cv::Vec3b>(0, 0) = cv::Vec3b(blue, green, red);

			//대상을 Lab 컬러 공간으로 변환
			cv::cvtColor(tmp, tmp, CV_BGR2Lab);

			target = tmp.at<cv::Vec3b>(0, 0);
		}
	}
	
	//오버로딩
	void setTargetColor(cv::Vec3b color) {

		target = color;
	}

	//검출할 컬러 얻기
	cv::Vec3b getTargetColor() const {
		return target;
	}
};

#endif

================ 3 colordetector.cpp ==================
#include "colordetector.h"
#include <vector>

cv::Mat ColorDetector::process(const cv::Mat &image) {

	//필요하다면 이진 맵 재할당
	//입력 영상의 크기와 같지만 1채널임
	result.create(image.size(), CV_8U);

	//필요하다면 Lab컬러 공간으로 변경
	if (useLab)
		cv::cvtColor(image, converted, CV_BGR2Lab);

	//반복자 얻기
	cv::Mat_<cv::Vec3b>::const_iterator it = image.begin<cv::Vec3b>();
	cv::Mat_<cv::Vec3b>::const_iterator itend = image.end<cv::Vec3b>();
	
	//결과 영상의 대한 반복자 얻기
	cv::Mat_<uchar>::iterator itout = result.begin<uchar>();

	//변환된 영상을 위한 반복자 얻기
	if (useLab) {
		it = converted.begin<cv::Vec3b>();
		itend = converted.end<cv::Vec3b>();
	}

	//각 화소에 대해 반복
	for (; it != itend; ++it, ++itout) {

		//대상 컬러로부터의 거리 계산
		if (getDistanceToTargetColor(*it) <= maxDist) {
			*itout = 255;
		}
		else {
			*itout = 0;
		}
	}

	return result;
}

<코드 2 - 그랩컷 알고리즘으로 영상 분할>
#include <iostream>
#include <opencv2/core.hpp>
#include <opencv2/highgui.hpp>
#include <opencv2/imgproc.hpp>

int main()
{
	cv::Mat image = cv::imread("../images/boldt.jpg");
	if (!image.data)
		return 0;

	cv::namedWindow("Original Image");
	cv::imshow("Original Image", image);

	//경계 사각형 정의
	//경계 사각형 바깥에 있는 화소를 배경으로 레이블링
	cv::Rect rectangle(50, 25, 210, 180);
	
	cv::Mat result;				//분할 (가능한 값은 4개)
	cv::Mat bgModel, fgModel;	//모델 (내부적으로 사용)

	//그랩컷 분할
	cv::grabCut(image,					//입력 영상
				result,					//분할 결과
				rectangle,				//전경을 포함한 사각형
				bgModel, fgModel,		//모델
				5,						//반복 횟수
				cv::GC_INIT_WITH_RECT);	//사각형 사용

	//입력/결과 분할 영상은 4가지 값 중 하나를 갖게 된다.
	//cv::GC_BGD = 0 배경에 분명히 속하는 화소(예를들어 사각형 밖에 있는 화소),
	//cv::GC_FGD = 1 전경에 분명히 속하는 화소(예를들어 아래 예제에는 없음),
	//cv::GC_PR_BGD = 2 아마도 배경에 속할 듯한 화소에 대한 값
	//cv::GC_PR_FGD = 3 아마도 전경에 속할 듯한 화소에 대한 값(예를들어 아래 예제에서 사각형 내부에 있는 화소를 얻기 위한 초기값)
	
	//전경일 가능성이 높게 표식된 화소 얻기, 3인 화소
	cv::compare(result, cv::GC_PR_FGD, result, cv::CMP_EQ);
	//or 비트별 논리곱 연산으로 첫 번째 비트 0(전경), 1(배경) 이냐로 판단할 수 있음
	//result = result & 1;

	//결과 영상 생성
	//모두 흰색인 영상 생성
	cv::Mat foreground(image.size(), CV_8UC3, cv::Scalar(255, 255, 255));
	//마스크를 사용해 배경 화소를 복사하지 않음
	image.copyTo(foreground, result);

	//원본 이미지에 경계 사각형 그리기
	cv::rectangle(image, rectangle, cv::Scalar(255, 255, 255), 1);
	cv::namedWindow("Image with rectangle");
	cv::imshow("Image with rectangle", image);

	cv::namedWindow("Foreground object");
	cv::imshow("Foreground object", foreground);

	cv::waitKey();
	return 0;
}

<코드 3 - 컬러 표현 반환>
//따로 만들지 않고 코드1를 수정해서 표현. 다양한 컬러 채널에 대한 내용은 위에 설명했다.

<코드 4 - 색상, 채도, 밝기로 컬러 표현>
#include <iostream>
#include <vector>
#include <opencv2/core.hpp>
#include <opencv2/highgui.hpp>
#include <opencv2/imgproc.hpp>

//피부인지 확인하는 함수
void detectHScolor(const cv::Mat& image,	//입력 영상
	double minHue, double maxHue,			//색상 간격
	double minSat, double maxSat,			//채도 간격
	cv::Mat& mask)							//출력 마스크
{
	//HSV 공간으로 변환
	cv::Mat hsv;
	cv::cvtColor(image, hsv, CV_BGR2HSV);

	//3채널을 3개의 영상으로 분리
	std::vector<cv::Mat> channels;
	cv::split(hsv, channels);
	//channels[0]은 색상
	//channels[1]은 채도
	//channels[2]은 명도

	//색상 마스킹
	cv::Mat mask1; //maxHue 이하
	//색상 값이 maxHue보다 작거나 같으면 255를 적용한다
	cv::threshold(channels[0], mask1, maxHue, 255, cv::THRESH_BINARY_INV);

	cv::Mat mask2; //minHue 이상
	//minHue보다 크면 255 작으면 0을 적용한다
	cv::threshold(channels[0], mask2, minHue, 255, cv::THRESH_BINARY);

	cv::Mat hueMask; //색상 마스크
	if (minHue < maxHue)
		hueMask = mask1 & mask2;
	else //간격이 0도 축과 교차하면
		hueMask = mask1 | mask2;

	//채도 마스킹
	cv::threshold(channels[1], mask1, maxSat, 255, cv::THRESH_BINARY_INV); //maxSat 이하 색상 값이 maxSat보다 작거나 같으면 255를 적용한다
	cv::threshold(channels[1], mask1, minSat, 255, cv::THRESH_BINARY); //mixSat 이상 minSat보다 크면 255 작으면 0을 적용한다

	cv::Mat satMask; //채도 마스크
	satMask = mask1 & mask2; //채도는 교차할 일이 없으므로 조건문 필요없음

	//마스크 조합
	mask = hueMask & satMask;
}

int main()
{
	cv::Mat image = cv::imread("../images/boldt.jpg");
	if (image.empty())
		return 0;

	cv::namedWindow("Original Image");
	cv::imshow("Original Image", image);

	//HSV 공간으로 변환
	cv::Mat hsv;
	cv::cvtColor(image, hsv, CV_BGR2HSV);

	//3채널을 3개의 영상으로 분리
	std::vector<cv::Mat> channels;
	cv::split(hsv, channels);
	//channels[0]은 색상
	//channels[1]은 채도
	//channels[2]은 명도

	//명도 값
	cv::namedWindow("Value");
	cv::imshow("Value", channels[2]);

	//채도 값
	cv::namedWindow("Saturation");
	cv::imshow("Saturation", channels[1]);

	//색상 값
	cv::namedWindow("Hue");
	cv::imshow("Hue", channels[0]);

	//변경 영상을 담을 새로운 빈 영상 생성
	cv::Mat newImage;
	//원래 명도값을 담아둘 임시 영상 생성
	cv::Mat tmp(channels[2].clone());

	//명도 값 변경하기, 명도 채널의 모든 화소는 255가 됨
	channels[2] = 255;

	//합치고 BGR로 다시 변환
	cv::merge(channels, hsv);
	cv::cvtColor(hsv, newImage, CV_HSV2BGR);

	cv::namedWindow("Fixed Value Image");
	cv::imshow("Fixed Value Image", newImage);

	//채도 값 변경하기
	channels[1] = 255;
	channels[2] = tmp;
	cv::merge(channels, hsv);
	cv::cvtColor(hsv, newImage, CV_HSV2BGR);

	cv::namedWindow("Fixed Saturation Image");
	cv::imshow("Fixed Saturation Image", newImage);

	//채도와 명도값 변경하기
	channels[1] = 255;
	channels[2] = 255;
	cv::merge(channels, hsv);
	cv::cvtColor(hsv, newImage, CV_HSV2BGR);

	cv::namedWindow("Fixed Saturation/Value Image");
	cv::imshow("Fixed Saturation/Value Image", newImage);


	//서로 다른 색상과 채도 조합을 보여주는 인공적인 HS 영상
	cv::Mat hs(128, 360, CV_8UC3);
	for (int h = 0; h < 360; h++)
	{
		for (int s = 0; s < 128; s++)
		{
			hs.at<cv::Vec3b>(s, h)[0] = h / 2;	//모든 색상 값
			hs.at<cv::Vec3b>(s, h)[1] = 255-s*2;//높은 채토부터 낮은 채도까지
			hs.at<cv::Vec3b>(s, h)[2] = 255;	//밝기 상수 값
		}
	}

	cv::cvtColor(hs, newImage, CV_HSV2BGR);
	
	cv::namedWindow("Hue/Saturation");
	cv::imshow("Hue/Saturation", newImage);

	cv::waitKey();
	

	//피부색 검출 테스트

	image = cv::imread("../images/girl.jpg");
	if (image.empty())
		return 0;

	cv::imshow("Original Image", image);

	cv::waitKey();

	//피부색 검출
	cv::Mat mask;
	detectHScolor(image,
		160, 10, //320도부터 20도까지의 색상
		25, 166, //-0.1부터 0.65까지의 채도
		mask);

	//마스크 된 영상 보여주기
	cv::Mat detected(image.size(), CV_8UC3, cv::Scalar(0, 0, 0));
	image.copyTo(detected, mask);

	cv::namedWindow("Detection result");
	cv::imshow("Detection result", detected);

	cv::waitKey();

	//휘도와 명도 비교하는 테스트

	//긴 줄의 이미지를 생성한다.
	cv::Mat linear(100, 256, CV_8U);
	for (int i = 0; i<256; i++)
		linear.col(i) = i;

	//Lab 색 공간 이미지 생성
	linear.copyTo(channels[0]);
	cv::Mat constante(100, 256, CV_8U, cv::Scalar(128));
	constante.copyTo(channels[1]);
	constante.copyTo(channels[2]);
	cv::merge(channels, image);

	//BGR로 다시 변환
	cv::Mat brightness;
	cv::cvtColor(image, brightness, CV_Lab2BGR);
	cv::split(brightness, channels);

	//결합한 이미지 생성
	cv::Mat combined(200, 256, CV_8U);
	cv::Mat half1(combined, cv::Rect(0, 0, 256, 100));
	linear.copyTo(half1);
	cv::Mat half2(combined, cv::Rect(0, 100, 256, 100));
	channels[0].copyTo(half2);

	cv::namedWindow("Luminance vs Brightness");
	cv::imshow("Luminance vs Brightness", combined);

	cv::waitKey();
	return 0;
}

4. 히스토그램으로 화소 세기 [Counting the Pixels with Histograms]
- 히스토그램이란 영상에서 특정한 값을 갖는 화소 개수를 제공하는 단순한 테이블이다. 영상의 내용을 특성화하고, 영상 내의 특정 객체나 질감을 검출할 때 주로 사용한다.
- 그레이레벨의 히스토그램은 256개의 항목(bin)을 갖는다. bin 0은 값이 0인 화소 개수를 제공, ... 히스토그램의 모든 항목을 합하면 화소의 개수이다.
- bin의 합이 1이 되도록 히스토그램을 정규화할 수도 있다. 이럴 경우, 각 bin은 영상 내 특정 값을 갖는 화소의 비율을 제공한다.
- cv::calcHist() 함수를 사용하면 히스토그램을 쉽게 계산할 수 있다. 임의 화소 값 타입과 범위를 갖는 다채널 영상의 히스토그램을 계산할 수 있는 일반적인 함수이다.
- cv::LUT()는 전체적으로 값을 변환하는 함수다. 명도값을 새로운 명도값으로 변형하는데 유용하며, imin = 0, 중간값 선형, imax = 255 이런식으로 _/￣ 명도값을 늘릴 수 있다. \ 이런식으로 역으로 매핑하면 명도가 역상이 된다.
- 히스토그램을 늘릴 수도 있는데, 잘라서(%or빈수 imax, imin) LUT()를 사용하거나 제공하는 함수인 equalizeHist()를 사용한다.
- 히스토그램 역투영으로 특정 영상 내용을 검출(찾는)할 수 있는데 4가지를 다룬다.
[흑백] ROI -> 히스토그램 찾기 -> 히스토그램 설정(정규화) -> 히스토그램 경계값 설정(-1.0f 역투영, 0.12f 이진 역투영) -> 역투영 얻기
[컬러] ROI  -> 컬러히스토그램 빈 설정(8) -> 컬러히스토그램 찾기 -> 히스토그램 설정(정규화) -> 히스토그램 경계값 설정(0.05f) -> 컬러 히스토그램의 역투영 얻기
[ab] ROI -> 컬러히스토그램 빈 설정(256) -> 컬러히스토그램 찾기 -> 히스토그램 설정(정규화) -> 히스토그램 경계값 설정(0.05f) -> BGR2Lab공간으로 변경 -> 채널{1,2ab선택 후} 역투영 얻기
[Hue] ROI -> 컬러히스토그램 빈 설정(180) -> 컬러히스토그램 찾기 -> 히스토그램 설정(정규화) -> 히스토그램의 경계값 설정(0.05f) -> BGR2HSV공간으로 변경 -> 채널 0hue 선택후 역투영 얻기
히스토그램의 역투영 결과는 지정한 영상 위치에서 영상 내용의 특정 조각을 발견할 확률을 나타내는 확률 맵이다. 객체의 정확한 위치를 찾을 때 매우 가능성이 큰 위치는 지정한 윈도우 내부에서 최대화한 확률이다.
* 윈도우(Window)는 행렬 형태의 화소 그룹으로 이해하면 되며, 마스크(mask), 커널(kernel)등으로 표현하기도 한다.
- 초기 위치부터 시작한 후 반복적으로 움직이면서 정확한 객체의 위치를 찾아내는 알고리즘을 평균 이동 알고리즘(mean shift algorithm)이라고 한다.
1) 평균 이동 알고리즘은 cv::meanShift함수로 opencv2/video/tracking.hpp안에 들어있다.
확률 함수의 지역 최대치(local maxima)가 있는 위치를 찾는 반복 계산법(iterative procedure)이다. 미리 정의된 윈도우 안에 있는 데이터 점의 중심(centroid)이나 가중 평균(weighted mean)을 찾는방식으로
수행한다. 이 알고리즘은 윈도우 중앙(window center)을 중심 위치로 옮긴 후 윈도우의 중앙이 안정점(stable point)으로 수렴할 때까지 해당 과정을 반복한다. OpenCV의 구현부에서 2개의 중지기준(stopping criteria)을 정의하며,
반복 최대 횟수(MAX_ITER), 그리고 안정점에 수렴되도록 고려돼야 하는 위치의 아래인 윈도우 중앙 변위 값(EPS)이다. 2개의 중지 기준은 cv::TermCriteria인스턴스에 저장된다. cv::meanShift함수는 수행했던 반복횟수를 반환한다.
	ex)
	//초기 윈도우 위치
	cv::rectangle(image, rect, cv::Scalar(0, 0, 255));

	//평균 이동으로 객체 탐색
	cv::TermCriteria criteria(cv::TermCriteria::MAX_ITER | cv::TermCriteria::EPS,
		10,		//최대 10회 반복
		1);		//또는 중심 위치 변화가 1픽셀 미만이 될 때까지
	cout << "meanshift= " << cv::meanShift(result, rect, criteria) << endl;

	//결과 윈도우 그리기
	cv::rectangle(image, rect, cv::Scalar(0, 255, 0));

2) OpenCV에서 색상 값의 범위는 0에서 180까지 이므로(8비트) 이므로 실무 현장에서 HSV컬러 공간을 다룰 때 어려움이 생길 수 있다. 이 경우에는 0~ 360의 범위를 가지를 수 있는 실수형(32비트) 영상으로 변환하거나
cv::cvtColor 함수와 cv::ConvertScale함수를 사용해 적절히 구현한다. RGB 컬러공간을 HSV컬러공간으로 변환할때는 RGB컬러영상의 각 채널 범위를 [0,1]로 변환하는 cv::ConvertScale를 호출한 후 cv::cvtColor로 변환한다.
반대는 cv::cvtColor로 변환한 후 RGB컬러공간의 각 채널이[0,255]범위를 갖도록 cv::ConvertScale함수를 호출한다.
3) OpenCV의 평균 이동 알고리즘을 개선한 버전인, 윈도우 크기와 방향을 바꿀 수 있는 캠시프트(CamShift)알고리즘이 있다.
4) 내용 기반 영상 검색(Content-based Image Retrieval:CBIR)은 컴퓨터 비전에서 중요한 문제이며, 주어진 질의 영상과 비슷한 내용이 존재하는 영상 집합을 찾는 과정으로 구성된다. 히스토그램을 간단하게 비교함으로 유사도를 측정할 수 있다.
히스토그램의 비교를 통해 검색하는 cv::compareHist()함수가 있다. double 수치로 결과를 나타내며 비슷한 정도를 수치화 할 수 있다.
플래그 종류는 더 다양하지만 일부만 간단하게 설명하자면
- HISTCMP_INTERSECT : 각 히스토그램에서 각 빈마다 두 값을 단순하게 비교한 후 최솟값을 유지한다. 유사도 측정은 이런 최솟값의 합이 된다. 두 영상이 컬러가 없는 히스토그램을 갖는다면 0인 인터섹션 값을 얻는 반면, 두 히스토그램이 동일하다면 화소의 총 개수와 같은 값을 얻는다.
- HISTCMP_CHISQR : 빈 간의 정규화된 제곱 차를 합하는 카이 제곱(Chi-Square)측정
- HISTCMP_CORREL : 신호처리에서 두 신호 간의 유사도를 측정하기 위해 사용하는 정규화된 상호 상관 연산자에 기반을 두고 있는 상관관계(Corrleation) 방법
- HISTCMP_BHATTACHARYYA : 통계에서 두 확률 분포 간의 유사도를 추정하기 위해 사용되는 바타차르야(Bhattacharyya) 측정이 있다.
5) 적분 영상으로 화소개수 세기 - 영상 부분 영역에 걸친 화소를 셀 때의 효율성을 극적으로 개선할 수 있는 도구로는 적분 영상(Integral Image)을 들 수 있다.
여러크기의 슬라이딩 윈도우(Sliding Window)를 갖고 계산하는 것을 포함한 응용에서 많이 사용된다.
* 슬라이딩 윈도우란 영상에서 객체를 찾는 가장 기본적인 방법이며, 영상 안에서 윈도우를 일정한 간격으로 이동시키면서 윈도우 내용을 기준으로 찾으려는 객체인지의 여부를 판단한다. 여기서 여러크기란 다양한 크기의 영상(저해상-고해상) 영상 피라미드를 생각하면 된다.
이때 객체의 크기와 위치를 모르기 때문에 영상 피라미드를 대상으로 찾으려는 객체가 있는지 반복적으로 조사한다. 이로 인해 처리 속도가 저하된다는 단점이 있다. 이것을 개선한 알고리즘 중에서 반복과정을 최소화한 ESS(Efficient Subwindow Search)방법을 들 수 있다.
여러 영상 영역에 걸친 화소를 합해야 할 때는 적분 영상이 유용하다.
* 적분 영상은 히스토그램을 이용해 시각적 추적을 할때도 유용하다. 코드에서 가장 빠른 속도를 보여준다. 
과정: 원 영상에서 히스토그램 계산 > 원 영상 작은 갯수 bin의 히스토그램 제작 > 원 영상 이진 평면으로 구성된 다채널 영상으로 변환 > 원 영상 적분 영상 계산 > 찾는 영상 같은 수의 bin의 히스토그램 생성 > 찾는 영상 이진 평면영상 생성 >
     찾는영상 적분영상 계산하기 > (범위를 줄 거면 수평인 긴 조각 순회하면서) 찾는 적분영상에서 히스토그램 계산 > 맨 처음에 계산 된 기준 히스토그램과 찾는 히스토그램 계산 된 것을 사용해 거리 계산 > 가장 비슷한 히스토그램 위치 찾아서 그 점을 기준으로 네모 치면 찾는 것
     
6) 적응적 경계화 - 고정된 경계화는 음영아래 있는 텍스트는 보이지 않을 수 있지만, 이를 극복하기위해 각 화소의 이웃으로 계산하는 지역 경계화를 사용하는 방법이 있다. 화소가 지역 평균 값과 두드러지게 차이가 난다면 이상치로 간주한 후, 경계화 과정에서 잘라낸다.
그로 인해 적응적 경계화에서는 모든 화소 주변의 지역 평균 계산이 필요하다. 적분 영상을 이용하면 필요한 여러 영상의 윈도우를 효율적으로 합산할 수 있다.
이것을 할 수 있는 방법으론 adaptiveThreshold()함수를 쓰거나 직접 적분계산으로 하거나 필터를 사용하는 방법이 있다.

<코드 1 - 히스토그램 계산>
#include <iostream>
#include <opencv2/core.hpp>
#include <opencv2/highgui.hpp>
#include <opencv2/imgproc.hpp>
#include "histogram.h"

using namespace std;

int main()
{
	cv::Mat image = cv::imread("../images/group.jpg", 0);
	if (image.empty()) return 0;

	cv::namedWindow("Image");
	cv::imshow("Image", image);

	//히스토그램 객체
	Histogram1D h;

	//히스토그램 계산
	cv::Mat histo = h.getHistogram(image);

	//각 빈을 순회
	for (int i = 0; i < 256; i++)
		cout << "Value" << i << " = " << histo.at<float>(i) << endl;

	//히스토그램을 영상으로 표시
	cv::namedWindow("Histogram");
	cv::imshow("Histogram", h.getHistogramImage(image));

	//히스토그램과 선택된 경계값으로 재표시
	cv::Mat hi = h.getHistogramImage(image);
	cv::line(hi, cv::Point(70, 0), cv::Point(70, 255), cv::Scalar(128));
	cv::namedWindow("Histogram with threshold value");
	cv::imshow("Histogram with threshold value", hi);

	//골 부분에 경계화하여 이진 영상 생성하기
	cv::Mat thresholded;	//결과 이진영상
	cv::threshold(image, thresholded,
		70,					//경계 값
		255,				//경계 값을 초과하는 픽셀에 할당 된 값
		cv::THRESH_BINARY);


	//경계 영상 표시
	cv::namedWindow("Binary Image");
	cv::imshow("Binary Image", thresholded);

	//평활화 영상
	cv::Mat eq = h.equalize(image);

	//평활화 결과 영상
	cv::namedWindow("Equalized Image");
	cv::imshow("Equalized Image", eq);

	//평활화 영상 히스토그램
	cv::namedWindow("Equalized H");
	cv::imshow("Equalized H", h.getHistogramImage(eq));

	//백분위수 1%에 각각 힌색과 백색으로 세팅해 늘린 영상
	cv::Mat str = h.stretch(image, 0.01f);

	//늘린 결과 영상
	cv::namedWindow("Stretched Image");
	cv::imshow("Stretched Image", str);

	//늘린 영상 히스토그램
	cv::namedWindow("Stretched H");
	cv::imshow("Stretched H", h.getHistogramImage(str));

	//최소값 80개의 빈수를 정해 각각 힌색과 백색으로 세팅해 늘린 영상
	cv::Mat str2 = h.stretch(image, 80);

	//늘린 결과 영상 2 
	cv::namedWindow("Stretched Image 2");
	cv::imshow("Stretched Image 2", str2);

	//늘린 영상 히스토그램 2
	cv::namedWindow("Stretched H 2");
	cv::imshow("Stretched H 2", h.getHistogramImage(str2));

	//영상 반전 테이블 생성
	cv::Mat lut(1, 256, CV_8U); // 1x256 행렬

	//Or
	//int dim(256);
	//cv::Mat lut(1,	//1차원
	//	&dim,			//256항목
	//	uhcar);			//uchar

	for (int i = 0; i < 256; i++)
	{
		//0은 255가 되고, 1은 254가 되는 등의 방식으로 처리
		lut.at<uchar>(i) = 255 - i;
	}
	
	//룩업 테이블 적용한 역상 표시하기
	cv::Mat luxR = h.applyLookUp(image, lut);

	//룩업 테이블 적용한 역상 표시하기
	cv::Mat luxR2 = h.applyLookUpWithIterator(image, lut);

	//역상(Negative) 영상
	cv::namedWindow("Negative Image");
	cv::imshow("Negative Image", luxR);

	//역상 히스토그램
	cv::namedWindow("Negative H");
	cv::imshow("Negative H", h.getHistogramImage(luxR));

	//역상(Negative) 영상 2
	cv::namedWindow("Negative Image 2");
	cv::imshow("Negative Image 2", luxR2);

	//역상 히스토그램 2
	cv::namedWindow("Negative H 2");
	cv::imshow("Negative H 2", h.getHistogramImage(luxR2));

	cv::waitKey();
	return 0;
}

<코드 2 - 특정 영상 내용을 검출하기 위한 히스토그램 >
#include <iostream>
#include <opencv2/core.hpp>
#include <opencv2/highgui.hpp>
#include "histogram.h"
#include "contentFinder.h"
#include "colorhistogram.h"

using namespace std;

int main()
{
	//입력 영상 읽어오기
	cv::Mat image = cv::imread("../images/waves.jpg", 0);
	if (!image.data)
		return 0;
	//ROI 영상 정의하기
	cv::Mat imageROI;
	imageROI = image(cv::Rect(216, 33, 24, 30));	//구름 영역

	//참조 영역 표시
	cv::namedWindow("Reference");
	cv::imshow("Reference", imageROI);

	//참조 영역의 히스토그램 찾기
	Histogram1D h;
	cv::Mat hist = h.getHistogram(imageROI);
	cv::namedWindow("Reference Hist");
	cv::imshow("Reference Hist", h.getHistogramImage(imageROI));

	//ContentFinder 인스턴스 생성
	ContentFinder finder;

	//히스토그램 역투영으로 설정
	finder.setHistogram(hist);
	finder.setThreshold(-1.0f);

	//역투영 얻기
	cv::Mat result1;
	result1 = finder.find(image);

	//반전영상 과 결과화면 생성
	cv::Mat tmp;
	result1.convertTo(tmp, CV_8U, -1.0, 255.0);
	cv::namedWindow("Backprojection Result");
	cv::imshow("Backprojection Result", tmp);

	//이진 역투영 얻기
	finder.setThreshold(0.12f);
	result1 = finder.find(image);

	//참조영역에 사각형 그리기
	cv::rectangle(image, cv::Rect(216, 33, 24, 30), cv::Scalar(0, 0, 0));

	//영상 표시
	cv::namedWindow("Image");
	cv::imshow("Image", image);
	
	//결과 표시
	cv::namedWindow("Detection Result");
	cv::imshow("Detection Result", result1);

	//컬러 영상 불러오기
	ColorHistogram hc;
	cv::Mat color = cv::imread("../images/waves.jpg");

	//관심영역 추출
	imageROI = color(cv::Rect(0, 0, 100, 45)); //푸른 하늘 영역

	//3D 컬러 히스토그램 얻기(채널당 8개의 빈)
	hc.setSize(8);	//8*8*8
	cv::Mat shist = hc.getHistogram(imageROI);

	//역투영할 히스토그램 설정
	finder.setHistogram(shist);
	finder.setThreshold(0.05f);

	//컬러 히스토그램의 역투영 얻기
	result1 = finder.find(color);

	cv::namedWindow("Color Detection Result");
	cv::imshow("Color Detection Result", result1);

	//두 번째 컬러 영상
	cv::Mat color2 = cv::imread("../images/dog.jpg");

	cv::namedWindow("Second Image");
	cv::imshow("Second Image", color2);

	//컬러 히스토그램의 역투영 얻기
	cv::Mat result2 = finder.find(color2);

	cv::namedWindow("Result Color 2");
	cv::imshow("Result Color 2", result2);

	//ab 컬러 히스토그램 얻기
	hc.setSize(256); //256*256
	cv::Mat colorhist = hc.getabHistogram(imageROI);

	//2D 히스토그램 표시하기
	colorhist.convertTo(tmp, CV_8U, -1.0, 255.0);
	cv::namedWindow("ab histogram");
	cv::imshow("ab histogram", tmp);

	//역투영할 히스토그램 설정
	finder.setHistogram(colorhist);
	finder.setThreshold(0.05f);

	//Lab 공간으로 변환하기
	cv::Mat lab;
	cv::cvtColor(color, lab, CV_BGR2Lab);

	//ab 히스토그램의 역투영 얻기
	int ch[2] = { 1, 2 };
	result1 = finder.find(lab, 0, 256.0f, ch);

	cv::namedWindow("Result ab 1");
	cv::imshow("Result ab 1",result1);

	//두 번째 컬러 영상
	cv::cvtColor(color2, lab, CV_BGR2Lab);

	//ab 히스토그램의 역투영 얻기
	result2 = finder.find(lab, 0, 256.0, ch);

	cv::namedWindow("Result ab 2");
	cv::imshow("Result ab 2", result2);

	//하늘 참조영역에 사각형 그리기
	cv::rectangle(color, cv::Rect(0, 0, 100, 45), cv::Scalar(0, 0, 0));
	cv::namedWindow("Color Image");
	cv::imshow("Color Image", color);
	
	//색상 히스토그램 얻기
	hc.setSize(180); //180개의 빈
	colorhist = hc.getHueHistogram(imageROI);

	//역투영할 히스토그램 설정
	finder.setHistogram(colorhist);

	//HSV로 변환
	cv::Mat hsv;
	cv::cvtColor(color, hsv, CV_BGR2HSV);

	//색 히스토그램의 역투영
	ch[0] = 0;
	result1 = finder.find(hsv, 0.0f, 180.0f, ch);

	cv::namedWindow("Result Hue 1");
	cv::imshow("Result Hue 1", result1);

	//두 번째 컬러 영상
	color2 = cv::imread("../images/dog.jpg");

	//HSV 공간으로 변환
	cv::cvtColor(color2, hsv, CV_BGR2HSV);

	//색상 히스토그램의 역변환 얻기
	result2 = finder.find(hsv, 0.0f, 180.0f, ch);

	cv::namedWindow("Result Hue 2");
	cv::imshow("Result Hue 2", result2);

	cv::waitKey();
	return 0;
}  

<코드 3 - 객체를 찾는 평균 이동 알고리즘 사용>
#include <iostream>
#include <vector>
#include <opencv2/core.hpp>
#include <opencv2/highgui.hpp>
#include <opencv2/video/tracking.hpp>

#include "contentFinder.h"
#include "colorhistogram.h"

using namespace std;

int main()
{
	//기준 영상 읽기
	cv::Mat image = cv::imread("../images/baboon01.jpg");
	if (!image.data) return 0;

	//초기 윈도우 위치
	cv::Rect rect(110, 45, 35, 45);
	cv::rectangle(image, rect, cv::Scalar(0, 0, 255));

	//개코 원숭이의 얼굴 ROI
	cv::Mat imageROI = image(rect);

	cv::namedWindow("Image 1");
	cv::imshow("Image 1", image);

	//개코 원숭이 얼굴의 색상 히스토그램 얻기
	int minSat = 65;
	ColorHistogram hc;
	cv::Mat colorhist = hc.getHueHistogram(imageROI, minSat);
	
	ContentFinder finder;
	finder.setHistogram(colorhist);
	finder.setThreshold(0.2f);

	//HSV공간으로 변환 (그냥 표시 용으로)
	cv::Mat hsv;
	cv::cvtColor(image, hsv, CV_BGR2HSV);

	//3채널을 3개의 영상으로 분리
	vector<cv::Mat> v;
	cv::split(hsv, v);

	//낮은 채도를 갖는 화소를 제외
	cv::threshold(v[1], v[1], minSat, 255, cv::THRESH_BINARY);
	cv::namedWindow("Saturation Mask");
	cv::imshow("Saturation Mask", v[1]);

	//두 번쨰 영상
	image = cv::imread("../images/baboon02.jpg");
	
	cv::namedWindow("Image 2");
	cv::imshow("Image 2", image);

	//HSV공간으로 변환
	cv::cvtColor(image, hsv, CV_BGR2HSV);

	//색상 히스토그램을 역투영한 결과 얻기
	int ch[1] = { 0 };
	finder.setThreshold(-1.0f);	//경계화하지 않음
	cv::Mat result = finder.find(hsv, 0.0f, 180.0f, ch);

	//역투영한 결과 표시
	cv::namedWindow("Backprojection on Second Image");
	cv::imshow("Backprojection on Second Image", result);

	//초기 윈도우 위치
	cv::rectangle(image, rect, cv::Scalar(0, 0, 255));

	//평균 이동으로 객체 탐색
	cv::TermCriteria criteria(cv::TermCriteria::MAX_ITER | cv::TermCriteria::EPS,
		10,		//최대 10회 반복
		1);		//또는 중심 위치 변화가 1픽셀 미만이 될 때까지
	cout << "meanshift= " << cv::meanShift(result, rect, criteria) << endl;

	//결과 윈도우 그리기
	cv::rectangle(image, rect, cv::Scalar(0, 255, 0));

	//영상 표시
	cv::namedWindow("Image 2 Result");
	cv::imshow("Image 2 Result", image);

	cv::waitKey();
	return 0;
}

<코드 4 - 히스토그램 비교를 이용한 유사 영상 검색>
#include <iostream>
#include <opencv2/core.hpp>
#include <opencv2/highgui.hpp>

#include "imageComparator.h"

using namespace std;

int main()
{
	//기준 영상 불러오기
	cv::Mat image = cv::imread("../images/waves.jpg");
	if (!image.data) return 0;

	//영상 표시하기
	cv::namedWindow("Query Image");
	cv::imshow("Query Image", image);

	ImageComparator c;
	c.setReferenceImage(image);

	//이미지를 불러와 기준 영상과 비교하기
	cv::Mat input = cv::imread("../images/dog.jpg");
	cout << "waves vs dog: " << c.compare(input) << endl;
	cv::namedWindow("dog");
	cv::imshow("dog", input);

	//이미지를 불러와 기준 영상과 비교하기
	input = cv::imread("../images/marais.jpg");
	cout << "waves vs marais: " << c.compare(input) << endl;
	cv::namedWindow("marais");
	cv::imshow("marais", input);

	//이미지를 불러와 기준 영상과 비교하기
	input = cv::imread("../images/bear.jpg");
	cout << "waves vs bear: " << c.compare(input) << endl;
	cv::namedWindow("bear");
	cv::imshow("bear", input);

	//이미지를 불러와 기준 영상과 비교하기
	input = cv::imread("../images/beach.jpg");
	cout << "waves vs beach: " << c.compare(input) << endl;
	cv::namedWindow("beach");
	cv::imshow("beach", input);

	//이미지를 불러와 기준 영상과 비교하기
	input = cv::imread("../images/polar.jpg");
	cout << "waves vs polar: " << c.compare(input) << endl;
	cv::namedWindow("polar");
	cv::imshow("polar", input);

	//이미지를 불러와 기준 영상과 비교하기
	input = cv::imread("../images/moose.jpg");
	cout << "waves vs moose: " << c.compare(input) << endl;
	cv::namedWindow("moose");
	cv::imshow("moose", input);

	//이미지를 불러와 기준 영상과 비교하기
	input = cv::imread("../images/lake.jpg");
	cout << "waves vs lake: " << c.compare(input) << endl;
	cv::namedWindow("lake");
	cv::imshow("lake", input);

	//이미지를 불러와 기준 영상과 비교하기
	input = cv::imread("../images/fundy.jpg");
	cout << "waves vs fundy: " << c.compare(input) << endl;
	cv::namedWindow("fundy");
	cv::imshow("fundy", input);

	cv::waitKey();
	return 0;
}

<코드 5 - 적분 영상을 사용하여 유사 객체 탐색하기>
#include <iostream>
#include <vector>
#include <opencv2/core.hpp>
#include <opencv2/highgui.hpp>
#include <opencv2/imgproc.hpp>

#include "histogram.h"
#include "integral.h"

using namespace std;

int main()
{
	//영상열기
	cv::Mat image = cv::imread("../images/bike55.bmp", 0);
	if (!image.data) return 0;

	//영상 ROI 정의(여기서는 자전거를 탄 여자 어린이)
	int xo = 97, yo = 112;
	int width = 25, height = 30;
	cv::Mat roi(image, cv::Rect(xo, yo, width, height));

	//합 계산
	//다채널 영상에 적용하는 스칼라 반환
	cv::Scalar sum = cv::sum(roi);
	cout << sum[0] << endl;

	//적분 영상 계산
	cv::Mat integralImage;
	cv::integral(image, integralImage, CV_32S);

	//3개의 덧셈/뺄셈을 사용해 영역에 걸친 합을 얻기
	int sumInt = integralImage.at<int>(yo + height, xo + width) - integralImage.at<int>(yo + height, xo) - integralImage.at<int>(yo, xo + width) + integralImage.at<int>(yo, xo);
	cout << sumInt << endl;

	//16개 빈의 히스토그램
	Histogram1D h;
	h.setNBins(16);

	//ROI 영상에 대한 히스토그램 계산하기
	cv::Mat refHistogram = h.getHistogram(roi);

	cv::namedWindow("Reference Histogram");
	cv::imshow("Reference Histogram", h.getHistogramImage(roi, 16));
	cout << refHistogram << endl;

	//먼저 이진 16평면영상 생성하기
	cv::Mat planes;
	convertToBinaryPlanes(image, planes, 16);

	//그 후 적분영상 계산하기
	IntegralImage<float, 16> intHisto(planes);

	//적분영상과 16개의 빈의 히스토그램 계산 테스팅
	cv::Vec<float, 16> histogram = intHisto(xo, yo, width, height);
	std::cout << histogram << std::endl;

	cv::namedWindow("Reference Histogram (2)");
	cv::Mat im = h.getImageOfHistogram(cv::Mat(histogram), 16);
	cv::imshow("Reference Histogram (2)", im);

	//두 번째 영상 찾기
	cv::Mat secondImage = cv::imread("../images/bike65.bmp", 0);
	if (!secondImage.data) return 0;

	//먼저 이진 16평면영상 생성하기
	convertToBinaryPlanes(secondImage, planes, 16);

	//그 후 적분영상 계산하기
	IntegralImage<float, 16> intHistogram(planes);

	//적분영상과 16개의 빈의 히스토그램 계산 테스팅
	histogram = intHistogram(135, 114, width, height);
	std::cout << histogram << std::endl;

	cv::namedWindow("Current Histogram");
	cv::Mat im2 = h.getImageOfHistogram(cv::Mat(histogram), 16);
	cv::imshow("Current Histogram", im2);

	std::cout << "Distance= " << cv::compareHist(refHistogram, histogram, cv::HISTCMP_INTERSECT) << std::endl;

	double maxSimilarity = 0.0;

	int xbest, ybest;

	//초기 영상에 있는 여자 어린이 위치 주변의 수평인 긴 조각 순회
	for (int y = 110; y < 120; y++)
	{
		for (int x = 0; x < secondImage.cols - width; x++)
		{
			//적분 영상을 이용해 16개 빈의 히스토그램 계산
			histogram = intHistogram(x, y, width, height);
			
			//기준 히스토그램과 거리 계산
			double distance = cv::compareHist(refHistogram, histogram, CV_COMP_INTERSECT);

			//매우 비슷한 히스토그램 위치 찾기
			if (distance > maxSimilarity)
			{
				xbest = x;
				ybest = y;
				maxSimilarity = distance;
			}

			//std::cout << "Distance(" << x << ", " << y << ")=" << distance << std::endl;
		}
	}

	std::cout << "Best soluction= (" << xbest << ", " << ybest << ")=" << maxSimilarity << std::endl;

	//타겟 오브젝트에 사각형 그리기
	cv::rectangle(image, cv::Rect(xo, yo, width, height), 0);
	cv::namedWindow("Initial Image");
	cv::imshow("Initial Image", image);

	cv::namedWindow("New Image");
	cv::imshow("New Image", secondImage);

	//최적 위치에서 사각형 그리기
	cv::rectangle(secondImage, cv::Rect(xbest, ybest, width, height), 0);

	//탐색 영역에 사각형 그리기
	cv::rectangle(secondImage, cv::Rect(0, 110, secondImage.cols, height + 10), 255);
	cv::namedWindow("Object location");
	cv::imshow("Object location", secondImage);

	cv::waitKey();
	return 0;
}

<코드 6 - 적분 영상과 적응적 경계화>
#include <iostream>
#include <opencv2/core.hpp>
#include <opencv2/highgui.hpp>
#include <opencv2/imgproc.hpp>

#include "integral.h"

int main()
{
	cv::Mat image = cv::imread("../images/book.jpg", 0);
	if (!image.data) return 0;

	//쉽게 보기위해 영상 회전 (-90, 270도 같은 것)
	cv::transpose(image, image);
	cv::flip(image, image, 0);

	//원본영상 표시
	cv::namedWindow("Original Image");
	cv::imshow("Original Image", image);

	//고정된 경계값 사용
	cv::Mat binaryFixed;
	cv::Mat binaryAdaptive;
	cv::threshold(image, binaryFixed, 70, 255, cv::THRESH_BINARY);

	//적응적 경계값 사용
	int blockSize = 21;	//이웃 화소의 크기
	int threshold = 10;	//화소를 (평균-경계 값)과 비교

	int64 time;
	time = cv::getTickCount();
	cv::adaptiveThreshold(image,		//입력 영상
		binaryAdaptive,					//출력 이진영상
		255,							//출력 최대값
		cv::ADAPTIVE_THRESH_MEAN_C,		//적응화 방법
		cv::THRESH_BINARY,				//경계화 종류
		blockSize,						//블럭의 사이즈
		threshold);						//경계값 사용
	time = cv::getTickCount() - time;
	std::cout << "time (adaptiveThreshold)= " << time << std::endl;

	//적분영상 계산
	IntegralImage<int, 1> integral(image);

	//적분결과 테스트하기
	std::cout << "sum= " << integral(18, 45, 30, 50) << std::endl;
	cv::Mat test(image, cv::Rect(18, 45, 30, 50));
	cv::Scalar t = cv::sum(test);
	std::cout << "sum test=" << t[0] << std::endl;

	cv::namedWindow("Fixed Threshold");
	cv::imshow("Fixed Threshold", binaryFixed);

	cv::namedWindow("Adaptive Threshold");
	cv::imshow("Adaptive Threshold", binaryAdaptive);

	cv::Mat binary = image.clone();

	time = cv::getTickCount();
	int nl = binary.rows;	//줄의 수
	int nc = binary.cols;	//줄 당 총 개체 수

	//적분 영상 계산
	cv::Mat iimage;
	cv::integral(image, iimage, CV_32S);

	//각 행
	int halfSize = blockSize / 2;
	for (int j = halfSize; j < nl - halfSize - 1; j++)
	{
		//j행의 주소 얻기
		uchar* data = binary.ptr<uchar>(j);
		int* idata1 = iimage.ptr<int>(j - halfSize);
		int* idata2 = iimage.ptr<int>(j + halfSize + 1);

		//각 행의 화소
		for (int i = halfSize; i < nc - halfSize - 1; i++)
		{
			//합 계산
			int sum = (idata2[i + halfSize + 1] - idata2[i - halfSize] - idata1[i + halfSize + 1] + idata1[i - halfSize]) / (blockSize*blockSize);

			//적응적 경계화 적용
			if (data[i] < (sum - threshold))
				data[i] = 0;
			else
				data[i] = 255;
		}
	}
	
	//추가 백색 테두리
	for (int j = 0; j < halfSize; j++)
	{
		uchar* data = binary.ptr<uchar>(j);

		for (int i = 0; i < binary.cols; i++)
		{
			data[i] = 255;
		}
	}
	for (int j = binary.rows - halfSize - 1; j < binary.rows; j++)
	{
		uchar* data = binary.ptr<uchar>(j);

		for (int i = 0; i < binary.cols; i++)
		{
			data[i] = 255;
		}
	}
	for (int j = halfSize; j < nl - halfSize - 1; j++)
	{
		uchar* data = binary.ptr<uchar>(j);

		for (int i = 0; i < halfSize; i++)
		{
			data[i] = 255;
		}
		for (int i = binary.cols - halfSize - 1; i < binary.cols; i++)
		{
			data[i] = 255;
		}
	}

	time = cv::getTickCount() - time;
	std::cout << "time integral= " << time << std::endl;

	cv::namedWindow("Adaptive Threshold (integral)");
	cv::imshow("Adaptive Threshold (integral)", binary);

	//영상 연산자를 사용한 적응적 경계화
	time = cv::getTickCount();
	cv::Mat filtered;
	cv::Mat binaryFiltered;
	
	//사각형 지역 박스 필터로 평균 픽셀 계산
	cv::boxFilter(image, filtered, CV_8U, cv::Size(blockSize, blockSize));

	//픽셀이 (평균+ 경계값) 보다 큰지 체크
	binaryFiltered = image >= (filtered - threshold);
	time = cv::getTickCount() - time;

	std::cout << "time filtered= " << time << std::endl;

	cv::namedWindow("Adaptive Threshold (filtered)");
	cv::imshow("Adaptive Threshold (filtered)", binaryFiltered);

	cv::waitKey();
	return 0;
}

<코드 7 - 헤더 파일들 (총 5개)>
================ 1. histogram.h ================
#if !defined HISTOGRAM
#define HISTOGRAM

#include <opencv2/core.hpp>
#include <opencv2/imgproc.hpp>

//그레이레벨 영상의 히스토그램 생성
class Histogram1D
{
private: 

	int histSize[1];		//히스토그램의 빈 개수
	float hranges[2];		//값 범위
	const float* ranges[1];	//값 범위를 가리키는 포인터
	int channels[1];		//조사할 채널 번호

public:

	Histogram1D()
	{
		//1D 히스토그램의 기본 인자 준비
		histSize[0] = 256;		//256개의 빈
		hranges[0] = 0.0;		//0부터(포함)
		hranges[1] = 256.0;		//256까지(제외)
		ranges[0] = hranges;
		channels[0] = 0;		//채널 0에서 봄
	}

	//Setter & Getter

	//계산할 히스토그램 채널 지정하기
	//기본 채널은 0
	void setChannel(int c)
	{
		channels[0] = c;
	}

	//사용된 채널 가져오기
	int getChannel()
	{
		return channels[0];
	}

	//픽셀 값의 범위 지정하기
	//기본 값은 [0, 256]
	void setRange(float minValue, float maxValue)
	{
		hranges[0] = minValue;
		hranges[1] = maxValue;
	}

	//최소 픽셀 값 가져오기
	float getMinValue()
	{
		return hranges[0];
	}

	//최대 픽셀 값 가져오기
	float getMaxValue()
	{
		return hranges[1];
	}

	//히스토그램의 빈 수 지정하기
	//기본 값은 256
	void setNBins(int nbins)
	{
		histSize[0] = nbins;
	}

	//히스토그램의 빈 수 가져오기
	int getNBins()
	{
		return histSize[0];
	}

	//1D 히스토그램 계산
	cv::Mat getHistogram(const cv::Mat &image)
	{
		cv::Mat hist;

		//히스토그램 계산
		cv::calcHist(&image,
			1,			//단일 영상의 히스토그램만
			channels,	//대상 채널
			cv::Mat(),	//마스크를 사용하지 않음
			hist,		//결과 히스토그램
			1,			//1D 히스토그램
			histSize,	//빈 개수
			ranges		//화소 값의 범위
		);
		
		return hist;
	}

	//1D 히스토그램을 계산한 후, 히스토그램 영상으로 반환
	cv::Mat getHistogramImage(const cv::Mat &image, int zoom = 1)
	{
		//먼저 히스토그램 계산
		cv::Mat hist = getHistogram(image);

		//영상 생성
		return getImageOfHistogram(hist, zoom);
	}

	//백분위수를 사용해서 소스 영상을 늘리기
	cv::Mat stretch(const cv::Mat &image, float percentile)
	{
		
		//백분위수인 화소 개수
		float number = image.total()*percentile;

		//먼저 히스토그램 계산
		cv::Mat hist = getHistogram(image);

		//히스토그램의 왼쪽 끝 찾기
		int imin = 0;

		for (float count = 0.0; imin < 256; imin++)
		{
			//imin에서의 화소 개수가 number보다 낮아야 함
			if ((count += hist.at<float>(imin)) >= number)
				break;
		}

		//히스토그램의 오른쪽 끝 찾기
		int imax = 255;

		for (float count = 0.0; imax >= 0; imax--)
		{
			//imax에서의 화소 개수가 number보다 낮아야 함
			if ((count += hist.at<float>(imax)) >= number)
				break;
		}

		//룩업 테이블 생성
		int dims[1] = { 256 };
		cv::Mat lookup(1, dims, CV_8U);

		for (int i = 0; i < 256; i++)
		{
			if (i < imin) lookup.at<uchar>(i) = 0;
			else if (i > imax) lookup.at<uchar>(i) = 255;
			else lookup.at<uchar>(i) = cvRound(255.0*(i - imin) / (imax - imin));
		}

		//룩업 테이블 적용
		cv::Mat result;
		result = applyLookUp(image, lookup);

		return result;
	}

	//최소값에 대한 bin의 수를 이용해서 소스 영상 늘리기
	cv::Mat stretch(const cv::Mat &image, int minValue = 0)
	{
		//먼저 히스토그램 계산
		cv::Mat hist = getHistogram(image);

		//히스토그램의 왼쪽 끝 찾기
		int imin = 0;

		for (; imin < histSize[0]; imin++)
		{
			//minValue보다 작은 bin들을 무시한다. 
			if (hist.at<float>(imin) > minValue)
				break;
		}

		//히스토그램의 오른쪽 끝 찾기
		int imax = histSize[0] -1;

		for (; imax >= 0; imax--)
		{
			//minValue보다 작은 bin들을 무시한다. 
			if (hist.at<float>(imax) > minValue)
				break;
		}

		//룩업 테이블 생성
		int dims[1] = { 256 };
		cv::Mat lookup(1, dims, CV_8U);

		for (int i = 0; i < 256; i++)
		{
			if (i < imin) lookup.at<uchar>(i) = 0;
			else if (i > imax) lookup.at<uchar>(i) = 255;
			else lookup.at<uchar>(i) = cvRound(255.0*(i - imin) / (imax - imin));
		}

		//룩업 테이블 적용
		cv::Mat result;
		result = applyLookUp(image, lookup);

		return result;
	}

	//Static Methods

	//히스토그램을 표현하는 영상 생성(정적 메소드)
	static cv::Mat getImageOfHistogram(const cv::Mat &hist, int zoom)
	{
		//최소 최대 빈 값 얻기
		double maxVal = 0;
		double minVal = 0;
		cv::minMaxLoc(hist, &minVal, &maxVal, 0, 0);

		//히스토그램 크기 얻기
		int histSize = hist.rows;

		//히스토그램을 표시하는 정사각형 영상
		cv::Mat histImg(histSize*zoom, histSize*zoom, CV_8U, cv::Scalar(255));

		//총 빈의 90%을 정점으로 설정(즉, 영상높이)
		int hpt = static_cast<int>(0.9*histSize);
		
		//빈당 수직선 그리기
		for (int h = 0; h < histSize; h++)
		{
			float binVal = hist.at<float>(h);
			if (binVal > 0)
			{
				int intensity = static_cast<int>(binVal*hpt / maxVal);
				cv::line(histImg, cv::Point(h*zoom, histSize*zoom), cv::Point(h*zoom, (histSize - intensity)*zoom), cv::Scalar(0), zoom);
			}
		}

		return histImg;
	}

	//소스 영상 평활화
	static cv::Mat equalize(const cv::Mat &image)
	{
		cv::Mat result;
		cv::equalizeHist(image, result);

		return result;
	}

	//1채널 입력 이미지에 룩업 테이블로 변환해 적용하기
	static cv::Mat applyLookUp(const cv::Mat& image, //입력이미지
		const cv::Mat& lookup) { //1x256 uchar 행렬

		//결과 이미지
		cv::Mat result;

		//룩업 테이블 적용하기
		cv::LUT(image, lookup, result);

		return result;
	}

	//1채널 입력 이미지에 룩업 테이블로 변환해 적용하기
	//이건 반복자를 사용한 테스트 버전; 항상 cv::LUT 함수를 사용하기
	static cv::Mat applyLookUpWithIterator(const cv::Mat& image, const cv::Mat& lookup)
	{
		//결과 영상 지정하기 (항상 1채널이여야함)
		cv::Mat result(image.rows, image.cols, CV_8U);
		cv::Mat_<uchar>::iterator itr = result.begin<uchar>();

		//입력 영상 반복 처리
		cv::Mat_<uchar>::const_iterator it = image.begin<uchar>();
		cv::Mat_<uchar>::const_iterator itend = image.end<uchar>();

		//각 픽셀에 룩업 적용하기
		for (; it != itend; ++it, ++itr)
		{
			*itr = lookup.at<uchar>(*it);
		}
		
		return result;
	}

};

#endif

================ 2. colorhistogram.h ================
#if !defined COLHISTOGRAM
#define COLHISTOGRAM

#include <opencv2/core.hpp>
#include <opencv2/imgproc.hpp>

class ColorHistogram
{
private:
	int histSize[3];			//각 차원의 사이즈
	float hranges[2];			//값 범위 (3개의 차원이 같다)
	const float* ranges[3];		//각 차원의 값 범위를 가리키는 포인터 배열
	int channels[3];			//고려할 채널

public:
	ColorHistogram()
	{
		//컬러 히스토그램 기본 인자 준비
		//각 차원은 사이즈와 범위를 가지고 있다
		histSize[0] = histSize[1] = histSize[2] = 256;
		hranges[0] = 0.0;		//BGR 범위는 0부터 256까지다
		hranges[1] = 256.0;
		ranges[0] = hranges;	//이 클래스의 모든 채널은 같은 범위를 가지고있다.
		ranges[1] = hranges;
		ranges[2] = hranges;
		channels[0] = 0;		//B채널
		channels[1] = 1;		//G
		channels[2] = 2;		//R
	}

	//각각 차원마다 히스토그램 사이즈 설정하기
	void setSize(int size)
	{
		//각 차원은 같은 사이즈를 갖고있다.
		histSize[0] = histSize[1] = histSize[2] = size;
	}

	//히스토그램 계산하기
	cv::Mat getHistogram(const cv::Mat &image)
	{
		cv::Mat hist;

		//BGR 색 히스토그램
		hranges[0] = 0.0;
		hranges[1] = 256.0;
		channels[0] = 0;
		channels[1] = 1;
		channels[2] = 2;

		//히스토그램 계산
		cv::calcHist(&image,
			1,			//단일 영상의 히스토그램만
			channels,	//대상 채널
			cv::Mat(),	//마스크를 사용하지 않음
			hist,		//결과 히스토그램
			3,			//3D 히스토그램
			histSize,	//빈 개수
			ranges		//화소 값의 범위
		);

		return hist;
	}

	//과도한 메모리 소모를 줄이기 위해 희소 행렬 사용할 수 있는 방법
	cv::SparseMat getSparseHistogram(const cv::Mat &image)
	{
		cv::SparseMat hist(3,	//차원의 개수
			histSize,			//각 차원의 크기
			CV_32F);

		//BGR 색 히스토그램
		hranges[0] = 0.0;
		hranges[1] = 256.0;
		channels[0] = 0;
		channels[1] = 1;
		channels[2] = 2;

		//히스토그램 계산하기
		cv::calcHist(&image,
			1,					//단일 영상 히스토그램만
			channels,			//대상 채널
			cv::Mat(),			//마스크를 사용하지 않음
			hist,				//결과 히스토그램
			3,					//3D 히스토그램
			histSize,			//빈 개수
			ranges				//화소 값의 범위
		);

		return hist;
	}

	//마스크로 1D 색상 히스토그램 계산하기
	//BGR 원 영상을 HSV로 변환
	//낮은 채도를 갖는 화소 무시
	cv::Mat getHueHistogram(const cv::Mat &image, int minSaturation = 0)
	{
		cv::Mat hist;

		//HSV컬러 공간으로 변환
		cv::Mat hsv;
		cv::cvtColor(image, hsv, CV_BGR2HSV);

		//사용할 마스크(또는 사용하지 않음)
		cv::Mat mask;
		
		//만약 마스크가 필요하실시 생성
		if (minSaturation > 0)
		{
			//3채널을 3개의 영상으로 분리
			std::vector<cv::Mat> v;
			cv::split(hsv, v);

			//낮은 채도를 갖는 화소를 제외
			cv::threshold(v[1], mask, minSaturation, 255, cv::THRESH_BINARY);
		}

		//1D 색상 히스토그램을 위한 인자 준비
		hranges[0] = 0.0;		//범위는 0부터 180까지임
		hranges[1] = 180.0;
		channels[0] = 0;		//색상 채널

		//히스토그램 계산
		cv::calcHist(&hsv,
			1,			//단일 영상의 히스토그램만
			channels,	//대상 채널
			mask,	//이진 마스크
			hist,		//결과 히스토그램
			1,			//1D 히스토그램
			histSize,	//빈 개수
			ranges		//화소 값의 범위
		);

		return hist;
	}

	//2D ab공간 히스토그램 계산하기
	//BGR 원 영상을 Lab로 변환
	//낮은 채도를 갖는 화소 무시
	cv::Mat getabHistogram(const cv::Mat &image)
	{
		cv::Mat hist;

		//Lab컬러 공간으로 변환
		cv::Mat lab;
		cv::cvtColor(image, lab, CV_BGR2Lab);

		//2D 색상 히스토그램을 위한 인자 준비
		hranges[0] = 0.0;
		hranges[1] = 256.0;
		channels[0] = 1;		//두 개의 대상 채널은 ab임
		channels[1] = 2;

		//히스토그램 계산
		cv::calcHist(&lab,
			1,			//단일 영상의 히스토그램만
			channels,	//대상 채널
			cv::Mat(),	//마스크를 사용하지 않음
			hist,		//결과 히스토그램
			2,			//2D 히스토그램
			histSize,	//빈 개수
			ranges		//화소 값의 범위
		);

		return hist;
	}
};

#endif

================ 3. contentFinder.h ================
#if !defined OFINDER
#define OFINDER

#include <opencv2/core.hpp>
#include <opencv2/imgproc.hpp>

class ContentFinder
{
private:
	//히스토그램 파라미터
	float hranges[2];
	const float* ranges[3];
	int channels[3];

	float threshold;			//경계값 결정
	cv::Mat histogram;			//희소화하지 않은 히스토그램
	cv::SparseMat shistogram;	//희소화한 히스토그램
	bool isSparse;

public:
	ContentFinder() : threshold(0.1f), isSparse(false)
	{
		//이 클래스에서 모든 채널은 같은 범위임
		ranges[0] = hranges;
		ranges[1] = hranges;
		ranges[2] = hranges;
	}

	//Setter & Getter

	//히스토그램의 [0, 1] 값에서 경계 값 설정
	void setThreshold(float t)
	{
		threshold = t;
	}

	//경계값 얻기
	float getThreshold()
	{
		return threshold;
	}

	//기준 히스토그램 설정
	void setHistogram(const cv::Mat& h)
	{
		isSparse = false;
		cv::normalize(h, histogram, 1.0);
	}

	//기준 히스토그램 설정 (희소화)
	void setHistogram(const cv::SparseMat& h)
	{
		isSparse = true;
		cv::normalize(h, shistogram, 1.0, cv::NORM_L2);
	}

	//단순화한 버전
	//범위가 [0, 256]인 모든 채널 사용
	cv::Mat find(const cv::Mat& image)
	{
		cv::Mat result;

		hranges[0] = 0.0;
		hranges[1] = 256.0;
		channels[0] = 0;
		channels[1] = 1;
		channels[2] = 2;

		return find(image, hranges[0], hranges[1], channels);
	}

	//히스토그램에 속하는 화소 찾기
	cv::Mat find(const cv::Mat& image, float minValue, float maxValue, int *channels)
	{
		cv::Mat result;

		hranges[0] = minValue;
		hranges[1] = maxValue;

		if (isSparse) //히스토그램 형태에 기반을 둔 적잘한 함수 호출
		{
			//히스토그램 차원은 채널 목록과 일치
			for (int i = 0; i < shistogram.dims(); i++)
				this->channels[i] = channels[i];

			cv::calcBackProject(&image,
				1,				//한 번에 영상 1개만 사용
				channels,		//영상 채널에 속하는 히스토그램 차원을 지정한 백터
				shistogram,		//사용할 히스토그램
				result,			//역투영 영상
				ranges,			//차원당 값의 범위
				255.0			//확률 값의 1을 255로 매핑하기 위해 선택한 재조정 인자
			);
		}
		else 
		{
			//히스토그램 차원은 채널 목록과 일치
			for (int i = 0; i < histogram.dims; i++)
				this->channels[i] = channels[i];

			cv::calcBackProject(&image,
				1,				//한 번에 영상 1개만 사용
				channels,		//영상 채널에 속하는 히스토그램 차원을 지정한 백터
				histogram,		//사용할 히스토그램
				result,			//역투영 영상
				ranges,			//차원당 값의 범위
				255.0			//확률 값의 1을 255로 매핑하기 위해 선택한 재조정 인자
			);
		}

		//이진 영상을 얻기 위해 역투영을 경계화
		if (threshold > 0.0)
			cv::threshold(result, result, 255.0*threshold, 255.0, cv::THRESH_BINARY);

		return result;

	}
};

#endif

================ 4. imageComparator.h ================
#if !defined ICOMPARATOR
#define ICOMPARATOR

#include <opencv2/core.hpp>
#include <opencv2/imgproc.hpp>
#include "colorhistogram.h"

class ImageComparator
{
private:
	cv::Mat refH;	//기준 히스토그램
	cv::Mat inputH;	//입력영상의 히스토그램

	ColorHistogram hist;	//생성할 히스토그램
	int nBins;				//각 컬러채널에 사용된 빈의 개수

public:
	ImageComparator() :nBins(8) {}

	//히스토그램을 비교할 때 사용하는 빈의 개수 설정
	void setNumberOfBins(int bins)
	{
		nBins = bins;
	}

	int getNumberOfBins()
	{
		return nBins;
	}

	//기준 영상의 히스토그램 계산
	void setReferenceImage(const cv::Mat& image)
	{
		hist.setSize(nBins);
		refH = hist.getHistogram(image);
	}

	//두 BGR 히스토그램을 사용해 영상 비교
	double compare(const cv::Mat& image)
	{
		inputH = hist.getHistogram(image);

		//교차점을 이용한 히스토그램 비교
		return cv::compareHist(refH, inputH, cv::HISTCMP_INTERSECT);
	}
};

#endif

================ 5. integral.h ================
#if !defined IINTEGRAL
#define IINTEGRAL

#include <opencv2/core.hpp>
#include <opencv2/highgui.hpp>
#include <vector>

template <typename T, int N>
class IntegralImage
{
	cv::Mat integralImage;

public:

	IntegralImage(cv::Mat image)
	{
		//(비용이 많이 드는) 적분 영상 계산
		cv::integral(image, integralImage, cv::DataType<T>::type);
	}

	//4개의 화소 접근으로부터 임의 크기의 부분 영역에 걸쳐 합을 계산하기
	cv::Vec<T, N> operator() (int xo, int yo, int width, int height)
	{
		//(xo, yo)에 있는 높이 * 너비의 크기인 윈도우
		return (integralImage.at<cv::Vec<T, N> >(yo + height, xo + width)
			- integralImage.at<cv::Vec<T, N> >(yo + height, xo)
			- integralImage.at<cv::Vec<T, N> >(yo, xo + width)
			+ integralImage.at<cv::Vec<T, N> >(yo, xo));
	}
};

//이진 평면으로 구성된 다채널 영상으로 변환하기
//nPlanes는 반드시 2의 지수 승이어야 함
void convertToBinaryPlanes(const cv::Mat& input, cv::Mat& output, int nPlanes)
{
	//제외하기 위한 비트 개수
	int n = 8 - static_cast<int>(log(static_cast<double>(nPlanes)) / log(2.0));

	//최하위 비트 제거에 사용하는 마스크
	uchar mask = 0xFF << n; // 예를 들어 div=16 라면 mask=0xF0

	//이진영상의 백터 생성
	std::vector<cv::Mat> planes;
	
	//최하위 비트들을 제거해 nBins를 줄임
	cv::Mat reduced = input & mask;

	//각 이진영상 평면 계산
	for (int i = 0; i < nPlanes; i++)
	{

		//각 화소의 1은 i<<shift와 동일하다
		planes.push_back((reduced == (i << n)) & 0x1);
	}

	//다채널 영상 생성하기
	cv::merge(planes, output);
}

#endif



5. 형태학 연산으로 영상 변환(Transforming images with morphological operations)
- 수학적 형태학은 이산 영상 분석과 처리를 위해 1960년대에 나왔던 이론, 기본 성분은 구조요소(structuring element)이다. 구조요소는 고정점(anchor point)가 있는 화소의 구성이다.
구조요소는 사각형, 원, 다이아몬드 같은 간단한 모양을 많이 사용한다. 형태학 용어로 영상의 보수는 이진 영상을 반전한 것을 뜻한다.
- 그레이레벨의 형태학을 생각할 때 산을 생각하면 이해하기 쉽다.
1) 침식(erosion), 팽창(dilation)은 가장 기본적인 형태학 연산자(필터이다). 우선, 침식은 현재 화소를 정의된 화소 집합에서 찾은 최소 화소 값으로 변경하고 팽창은 반대다.
더 큰 구조요소나 여러 번 영상을 침식/팽창하면 더 강하게 된다. 제자리 처리(입력영상=결과영상)이 가능하다.
2) 열림(opening), 닫힘(closing)은 고수준 형태학 필터이다. cv::morphologyEx()함수를 사용해서 적용할 수 있다. 또는 원 영상을 팽창> 침식 시키면 닫힌 영상, 침식 > 팽창 시키면 열린 영상을 얻을 수 있다.
닫힘 필터는 여러 인접한 객체를 연결. 구조 요소를 완전히 포함하기엔 너무나 작은 홀이나 틈(gap)을 모두 제거한다.
열림 필터는 상호적으로 장면에 있는 여러 작은 객체를 제거한다.
3) 기울기(gradient)는 영상의 에지 추출을 할 수 있는 흥미로운 필터로 cv::morphologyEx()함수를 사용해 이용할 수 있다. 원리는 팽창한 영상에서 침식한 영상의 차를 계산하면 검출 할 수 있다. 간단하게 원영상과 침식, 팽창의 차를 구해도 구할 수 있다.
4) 탑햇변환(top-hat transform)은 영상에서 작은 지역 전경을 추출하는 데, 이 연산자를 사용할 수 있다. 블랙탑햇변환은 검은색을 추출한다. 원리는 열림, 닫힘과 원 영상의 차를 사용해서 구한다.
   열리면 지역 봉우리(local leak)=추출하려는 전경 객체가 제거된다. 닫히면 아래쪽 봉우리가 제거 = 블랫 탑햇의 원리다. 
5) 워터쉐드변환(watershed transformation)은 동질 영역 분할에 사용되는 인기 있는 영상처리 알고리즘이다. 이 알고리즘은 영상을 위상적 지형으로 봤을 때, 동질 영역은 상대적으로 가파른 에지로 구분된 평탄한 유역에 대응한다는 아이디어에 의거한다.
   cv::watershed()함수를 사용하며, 영상 분할의 정의를 안내하는 미리 정의된 마커의 집합을 사용한다. 마커의 집합은 검은색0(알수없는화소), 흰색, 회색등으로 전경과 배경을 구분짓는 영상이다. 다양한 방법으로 마커를 구성할 수 있다. 배경부분에 큰 사각형 테두리, 전경에 작은 사각형 테두리 이런식으로도.
   워터쉐드의 선 부분은 -1를 허용하며 함수가 반환한다. 워터쉐드 선만 뽑아내기 위해 선형변환 0 (-1*255+255 = 0)을 적용한다. 나머진 다 255
6) MSER(Maximally Stable External Region)알고리즘은 영상의 의미있는 영역을 추출하기 위해 동일한 침수 유추(immersion analogy)를 사용한다.
   계산하는 클래스가 CV::Feature2D 안에있는 cv::MSER이다. 

<코드 1 - 형태학 필터와 형태학 연산자>
#include <opencv2/core.hpp>
#include <opencv2/highgui.hpp>
#include <opencv2/imgproc.hpp>

int main()
{
	//입력 영상 읽기
	cv::Mat image = cv::imread("../images/binary.bmp");
	if (!image.data) return 0;

	//영상 표시
	cv::namedWindow("Image");
	cv::imshow("Image", image);

	//영상 침식
	//3*3 기본 구조요소로 (SE)
	cv::Mat eroded;
	cv::erode(image, eroded, cv::Mat());

	//침식 영상 표시
	cv::namedWindow("Eroded Image");
	cv::imshow("Eroded Image", eroded);

	//영상 팽창
	cv::Mat dilated; //목적영상
	cv::dilate(image, dilated, cv::Mat());

	//팽창 영상 표시
	cv::namedWindow("Dilated Image");
	cv::imshow("Dilated Image", dilated);

	//더 큰 구조요소(SE)로 영상 침식
	//1을 모두 포함하는 7*7 행렬 생성
	cv::Mat element(7, 7, CV_8U, cv::Scalar(1));

	//구조요소(SE)로 영상 침식
	cv::erode(image, eroded, element);

	//더 큰 침식 영상 표시
	cv::namedWindow("Eroded Image (7x7)");
	cv::imshow("Eroded Image (7x7)", eroded);

	//영상을 세 번 침식
	cv::erode(image, eroded, cv::Mat(), cv::Point(-1, -1), 3);

	//3번 침식 영상 표시
	cv::namedWindow("Eroded Image (3 times)");
	cv::imshow("Eroded Image (3 times)", eroded);

	//영상 닫힘
	cv::Mat element5(5, 5, CV_8U, cv::Scalar(1));
	cv::Mat closed;
	cv::morphologyEx(image, closed,		//입력 영상과 결과 영상
					 cv::MORPH_CLOSE,	//연산자 코드
					 element5);			//구조 요소(SE)

	//닫힌 영상 표시
	cv::namedWindow("Closed Image");
	cv::imshow("Closed Image", closed);

	//영상 열림
	cv::Mat opened;
	cv::morphologyEx(image, opened, cv::MORPH_OPEN, element5);

	//열린 영상 표시
	cv::namedWindow("Opened Image");
	cv::imshow("Opened Image", opened);

	//명시적 닫힘
	//1. 원 영상을 팽창
	cv::Mat result;
	cv::dilate(image, result, element5);

	//2. 팽창한 영상을 제자리에서 침식
	cv::erode(result, result, element5);

	//명시적 닫힌 영상 표시
	cv::namedWindow("Closed Image (2)");
	cv::imshow("Closed Image (2)", result);

	//닫히고 열린 영상
	cv::morphologyEx(image, image, cv::MORPH_CLOSE, element5);
	cv::morphologyEx(image, image, cv::MORPH_OPEN, element5);

	//닫히고 열린 영상 표시
	cv::namedWindow("Closed|Opened Image");
	cv::imshow("Closed|Opened Image", image);
	cv::imwrite("binaryGroup.bmp", image);

	//입력 영상 읽기
	image = cv::imread("../images/binary.bmp");
	if (!image.data) return 0;

	//열리고 닫힌 영상
	cv::morphologyEx(image, image, cv::MORPH_OPEN, element5);
	cv::morphologyEx(image, image, cv::MORPH_CLOSE, element5);

	//열리고 닫힌 영상 표시
	cv::namedWindow("Opened|Closed Image");
	cv::imshow("Opened|Closed Image", image);

	//입력 영상 불러오기 (그레이레벨)
	image = cv::imread("../images/boldt.jpg", 0);
	if (!image.data) return 0;

	//3x3 구조요소(SE)를 사용해 기울기 영상 얻기
	cv::morphologyEx(image, result, cv::MORPH_GRADIENT, cv::Mat());

	//형태학 외각선 영상 표시 (반전)
	cv::namedWindow("Edge Image");
	cv::imshow("Edge Image", 255 - result);

	//경계값 적용해 이진 영상 얻기
	int threshold(80);
	cv::threshold(result, result, threshold, 255, cv::THRESH_BINARY);

	//경계값 적용된 외곽선 영상 표시
	cv::namedWindow("Thresholded Edge Image");
	cv::imshow("Thresholded Edge Image", result);

	//입력 영상 불러오기 (그레이레벨)
	image = cv::imread("../images/book.jpg", 0);
	if (!image.data) return 0;

	//보기쉽게 영상 회전해 표시
	cv::transpose(image, image);
	cv::flip(image, image, 0);

	//7x7 구조요소(SE)를 사용해 블랙 탑햇 변환 적용
	cv::Mat element7(7, 7, CV_8U, cv::Scalar(1));
	cv::morphologyEx(image, result, cv::MORPH_BLACKHAT, element7);

	//탑햇 영상 표시 (반전)
	cv::namedWindow("7x7 Black Top-hat Image");
	cv::imshow("7x7 Black Top-hat Image", 255 - result);

	//경계값 적용해 이진 영상 얻기
	threshold = 25;
	cv::threshold(result, result, threshold, 255, cv::THRESH_BINARY);

	//경계값 적용된 블랙 탑햇 변환 영상 표시 (반전)
	cv::namedWindow("Thresholded Black Top-hat");
	cv::imshow("Thresholded Black Top-hat", 255 - result);

	//7x7 구조요소(SE)를 사용해 닫힘 적용
	cv::morphologyEx(image, result, cv::MORPH_CLOSE, element7);

	//7x7 닫힌 영상 표시 (반전)
	cv::namedWindow("7x7 Closed Image");
	cv::imshow("7x7 Closed Image", 255 - result);

	cv::waitKey();
	return 0;
}

<코드 2 - 워터쉐드를 이용한 영상 분할 (헤더파일 코드 포함)>
#include <iostream>
#include <opencv2/core.hpp>
#include <opencv2/highgui.hpp>
#include <opencv2/imgproc.hpp>
#include "watershedSegmentation.h"

int main()
{
	//입력 영상 읽기
	cv::Mat image = cv::imread("../images/group.jpg");
	if (!image.data) return 0;

	//영상 표시
	cv::namedWindow("Original Image");
	cv::imshow("Original Image", image);

	//이진 맵 가져오기
	cv::Mat binary;
	binary = cv::imread("../images/binary.bmp", 0);

	//이진 영상 표시
	cv::namedWindow("Binary Image");
	cv::imshow("Binary Image", binary);

	//잡음과 더 작은 객체 제거
	cv::Mat fg;
	cv::erode(binary, fg, cv::Mat(), cv::Point(-1, -1), 4);
	
	//전경 영상 표시
	cv::namedWindow("Foreground Image");
	cv::imshow("Foreground Image", fg);

	//객체 없는 영상 화소 식별
	cv::Mat bg;
	cv::dilate(binary, bg, cv::Mat(), cv::Point(-1, -1), 4);
	cv::threshold(bg, bg, 1, 128, cv::THRESH_BINARY_INV);

	//배경 영상 표시
	cv::namedWindow("Background Image");
	cv::imshow("Background Image", bg);

	//마커 영상 생성
	cv::Mat markers(binary.size(), CV_8U, cv::Scalar(0));
	markers = fg + bg;
	cv::namedWindow("Markers");
	cv::imshow("Markers", markers);

	//워터쉐드 분할 객체 생성
	WatershedSegmenter segmenter;

	//마커를 설정한 후 처리
	segmenter.setMarkers(markers);
	segmenter.process(image);

	//분할 결과 표시
	cv::namedWindow("Segmentation");
	cv::imshow("Segmentation", segmenter.getSegmentation());

	//워터쉐드 표시
	cv::namedWindow("Watersheds");
	cv::imshow("Watersheds", segmenter.getWatersheds());

	//또 다른 이미지 열기
	image = cv::imread("../images/tower.jpg");

	//배경 화소 식별
	cv::Mat imageMask(image.size(), CV_8U, cv::Scalar(0));
	cv::rectangle(imageMask, cv::Point(5, 5), cv::Point(image.cols - 5, image.rows - 5), cv::Scalar(255), 3);
	
	//(영상 가운데의) 전경 화소 식별
	cv::rectangle(imageMask, cv::Point(image.cols / 2 - 10, image.rows / 2 - 10), cv::Point(image.cols / 2 + 10, image.rows / 2 + 10), cv::Scalar(1), 10);
	
	//마커를 설정한 후 처리
	segmenter.setMarkers(imageMask);
	segmenter.process(image);
	
	//영상과 마커 표시
	cv::rectangle(image, cv::Point(5, 5), cv::Point(image.cols - 5, image.rows - 5), cv::Scalar(255, 255, 255), 3);
	cv::rectangle(image, cv::Point(image.cols / 2 - 10, image.rows / 2 - 10), cv::Point(image.cols / 2 + 10, image.rows / 2 + 10), cv::Scalar(1, 1, 1), 10);

	cv::namedWindow("Image with marker");
	cv::imshow("Image with marker", image);

	//워터쉐드 표시
	cv::namedWindow("Watershed");
	cv::imshow("Watershed", segmenter.getWatersheds());

	cv::waitKey();
	return 0;
}

================== watershedSegmentation.h ==================

#if !defined WATERSHS
#define WATERSHS

#include <opencv2/core.hpp>
#include <opencv2/imgproc.hpp>

class WatershedSegmenter
{
private:
	cv::Mat markers;

public:
	void setMarkers(const cv::Mat& markerImage)
	{
		//정수형 영상으로 변환
		markerImage.convertTo(markers, CV_32S);
	}

	cv::Mat process(const cv::Mat &image)
	{
		//워터쉐드 적용
		cv::watershed(image, markers);

		return markers;
	}

	//결과를 영상 형태로 변환
	cv::Mat getSegmentation()
	{
		cv::Mat tmp;
		// 255보다 높은 레이블을 갖는 모든 분할에 255값을 할당
		markers.convertTo(tmp, CV_8U);

		return tmp;
	}

	//워터쉐드를 영상 형태로 변환
	cv::Mat getWatersheds()
	{
		cv::Mat tmp;
		
		//변환하기 전에 각 화소 p를 255*p+255로 바꿈
		markers.convertTo(tmp, CV_8U, 255, 255);

		return tmp;
	}
};

#endif


<코드 3 - MSER를 이용해 두드러진 영역 추출>
#include <iostream>
#include <opencv2/core.hpp>
#include <opencv2/highgui.hpp>
#include <opencv2/imgproc.hpp>
#include <opencv2/features2d.hpp>
#include <vector>

int main()
{
	//입력 영상 읽기
	cv::Mat image = cv::imread("../images/building.jpg", 0);
	if (image.empty()) return 0;

	//영상 표시
	cv::namedWindow("Image");
	cv::imshow("Image", image);

	//기본 MSER 검출기
	cv::Ptr<cv::MSER> ptrMSER = cv::MSER::create(5,			//지역을 검출하기 위한 델타 값
		200,		//최소 허용 면적
		2000);		//최대 허용 면적

	//점 집합의 백터
	std::vector<std::vector<cv::Point> > points;

	//직사각형의 백터
	std::vector<cv::Rect> rects;

	//MSER 특징 검출
	ptrMSER->detectRegions(image, points, rects);

	std::cout << points.size() << " MSERs detected" << std::endl;

	//흰색 영상 생성
	cv::Mat output(image.size(), CV_8UC3);
	output = cv::Scalar(255, 255, 255);

	//OpenCV 난수 발생기(random number generator)
	cv::RNG rng;

	//MSER의 색영역 표시
	//각각 검출된 특징에 대해 가장 큰 MSER부터 역순서로 표시
	for (std::vector<std::vector<cv::Point>>::reverse_iterator it = points.rbegin(); it != points.rend(); ++it)
	{
		//임의 색 생성
		cv::Vec3b c(rng.uniform(0, 254),
			rng.uniform(0, 254),
			rng.uniform(0, 254));

		std::cout << "MSER size= " << it->size() << std::endl;

		//MSER 집합의 각 점에 대해
		for (std::vector<cv::Point>::iterator itPts = it->begin(); itPts != it->end(); ++itPts)
		{
			//MSER 화소들을 덮어 쓰지 않음
			if (output.at<cv::Vec3b>(*itPts)[0] == 255)
			{
				output.at<cv::Vec3b>(*itPts) = c;
			}
		}
	}

	cv::namedWindow("MSER point sets");
	cv::imshow("MSER point sets",output);
	cv::imwrite("mser.bmp", output);

	//사각형 MSER를 추출해 표시
	std::vector<cv::Rect>::iterator itr = rects.begin();
	std::vector<std::vector<cv::Point>>::iterator itp = points.begin();
	for (; itr != rects.end(); ++itr, ++itp)
	{
		//비율 판정법(ratio test)
		if (static_cast<double>(itp->size()) / itr->area() > 0.6)
			cv::rectangle(image, *itr, cv::Scalar(255), 2);
	}

	//결과 영상을 표시
	cv::namedWindow("Rectangular MSERs");
	cv::imshow("Rectangular MSERs", image);

	//입력 영상 다시불러오기
	image = cv::imread("../images/building.jpg", 0);
	if (image.empty()) return 0;

	//MSER를 추출한 후 타원으로 표시
	for (std::vector<std::vector<cv::Point>>::iterator it = points.begin(); it != points.end(); ++it)
	{
		//MSER 집합의 각 점에 대해
		for (std::vector<cv::Point>::iterator itPts = it->begin(); itPts != it->end(); ++itPts)
		{
			//경계 사각형 추출
			cv::RotatedRect rr = cv::minAreaRect(*it);
			
			//타원이 가능한지 확인
			if (rr.size.width / rr.size.height > 0.6 || rr.size.height / rr.size.width < 1.6)
				cv::ellipse(image, rr, cv::Scalar(255), 2);
		}
	}

	//영상 표시
	cv::namedWindow("MSER ellipses");
	cv::imshow("MSER ellipses", image);

	cv::waitKey();
	return 0;
}



6. 영상 필터링[Filtering the Images]
1) 필터링(filtering)은 신호처리와 영상처리의 기본 작업 중에 하나이며, 주어진 응용의 맥락에서 중요한 정보 전달로 고려할 수 있는 영상의 어떤 측면을 선택적으로 추출하는 데 목적이 있다.
- 필터링은 영상의 잡음을 제거하고, 흥미로운 시각적 특징을 추출하며, 영상 재샘플링(크기조정or 화소값 변환)이 가능해지는 처리를 한다.
- 필터링은 일반적으로 신호 시스템(Signal and Systems)이론의 뿌리에 둔다.
- 주파수 영역 분석(Frequency domain analysis)란, 명도의 변화가 급격하면 높은 주파수라고 하며, 명도의 변화가 느리거나 거의없으면 낮은 주파수, 영상에서 변화의 주기를 관찰하는 것이
주파수 영역(frequency domain), 우리가 직접 못보는 변환된 영상 그레이레벨 분포를 관찰해 영상을 특성화한 것은 공간 영역(spatial domain)이라고 한다.(우리가 직접 볼 수 있는 영상)
- 주파수 영역은 수직 주파수(수직 방향에서 변화)와 수평 주파수(수평 방향에서 변화)가 있다.
- 저주파 통과 필터(low-pass filter) 고주파 성분을 제거하는 필터, 고주파 통과 필터(high-pass filter) 저주파 성분을 제거하는 필터
- 저주파 통과 필터를 달성하는 한 가지 간단한 방법은 각 화소를 주변에 있는 화소의 평균 값으로 대치하는 것으로 급격한 명도 변화가 부드러워 진다.
- blur()함수, 가우시안(종 모양 함수) 블러함수(gaussianblur) 가우시안 블러는 가까이 위치한 화소에 더 많은 중요성(가중치)을 부여하는 함수이다. 보통 box형이고 이런 값이 정확히 일치하는 경우 선형이라고 한다.
- boxfilter는 1로만 만들어진 정사각형 커널이고 blur는 1/n으로 계수로 나눈다. 선형필터를 적용하면 커널을 영상의 각 화소에 걸쳐 이동하면서 대응하는 각 화소에 연계되는 가중치를 곱하는데 수학적으로 이런 작업을 회선(convolution)이라고 한다.
- 가우시안 계수는 1보다 크면 가중치가 낮아지며, 작으면 가중치가 커진다.
- 노이즈가 심한경우 Median Filter를 사용하면 매우 효과적이다. 
- 1D로 분리해 필터링 할 수 있으며, cv::sepFilter2D()를 사용하면 된다. cv::filter2D()함수를 사용해 한번에 사용할 수 있다.
- 중간값 필터 medianblur(미디안블러)는 잡티제거에 효과적인 블러다. 픽셀을 뭉갠다. 다른 필터와 달리 비선형이다. 에지의 선명도를 보존하지만, 균등한 영역에 있는 질감을 지우는 단점도 있다. 원리는 픽셀을 집합화해 그 중 중간값으로 대체하는 방식임.
2) 재샘플링 - 영상의 크기를 축소하는 과정은 다운샘플링, 크기를 확대하는 과정은 업샘플링이라고 한다. 영상의 시각적 품질을 최대한 보존해야한다.
축소시에 예를들어 4행과 4열마다 1로 줄여 원래의 크기를 4배로 축소한다. 그러므로 품질이 떨어지고 계단모양(에일리어싱aliasing)이 나타난다. 따라서 축소 시 고주파 성분을 제거해야한다. 그래서 축소전에 저주파 통과 필터를 사용한다.
여기서 볼 수 있는 이론은 나이퀴스트-새넌 이론인데 영상을 2배로 다운샘플링했을 때 표현 가능한 주파수의 대역폭이 2배로 축소된다는 것을 입증한다.
- OpenCV에서 사용되는 재샘플링 함수로 cv::pyrDown / cv::pyrUp 함수가 있다. 영상을 두배로 축소하거나 확대하는 함수로 그 전에 5*5 가우시안 필터(저주파 통과 필터)를 사용한다.
 확대시에는 먼저 확대(0을 삽입해 업샘플링) 후 5*5 가우시안 필터를 확대한 영상에 적용한다.(확대시 또한 계수에 4를 곱한다.) 주로 영상 피라미드를 생성할 때 많이 사용한다.
- 결과영상을 원하는 크기로 지정할 수 있는 일반적인 cv::resize 함수도 있다. 마지막 인자는 재샘플링 처리에서 사용되는 보간방법을 선택한다.
3) 보간 - 보간을 처리하는 가장 기본적인 처리 방법은 최근접 이웃 전략(nearest neighbor strategy)를 사용하는 것이다. 이 방법은 먼저 왼쪽 오른쪽 수직으로 화소값을 보간, 그 후 원하는 위치에서 수평으로 보간.
다른 보간방법으로는 양선형 보간법(bilinear interpolation) - 기본 cv::resize의 방법
고등차수 보간법(bicubic interpolation)- 우수한 결과를 만들어내는 보간법. 4x4화소의 이웃을 고려하고 입방 조건 계산을 의미하기에 느리다.
4) 에지 검출(방향성 필터) - 영상의 고주파 내용을 증폭해서(고주파 통과 필터)영상의 에지 검출(Edge Detection)을 할 수 있다.
이 때 사용하는 필터는 소벨(Sobel)필터라고 불리는 데, 방향성 필터라고도 한다. 그 이유는 수평이나 수직 영상 주파수에만 영향을 주기 때문이다.
-1  0  1
-2  0 -2
-1  0  1

-1 -2 -1
 0  0  0
 1  2  1
cv::Sobel() 가로 세로를 얻어 norm을 얻기 위해 조합한다. 소벨 연산자의 커널은 양수 값과 음수 값을 포함하기 때문에 소벨 필터의 결과는 일반적으로 16비트의 부호 있는 정수형 영상으로 계산된다.
영상을 2차원 함수로 바라본다면 소벨 연산자는 수평 방향과 수직 방향에서 영상의 변화를 측정하는 것 처럼 보일 수 있다. 수학적 용어로는 이 측정을 기울기(gradient)라고 부르며, 두 직교 방향에서 함수의 1차 미분으로부터 만들어진 2D벡터로 정의된다.
소벨 연산자는 수평, 수직 방향에서 화소 차이에 의한 영상 기울기의 근사치를 제공한다. 기울기 벡터의 놈은 일반적으로 유클리디안 놈(L2 norm)으로 계산된다.
다만, 영상처리에서는 절대 값의 합으로 놈을 종종 계산한다. 그걸 L1 놈이라고 하며 L2 놈에 가까운 값을 제공하지만 계산 비용이 더 적게 든다. 
놈과 각도가 둘 다 필요할 시에는 L2 소벨을 부동소수점으로 계산하고, cartToPolar() 함수를 사용해 두개 다 구해야한다.
기울기 강도를 경계화해 이진 에지 맵을 얻을 수 있다. 히스테리시스 경계화 개념을 사용하면 최적의 경계화를 얻을 수 있다.
기울기를 추정하기 위해 다양한 기울기 연산자를 사용한다.
1. Prewitt 방향성이 살짝 약한 연산자
-1  0  1
-1  0  1
-1  0  1

-1 -1 -1
 0  0  0
 1  1  1
2. Roberts 간단한, 단순한 2x2 커널
 1  0
 0 -1
 
 0  1
-1  0
3. Scharr 기울기 방향을 보다 정확하게 추정할 때 사용한다.
-3  0  3
-10 0 10
-3  0  3

-3-10 -3
 0  0  0
 3 10  3
cv::Sobel(image,sobelX,CV_16S,1,0,CV_SCHARR) or cv::Scharr(image,scharrX,CV_16S,1,0,3) 이런식으로 적용
+ 가우시안 미분 7x7 처럼 커널의 크기를 키워 sobel를 적용하면, 고주파와 저주파가 둘다 적용되어 대역 통과 필터가 된다. 이러면 가우시안 필터효과와 에지 검출이 둘다 적용되는 것.

5) 라플라시안(Laplacian) - 영상 미분 계산에 기반을 두는 다른 고주파 선형 필터다. 영상 함수의 곡률curvature을 측정하기 위해 2차 미분을 계산한다.
 0  1  0
 1 -4  1
 0  1  0
cv::Laplacian()함수를 사용하고, 이 함수는 cv::getDerivKernels() 함수를 이용해 적용된다. 라플라시안은 2차 미분이다. 라플라시안은 잡음에 매우 민감하다. 고주파 통과 필터.
라플라시안의 영교차(서로 다른 부호인 화소 사이에 위치)를 통해 영상 에지를 구할 수 있다. 라플라시안의 영교차는 모든 에지를 검출한다. 강한 에지와 약한 에지 사이를 구분할 수 없다.
라플라시안을 사용해 영상의 명암 대비 향상이 가능하다. - 원 영상에 라플라시안을 뺌으로써 영상의 명암 대비를 향상할 수 있다.
1에 라플라시안 커널을 뺀 것과 동일하다.

6) 가우시안 차분(Difference of Gaussians: DoG) - 가우시안 다른 계수로 구한 값의 차, DoG의 영교차를 구하면 더 정확하게 구할 수 있다. scale-space 표현을 얻을 수 있다.
DoG는 LoG(Laplacian of Gaussian)필터의 훌륭한 근사화가 될 수 있다.

<코드 1 - 필터 - 저주파 통과 필터, 다운샘플링, 중간 값 필터>
#include <iostream>
#include <opencv2/core.hpp>
#include <opencv2/imgproc.hpp>
#include <opencv2/highgui.hpp>

int main()
{
	//입력 영상 읽기
	cv::Mat image = cv::imread("../images/boldt.jpg", 0);
	if (!image.data) return 0;

	//영상 표시
	cv::namedWindow("Original Image");
	cv::imshow("Original Image", image);

	//평균값필터를 가지고 영상을 흐리게 처리하기
	cv::Mat result;
	cv::blur(image, result, cv::Size(5, 5));

	//흐리게한 영상을 표시
	cv::namedWindow("Mean filtered Image");
	cv::imshow("Mean filtered Image", result);

	//9x9 평균값필터를 사용해 흐리게 처리하기
	cv::blur(image, result, cv::Size(9, 9));

	//흐리게한 영상을 표시
	cv::namedWindow("Mean filtered Image (9x9)");
	cv::imshow("Mean filtered Image (9x9)", result);

	//가우시안 블러 영상
	cv::GaussianBlur(image, result,
						cv::Size(5, 5),		//필터의 크기
						1.5);				//가우시안의 모양을 조정하는 계수

	//가우시안 블러된 영상 표시
	cv::namedWindow("Gaussian filtered Image");
	cv::imshow("Gaussian filtered Image", result);

	cv::GaussianBlur(image, result, cv::Size(9, 9), 1.7);

	//가우시안 블러 (9x9)된 영상 표시
	cv::namedWindow("Gaussian filtered Image (9x9)");
	cv::imshow("Gaussian filtered Image (9x9)", result);

	//가우시안 커널 (1.5) 적용하기
	cv::Mat gauss = cv::getGaussianKernel(9, 1.5, CV_32F);

	//커널 값 표시
	cv::Mat_<float>::const_iterator it = gauss.begin<float>();
	cv::Mat_<float>::const_iterator itend = gauss.end<float>();
	std::cout << "1.5 = [";
	for (; it != itend; ++it)
	{
		std::cout << *it << " ";
	}
	std::cout << "]" << std::endl;

	//가우시안 커널 (0.5) 적용하기
	gauss = cv::getGaussianKernel(9, 0.5, CV_32F);

	//커널 값 표시
	it = gauss.begin<float>();
	itend = gauss.end<float>();
	std::cout << "0.5 = [";
	for (; it != itend; ++it)
	{
		std::cout << *it << " ";
	}
	std::cout << "]" << std::endl;

	//가우시안 커널 (2.5) 적용하기
	gauss = cv::getGaussianKernel(9, 2.5, CV_32F);

	//커널 값 표시
	it = gauss.begin<float>();
	itend = gauss.end<float>();
	std::cout << "2.5 = [";
	for (; it != itend; ++it)
	{
		std::cout << *it << " ";
	}
	std::cout << "]" << std::endl;

	//가우시안 커널 (9 요소들) 적용하기
	gauss = cv::getGaussianKernel(9, -1, CV_32F);

	//커널 값 표시
	it = gauss.begin<float>();
	itend = gauss.end<float>();
	std::cout << "9 = [";
	for (; it != itend; ++it)
	{
		std::cout << *it << " ";
	}
	std::cout << "]" << std::endl;

	//분리된 커널로 (2.5) 적용하기
	cv::Mat kx, ky;
	cv::getDerivKernels(kx, ky, 2, 2, 7, true);

	//커널 값 표시
	cv::Mat_<float>::const_iterator kit = kx.begin<float>();
	cv::Mat_<float>::const_iterator kitend = kx.end<float>();
	std::cout << "[";
	for (; kit != kitend; ++kit)
	{
		std::cout << *kit << " ";
	}
	std::cout << "]" << std::endl;
		
	//Salt&Pepper 노이즈 포함해서 입력 영상 읽기
	image = cv::imread("../images/salted.bmp", 0);
	if (!image.data) return 0;

	cv::namedWindow("S&P Image");
	cv::imshow("S&P Image", image);

	//평균값필터를 사용해서 영상 블러효과 주기
	cv::blur(image, result, cv::Size(5, 5));

	//블러된 영상 표시
	cv::namedWindow("Mean filtered S&P Image");
	cv::imshow("Mean filtered S&P Image",result);

	//미디안 블러 필터 적용 마지막 파라미터는 중간 값 필터의 크기임
	cv::medianBlur(image, result, 5);

	//블러된 영상 표시
	cv::namedWindow("Median filtered Image");
	cv::imshow("Median filtered Image", result);

	//영상의 크기를 4배 감소 (잘못된 방법)
	image = cv::imread("../images/boldt.jpg", 0);
	cv::Mat reduced(image.rows / 4, image.cols / 4, CV_8U);

	for (int i = 0; i < reduced.rows; i++)
		for (int j = 0; j < reduced.cols; j++)
			reduced.at<uchar>(i, j) = image.at<uchar>(i * 4, j * 4);

	//축소된 영상 표시
	cv::namedWindow("Badly reduced Image (aliasing)");
	cv::imshow("Badly reduced Image (aliasing)", reduced);

	cv::resize(reduced, reduced, cv::Size(), 4, 4, cv::INTER_NEAREST);

	//축소된(resize 사용한) 영상 표시
	cv::namedWindow("Badly reduced (resize)");
	cv::imshow("Badly reduced (resize)", reduced);

	cv::imwrite("badlyreducedimage.bmp", reduced);

	//먼저 고주파 성분 제거
	cv::GaussianBlur(image, image, cv::Size(11, 11), 1.75);

	//4화소마다 1화소만 유지
	cv::Mat reduced2(image.rows / 4, image.cols / 4, CV_8U);
	for (int i = 0; i < reduced2.rows; i++)
		for (int j = 0; j < reduced2.cols; j++)
			reduced2.at<uchar>(i, j) = image.at<uchar>(i * 4, j * 4);

	//축소된 영상 표시
	cv::namedWindow("Reduced Image, original size");
	cv::imshow("Reduced Image, original size", reduced2);

	cv::imwrite("reducedimage.bmp", reduced2);

	//NN으로 재샘플링
	cv::Mat newImage;
	cv::resize(reduced2, newImage, cv::Size(), 4, 4, cv::INTER_NEAREST);
	
	//축소된(resize 사용한) 영상 표시
	cv::namedWindow("Reduced Image (resize)");
	cv::imshow("Reduced Image (resize)", newImage);

	//bilinear로 재샘플링
	cv::resize(reduced2, newImage, cv::Size(), 4, 4, cv::INTER_LINEAR);

	//축소된(resize 사용한) 영상 표시
	cv::namedWindow("Bilinear resizing");
	cv::imshow("Bilinear resizing", newImage);

	//피라미드 영상 생성
	cv::Mat pyramid(image.rows, image.cols + image.cols / 2 + image.cols / 4 + image.cols / 8, CV_8U, cv::Scalar(255));
	image.copyTo(pyramid(cv::Rect(0, 0, image.cols, image.rows)));

	cv::pyrDown(image, reduced); //영상을 절반으로 축소함
	reduced.copyTo(pyramid(cv::Rect(image.cols, image.rows / 2, image.cols / 2, image.rows / 2)));
	cv::pyrDown(reduced, reduced2); //또다른 영상을 절반으로 축소함
	reduced2.copyTo(pyramid(cv::Rect(image.cols + image.cols / 2, image.rows - image.rows / 4, image.cols / 4, image.rows / 4)));
	cv::pyrDown(reduced2, reduced); //또다른 영상을 절반으로 축소함
	reduced.copyTo(pyramid(cv::Rect(image.cols + image.cols / 2 + image.cols/4, image.rows - image.rows / 8, image.cols / 8, image.rows / 8)));

	//피라미드 표시
	cv::namedWindow("Pyramid of images");
	cv::imshow("Pyramid of images", pyramid);

	cv::waitKey();
	return 0;
}

<코드 2 - 필터 - 에지를 검출하는 방향성 필터(고주파 통과 필터)와 라플라시안>
#include <iostream>
#include <iomanip>
#include <opencv2/core.hpp>
#include <opencv2/imgproc.hpp>
#include <opencv2/highgui.hpp>
#include "laplacianZC.h"

int main()
{
	//입력 영상 읽기
	cv::Mat image = cv::imread("../images/boldt.jpg", 0);
	if (image.empty()) return 0;

	//영상 표시
	cv::namedWindow("Original Image");
	cv::imshow("Original Image", image);

	//소벨 가로(X) 미분계산
	cv::Mat sobelX;
	cv::Sobel(image,	//입력
		sobelX,			//결과
		CV_8U,			//영상타입
		1, 0,			//커널지정
		3,				//정방향 커널 크기
		0.4, 128);		//크기 조정과 오프셋

	//소벨 가로 영상 표시
	cv::namedWindow("Sobel X Image");
	cv::imshow("Sobel X Image", sobelX);

	//소벨 세로(Y) 미분계산
	cv::Mat sobelY;
	cv::Sobel(image,	//입력
		sobelY,			//결과
		CV_8U,			//영상타입
		0, 1,			//커널지정
		3,				//정방향 커널 크기
		0.4, 128);		//크기 조정과 오프셋

	//소벨 세로 영상 표시
	cv::namedWindow("Sobel Y Image");
	cv::imshow("Sobel Y Image", sobelY);

	//소벨 놈 계산
	cv::Sobel(image, sobelX, CV_16S, 1, 0);
	cv::Sobel(image, sobelY, CV_16S, 0, 1);
	
	//L1 놈 계산
	cv::Mat sobel;
	sobel = abs(sobelX) + abs(sobelY);

	//소벨 최솟값/최댓값 찾기
	double sobmin, sobmax;
	cv::minMaxLoc(sobel, &sobmin, &sobmax);
	std::cout << "sobel value range: " << sobmin << " " << sobmax << std::endl;

	//소벨 가로(X) 미분 (7x7)
	cv::Sobel(image, sobelX, CV_8U, 1, 0, 7, 0.001, 128);

	//7x7 소벨 가로 영상 표시
	cv::namedWindow("Sobel X Image (7x7)");
	cv::imshow("Sobel X Image (7x7)", sobelX);

	//창 화소 값들을 출력
	for (int i = 0; i < 12; i++) {
		for (int j = 0; j < 12; j++)
			std::cout << std::setw(5) << static_cast<int>(sobel.at<short>(i+79,j+215)) << " ";
		std::cout << std::endl;
	}
	std::cout << std::endl;
	std::cout << std::endl;
	std::cout << std::endl;

	//8비트 영상으로 변환
	//sobelImage = -alpha*sobel + 255
	cv::Mat sobelImage;
	sobel.convertTo(sobelImage, CV_8U, -255. / sobmax, 255);

	//소벨 놈 영상 표시
	cv::namedWindow("Sobel Image");
	cv::imshow("Sobel Image", sobelImage);

	//소벨 놈에 경계화 적용 (낮은 경계화 값)
	cv::Mat sobelThresholded;
	cv::threshold(sobelImage, sobelThresholded, 225, 255, cv::THRESH_BINARY);

	//이진 경계화한 소벨 영상 표시
	cv::namedWindow("Binary Sobel Image (low)");
	cv::imshow("Binary Sobel Image (low)", sobelThresholded);

	//소벨 놈에 경계화 적용 (높은 경계화 값)
	cv::threshold(sobelImage, sobelThresholded, 190, 255, cv::THRESH_BINARY);

	//이진 경계화한 소벨 영상 표시
	cv::namedWindow("Binary Sobel Image (high)");
	cv::imshow("Binary Sobel Image (high)", sobelThresholded);

	//3x3 라플라시안 계산
	cv::Mat laplace;
	cv::Laplacian(image, laplace, CV_8U, 1, 1, 128);

	//라플라시안 영상 표시
	cv::namedWindow("Laplacian Image");
	cv::imshow("Laplacian Image", laplace);

	int cx(238), cy(90);
	int dx(12), dy(12);

	//작은 윈도우 추출
	cv::Mat window(image, cv::Rect(cx, cy, dx, dy));
	cv::namedWindow("Image window");
	cv::imshow("Image window", window);
	cv::imwrite("window.bmp", window);

	//LaplacianZC 클래스를 사용해 라플라시안 계산
	LaplacianZC laplacian;
	laplacian.setAperture(7); //7x7 라플라시안
	cv::Mat flap = laplacian.computeLaplacian(image);

	//라플라시안의 최대/최솟값 표시
	double lapmin, lapmax;
	cv::minMaxLoc(flap, &lapmin, &lapmax);

	//7x7 라플라시안 영상 표시
	laplace = laplacian.getLaplacianImage();
	cv::namedWindow("Laplacian Image (7x7)");
	cv::imshow("Laplacian Image (7x7)", laplace);
	
	//영상 값들 출력
	std::cout << std::endl;
	std::cout << "image values:\n\n";
	for (int i = 0; i < dx; i++)
	{
		for (int j = 0; j < dy; j++)
			std::cout << std::setw(5) << static_cast<int>(image.at<uchar>(i + cy, j + cx)) << " ";
		std::cout << std::endl;
	}

	//라플라시안 값들 출력
	std::cout << "Laplacian value range=[" << lapmin << ", " << lapmax << "]\n";
	std::cout << std::endl;
	for (int i = 0; i < dx; i++)
	{
		for (int j = 0; j < dy; j++)
			std::cout << std::setw(5) << static_cast<int>(flap.at<float>(i + cy, j + cx)/ 100) << " ";
		std::cout << std::endl;
	}
	std::cout << std::endl;

	//영교차 점들 계산과 표시
	cv::Mat zeros;
	zeros = laplacian.getZeroCrossings(flap);
	cv::namedWindow("Zero-crossings");
	cv::imshow("Zero-crossings", 255 - zeros);
	
	//윈도우 화소 값을 출력
	std::cout << "Zero values:\n\n";
	for (int i = 0; i < dx; i++) {
		for (int j = 0; j < dy; j++)
			std::cout << std::setw(2) << static_cast<int>(zeros.at<uchar>(i + cy, j + cx)) / 255 << " ";
		std::cout << std::endl;
	}

	//다운샘플링과 업샘플링한 영상
	cv::Mat reduced, rescaled;
	cv::pyrDown(image, reduced);
	cv::pyrUp(reduced, rescaled);

	//리스케일한 영상 표시
	cv::namedWindow("Rescaled Image");
	cv::imshow("Rescaled Image", rescaled);

	//가우시안 피라미드의 차분 계산
	cv::Mat dog;
	cv::subtract(rescaled, image, dog, cv::Mat(), CV_16S);
	cv::Mat dogImage;
	dog.convertTo(dogImage, CV_8U, 1.0, 128);

	//DoG 영상 표시
	cv::namedWindow("DoG Image (from pyrdown/pyrup)");
	cv::imshow("DoG Image (from pyrdown/pyrup)", dogImage);

	//두개의 가우시안 필터 적용
	cv::Mat gauss05;
	cv::Mat gauss15;
	cv::GaussianBlur(image, gauss05, cv::Size(), 0.5);
	cv::GaussianBlur(image, gauss15, cv::Size(), 1.5);

	//가우시안 차분 계산
	cv::subtract(gauss15, gauss05, dog, cv::Mat(), CV_16S);
	dog.convertTo(dogImage, CV_8U, 2.0, 128);

	//DoG 영상 표시
	cv::namedWindow("DoG Image");
	cv::imshow("DoG Image", dogImage);

	//두개의 가우시안 필터 적용하기
	cv::Mat gauss20;
	cv::GaussianBlur(image, gauss20, cv::Size(), 2.0);
	cv::Mat gauss22;
	cv::GaussianBlur(image, gauss22, cv::Size(), 2.2);

	//가우시안 차분 계산
	cv::subtract(gauss22, gauss20, dog, cv::Mat(), CV_32F);
	dog.convertTo(dogImage, CV_8U, 10.0, 128);

	//DoG 영상 표시
	cv::namedWindow("DoG Image (2)");
	cv::imshow("DoG Image (2)", dogImage);

	//DoG의 영교차 표시
	zeros = laplacian.getZeroCrossings(dog);
	cv::namedWindow("Zero-crossings of DoG");
	cv::imshow("Zero-crossings of DoG", 255 - zeros);

	//영상과 영상의 윈도우 표시
	cv::rectangle(image, cv::Rect(cx, cy, dx, dy), cv::Scalar(255,255,255));
	cv::namedWindow("Original Image with window");
	cv::imshow("Original Image with window", image);

	cv::waitKey();
	return 0;
}


============================ laplacianZC.h ============================
#if !defined LAPLACEZC
#define LAPLACEZC

#include <opencv2/core.hpp>
#include <opencv2/imgproc.hpp>

class LaplacianZC
{
private:
	//라플라시안
	cv::Mat laplace;

	//라플라시안 커널의 구경 크기
	int aperture;

public:
	LaplacianZC() : aperture(3) {}

	//커널의 구경 크기 설정
	void setAperture(int a)
	{
		aperture = a;
	}

	//커널의 구경 크기 가져오기
	int getAperture() const
	{
		return aperture;
	}

	//라플라시안을 부동소수점으로 계산
	cv::Mat computeLaplacian(const cv::Mat& image)
	{
		//라플라시안 계산
		cv::Laplacian(image, laplace, CV_32F, aperture);

		return laplace;
	}

	//라플라시안 결과를 8비트 영상으로 얻기
	//0은 그레이레벨 128에 대응
	//scale을 제공하지 않으면 최댓값을 명도 255로 조정
	//이 메소드를 호출하기 전에 computeLaplacian를 호출해야 함
	cv::Mat getLaplacianImage(double scale = -1.0)
	{
		if (scale < 0)
		{
			double lapmin, lapmax;
			cv::minMaxLoc(laplace, &lapmin, &lapmax);

			scale = 127 / std::max(-lapmin, lapmax);
		}

		cv::Mat laplaceImage;
		laplace.convertTo(laplaceImage, CV_8U, scale, 128);

		return laplaceImage;
	}

	//영교차의 이진 영상 얻기
	//라플라시안 영상은 CV_32F이어야 함
	cv::Mat getZeroCrossings(cv::Mat laplace)
	{
		//0에서 경계화
		//음수 값은 검은색
		//양수 값은 흰색
		cv::Mat signImage;
		cv::threshold(laplace, signImage, 0, 255, cv::THRESH_BINARY);

		//+/- 영상을 CV_8U로 변환
		cv::Mat binary;
		signImage.convertTo(binary, CV_8U);

		//+/- 영역의 이진 영상을 팽창
		cv::Mat dilated;
		cv::dilate(binary, dilated, cv::Mat());

		//영교차 외각선 변환
		return dilated - binary;
	}
};

#endif

7. 선, 외곽선, 성분 추출 [Extracting Lines, Contours and Components]
영상의 의미있는 내용을 추출하는 방법에 대해 다룬다.
1) 캐니 연산자
- 기존 에지 검출 시 필요 이상으로 두껍거나 너무 많거나 적은 에지를 검출하는 부분을 해결하기 위해 만든 연산자
- 사용법: cv::Canny(그레이레벨 영상, 결과 외곽선, 낮은경계값, 높은경계값)
- 히스테리시스 경계화라고 하는데 낮은 경계의 값에 속하는 에지들을 높은 경계의 값에 속하는 에지에 연결하도록 처리한다. 고립된 애들은 제거한다.
- 계산 복잡도의 비용이 크긴하다. 그리고 히스테리시스 경계화하기전에 기울기 방향에서 기울기 강도가 최대가 아닌 모든 점을 제거한다.

2) 영상에서 하프 변환으로 선 검출
- 영상에서 직선이 많은데 직선은 객체 인식과 영상 이해의 중요한 역할을 한다.
- 허프 변환(Hough transform)은 영상에서 특정한 특징을 검출할 때 자주 사용하는 고전적인 알고리즘이다. 초기에 영상에서 선을 검출하기 위해 만들어졌다.
- p = xcos@ + ysin@ 방정식을 사용해 선을 표현한다. 
- 사용법: cv::HoughLines(선 형태로 정렬된 점 집합, 구해진 이진 맵) 결과는 cv::Vec2f 요소의 백터 선(p,@)의 파라미터로 표현하는 값이다.
- 캐니 연산자를 적용한 후 허프 변환을 사용해 선을 검출하는 편이다.
- 허프 변환은 영상에 걸친 에지 화소의 정렬을 단순하게 찾는다. 그래서 우발적인 화소 정렬이나 여러 개의 선이 동일한 화소 정렬을 통해 지나갈 때 다중 검출을 할 우려가 있다.
- 이 문제를 극복하기 위해 선분 검출을 허용하는 허프 변환의 변종이 제안됐다. 확률적 허프 변환이며 cv::HoughLinesP 함수로 구현된다.
- 확률적 허프 변환은 몇가지 수정을 더했다. 받아들이기 위한 선분의 최소길이, 허용하는 최대 화소 간격을 정할 수 있고, 무작위 순서로 점을 선택해 누산기의 항목이 지정된
최솟값에 도달할 때마다 대응하는 선을 따라 영상을 조회한 후 해당 선을 통과해 지나가는 모든 점을 제거한다.(선에 투표를 아직 안해도)
- 허프 변환은 충분한 점 개수를 통해서 그 점들을 지나갈 수 있는 모든 선분을 구해서 동일한 선분이 많은 점을 통해 지나갈 때 이 선을 찾는 식으로 진행된다.
- 허프 변환은 주어진 선을 얼마나 식별했는지 세기 위해 2차원 누산기를 사용한다. 서로 다른 (p, @) 값의 매핑이다. 값들은 선이다. 

3) 원 검출
- 원인 경우 방정식은 r^2 = (x - x0)^2 + (y - y0)^2 3차원 누산기가 필요하지만 정밀하게 하기위해 2차원 누적기를 사용해서 할 수 있다.
- 우선 가능한 원의 중심을 검출하고, 가능한 반지름의 1D 히스토그램을 두 번째 패스를 하는 동안에 구축한다. 
- HoughCircles()함수를 사용하며, 잘못된 원 검출을 유발할 수 있는 영상 잡음을 줄이기 위해 영상을 blur로 부드럽게 해야한다.

4) 선을 점 집합에 맞추기
- 정확하게 추정한 선의 위치와 방향을 얻는 것도 중요할 수 있다.
- cv::HoughLinesP를 사용해 검출한 선은 vector<cv::Vec4i>에 포함되는데 이것과 외곽선의 캐니 영상을 갖고 교차하는 선을 구해 첫 번째에 속한 것으로 보이는 점 집합을 추출할 수 있다.
- 추출한 점들의 집합을 vector에 집어넣고 cv::fitLine 함수를 호출하면 최적으로 맞춘 선을 쉽게 찾는다. vector<Vec4f>의 첫 두 값은 단일 방향 벡터고, 마지막 두 값은 한 점의 좌표를 제공한다.
- 이걸 이용해 선을 그리면 된다.
- cv::fitEclipse 함수는 타원을 2D 점 집합에 맞추며, 회전된 사각형(cv::RotatedRect 인스턴스)를 반환한다. 이때 이 사각형 안에 타원이 새겨져 있다.

5) 연결 성분 추출
- 객체 표현을 위해서 첫 번째로 특정 관심 개체가 위치한다는 걸 보여주는 이진 영상을 생성하고, 두 번째로 0, 1로 구성된 집단을 포함하는 객체를 추출한다.
그리고 마지막으로 이런 영상의 연결 성분(연결된 화소 집합으로 만들어진 모양)으로 객체를 추출한다
- cv::findContours() 연결성분의 외곽선을 구하는 함수, cv::drawContours() 외곽선 백터를 가지고 그리는 함수.
- 개별로 분석해서 제거할 수 있고 외곽선을 계층으로 구성하는 것도 가능하다.

6) 성분 모양의 기술자 계산
- 연결 성분의 모양을 기술하는데 사용할 수 있는 것을 모양 기술자라고 한다.
- 경계 상자 cv::boundingRect(); -> cv::rectangle();
==> 정확하게 찾아내기 가장 간결한 방법, 보행자 영상과 자동차 영상을 구분하기 위해 종횡비 사용.
- 가장 작은 둘러싼 원 cv::minEnclosingCircle(); -> cv::circle();
==> 근사화한 성분 크기와 위치가 필요할 때 사용
- 다각형 근사 cv::approxPolyDP(); -> cv::polylines();
==> 모양과 비슷한 훨씬 간결한 표현을 다루고 싶을 때 유용
- 블록 껍질 cv::convexHull(); -> cv::polylines();
==> 모양을 에워싼 최소 블록 다각형, 오목한 위치에서 벗어나게 할 수 있다.
- 모멘트 계산(모든 성분 내부에 질량 중심[무게 중심]을 그린다.)
cv::Moments mom = cv::moments(cv::Mat(*itc++));
cv::circle(result, cv::Point(mom.m10/mom.m00, mom.m01/mom.m00),2,cv::Scalar(0),2);

그 외에도
cv::convexityDefects() 블록 결손으로 지정되는 위치를 식별하는 특별한 함수
cv::minAreaRect() 가장 작은 회전된 사각형을 계산한다.
cv::contourArea() 외곽선(안에 있는 화소 개수)의 면적을 추정한다.
cv::pointPolygenText() 점이 외곽선 내부에 있는지 외부에 있는지 여부를 결정한다.
cv::matchShapes() 두 외곽선의 유사성을 측정한다. 

7) 사변형 검출
- MSER 특징은 영상에서 모양을 추출하기 위한 효율적인 도구가 된다. 사변형(quadrilateral)
- 형태학 필터로 정리 후 -> 외곽선 얻고 -> 외곽선을 순회하면서 외곽선을 다각형으로 거의 근사화 한다.
- 사각형을 간단하게 검출할 수 있는데 인접한 에지 간의 각도를 측정한 후 90도에서 너무나 많이 벗어난 각도를 갖는 사변형을 배제하면 된다.

=============   openCV 클래스와 함수 정리   =============

가. cv::Mat - 기본적인 영상을 담을 클래스, 행렬이다.
ex) cv::Mat image; 크기가 0x0인 빈 영상(image) 생성.
- 헤더와 데이터 블록(=메모리 블록)으로 구성되어 있으며, 헤더에는 행렬과 관련있는 모든정보(크기, 채널 수, 자료형 등)가 들어 있고, 데이터 블록에는 영상의 모든 화소 값이 들어있다.
- 헤더에는 데이터 블록(= data속성)을 가리키는 포인터 변수가 들어있다. 같은 데이터 블록을 가리키기 위해 헤더를 복사하는 것은 메모리 누수를 줄일 수 있는 방법이다.
- 생성자로 (int rows, int cols, int type, int scalar); 생성가능 //세로길이, 가로길이, 타입, 색 
ex) cv::Mat abc(240,320,CV_8U,cv::Scalar(100)); // 240행 320열 영상 생성 CV_8U 에서 U문자는 부호가 없다는 것을 의미하고 S는 부호 있는 숫자 가능. F부동소숫점 숫자. C채널.
- Range를 사용한 생성자 (cv::Range rowsRange, cv::Range colsRange) //세로, 가로
- Rect를 사용한 생성자 (cv::Rect ROIRect) //ROI를 위한 생성자
- 변수에 값을 할당하는 경우, scalar값(색)을 넣을 수 있다.
ex) iamge1 = 200; // 만약 CV_8U라면 0-255;200이므로 밝은 회색이 될 것이다.
  1) int rows, int cols - 세로길이, 가로길이 속성.
  2) cv::MatSize size - 사이즈 알려주는 속성.
  3) bool empty() - 비어있는지 확인하는 함수 (유효한지 확인할 때 씀).
  	ex) if(image.empty()) return 0; == if(!image.data) return 0;
  4) int channels() - 영상의 채널개수 확인하는 함수
  5) <type> at<type>(Pointype) - 화소(행렬의 원소)에 접근하는 함수, 화소값을 얻기 위한 함수. 
  - at함수는 어떠한 타입변환도 수행하지 않는다.
  ex) image.at<uchar>(j,i) = 255;
  ex) image.at<cv::Vec3b>(j,i) = cv::Vec3b(255, 255, 255);
  - at함수는 무작위로 화소에 접근해야할 때만 사용하는편이 좋고, 영상 전체를 조회할 때는 사용하지 말아야한다.
  6) void create(int rols, int cols, int type) - 영상을 할당하거나 재할당하는 함수, 재할당 시 크기 및 타입이 일치하면 새로운 메모리 할당을 하지 않는다.
  7) cv::Mat clone(), void copyTo(cv::Mat targetMat) - 영상을 깊은복사 시킬 때 사용하는 변수. 값 변경이 영향을 끼치지 않게 할 때 사용한다. 목적영상에 create()함수를 호출 한다.
	ex) image1.create(200,200,CV_8U);
  8) void convertTo(cv::Mat targetMat, int type, double alpha=(1.0), double delta=(0.0)) - 영상을 다른 자료형의 형태로 복사해야 할 때 사용한다. 단, 반드시 두 대상의 채널이 같아야한다.
	ex) image1.convertTo(image2,CV_32F,1/255.0,0.0);  //인자의 alpha자리는 scaling factor(축적 계수), delta자리는 offset(오프셋)이다.
    // 여기서 [0-1]인 부동소수점형으로 바꾸는것 이기에 [0-255] / 255 = 1/255.0을 축적 계수로 사용하는 것이다.
  9) cv::Mat rowRange(int start, int end), cv::Mat colRange(int start, int end) - ROI용 행/열 일부를 지정하는 코드.
  	ex) cv::Mat imageROI = image.rowRange(start, end);
  - cv::Mat는 참조 카운팅과 얕은 복사를 구현해 놓았기에 편집 시 다른영상에도 영향을 주는 참조형(얕은복사)하는 방법은 아래와 같고, (함수나 클래스에서도 그냥 Mat를 리턴 시에는 앏은복사다!)
	ex) cv::Mat image4(image3) ;
    	    image1 = image3;
  	깊은 복사는 copyTo()이나 clone() 함수를 사용한다.
	ex) image3.copyTo(image2);
    	    cv::Mat image5 = image3.clone();
  10) cv::Mat_<type> 클래스 - cv::Mat의 템플릿 서브클래스로서, 몇 가지 보조 메소드를 가지고있다.
  - operator() 보조 메서드로 행렬 원소(Pixel)에 직접 접근이 가능하다. (at() 대용)
  	ex) cv::Mat_<uchar> im2(image);
            im2(50,100) = 0;
	ex) cv::Mat_<uchar>& im2= reinterpret_cast<cv::Mat_<uchar>&>(image); //참조형으로 선언하는 법
            im2(50,100) = 255;
  - cv::Mat_<type>::iterator 반복자변수명 - 이런식으로 정의된 iterator 타입을 사용할 수 있다. 
  	ex) cv::Mat_<cv::Vec3b>::iterator it;
  11) int elemSize() - 화소의 크기를 바이트 단위로 가져오는 함수
  	ex) image.elemSize(); // CV_16SC3 이면 2*3 = 6
  12) int step - 유효 너비(effective width)를 바이트 단위로 제공하는 속성. 한 행의 바이트 개수((cols [+ extra pixel]) * elemSize)
  * 여기서 유효너비라고 표현하는 이유는 데이터길이를 맞추기 위한 추가화소가 추가됬을 수 있기 때문이다.
  13) int total() - 행렬 내의 화소의 총 개수를 반환한다.
  14) <type>* ptr<type>(int rowsNum) - 영상의 행 주소를 직접 가져오는 함수. 행 번호(rowsNum)의 주소를 반환하는 템플릿 함수다.
  	ex) uchar* data = image.ptr<uchar>(0); //0번 행의 주소를 반환
	    for (int i = 0; i < nc; i++) 
	    {
		data[i] = data[i] / div * div + div / 2; // i를 사용한 방법
		// *data++ = *data / div * div + div / 2; // 포인터 산술을 그대로 사용하는 방법
	    }
  - 영상 조회 시 at함수보다 더 효율적이다.
  15) uchar* data - 메모리 블록(=데이터 블록)안의 첫 번째 요소의 주소를 제공하는 속성.
  16) bool isContinuous() - 직렬(추가 화소를 채우지 않았는지= 연속성)인지 확인하는 함수. 조건 ( step == cols*elemSize() ) 와 동일.
                            추가 화소를 채우지 않았을 경우 W*H 화소의 긴 1차원 배열로 볼 수 있다.
  17) cv::Mat reshape(int newChannelsNum, int newRowsNum) - 매트의 채널개수 행,열을 재조정하는 함수 (인자 2개 입력시 = 행의 개수에 따라 열 개수는 자동으로 조정 됨.)
                                                            (참고로 채널개수에 1입력시 NX1 3채널 일 경우 NX3 1채널로 바뀐다. 즉, 3채널 중 2개가 사라지는게 아니라 직렬화 된다는 말)
							    속도적인 면을봤을 때 직렬화시 빠른방법이다.
  18) cv::MatIterator_<type> 클래스 - (_ 가 붙으면 템.서.) 템플릿 서브클래스, 반환타입을 type에 적는다. 영상에 대한 반복자 역할을 한다. 일반적으로 begin, end반복자 메소드를 이용해 화소를 순회한다.
  - begin 메소드는 첫 번째 요소를 가리키는 반복자를 반환, 그러나 end 메소드는 마지막 요소의 다음, 즉 유효하지 않은 곳을 가리키는 반복자를 반환한다.
  	ex) cv::MatIterator_<cv::Vec3b> it = image.begin<cv::Vec3b>();
	    cv::MatIterator_<cv::Vec3b> itend = image.end<cv::Vec3b>();
	    uchar div2 = div >> 1;
	    for (; it != itend; it++)
	    {
		(*it)[0] = (*it)[0] / div * div + div2;
		(*it)[1] = (*it)[1] / div * div + div2;
		(*it)[2] = (*it)[2] / div * div + div2;
	    }
  - 반복자로 산술도 가능하다. 영상의 두 번째 행에서 시작하고 싶다면 image.begin() + image.cols, 마지막 행 전에 중단하고 싶다면 image.end() - image.cols 이런식으로 가능.
  - 반복자를 사용할 때는 역참조 연산자를 사용해야한다. element = *it; 읽기, *it = element; 쓰기
  - 상수반복자도 있다. cv::MatConstInterator_<type> 반복자명 or cv::Mat_<type>::const_iterator 반복자명 이렇게 선언가능.
  - iterator가 양이 많지 않다면 빠르지 않다. 많을 때 유리.
  19) cv::MatIterator_<type> begin(), end() - 첫 번째 요소, 마지막 요소의 다음 유효하지 않는 곳을 가리키는 반복자를 반환하는 함수
  - Mat_로 생성된 객체에서도 begin(), end()를 쓸 수 있는데 이때는 생성시 타입을 정했기 때문에 <type>을 쓰지않아도 된다.
  	ex) cv::Mat_<cv::Vec3b> cimage(image);
	    cv::Mat_<cv::Vec3b>::iterator it = cimage.begin();
  20) cv::Mat setTo(cv::InputArray value,cv::InputArray mask = noArray()) - 특정 요소값을 특정수치로 바꾸는 것. 대량으로 바꿀 때 사용.
  	ex) result.row(0).setTo(cv::Scalar(0)); 첫 번째 행을 검은색으로 바꾼다.
  21) int dims - 차원의 개수를 알려주는 속성
  	ex) for (int i = 0; i < histogram.dims; i++) //histogram이 3차원이면 3
	    
나. Mat cv::imread(String filename, [int option]) - 영상을 읽어 디코딩하고 메모리에 할당하는 읽기 함수
ex) image = cv::imread("puppy.jpg");
- 지원하는 포맷은 bmp, jpg, tiff, png 등등.
- 상대위치의 현재위치는 .cpp 파일의 위치이며 확장자도 포함해야한다.
- 절대위치는 "D:\image\test.jpg" 이런식으로 표현
- 영상을 불러올 때 그레이레벨 영상으로 읽어오는 옵션이 있는데, 이것이 큰 장점이 되는 이유는
  여러 컴퓨터 비전 알고리즘이 그레이레벨 영상을 요구하고, 입력 컬러 영상을 즉시 변환하기에 시간을 절약하고 메모리 사용량을 최소화 할 수 있기 때문이다.
- [옵션] 1) CV_LOAD_IMAGE_GRAYSCALE or 0 - 그레이레벨 영상, CV_8U 부호 없는 바이트(C++의 unsigned char)
         2) CV_LOAD_IMAGE_COLOR or 1 - 3채널 영상(생략 시 디폴트), CV_8UC3 화소 당 3바이트
         3) 음수 값 입력 시 - 영상을 저장했던 포맷 그대로 (alpha 채널= 투명한 것을 불러오고 싶으면 이 방법으로 밖에 없다.)
         4) CV_LOAD_IMAGE_ANYDEPTH | CV_LOAD_IMAGE_ANYCOLOR - 영상의 깊이와 컬러/그레이레벨과 상관없이 안전하게 읽어올 수
                                                              있어서 이런식으로 사용하기도 한다.
         
  그 외 더 자세한 옵션과 내용.
       IMREAD_UNCHANGED            = -1, //!< If set, return the loaded image as is (with alpha channel, otherwise it gets cropped).
       IMREAD_GRAYSCALE            = 0,  //!< If set, always convert image to the single channel grayscale image.
       IMREAD_COLOR                = 1,  //!< If set, always convert image to the 3 channel BGR color image.
       IMREAD_ANYDEPTH             = 2,  //!< If set, return 16-bit/32-bit image when the input has the corresponding depth, otherwise convert it to 8-bit.
       IMREAD_ANYCOLOR             = 4,  //!< If set, the image is read in any possible color format.
       IMREAD_LOAD_GDAL            = 8,  //!< If set, use the gdal driver for loading the image.
       IMREAD_REDUCED_GRAYSCALE_2  = 16, //!< If set, always convert image to the single channel grayscale image and the image size reduced 1/2.
       IMREAD_REDUCED_COLOR_2      = 17, //!< If set, always convert image to the 3 channel BGR color image and the image size reduced 1/2.
       IMREAD_REDUCED_GRAYSCALE_4  = 32, //!< If set, always convert image to the single channel grayscale image and the image size reduced 1/4.
       IMREAD_REDUCED_COLOR_4      = 33, //!< If set, always convert image to the 3 channel BGR color image and the image size reduced 1/4.
       IMREAD_REDUCED_GRAYSCALE_8  = 64, //!< If set, always convert image to the single channel grayscale image and the image size reduced 1/8.
       IMREAD_REDUCED_COLOR_8      = 65, //!< If set, always convert image to the 3 channel BGR color image and the image size reduced 1/8.
       IMREAD_IGNORE_ORIENTATION   = 128 //!< If set, do not rotate the image according to EXIF's orientation flag.


다. void cv::namedWindow(String windowname) - 창 정의하는 함수 (디폴트 창의 이름을 바꾸거나, 창 변수를 생성하는 함수라고 봐도 됨.)
ex) cv::namedWindow("Original Image");
- 창을 이름으로 식별한다. 즉, 창을 변수처럼 사용할 수 있다.

라. void cv::imshow(String windowname, Mat showmat) - 영상을 특정 창에 보여줄 때 사용하는 함수 (만약, 없는 이름의 창을 적으면, 자동으로 그 이름으로 창이 생성되고 거기에 보여진다.)
ex) cv::imshow("Original Image", image);

마. int cv::waitKey(int key) - 특정 시간동안 사용자 키 입력을 기다리는 함수 (인자가 0일 때나 없을 때는 무제한 기다린다. 양수 일때는 ms동안 기다림)
ex) cv::waitKey(0); = cv::waitKey();
- 이걸 활용해서 콘솔에서 프로세스를 일시정지시키면 테스팅하기 좋다. 그런용도로 써보자.

바. void cv::filp(Mat Ori, Mat Changed, int method) - 영상을 뒤집기 하는 함수 (수평이면 양수, 수직이면 0, 둘다면 음수)
ex) cv::filp(image, image, 1); cv::Mat result; cv::filp(image, result, -1);
- 자기 자신변수에 넣거나(in-place 방법), 다른 변수에 담을 수 있다.

사. bool cv::imwrite(String filename, Mat savemat, [int option]) - 영상을 디스크에 저장하는 함수
ex) cv::imwrite("output.png", result);
- 지원하는 포맷은 bmp, jpg, tiff, png 등등.
- 상대위치의 현재위치는 .cpp 파일의 위치이며 확장자도 포함해야한다.
- 절대위치는 "D:\image\test.jpg" 이런식으로 표현
- [옵션]

  그 외 더 자세한 옵션과 내용.
       IMWRITE_JPEG_QUALITY        = 1,  //!< For JPEG, it can be a quality from 0 to 100 (the higher is the better). Default value is 95.
       IMWRITE_JPEG_PROGRESSIVE    = 2,  //!< Enable JPEG features, 0 or 1, default is False.
       IMWRITE_JPEG_OPTIMIZE       = 3,  //!< Enable JPEG features, 0 or 1, default is False.
       IMWRITE_JPEG_RST_INTERVAL   = 4,  //!< JPEG restart interval, 0 - 65535, default is 0 - no restart.
       IMWRITE_JPEG_LUMA_QUALITY   = 5,  //!< Separate luma quality level, 0 - 100, default is 0 - don't use.
       IMWRITE_JPEG_CHROMA_QUALITY = 6,  //!< Separate chroma quality level, 0 - 100, default is 0 - don't use.
       IMWRITE_PNG_COMPRESSION     = 16, //!< For PNG, it can be the compression level from 0 to 9. A higher value means a smaller size and longer compression time. If specified, strategy is changed to IMWRITE_PNG_STRATEGY_DEFAULT (Z_DEFAULT_STRATEGY). Default value is 1 (best speed setting).
       IMWRITE_PNG_STRATEGY        = 17, //!< One of cv::ImwritePNGFlags, default is IMWRITE_PNG_STRATEGY_RLE.
       IMWRITE_PNG_BILEVEL         = 18, //!< Binary level PNG, 0 or 1, default is 0.
       IMWRITE_PXM_BINARY          = 32, //!< For PPM, PGM, or PBM, it can be a binary format flag, 0 or 1. Default value is 1.
       IMWRITE_EXR_TYPE            = (3 << 4) + 0, /* 48 */ //!< override EXR storage type (FLOAT (FP32) is default)
       IMWRITE_WEBP_QUALITY        = 64, //!< For WEBP, it can be a quality from 1 to 100 (the higher is the better). By default (without any parameter) and for quality above 100 the lossless compression is used.
       IMWRITE_PAM_TUPLETYPE       = 128,//!< For PAM, sets the TUPLETYPE field to the corresponding string value that is defined for the format

아. cv::setMouseCallback(String windowname, cv::MouseCallback callbackfunctionname, void *userdata) - 영상 위에 마우스 정보를 가져오는 이벤트 함수
ex) void onMouse(int event, int x, int y, int flags, void* param) {
  cv::Mat *im = reinterpret_cast<cv::Mat*>(param);
	switch (event)
	{
		case CV_EVENT_LBUTTONDOWN:
			std::cout << "at (" << x << ", " << y << ") value is: " << static_cast<int>(im->at<uchar>(cv::Point(x, y))) << std::endl;
			break;
	}
}
... //...은 생략을 의미 위에 콜백함수 시그니처의 형태로 만들어놓고 써야한다. 
cv::setMouseCallback("Original Image", onMouse, reinterpret_cast<void*>(&image));
- onMouse 시그니처의 첫번째 인자는 이벤트 타입, x, y는 마우스 좌표, flags는 이벤트 발생 시 버튼을 눌렀는지 결정하는데 사용되고,
  마지막은 포인터 형태의 함수에 추가 파라미터를 보낼 때 사용.
- event 파라미터로 CV_EVENT_MOUSEMOVE, CV_EVENT_MOUSELBUTTONUP, or DOWN, CV_EVENT_MOUSERBUTTONDOWN, or UP 등 다른 이벤트를 받을 수 있다.

#include <opencv2/imgproc.hpp> 필요한 함수들 (자, 차, 하, 커, 터, 퍼, 허, 고, 로, 소, 오, 초, 드, 르, 므, 브, 스, 으, 트, 프, 흐, 기, 니, 디, 리, 미, 비, 시)

자. void cv::circle(~~), ellipse(~~), line(~~), rectangle(~~) - 드로잉 함수
ex) cv::circle(image //영상, cv::Point(155,110) //중심점, 65 //반지름, 0 //컬러(0은 검은색), 3 //굵기);

차. void cv::putText(~~) - 텍스팅 함수
ex) cv::putText(image //영상, "This is a dog. " //내용, cv::Point(40,200) //텍스트 위치, cv::FONT_HERSHEY_PLAIN //타입, 2.0 //폰트배율, 255 //색(흰색), 2//굵기);

카. int64 cv::getTickCount() - 컴퓨터를 시작한 최종시간 이후에 발생한 클록 사이클 수 제공. 시간 측정시(타이머 용으로) 사용.

타. double cv::getTickFrequency() - 1초당 사이클 수를 제공. 역시 시간계산을 위해 getTickCount()와 같이 쓴다.
ex) const int64 start = cv::getTickCount();
    colorReduce(image); //시간측정 할 함수 or 내용들..
    double duration = (cv::getTickCount() - start) / cv::getTickFrequency(); // 초 단위인 경과시간을 알수 있다. 만약 ms일 경우 1000.0을 곱하면 됨. 

파. template<type> cv::saturate_cast<type>(type value) - 해당 타입으로 수치를 지정한다. 0-255이면 음수 값은 0, 255넘은 값은 255로 소수점은 가까운 정수로 반올림.  
ex) *output++ = cv::saturate_cast<uchar>(5 * current[i] - current[i - nchannals] - current[i + nchannals] - previous[i] - next[i]);

하. void cv::filter2D(cv::InputArray src, cv::OutputArray dst, int dept, cv::InputArray kernel) - 행렬커널로 영상을 필터링하는 함수.
ex) cv::filter2D(image, result, image.depth(), kernel);

거. void cv::add(cv::InputArray src1, cv::InputArray src2, cv::OutputArray rst, cv::InputArray mask = noArray()) - 이진 산술 함수중에 더하기 두 이미지의 합성에 사용한다.
ex) cv::add(imageA,imageB,resultC);
ex) cv::add(imageA,cv::Scalar(k),resultC);
ex) cv::add(imageA,imageB,resultC,mask);

너. void cv::substract(cv::InputArray src1, cv::InputArray src2, cv::OutputArray rst, cv::InputArray mask = noArray()) - 이진 산술 함수중에 빼기 두 이미지의 합성에 사용한다.

더. void cv::multiply(cv::InputArray src1, cv::InputArray src2, cv::OutputArray rst, cv::InputArray mask = noArray()) - 이진 산술 함수중에 곱하기 두 이미지의 합성에 사용한다.

러. void cv::divide(cv::InputArray src1, cv::InputArray src2, cv::OutputArray rst, cv::InputArray mask = noArray()) - 이진 산술 함수중에 나누기 두 이미지의 합성에 사용한다.

머. void cv::absdiff(cv::InputArray src1, cv::InputArray src2, cv::OutputArray rst, cv::InputArray mask = noArray()) - 이진 산술 함수중에 차이의 절대값을 구한다. 두 이미지의 합성에 사용한다.

버. void cv::addWeighted(cv::InputArray src1, double alpha, cv::InputArray src2, double beta, double gamma, cv::OutputArray rst) - 가중치를 두며 add하는 방식, 가중치는 0에서 1까지다. 
ex) cv::addWeighted(imageA,k1,imageB,k2,k3,resultC);

서. void scaleAdd(imageA, k, imageB, resultC) - 스칼라 값을 add하는 방식, k에 스칼라 값
ex) cv::scaleAdd(imageA,k,imageB,resultC);

어. void bitwise_and(cv::InputArray src1, cv::InputArray src2, cv::OutputArray rst, cv::InputArray mask = noArray()), bitwise_or, bitwise_xor, bitwise_not
  - 비트별 산술 함수들. 화소를 이진으로 표현한 각 비트에 연산자를 적용한다.

저. cv::OutputArray cv::max(cv::InputArray src1, cv::InputArray src2), min - 최대/최소 화소값을 찾는 함수

처. cv::OutputArray cv::sqrt(cv::InputArray src), pow, abs, cuberoot, exp, log - 그 외 산술함수들

커. void cv::remap(cv::InputArray src, cv::OutputArray dst, cv::InputArray map1, cv::InputArray map2, int interpolation) - 리맵핑하는 함수로 원시영상, 목적영상, x맵, y맵, 보간방법 인자로 구성되어 있다.
ex) cv::remap(image, result, srcX, srcY, CV_INTER_LINEAR);

터. double cv::threshold(cv::InputArray src, cv::OutputArray dst, double thresh, double maxval, int type) - 모든화소를 정해놓은 경계값과 비교할 때 사용하는 함수로 일반 경계화 모드(cv::THRESH_BINARY)에서 모든화소가 경계값보다 크면 정의된 최댓값을 할당하고, 작으면 0을 할당한다.
- 반전모드(cv::THRESH_BINARY_INV) 경계값보다 작거나 같으면 최댓값을 할당하고 cv::THRESH_TOZERO는 화소가 경계값보다 크면 놔두고, 아니면 0할당.. cv::THRESH_TOZERO_INV도 있다.  
ex) cv::threshold(output, output, maxDist, 255, cv::THRESH_BINARY_INV);
 
퍼. int cv::floodFill(cv::InputArray src, cv::Point seedPoint, cv::Scalar newVal, cv::Rect *rect=(cv::Rect*)0, cv::Scalar loDiff = cv::Scalar(), cv::Scalar upDiff = cv::Scalar(), int flags=4)
- 주어진 대상 컬러와 비슷한 컬러를 갖는 화소를 식별하는데 화소의 이웃상태에 따른다.
ex) cv::floodFill(image,			//입력/결과 영상
		  cv::Point(100, 50),		//초기 점
		  cv::Scalar(255, 255, 255),	//다시 그린 컬러
		  (cv::Rect*)0,			//다시 그린 집합의 경계 사각형
		  cv::Scalar(35, 35, 35),	//낮은 차이 경계값
		  cv::Scalar(35, 35, 35),	//높은 차이 경계값
		  cv::FLOODFILL_FIXED_RANGE);	//시드 화소와 비교할 화소

허. void cv::cvtColor(cv::InputArray src, cv::OutputArray dst, int code) - 컬러 변환함수로 다양한 컬러공간으로 변환할 수 있다. Lab칼러공간을 이용할 수도 있다. RGB2GRAY 이런 기본 기능도 있다.
ex) cv::cvtColor(image, converted, CV_BGR2Lab);

고. void grabCut(cv::InputArray img, cv::InputOutputArray mask, cv::Rect rect, cv::InputOutputArray bgdModel, cv::InputOutputArray fgdModel, int iterCount, int mode)
- 그랩컷 알고리즘 함수로 정지 영상에서 전경 객체를 추출하고 싶을 때 사용하기에 가장 좋은 알고리즘.
- 입력/결과 분할 영상은 4가지 값 중 하나를 갖게 된다.
  cv::GC_BGD = 0 배경에 분명히 속하는 화소(예를들어 사각형 밖에 있는 화소),
  cv::GC_FGD = 1 전경에 분명히 속하는 화소(예를들어 아래 예제에는 없음),
  cv::GC_PR_BGD = 2 아마도 배경에 속할 듯한 화소에 대한 값
  cv::GC_PR_FGD = 3 아마도 전경에 속할 듯한 화소에 대한 값(예를들어 아래 예제에서 사각형 내부에 있는 화소를 얻기 위한 초기값)
  
ex) cv::Mat result;			//분할 (가능한 값은 4개)
    cv::Mat bgModel, fgModel;		//모델 (내부적으로 사용)
    cv::grabCut(image,			//입력 영상
		result,			//분할 결과
		rectangle,		//전경을 포함한 사각형
		bgModel, fgModel,	//모델
		5,			//반복 횟수
		cv::GC_INIT_WITH_RECT);	//사각형 사용
		
노. void compare(cv::InputArray src1, cv::InputArray src2, cv::OutputArray dst, int cmpop) - 두 개의 입력값의 scalar 값을 비교하는 함수로 만족하는 src1의 화소만 dst결과값으로 뽑아낼 수 있다.
ex) cv::compare(result, cv::GC_PR_FGD, result, cv::CMP_EQ);

도. void cv::split(cv::InputArray m, cv::OutputArrayOfArrays mv), void merge(cv::InputArrayOfArrays mv, cv::OutputArray dst) - 영상 채널 분리/결합, 각 채널을 따로 처리할 때 사용한다.
- 사용법은 void cv::split(분리할, 분리된) 과 cv::merge(합칠,합쳐진)로 가능하다.
ex) // 3개의 Mat로 이뤄진 Vector 선언
    std::vector<cv::Mat> planes;
    // 3채널 이미지의 채널을 모두 나눠 3개의 이미지로 split함수
    cv::split(image1, planes);
    // 블루채널에 ADD하기
    planes[0] += image2;
    // 다시 3채널 합쳐서 하나의 3채널 이미지로
    cv::merge(planes, result);

로. void calcHist(const cv::Mat *images, int nimages, const int *channels, cv::InputArray mask, cv::OutputArray hist, int dims, const int *histSize, const float **ranges)
- 임의 화소 값 타입과 범위를 갖는 다채널 영상의 히스토그램을 계산할 수 있는 일반적인 함수이다.
ex) //히스토그램 계산하기
    cv::calcHist(&image,
    1,			//단일 영상 히스토그램만
    channels,		//대상 채널
    cv::Mat(),		//마스크를 사용하지 않음
    hist,		//결과 히스토그램
    3,			//3D 히스토그램
    histSize,		//빈 개수
    ranges		//화소 값의 범위
    );

모. void minMaxLoc(cv::InputArray src, double *minVal, double *maxVal=(double *)0, cv::Point *minLoc = (cv::Point *)0, cv::Point *maxLoc = (cv::Point *)0, cv::InputArray mask = noArray())
- 배열 내에서 최대, 최소값을 찾는 함수 멀티 채널 배열에서는 작동하지 않는다.
ex) //최소 최대 빈 값 얻기
    double maxVal = 0;
    double minVal = 0;
    cv::minMaxLoc(hist, &minVal, &maxVal, 0, 0);

보. void cv::LUT(cv::InputArray src, cv::InputArray lut, cv::OutputArray dst) - LUT는 전체적으로 변환을 하는 방법으로 이 함수는 간단한 일대일(또는 다대일) 함수로서 화소 값을 새로운 화소 값으로 변환하는 방법이다.
- 이 방법으로 모든 화소의 명도를 주어진 새로운 명도 값으로 변경하는 것도 할 수 있다.
ex) //룩업 테이블 적용하기
    cv::LUT(image, lookup, result);

소. int cvRound(double value) - 반올림 시키는 cv imgproc의 함수
ex) lookup.at<uchar>(i) = cvRound(255.0*(i - imin) / (imax - imin));

오. void cv::equalizeHist(cv::InputArray src, cv::OutputArray dst) - 그레이 스케일 영상의 히스토그램을 평활화 해주는 함수.
ex) cv::equalizeHist(image, result);

조. void cv::normalize(cv::InputArray src, cv::InputOutputArray dst, double alpha = (1.0)) - 배열을 정규화하는 함수
ex) cv::normalize(h, histogram, 1.0);

초. void cv::calcBackProject(const cv::Mat *images, int nimages, const int *channels, cv::InputArray hist, cv::OutputArray backProject, const float **ranges, double scale = (1.0))
- 입력 영상의 각 화소를 정규화 된 히스토그램에서 읽어 들인 대응하는 확률 값으로 바꿔 히스토그램을 구성한 후 역투영하는 함수. 
ex) cv::calcBackProject(&image,
    1,			//한 번에 영상 1개만 사용
    channels,		//영상 채널에 속하는 히스토그램 차원을 지정한 백터
    histogram,		//사용할 히스토그램
    result,		//역투영 영상
    ranges,		//차원당 값의 범위
    255.0		//확률 값의 1을 255로 매핑하기 위해 선택한 재조정 인자
    );

코. cv::SparseMat - 희소화한 행렬이다.
-Mat와 거의 비슷하다. 과도한 메모리 소모를 줄이기 위해 사용하는 방법이다.
ex) cv::SparseMat hist(3,	//차원의 개수
    histSize,			//각 차원의 크기
    CV_32F);

토. cv::TermCriteria - 반복적인 알고 리즘을 위한 시한적인 한계를 정의하는 클래스이다. meanShift알고리즘에서 사용한다.
ex) cv::TermCriteria criteria(cv::TermCriteria::MAX_ITER | cv::TermCriteria::EPS,
     10,		//최대 10회 반복
     1);		//또는 중심 위치 변화가 1픽셀 미만이 될 때까지
    cout << "meanshift= " << cv::meanShift(result, rect, criteria) << endl;
  
#include <opencv2/video/tracking.hpp> 가 필요한 함수들 (포)

포. int cv::meanShift(cv::InputArray probImage, cv::Rect &window, cv::TermCriteria criteria) - 평균 이동 알고리즘 백투영영상으로부터 객체를 찾는 알고리즘 
- opencv2/video/tracking.hpp안에 들어있다.
확률 함수의 지역 최대치(local maxima)가 있는 위치를 찾는 반복 계산법(iterative procedure)이다. 미리 정의된 윈도우 안에 있는 데이터 점의 중심(centroid)이나 가중 평균(weighted mean)을 찾는방식으로
수행한다. 이 알고리즘은 윈도우 중앙(window center)을 중심 위치로 옮긴 후 윈도우의 중앙이 안정점(stable point)으로 수렴할 때까지 해당 과정을 반복한다. OpenCV의 구현부에서 2개의 중지기준(stopping criteria)을 정의하며,
반복 최대 횟수(MAX_ITER), 그리고 안정점에 수렴되도록 고려돼야 하는 위치의 아래인 윈도우 중앙 변위 값(EPS)이다. 2개의 중지 기준은 cv::TermCriteria인스턴스에 저장된다. cv::meanShift함수는 수행했던 반복횟수를 반환한다.
ex) // initial window position
    cv::rectangle(image, rect, cv::Scalar(0,0,255));
    // search objet with mean shift
    cv::TermCriteria criteria(cv::TermCriteria::MAX_ITER | cv::TermCriteria::EPS,
    10,     // iterate max 10 times
    1);     // or until the change in centroid position is less than 1px
    cout << "meanshift= " << cv::meanShift(result,rect,criteria) << endl;
    
    // draw output window
    cv::rectangle(image, rect, cv::Scalar(0,255,0));

호. double cv::compareHist(cv::InputArray H1, cv::InputArray H2, int method) - 두 히스토그램을 비교해 수치로 나타내는 함수.
ex) //두 BGR 히스토그램을 사용해 영상 비교
    double compare(const cv::Mat& image)
    {
	    inputH = hist.getHistogram(image);
	    
	    //교차점을 이용한 히스토그램 비교
	    return cv::compareHist(refH, inputH, cv::HISTCMP_INTERSECT);
    }
플래그 종류(method 매개변수)는
- HISTCMP_INTERSECT : 각 히스토그램에서 각 빈마다 두 값을 단순하게 비교한 후 최솟값을 유지한다. 유사도 측정은 이런 최솟값의 합이 된다. 두 영상이 컬러가 없는 히스토그램을 갖는다면 0인 인터섹션 값을 얻는 반면, 두 히스토그램이 동일하다면 화소의 총 개수와 같은 값을 얻는다.
- HISTCMP_CHISQR : 빈 간의 정규화된 제곱 차를 합하는 카이 제곱(Chi-Square)측정
- HISTCMP_CORREL : 신호처리에서 두 신호 간의 유사도를 측정하기 위해 사용하는 정규화된 상호 상관 연산자에 기반을 두고 있는 상관관계(Corrleation) 방법
- HISTCMP_BHATTACHARYYA : 통계에서 두 확률 분포 간의 유사도를 추정하기 위해 사용되는 바타차르야(Bhattacharyya) 측정이 있다.
    
그. void integral(cv::InputArray src, cv::OutputArray sum, int sdepth = -1) - 영상을 적분 계산할때 사용하는 함수이다.
ex) cv::Mat integralImage;
    cv::integral(image, integralImage, CV_32S);

느. void cv::transpose(cv::InputArray src, cv::OutputArray dst) - 시계방향으로 90도 돌린다.
ex) cv::transpose(image, image);

드. void cv::boxFilter(cv::InputArray src, cv::OutputArray dst, int ddepth, cv::Size ksize, cv::Point anchor) - 계산 용도나 흐려지게 하는 용도로 사용하는 것 같다.
ex) cv::boxFilter(image, filtered, CV_8U, cv::Size(blockSize, blockSize));

르. adaptiveThreshold(cv::InputArray src, cv::OutputArray dst, double maxValue, int adaptiveMethod, int thresholdType, int blockSize, double C) - 적응적 경계값을 적용시키는 함수, 간단하게 적용할 수 있는게 좋다.
ex) cv::adaptiveThreshold(image,		//입력 영상
      		binaryAdaptive,			//출력 이진영상
		255,				//출력 최대값
		cv::ADAPTIVE_THRESH_MEAN_C,	//적응화 방법
		cv::THRESH_BINARY,		//경계화 종류
		blockSize,			//블럭의 사이즈
		threshold);			//경계값 사용

므. void cv::erode(cv::InputArray src, cv::OutputArray dst, cv::InputArray kernel, cv::Point anchor, int iterations) - 영상을 구조요소(SE)로 침식시키는 필터 함수. 현재 화소를 정의된 화소 집합에서 찾은 최소 화소 값으로 변경한다.
ex) cv::erode(image, eroded, cv::Mat());
ex) //더 큰 구조요소(SE)로 영상 침식
    //1을 모두 포함하는 7*7 행렬 생성
    cv::Mat element(7, 7, CV_8U, cv::Scalar(1));

    //구조요소(SE)로 영상 침식
    cv::erode(image, eroded, element);
ex) //영상을 세 번 침식
    cv::erode(image, eroded, cv::Mat(), cv::Point(-1, -1), 3);    

브. void cv::dilate(cv::InputArray src, cv::OutputArray dst, cv::InputArray kernel, cv::Point anchor, int iterations) - 영상을 구조요소(SE)로 팽창시키는 필터 함수. 현재 화소를 정의된 화소 집합에서 찾은 최대 화소 값으로 변경한다.
ex) cv::dilate(image, dilated, cv::Mat());

스. void cv::morphologyEx(cv::InputArray src, cv::OutputArray dst, int op, cv::InputArray kernel, cv:Point anchor, int iterations) - 형태학적 변형(침식, 팽창)을 보완한다. 열림, 닫힘, 기울기, 탑햇 등 필터 적용에 사용된다.
ex)     cv::Mat element5(5, 5, CV_8U, cv::Scalar(1));
	cv::Mat closed;
	cv::morphologyEx(image, closed,	//입력 영상과 결과 영상
	cv::MORPH_CLOSE,		//연산자 코드
	element5);			//구조 요소(SE)

으. void cv::watershed(cv::InputArray image, cv::InputOutputArray markers) - 워터쉐드 알고리즘을 사용해 마커 기반 영상 분할하는 함수, 동질 영역 분할에 사용된다.
ex) //워터쉐드 적용
    cv::watershed(image, markers);

#include <opencv2/feature2D.hpp> 필요한 함수들 (즈)

즈. cv::MSER - 추상 클래스 MSER(Maximally Stable External Region) 알고리즘을 계산하는 클래스. - 의미있는 영역을 추출하기 위해 침수 유추를 사용한다.
- create(int _delta, int_min_area, int_max_area) - MSER 검출기 생성 함수
- detectRegions(cv::InputArray image, std::vector<std::vector<cv::Point>> &msers, std::vector<cv::Rect> &bboxes) - MSER 특징 검출하는 함수()
- 
ex)	//기본 MSER 검출기
	cv::Ptr<cv::MSER> ptrMSER = cv::MSER::create(5,			//지역을 검출하기 위한 델타 값
						     200,		//최소 허용 면적
						     2000);		//최대 허용 면적

	//점 집합의 백터
	std::vector<std::vector<cv::Point> > points;

	//직사각형의 백터
	std::vector<cv::Rect> rects;

	//MSER 특징 검출
	ptrMSER->detectRegions(image, points, rects);

	std::cout << points.size() << " MSERs detected" << std::endl;

	//흰색 영상 생성
	cv::Mat output(image.size(), CV_8UC3);
	output = cv::Scalar(255, 255, 255);

	//OpenCV 난수 발생기(random number generator)
	cv::RNG rng;

	//MSER의 색영역 표시
	//각각 검출된 특징에 대해 가장 큰 MSER부터 역순서로 표시
	for (std::vector<std::vector<cv::Point>>::reverse_iterator it = points.rbegin(); it != points.rend(); ++it)
	{
		//임의 색 생성
		cv::Vec3b c(rng.uniform(0, 254),
			rng.uniform(0, 254),
			rng.uniform(0, 254));

		std::cout << "MSER size= " << it->size() << std::endl;

		//MSER 집합의 각 점에 대해
		for (std::vector<cv::Point>::iterator itPts = it->begin(); itPts != it->end(); ++itPts)
		{
			//MSER 화소들을 덮어 쓰지 않음
			if (output.at<cv::Vec3b>(*itPts)[0] == 255)
			{
				output.at<cv::Vec3b>(*itPts) = c;
			}
		}
	}

	cv::namedWindow("MSER point sets");
	cv::imshow("MSER point sets",output);
	
츠. cv::RNG - 랜덤 숫자 생성기 클래스 객체 생성 후 .uniform(숫자범위,~)로 생성할 수 있다.
ex) 	//OpenCV 난수 발생기(random number generator)
	cv::RNG rng;

	//MSER의 색영역 표시
	//각각 검출된 특징에 대해 가장 큰 MSER부터 역순서로 표시
	for (std::vector<std::vector<cv::Point>>::reverse_iterator it = points.rbegin(); it != points.rend(); ++it)
	{
		//임의 색 생성
		cv::Vec3b c(rng.uniform(0, 254), rng.uniform(0, 254), rng.uniform(0, 254));


크. cv::RotatedRect - 회전된 사각형을 표현하는 클래스
ex) 	//경계 사각형 추출
	cv::RotatedRect rr = cv::minAreaRect(*it);

트. cv::RotatedRect cv::minAreaRect(cv::InputArray points) - 회전된 사각형을 둘러싸는 영역 최소 직사각형을 반환한다.
ex) 	//경계 사각형 추출
	cv::RotatedRect rr = cv::minAreaRect(*it);

프. void blur(cv::InputArray src, cv::OutputArray dst, cv::Size ksize, cv::Point anchor = cv::Point(-1,-1) - 블러효과 주는 함수
ex) cv::blur(image, result, cv::Size(9, 9));

흐. void GaussianBlur(cv::InputArray src, cv::OutputArray dst, cv::Size ksize, cv::Point anchor, double sigmaX) - 가우시안 블러효과 주는 함수.
ex) cv::GaussianBlur(image, result,
		     cv::Size(5, 5),		//필터의 크기
       		     1.5);			//가우시안의 모양을 조정하는 계수

기. cv::Mat cv::getGaussianKernel(int ksize, double sigma, int ktype) - 가우시안 필터의 계수를 반환하는 함수
ex) //가우시안 커널 (1.5) 적용하기
    cv::Mat gauss = cv::getGaussianKernel(9, 1.5, CV_32F);

니. void cv::getDerivKernel(cv::OutputArray ky, int dx, int dy, int ksize, bool normalize =false) - x, y축으로 나눠 필터 계수를 반환하는 함수 
ex) //분리된 커널로 (2.5) 적용하기
    cv::Mat kx, ky;
    cv::getDerivKernels(kx, ky, 2, 2, 7, true);

디. void cv::medianBlur(cv::InputArray src, cv::OutputArray dst, int ksize) - 미디안 블러(중간값 ) 적용 함수
ex) //미디안 블러 필터 적용
    cv::medianBlur(image, result, 5);

리. void cv::resize(cv::InputArray src, cv::OutputArray dst, cv::Size dsize, double fx = (0,0), double fy = (0,0), int interpolation = 1) - 재샘플링 하는 함수로 영상의 크기를 조정할 때(축소, 확대) 사용하는 함수다. 마지막 인수는 보간방식을 정하는 것이다.
ex) cv::resize(reduced, reduced, cv::Size(), 4, 4, cv::INTER_NEAREST);

미. void cv::pyrDown / cv::pyrUp(cv::InputArray src, cv::OutputArray dst, const cv::Szie &dstsize = cv::Size(), int borderType =4) - 사이즈를 2배로 축소/확대 하는 함수. 피라미드 영상 제작시에 많이 사용한다.
ex) cv::pyrDown(image, reduced); //영상을 절반으로 축소함

비. void cv::Sobel(cv::InputArray src, cv::OutputArray dst, int ddepth, int dx, int dy, int ksize = 3, double scale = (1.0), double delta = (0.0)) - 에지를 검출하기 위한 필터이다. 방향성 필터라고도 한다.

시. void cv::Laplacian(cv::InputArray src, cv::OutputArray dst, int ddepth, int ksize =1, double scale = (1.0)) - 라플라시안 계산하는 함수, 미반 계산에 기반을 두는 다른 고주파 선형 필터다. 곡률을 측정하기 위해 2차 미분을 계산한다. 

이. void cv::minMaxLoc(cv::InputArray src, double *minVal, doulbe *maxVal = (double *)0, cv::Point *minLoc = (cv::Point *)0, *maxLoc = (cv::Point *)0, mask) - 배열에서의 최솟값과 최대값을 찾아 넣는다.

지.