GIS Developer

이 글의 원문은 https://opencv-python-tutroals.readthedocs.io/en/latest/py_tutorials/py_imgproc/py_watershed/py_watershed.html 입니다.

회색조 이미지는 지형처럼 해석할 수 있는데, 값이 높은 픽셀 위치는 산꼭대기이고 값이 낮은 픽셀 위치는 계곡이라고 해석할 수 있습니다. 지형이므로 고립되어 분리된 계곡이 있을 것이고 이 계곡들을 서로 다른 색의 물로 채우기 시작하면 물이 점점 차오르다가 이웃한 계곡의 언저리에서 물이 합쳐지게 됩니다. 물이 합쳐지는 것을 피하기 위해서 합쳐지는 순간에서의 위치에 경계를 생성하는거죠. 그럼 이 경계선이 이미지 분할의 결과가 됩니다. 이것이 바로 Watershed 알고리즘의 기본철학입니다. 아래의 동영상 이미지를 보면 좀더 직관적으로 이해할 수 있습니다.

이 방식을 통해 이미지를 분할하게 되면 분할에 오류가 발생할 수 있는데, 이는 이미지의 잡음이나 어떤 불규칙한 것들로 인한 요소 등이 이유입니다. 그래서 OpenCV는 마커 기반의 Watershed 알고리즘을 구현해 제공하는데.. 각 계곡을 구성하는 화소들을 병합시켜 번호를 매기고, 병합 수 없는 애매한 화소는 0값을 매깁니다. 이를 인터렉티브한 이미지 분할 기법이라고 합니다. 우리가 알고 있는 객체에 각각에 대해 0 이상의 번호를 매기는 것인데요. 전경이 되거나 객체인 것에, 또 배경에도 0 이상의 값을 매깁니다. 그러나 그외 불명확하다라고 판단되는 것은 0을 매깁니다. 이 불명확한 것이 어떤 요소, 즉 배경인지 전경인지 또는 어떤 객체의 소유인지는 Watershed 알고리즘을 통해 결정됩니다. Watershed 알고리즘을 통해 분할 경계선이 생길 것이고 이 경계선에 대해서는 -1 값을 매깁니다.

자, 이제 이론에 대한 설명은 끝났으므로 예제 코드를 살펴보겠습니다.

import cv2
import numpy as np
from matplotlib import pyplot as plt

img = cv2.imread('./data/water_coins.jpg')

# 이진 이미지로 변환
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
ret, thresh = cv2.threshold(gray, 0, 255, cv2.THRESH_BINARY_INV+cv2.THRESH_OTSU)

# 잡음 제거
kernel = np.ones((3,3), np.uint8)
opening = cv2.morphologyEx(thresh, cv2.MORPH_OPEN, kernel, iterations=2)

# 이미지 확장을 통해 확실한 배경 요소 확보
sure_bg = cv2.dilate(opening, kernel, iterations=3)

# distance transform을 적용하면 중심으로 부터 Skeleton Image를 얻을 수 있음.
# 이 결과에 Threshold를 적용하여 확실한 객체 또는 전경 요소를 확보
dist_transform = cv2.distanceTransform(opening, cv2.DIST_L2, 5)
ret, sure_fg = cv2.threshold(dist_transform, 0.5*dist_transform.max(), 255, 0)
sure_fg = np.uint8(sure_fg)

# 배경과 전경을 제외한 영역 곳을 확보
unknown = cv2.subtract(sure_bg, sure_fg)

# 마커 생성 작성
ret, markers = cv2.connectedComponents(sure_fg)
markers = markers + 1
markers[unknown == 255] = 0

# 앞서 생성한 마커를 이용해 Watershed 알고리즘을 적용
markers = cv2.watershed(img, markers)
img[markers == -1] = [255,0,0]

images = [gray,thresh,opening, sure_bg, dist_transform, sure_fg, unknown, markers, img]
titles = ['Gray', 'Binary', 'Opening', 'Sure BG', 'Distance', 'Sure FG', 'Unknow', 'Markers', 'Result']

for i in range(len(images)):
    plt.subplot(3,3,i+1)
    plt.imshow(images[i])
    plt.title(titles[i])
    plt.xticks([])
    plt.yticks([])

plt.show()

실행 결과는 다음과 같습니다.

코드와 실행 결과를 비교해 가며, 설명을 해 보면.. 먼저 5번 코드에서 입력 이미지를 파일로부터 읽고 이 이미지를 2진 이미지로 생성하는 것이 5-9번 코드이고 결과 이미지의 Binary입니다. 잡음을 제거 하기 위해 12-13번 코드가 실행되고 결과 이미지의 Opening입니다. 잡음을 제거한 이미지에 dilate 함수를 통해 이미지의 객체를 확장시킨 것이 16번 코드이고 결과 이미지의 Sure_BG입니다. 이제 확실한 전경 또는 객체에 대한 화소를 얻기 위해 18-22번 코드가 실행되고 그 결과 이미지는 Sure_FG입니다. Sure_FG는 결과 이미지의 Distance 이미지로부터 threshold 처리를 통해 얻어진 것입니다. 이제 배경인 Sure_BG에서 전경인 Sure_FG를 빼면 애매모호한 영역을 얻을 수 있게 되는데, 25번 코드가 이에 해당되고 그 결과 이미지는 Unknonw입니다. 즉 어떤 문제를 해결하기 위해 문제의 범위를 좁혀 나가고 있다는 것을 직감할 수 있습니다. 이제 마커 이미지를 sure_fg를 이용해 생성하는데 28-30번 코드입니다. 머커는 0값부터 지정되므로 결과 마커에 1씩 증감시키고, 애매모호한 부분에 대해서는 0 값을 지정합니다. 앞서 이론에 언급했던 것처럼요. 마커가 준비되었으므로, 이제 Watershed 알고리즘을 적용하고 분할 경계선에 해당되는 화소에 지정된 값인 -1을 가지는 부분을 [255,0,0] 색상으로 지정하는 것이 33-34번 코드이며, 최종 결과 이미지인 Result입니다.

이 글의 원문은 https://opencv-python-tutroals.readthedocs.io/en/latest/py_tutorials/py_imgproc/py_houghcircles/py_houghcircles.html#hough-circles 입니다.

앞서 이미지에서 선형 도형을 검출하는데, Hough Transform 알고리즘을 사용했습니다. 이 알고리즘은 수학적 모델링이 가능한 모든 도형을 이미지에서 검출할 수 있는 방법입니다. 그렇다면 원형에 대한 수학적 모델식을 이용해 Hought Transform을 적용할 수 있는데, 문제는 원에 대한 수학식이 중심점 (x, y)와 반지름(r)이라는 3개의 매개변수로 구성되어 있고, 결국 3차원 배열이라는 저장소를 요구한다는 점. 그럼으로 인해 연산이 매우 비효율적이라는 점입니다. 이에 대한 개선으로 Gradient(가장자리에서의 기울기값)을 이용하여 Hought Transform을 적용할 수 있고, 이에 대한 구현으로 OpenCV에서는 cv2.HoughCircles 함수를 제공합니다. 이 함수의 예는 다음과 같습니다.

import cv2
import numpy as np

img = cv2.imread('./data/opencv_logo.png',0)
img = cv2.medianBlur(img,5)
cimg = cv2.cvtColor(img,cv2.COLOR_GRAY2BGR)

circles = cv2.HoughCircles(img,cv2.HOUGH_GRADIENT,1,20,
                            param1=50,param2=30,minRadius=0,maxRadius=0)

circles = np.uint16(np.around(circles))
for i in circles[0,:]:
    cv2.circle(cimg,(i[0],i[1]),i[2],(0,255,0),2)

cv2.imshow('detected circles',cimg)
cv2.waitKey(0)
cv2.destroyAllWindows()

cv2.HoughCircles는 제법 많은 인자를 받는데요. 위의 예제를 통해 보면, 첫번째는 입력 이미지로써 8비트 단일 채널인 Grayscale 이미지, 두번째는 방식으로써 현재는 cv2.HOUGH_GRADIENT만을 지원합니다. 세번째는 대부분 1을 지정하는데, 이 경우 입력 이미지와 동일한 해상도가 사용됩니다. 네번째는 검출한 원의 중심과의 최소거리값으로 이 최소값보다 작으면 원으로 판별되지 않습니다. 그리고 param1은 Canny Edge에 전달되는 인자값, param2는 검출 결과를 보면서 적당이 조정해야 하는 값으로 작으면 오류가 높고 크면 검출률이 낮아진다고 합니다. minRadius와 masRadius는 각각 원의 최소, 최대 반지름이고 0으로 지정하면 사용되지 않습니다. 결과는 다음과 같습니다.

이 글의 원문은 https://opencv-python-tutroals.readthedocs.io/en/latest/py_tutorials/py_imgproc/py_houghlines/py_houghlines.html#hough-lines 입니다.

이미지에서 선 모양의 도형을 검출하는 Hough Transform에 대해 살펴보고, 이 알고리즘을 구현한 OpenCV의 함수를 살펴봅니다.

먼저 Hough Transfom은 이미지에서 수학적으로 표현 가능한 도형을 검색하는 기술입니다. 그 도형 중 선형에 대해 검색해 볼텐데요. 선에 대한 방정식은 우리가 흔히 알고 있는 기울기(m)와 y절편(c)로 표현되는 𝑦=m𝑥+c도 있지만 삼각함수에 의한 매개변수 방정식으로써는 r = 𝑥cos𝜃 + 𝑦sin𝜃 로도 표현됩니다.

r는 원점으로부터 직선까지의 수직거리이고, 𝜃는 수직선으로부터 x축까지의 반시계방향 각도입니다. 이 선에 대한 모델은 (r, 𝜃)로 표현되고, 이를 2차원 배열에 맵핑하는 것을 생각해 볼 수 있습니다. 즉, 2차원 배열의 열(row)가 r이고 행(column)이 𝜃로 정합니다. 거리 r과 각도 𝜃에 대한 정밀도를 고려하지 않으면 배열의 크기는 무한대가 됩니다. 그래서 r은 이미지의 대각 크기로 하며 단위는 1로 합니다. 이미지는 픽셀로 구분되니까요. 그리고 𝜃는 0-180의 범위로 하고 단위는 1로 합니다. 𝜃를 0-180로 하면 어떠한 선도 표현 가능하고, 단위를 1로 한다는 것은 회전된 선을 총 180개로만 표현 가능하다는 것입니다. 즉, 1도 단위는 정밀도의 단위입니다. 이제, 100×100 크기의 이미지에 시작점(30,50)과 끝점(70,50)으로 연결된 선에 대해 Hough Transfrom 알고리즘을 고려해 보겠습니다. 이 선을 구성하는 모든 픽셀들을 고려하는 것이 맞겠으나, 여기서는 편의상 시작점과 끝점만을 고려해 보겠습니다. r = 𝑥cos𝜃 + 𝑦sin𝜃 식에 대해서 (𝑥, 𝑦)가 (30, 50)인 𝜃는 모든 0-180까지에 대해 r을 구하고 구해진 (r, 𝜃)에 해당하는 배열 요소의 값을 1 증가시킵니다. 물론 초기 배열의 모든 항목은 0으로 초기화되어 있겠지요. 그 다음에 다시 (𝑥, 𝑦)가 (70, 50)인 𝜃는 모든 0-180까지에 대해 r을 구하고 구해진 (r, 𝜃)에 해당하는 배열 요소의 값을 1 증가시킵니다. 결과적으로 배열의 항목 중 가장 큰 값을 찾아 보면 r=50, 𝜃=90이 되고 이미지에서 선에 대한 매개변수 정의의 값과 일치합니다.

이제 이 Hough Transform을 OpenCV에서 구현한 예제를 살펴 보겠습니다.

import cv2
import numpy as np

img = cv2.imread('./data/dave.jpg')
gray = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)
edges = cv2.Canny(gray,50,150,apertureSize = 3)

lines = cv2.HoughLines(edges,1,np.pi/180,150)
for line in lines:
    rho,theta = line[0]
    a = np.cos(theta)
    b = np.sin(theta)
    x0 = a*rho
    y0 = b*rho
    x1 = int(x0 + 1000*(-b))
    y1 = int(y0 + 1000*(a))
    x2 = int(x0 - 1000*(-b))
    y2 = int(y0 - 1000*(a))

    cv2.line(img,(x1,y1),(x2,y2),(0,0,255),1)

cv2.imshow('edges', edges)
cv2.imshow('result', img)
cv2.waitKey()
cv2.destroyAllWindows()

실제 칼러 영상에 대해 바로 Hough Transform를 적용하기에는 너무 복잡해서 먼저 Gray 영상으로 변환하고 경계선을 추출한 뒤에 Hough Transform를 적용합니다. Hough Transform를 적용하는 코드가 8번인데, cv2.HoughLines 함수의 인자는 살펴보면, 첫번째는 입력 이미지, 두번째는 r의 정밀도(1로 지정했으며 1픽셀 단위), 세번째는 𝜃의 정밀도(1도로 지정했으며 라이언 단위), 네번째는 앞서 언급한 (r, 𝜃)에 해당하는 배열 요소에 저장된 값 중 네번째 인자로 지정된 값 이상인 것만을 추출하기 위한 조건값입니다.

실행해 보면 결과는 다음과 같습니다.

앞서 살펴본 Hough Transform 알고리즘은 선을 구성하는 모든 픽셀에 대해 2차원 배열 항목에 대한 값 처리를 수행하고 있어 퍼포먼스가 제법 떨어집니다. 이에 대해서 모든 픽셀 값을 처리하지 않고 적당히 필요한 만큼 확률적으로 픽셀들을 선택해 연산하는 방법(Probabilistic Hough Transform)이 있는데, 그 예가 아래와 같습니다.

import cv2
import numpy as np

img = cv2.imread('./data/dave.jpg')
gray = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)
edges = cv2.Canny(gray,50,150,apertureSize = 3)
minLineLength = 50
maxLineGap = 10

lines = cv2.HoughLinesP(edges,1,np.pi/180,100,minLineLength,maxLineGap)

for line in lines:
    x1,y1,x2,y2 = line[0]
    cv2.line(img,(x1,y1),(x2,y2),(0,255,0),1)

cv2.imshow('edges', edges)
cv2.imshow('result', img)
cv2.waitKey()
cv2.destroyAllWindows()

10번 코드의 cv2.HoughLinesP 함수가 바로 Probabilistic Hough Transform 방법을 사용하는데, 기존의 cv2.HoughLines 함수와 4개의 인자는 동일하지만 추가적으로 2개 인자가 지정되어 있습니다. 첫번째는 minLineLength로 검출된 선의 길이가 이 인자값보다 작으면 선이 아니라는 조건값이고, 두번째는 maxLineGap로 2개의 선 사이의 거리가 이 값보다 작다면 하나의 선으로 인식하라는 조건값입니다. 결과는 다음과 같습니다.

이 글의 원문은 https://opencv-python-tutroals.readthedocs.io/en/latest/py_tutorials/py_imgproc/py_transforms/py_fourier_transform/py_fourier_transform.html#fourier-transform 입니다.

퓨리에 변환이란 어떤 입력 신호를 다수의 sin과 cos 함수의 합으로 변환한 것을 의미합니다. sin과 cos 함수의 합이므로 그래프를 그려보면 어떤 반복적인 주기를 가지고 있을 것입니다. 이러한 퓨리에 변환을 이미지에 적용할 수 있는데, 이미지에 적용한 퓨리에 변환의 결과를 얻는 것을 2D DFT(Discrete Fourier Transform)이라고 합니다. 또한 이렇게 얻은 퓨리에 변환 결과를 이용해 다시 역으로 이미지를 얻는 것을 역 퓨리에 변환이라고 합니다. 퓨리에 변환은 Numpy와 OpenCV 모두에서 함수로 제공합니다. 먼저 Numpy에서 제공하는 퓨리에 변환에 대해서 살펴보면..

import cv2
import numpy as np
from matplotlib import pyplot as plt

img = cv2.imread('./data/messi5.jpg',0)
f = np.fft.fft2(img)
fshift = np.fft.fftshift(f)
magnitude_spectrum = 20*np.log(np.abs(fshift))

plt.subplot(121),plt.imshow(img, cmap = 'gray')
plt.title('Input Image'), plt.xticks([]), plt.yticks([])
plt.subplot(122),plt.imshow(magnitude_spectrum, cmap = 'gray')
plt.title('Magnitude Spectrum'), plt.xticks([]), plt.yticks([])
plt.show()

실행 결과는 다음과 같습니다.

왼쪽은 입력 이미지이고 오른쪽은 이미지에 대한 푸리에 변환의 결과를 시각화한 것입니다. 6번 코드의 np.fft.fft2 함수가 이미지에 대한 푸리에 변환을 실행하는 것이고, 7번 코드의 np.fft.fftshift 함수는 푸리에 변환의 결과를 중심으로 이동시킵니다. 푸리에 변환은 반복적인 주기를 갖으므로 이처럼 그 결과를 중심으로 이동시키는 것이 시각화 관점에서 좋습니다. 그리고 8번 코드는 푸리에 변환의 결과의 값을 증폭시킵니다. 워낙 푸리에 변환의 값이 작기때문에 이를 시각화하면 두드러진 특징을 살펴볼 수 없어 값을 증폭시킵니다.

이제 푸리에 변환의 결과를 변경해서, 변경된 푸리에 변환을 통해 이미지로 역 변환시키는 코드를 살펴보겠습니다.

import cv2
import numpy as np
from matplotlib import pyplot as plt

img = cv2.imread('./data/messi5.jpg',0)
f = np.fft.fft2(img)
fshift = np.fft.fftshift(f)

rows,cols = img.shape
crow,ccol = (int)(rows/2),(int)(cols/2)
fshift[crow-30:crow+30, ccol-30:ccol+30] = 0
f_ishift = np.fft.ifftshift(fshift)
img_back = np.fft.ifft2(f_ishift)
img_back = np.abs(img_back)

plt.subplot(131),plt.imshow(img, cmap = 'gray')
plt.title('Input Image'), plt.xticks([]), plt.yticks([])
plt.subplot(132),plt.imshow(img_back, cmap = 'gray')
plt.title('Image after HPF'), plt.xticks([]), plt.yticks([])
plt.subplot(133),plt.imshow(img_back)
plt.title('Result in JET'), plt.xticks([]), plt.yticks([])

plt.show()

푸리에 변환 결과에 어떤 변경을 가했는지 언급하면, 11번 코드에서 푸리에 변환 결과 이미지의 중심을 기준으로 좌우로 30픽셀 범위 영역의 값을 0으로 변경하고 있습니다. 이렇게 변경된 푸리에 변환 결과를 통해 역 변환시키는 코드가 12번과 13번 코드입니다. 결과는 다음과 같습니다.

이미지의 Edge를 추출한 결과가 도출되었습니다. 다음으로 OpenCV를 통한 푸리에 변환에 대해 살펴보겠습니다.

import numpy as np
import cv2
from matplotlib import pyplot as plt

img = cv2.imread('./data/messi5.jpg',0)

dft = cv2.dft(np.float32(img),flags = cv2.DFT_COMPLEX_OUTPUT)
dft_shift = np.fft.fftshift(dft)

magnitude_spectrum = 20*np.log(cv2.magnitude(dft_shift[:,:,0],dft_shift[:,:,1]))

plt.subplot(121),plt.imshow(img, cmap = 'gray')
plt.title('Input Image'), plt.xticks([]), plt.yticks([])
plt.subplot(122),plt.imshow(magnitude_spectrum, cmap = 'gray')
plt.title('Magnitude Spectrum'), plt.xticks([]), plt.yticks([])
plt.show()

실행 결과는 아래와 같고 Numpy를 통한 푸리에 변환과 동일합니다.

이제 여기서 푸리에 변환 결과에 어떤 변경을 가하고 난뒤 푸리에 역변환을 통해 이미지를 얻어 보겠습니다. 이번 변경은 앞서서 가운데 영역을 0으로 설정했는데, 이번에는 1로 설정합니다.

import numpy as np
import cv2
from matplotlib import pyplot as plt

img = cv2.imread('./data/messi5.jpg',0)

dft = cv2.dft(np.float32(img),flags = cv2.DFT_COMPLEX_OUTPUT)
dft_shift = np.fft.fftshift(dft)

rows, cols = img.shape
crow,ccol = int(rows/2), int(cols/2)

# create a mask first, center square is 1, remaining all zeros
mask = np.zeros((rows,cols,2),np.uint8)
mask[crow-30:crow+30, ccol-30:ccol+30] = 1

# apply mask and inverse DFT
fshift = dft_shift*mask
f_ishift = np.fft.ifftshift(fshift)
img_back = cv2.idft(f_ishift)
img_back = cv2.magnitude(img_back[:,:,0],img_back[:,:,1])

plt.subplot(121),plt.imshow(img, cmap = 'gray')
plt.title('Input Image'), plt.xticks([]), plt.yticks([])
plt.subplot(122),plt.imshow(img_back, cmap = 'gray')
plt.title('Magnitude Spectrum'), plt.xticks([]), plt.yticks([])
plt.show()

실행 결과는 다음과 같습니다.

이미지에 블러링 필터가 적용된 것과 같습니다. 그렇다면 왜 푸리에 변환과 그 역변환을 통해 원래의 이미지가 Edge 추출이나 Blur 효과가 적용되는지 직관적으로 이해하기 위해 다음 예제를 살펴보겠습니다.

import cv2
import numpy as np
from matplotlib import pyplot as plt

# simple averaging filter without scaling parameter
mean_filter = np.ones((3,3))

# creating a guassian filter
x = cv2.getGaussianKernel(5,10)
gaussian = x*x.T

# different edge detecting filters
# scharr in x-direction
scharr = np.array([[-3, 0, 3],
                   [-10,0,10],
                   [-3, 0, 3]])
# sobel in x direction
sobel_x= np.array([[-1, 0, 1],
                   [-2, 0, 2],
                   [-1, 0, 1]])
# sobel in y direction
sobel_y= np.array([[-1,-2,-1],
                   [0, 0, 0],
                   [1, 2, 1]])
# laplacian
laplacian=np.array([[0, 1, 0],
                    [1,-4, 1],
                    [0, 1, 0]])

filters = [mean_filter, gaussian, laplacian, sobel_x, sobel_y, scharr]
filter_name = ['mean_filter', 'gaussian','laplacian', 'sobel_x', \
                'sobel_y', 'scharr_x']
fft_filters = [np.fft.fft2(x) for x in filters]
fft_shift = [np.fft.fftshift(y) for y in fft_filters]
mag_spectrum = [np.log(np.abs(z)+1) for z in fft_shift]

for i in range(6):
    plt.subplot(2,3,i+1),plt.imshow(mag_spectrum[i],cmap = 'gray')
    plt.title(filter_name[i]), plt.xticks([]), plt.yticks([])

plt.show()

위의 코드를 실행해보면 아래와 같은데.. 각 행렬에 대해 푸리에 변환을 수행해 그 결과를 살펴볼 수 있습니다.

처음 Numpy 방식에서는 푸리에 변환에 위의 예제 결과에서의 laplacian으로 변경했고, 두번째 OpenCV 방식에서는 mean_filter나 gaussian으로 변경하여 푸리에 역변환을 수행했다는 것을 상기할 수 있습니다.

이 글의 원문은 https://opencv-python-tutroals.readthedocs.io/en/latest/py_tutorials/py_imgproc/py_template_matching/py_template_matching.html#template-matching 입니다.

템플릿 매칭이란 어떤 큰 이미지에 존재하는 다른 작은 조각 이미지(템플릿 이미지)가 어디에 존재하는지를 찾아 내는 것입니다. 예를들어 아래의 이미지 중 왼쪽 이미지에서 오른쪽의 조각 이미지를 찾아내는 것을 말합니다.

위의 입력 이미지를 활용하여 템플릿 매칭에 대한 OpenCV 예제를 살펴보면..

import cv2
import numpy as np
from matplotlib import pyplot as plt

img = cv2.imread('./data/messi5.jpg',0)
img2 = img.copy()
template = cv2.imread('./data/messi_face.jpg',0)
w, h = template.shape[::-1]

# All the 6 methods for comparison in a list
methods = ['cv2.TM_CCOEFF', 'cv2.TM_CCOEFF_NORMED', 'cv2.TM_CCORR',
            'cv2.TM_CCORR_NORMED', 'cv2.TM_SQDIFF', 'cv2.TM_SQDIFF_NORMED']

for meth in methods:
    img = img2.copy()
    method = eval(meth)

    # Apply template Matching
    res = cv2.matchTemplate(img,template,method)
    min_val, max_val, min_loc, max_loc = cv2.minMaxLoc(res)

    # If the method is TM_SQDIFF or TM_SQDIFF_NORMED, take minimum
    if method in [cv2.TM_SQDIFF, cv2.TM_SQDIFF_NORMED]:
        top_left = min_loc
    else:
        top_left = max_loc
    bottom_right = (top_left[0] + w, top_left[1] + h)

    cv2.rectangle(img,top_left, bottom_right, 255, 2)

    plt.subplot(121),plt.imshow(res,cmap = 'gray')
    plt.title('Matching Result'), plt.xticks([]), plt.yticks([])
    plt.subplot(122),plt.imshow(img,cmap = 'gray')
    plt.title('Detected Point'), plt.xticks([]), plt.yticks([])
    plt.suptitle(meth)

    plt.show()

OpenCV에서 제공하는 템플릿 매칭에 대한 함수는 cv2.matchTemplate입니다. 총 6가지 종류의 탬플릿 매칭 알고리즘을 제공하는데 11번 코드의 배열에 언급되어 있습니다. 총 6개의 결과가 표시되는데 이해를 돕기 위해 하나만 언급하면 다음과 같습니다.

위의 예제는 단 하나의 매칭 결과만을 반환하는데, 만약 이미지에 동일한 템플릿 이미지가 여러개 존재할 경우에 대한 예제를 살펴보겠습니다. 먼저 입력 이미지인데요. 아래의 왼쪽 이미지에서 오른쪽의 조각 이미지를 찾아내고자 합니다.

코드는 다음과 같습니다.

import cv2
import numpy as np
from matplotlib import pyplot as plt

img_rgb = cv2.imread('./data/mario.png')
img_gray = cv2.cvtColor(img_rgb, cv2.COLOR_BGR2GRAY)
template = cv2.imread('./data/coin.png',0)
w, h = template.shape[::-1]

res = cv2.matchTemplate(img_gray,template,cv2.TM_CCOEFF_NORMED)
threshold = 0.8
loc = np.where(res >= threshold)
for pt in zip(*loc[::-1]):
    cv2.rectangle(img_rgb, pt, (pt[0] + w, pt[1] + h), (0,0,255), 2)

cv2.imshow('result', img_rgb)
cv2.waitKey()
cv2.destroyAllWindows()

결과는 다음과 같습니다.

일치하는 것을 1개만 찾을때는 최대, 최소값에 기반하지만 여러개를 찾을 경우에는 임계치 조건(위의 예제의 경우 0.8)을 사용하여 임계치 값보다 큰 모든 매칭 영역을 표시하고 있습니다.