Goal¶

• 이미지 파일을 읽고, 보고, 저장하는 방법에 대해서 알아봅니다.
• 관련 함수인 cv2.imread(), cv2.imshow(), cv2.imwrite() 에 대해서 알아 봅니다.

이미지 읽기¶

우선 openCV모듈을 import합니다.:

>>> import cv2

cv2.imread() 함수를 이용하여 이미지 파일을 읽습니다. 이미지 파일의 경로는 절대/상대경로가 가능합니다.

>>> img = cv2.imread('lena.jpg', cv2.IMREAD_COLOR)

cv2.imread(fileName, flag)¶

이미지 파일을 flag값에 따라서 읽어들입니다.

Parameters:	fileName (str) – 이미지파일의 경로 flag (int) – 이미지 파일을 읽을 때의 Option.
Returns:	image객체 행렬
Return type:	numpy.ndarray

이미지 읽기의 flag는 3가지가 있습니다.

• cv2.IMREAD_COLOR : 이미지 파일을 Color로 읽어들입니다. 투명한 부분은 무시되며, Default값입니다.
• cv2.IMREAD_GRAYSCALE : 이미지를 Grayscale로 읽어 들입니다. 실제 이미지 처리시 중간단계로 많이 사용합니다.
• cv2.IMREAD_UNCHANGED : 이미지파일을 alpha channel까지 포함하여 읽어 들입니다.

img값은 numpy의 ndarray type입니다. numpy는 python에서 수학적 처리를 위한 모듈로 openCV에서도 많이 사용됩니다. img가 어떤 형태의 행렬인지 확인을 해보려면 아래와 같이 입력합니다.

>>> img.shape
(206, 207, 3)

이미지는 3차원 행렬로 return이 됩니다. 206은 행(Y축), 207은 열(X축), 3은 행과 열이 만나는 지점의 값이 몇개의 원소로 이루어져 있는지를 나타납니다. 위 값의 의미는 이미지의 사이즈는 207 X 206이라는 의미입니다.

그렇다면 3은 어떤 의미일까요. 바로 색을 표현하는 BGR값입니다. 일반적으로 RGB로 많이 나타내는데, openCV는 B(lue), G(reen), R(ed)로 표현을 합니다.

다음은 읽은 이미지를 보는 방법에 대해서 알아보겠습니다.

이미지 보기¶

cv2.imshow() 함수는 이미지를 사이즈에 맞게 보여줍니다.

>>> c22.imshow('image', img)
>>> cv2.waitKey(0)
>>> cv2.destroyAllWindows()

cv2.imshow(title, image)¶

읽어들인 이미지 파일을 윈도우창에 보여줍니다.

Parameters:	title (str) – 윈도우 창의 Title image (numpy.ndarray) – cv2.imread() 의 return값

cv2.waitKey() 는 keyboard입력을 대기하는 함수로 0이면 key입력까지 무한대기이며 특정 시간동안 대기하려면 milisecond값을 넣어주면 됩니다.

cv2.destroyAllWindows() 는 화면에 나타난 윈도우를 종료합니다. 일반적으로 위 3개는 같이 사용됩니다.

Sample Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

import cv2

fname = 'lena.jpg'

original = cv2.imread(fname, cv2.IMREAD_COLOR)
gray = cv2.imread(fname, cv2.IMREAD_GRAYSCALE)
unchange = cv2.imread(fname, cv2.IMREAD_UNCHANGED)

cv2.imshow('Original', original)
cv2.imshow('Gray', gray)
cv2.imshow('Unchange', unchange)

cv2.waitKey(0)
cv2.destroyAllWindows()

Sample Image

아래는 각 flag에 따른 이미지 결과입니다.

Original

Grayscale

Unchange

이미지 저장하기¶

cv2.imwrite() 함수를 이용하여 변환된 이미지나 동영상의 특정 프레임을 저장합니다.

>>> cv2.imwrite('lenagray.png', gray)

cv2.imwrite(fileName, image)¶

image파일을 저장합니다.

Parameters:	fileName (str) – 저장될 파일명 image – 저장할 이미지

Sample Code

이미지를 읽어서 esc키를 누르면 종료, ‘s’ key를 누르면 grayscale이미지가 저장이 되는 Sample입니다. cv2.waitKey() 사용을 잘 보시기 바랍니다.:

import cv2

img = cv2.imread('lena.jpg', cv2.IMREAD_GRAYSCALE)
cv2.imshow('image',img)
k = cv2.waitKey(0)
if k == 27: # esc key
    cv2.destroyAllWindow()
elif k = ord('s'): # 's' key
    cv2.imwrite('lenagray.png',img)
    cv2.destroyAllWindow()

Matplotlib 사용하기¶

Matplotlib는 다양한 plot기능을 가진 Python Plot Library입니다. 이미지를 zoom하거나 하나의 화면에 여러개의 이미지를 보고자 할 때 유용합니다.

Sample Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

#-*- coding:utf-8 -*-
import cv2
from matplotlib import pyplot as plt # as는 alias 적용시 사용

img = cv2.imread('lena.jpg', cv2.IMREAD_COLOR)

plt.imshow(img)
plt.xticks([]) # x축 눈금
plt.yticks([]) # y축 눈금
plt.show()

Result

Matplotlib Result

그런데 결과가 좀 이상합니다. 원본은 붉은색 계열인데, 결과는 파란색 계열로 나타납니다.

이유는 openCV는 BGR로 사용하지만, Matplotlib는 RGB로 이미지를 보여주기 때문입니다.

즉 결과 값은 3차원 배열의 값중 첫번째와 세번째 배열값을 서로 바꿔 주여야 합니다.

그럼 변경된 Sample을 보시기 바랍니다.

Sample Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

#-*- coding:utf-8 -*-
import cv2
from matplotlib import pyplot as plt # as는 alias 적용시 사용

img = cv2.imread('lena.jpg', cv2.IMREAD_COLOR)

b, g, r = cv2.split(img)   # img파일을 b,g,r로 분리
img2 = cv2.merge([r,g,b]) # b, r을 바꿔서 Merge

plt.imshow(img2)
plt.xticks([]) # x축 눈금
plt.yticks([]) # y축 눈금
plt.show()

Result

RGB값으로 변경한 결과

Goal¶

• 동영상을 읽고, 보여주고, 저장할 수 있다.
• 관련 함수인 cv2.VideoCapure() , cv2.VideoWriter() 에 대해서 알 수 있다.

Camera로 부터 영상 재생¶

Camera로부터 영상을 읽어, 화면에 보옂기 위해서 아래와 같은 순서로 진행을 합니다.

• VideoCapture Object를 생성합니다. 변수로는 camera device index나 동영상 파일명을 넘겨줍니다. 일반적으로 0 이면 Camera와 연결이 됩니다.
• Loop를 돌면서 frame을 읽어 들입니다.
• 읽은 frame에 대해서 변환작업을 수행한 후, 화면에 보여줍니다.
• 영상 재생이 끝나면, VideoCapure Object를 release하고 window를 닫습니다.

아래 예제는 동영상을 읽어 grayscale로 변환 후 재생하는 예제입니다.

Sample Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

# -*-coding: utf-8 -*-
import cv2

# cap 이 정상적으로 open이 되었는지 확인하기 위해서 cap.isOpen() 으로 확인가능
cap = cv2.VideoCapture(0)

# cap.get(prodId)/cap.set(propId, value)을 통해서 속성 변경이 가능.
# 3은 width, 4는 heigh

print 'width: {0}, height: {1}'.format(cap.get(3),cap.get(4))
cap.set(3,320)
cap.set(4,240)

while(True):
    # ret : frame capture결과(boolean)
    # frame : Capture한 frame
    ret, frame = cap.read()

    if (ret):
        # image를 Grayscale로 Convert함.
        gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)

        cv2.imshow('frame', gray)
        if cv2.waitKey(1) & 0xFF == ord('q'):
            break

cap.release()
cv2.destroyAllWindows()

File로 부터 영상 재생¶

File로 부터 동영상 재생도 Camera에서 영상 재생과 동일합니다.

Sample Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

import cv2

cap = cv2.VideoCapture('vtest.avi')

while(cap.isOpened()):
    ret, frame = cap.read()
    gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
    cv2.imshow('frame',gray)

    if cv2.waitKey(1) & 0xFF == ord('q'):
        break
cap.release()
cv2.destroyAllWindows()

영상 저장¶

영상을 저장하기 위해서는 cv2.VideoWriter Object를 생성해야 합니다.

cv2.VideoWriter(outputFile, fourcc, frame, size)¶

영상을 저장하기 위한 Object

Parameters:	outputFile (str) – 저장될 파일명 fourcc – Codec정보. cv2.VideoWriter_fourcc() frame (float) – 초당 저장될 frame size (list) – 저장될 사이즈(ex; 640, 480)

fourcc정보는 cv2.VideoWriter_fourcc('M','J','P','G') 또는 cv2.VideoWriter_fourcc(*'MJPG) 와 같이 표현할 수 있습니다. 각 OS마다 지원하는 codec 다릅니다.(Windows는 DIVX)

Sample Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

# -*-coding: utf-8 -*-

import cv2

cap = cv2.VideoCapture(0)

fourcc = cv2.VideoWriter_fourcc(*'DIVX')
out = cv2.ViewoWriter('output.avi', fourcc, 25.0, (640,480))

while (cap.isOpend()):
    ret, frame = cap.read()

    if ret:
        # 이미지 반전,  0:상하, 1 : 좌우
        frame = cv2.flip(frame, 0)

        out.write(frame)

        cv2.imshow('frame', frame)

        if cv2.waitKey(0) & 0xFF == ord('q'):
            break
    else:
        break

cap.release()
out.release()
cv2.destroyAllWindows()

Goal¶

• 다양한 모양의 도형을 그릴 수 있다.
• cv2.line() , cv2.circle() , cv2.rectangle() , cv2.putText() 사용법을 알 수 있다.

도형그리기는 동영상이나 이미지에서 Match가 되는 영역을 찾은 후에 사용자가 인식하기 쉽게 표시하는 목적으로 사용됩니다.

Line 그리기¶

Start와 End 점을 연결하여 직선을 그립니다.

cv2.line(img, start, end, color, thickness)¶

Parameters:	img – 그림을 그릴 이미지 파일 start – 시작 좌표(ex; (0,0)) end – 종료 좌표(ex; (500. 500)) color – BGR형태의 Color(ex; (255, 0, 0) -> Blue) thickness (int) – 선의 두께. pixel

Sample Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

import numpy as np
import cv2

#모두 0으로 되어 있는 빈 Canvas(검정색)
img = np.zeros((512, 512, 3), np.uint8)
img = cv2.line(img, (0, 0), (511, 511), (255, 0, 0), 5)

cv2.imshow('image',img)
cv2.waitKey(0)
cv2.destroyAllWindows()

사각형 그리기¶

top-left corner와 bottom-right corner점을 연결하는 사각형을 그립니다.

cv2.rectangle(img, start, end, color, thickness)¶

Parameters:	img – 그림을 그릴 이미지 start – 시작 좌표(ex; (0,0)) end – 종료 좌표(ex; (500. 500)) color – BGR형태의 Color(ex; (255, 0, 0) -> Blue) thickness (int) – 선의 두께. pixel

Sample Code

img = cv2.rectangle(img, (384, 0), (510, 128), (0,255,0), 3)

원 그리기¶

cv2.circle(img, center, radian, color, thickness)¶

Parameters:	img – 그림을 그릴 이미지 center – 원의 중심 좌표(x, y) radian – 반지름 color – BGR형태의 Color thickness – 선의 두께, -1 이면 원 안쪽을 채움

Sample Code

img = cv2.circle(img, (447,63), 63, (0,0,255), -1)

타원 그리기¶

cv2.ellipse(img, center, axes, angle, startAngle, endAngle, color[, thickness[, lineType[, shift]]]) → img

Parameters:	img – image center – 타원의 중심 axes – 중심에서 가장 큰 거리와 작은 거리 angle – 타원의 기울기 각 startAngle – 타원의 시작 각도 endAngle – 타원이 끝나는 각도 color – 타원의 색 thickness – 선 두께 -1이면 안쪽을 채움

Sample Code

img = cv2.ellipse(img, (256,256), (100,50), 0, 0, 180, 255, -1)

Polygon 그리기¶

cv2.polylines(img, pts, isClosed, color, thickness)¶

Parameters:	img – image pts (array) – 연결할 꼭지점 좌표 isClosed – 닫흰 도형 여부 color – Color thickness – 선 두께

Sample Code

pts = np.array([[10,5], [20,30], [70,20], [50,10]], np.int32) # 각 꼭지점은 2차원 행렬로 선언
# 이미지에 표현하기 위해 3차원 행렬로 변환. 변환이전과 이후의 행렬 갯수는 동일해야함.
# -1은 원본에 해당하는 값을 그대로 유지.
pts = pts.reshape((-1, 1, 2))
img = cv2.polylines(img, [pts], True, (0,255,255))

이미지에 Text 추가¶

cv2.putText(img, text, org, font, fontSacle, color)¶

Parameters:	img – image text – 표시할 문자열 org – 문자열이 표시될 위치. 문자열의 bottom-left corner점 font – font type. CV2.FONT_XXX fontSacle – Font Size color – fond color

Sample Code

cv2.putText(img, 'OpenCV', (10,500), cv2.FONT_HERSHEY_SIMPLEX, 4, (255,255,255), 2)

지금까지 예제로 보여 주웠던 Sample Code를 실행시키면 아래와 같은 결과가 나옵니다.

Goal¶

• Mouse Event의 적용 방법에 대해서 알 수 있다.
• cv2.setMouseCallback() 함수에 대해서 알 수 있다.

작동방법¶

OpenCV에는 이미 Mouse Event의 종류에 대해서 사전 정의가 되어 있습니다. 확인을 하기 위해서 Python Terminal에서 아래와 같이 입력해보시기 바랍니다.

>>> import cv2
>>> events = [i for i in dir(cv2) if 'EVENT' in i]
>>> print events

실행을 하면 다양한 Mouse Event의 종류를 알 수 있습니다. 어떤 종류의 Event인지는 이름을 보면 쉽게 알 수 있습니다.:

'EVENT_FLAG_ALTKEY', 'EVENT_FLAG_CTRLKEY', 'EVENT_FLAG_LBUTTON', 'EVENT_FLAG_MBUTTON', 'EVENT_FLAG_RBUTTON', 'EVENT_FLAG_SHIFTKEY', 'EVENT_LBUTTONDBLCLK', 'EVENT_LBUTTONDOWN', 'EVENT_LBUTTONUP', 'EVENT_MBUTTONDBLCLK', 'EVENT_MBUTTONDOWN', 'EVENT_MBUTTONUP', 'EVENT_MOUSEHWHEEL', 'EVENT_MOUSEMOVE', 'EVENT_MOUSEWHEEL', 'EVENT_RBUTTONDBLCLK', 'EVENT_RBUTTONDOWN', 'EVENT_RBUTTONUP'

Mouse Event를 확인하고 Callback을 호출하는 함수가 cv2.setMouseCallback() 입니다.

cv2.setMouseCallback(windowName, callback, param=None)¶

Parameters:	windowName – windowName callback – callback함수. callback함수에는 (event, x, y, flags, param)가 전달 됨. param – callback함수에 전달되는 Data

간단한 Demo¶

아래 Demo는 화면에 Double-Click을 하면 원이 그려지는 예제입니다.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

import cv2
import numpy as np

# callback함수
def draw_circle(event, x, y, flags, param):
    if event == cv2.EVENT_LBUTTONDBLCLK:
        cv2.circle(img,(x,y), 100,(255,0,0),-1)

# 빈 Image 생성
img = np.zeros((512,512,3), np.uint8)
cv2.namedWindow('image')
cv2.setMouseCallback('image', draw_circle)

while(1):
    cv2.imshow('image', img)
    if cv2.waitKey(0) & 0xFF == 27:
        break

cv2.destroyAllWindows()

Advanced Demo¶

다음은 마우스를 누른 상태에서 이동시 원 또는 사각형을 그리는 Demo입니다. 이 예제는 향후 대상 추적이나 이미지 Segmentaion시 응용될 수 있습니다.(ex; 이미지에서 대상을 마우스로 선택하고 동일한 대상을 찾는 경우)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

#-*- coding:utf-8 -*-
import cv2
import numpy as np 

drawing = False #Mouse가 클릭된 상태 확인용
mode = True # True이면 사각형, false면 원
ix,iy = -1,-1


# Mouse Callback함수
def draw_circle(event, x,y, flags, param):
	global ix,iy, drawing, mode

	if event == cv2.EVENT_LBUTTONDOWN: #마우스를 누른 상태
		drawing = True 
		ix, iy = x,y
	elif event == cv2.EVENT_MOUSEMOVE: # 마우스 이동
		if drawing == True:            # 마우스를 누른 상태 일경우
			if mode == True:
				cv2.rectangle(img,(ix,iy),(x,y),(255,0,0),-1)
			else:
				cv2.circle(img,(x,y),5,(0,255,0),-1)

	elif event == cv2.EVENT_LBUTTONUP:
		drawing = False;             # 마우스를 때면 상태 변경
		if mode == True:
			cv2.rectangle(img,(ix,iy),(x,y),(255,0,0),-1)
		else:
			cv2.circle(img,(x,y),5,(0,255,0),-1)


img = np.zeros((512,512,3), np.uint8)
cv2.namedWindow('image')
cv2.setMouseCallback('image',draw_circle)

while True:
	cv2.imshow('image', img)

	k = cv2.waitKey(1) & 0xFF

	if k == ord('m'):    # 사각형, 원 Mode변경
		mode = not mode
	elif k == 27:        # esc를 누르면 종료
		break

cv2.destroyAllWindows()

Goal¶

• trackbar와 OpenCV의 연동 방법에 대해서 알 수 있다.
• cv2.getTrackbarPos() , cv2.createTrackbar() 함수에 대해서 알 수 있다.

Demo¶

Trackbar에 대해서는 간단한 Demo를 보면서 설명하겠습니다. Demo의 내용은 4개의 Tranckbar로 구성이 되어 있습니다. 3개는 RGB의 값을 표현하며, 나머지 하나는 초기화 하는 기능입니다.

Demo에서 사용하는 cv2.getTrackbarPos() , cv2.createTrackbar() 함수에 대해서 알아 보겠습니다.

cv2.createTrackbar(trackbarName, windowName, value, count, onChange)¶

Parameters:	trackbarName – trackbar Name windowName – Named Window value (int) – Trackbar가 생성될 때 초기 값 count – Tracbar의 Max값. Min값은 항상 0 onChange – Slide값이 변경될 때 호출 되는 Callback함수. 전달되는 Paramter는 trackbar Position

cv2.getTrackbarPos(trackbarName, windowName)¶

Parameters:	trackbarName – trackbar Name windowName – Trackbar가 등록된 Named Window

Sample Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

#-*- coding: utf-8 -*-
import cv2
import numpy as np

def nothing(x):
    pass

img = np.zeros((300,512,3), np.uint8)
cv2.namedWindow('image')

# trackbar를 생성하여 named window에 등록
cv2.createTrackbar('R', 'image', 0, 255, nothing)
cv2.createTrackbar('G', 'image', 0, 255, nothing)
cv2.createTrackbar('B', 'image', 0, 255, nothing)

switch = '0:OFF\n1:On'
cv2.createTrackbar(switch, 'image', 1, 1, nothing)

while(1):
    cv2.imshow('image', img)

    if cv2.waitKey(1) & 0xFF == 27:
        break

    r = cv2.getTrackbarPos('R','image')
    g = cv2.getTrackbarPos('G', 'image')
    b = cv2.getTrackbarPos('B', 'image')
    s = cv2.getTrackbarPos(switch, 'image')

    if s == 0:
        img[:] = 0 # 모든 행/열 좌표 값을 0으로 변경. 검은색
    else:
        img[:] = [b,g,r] # 모든 행/열 좌표값을 [b,g,r]로 변경

cv2.destroyAllWindows()

Goal¶

• 개별 Pixcel에 접근하고, 수정할 수 있다.
• 이미지의 기본 속성을 확인 할 수 있다.
• 이미지의 ROI(Region of Image)를 설정할 수 있다.
• 이미지를 분리하고, 합칠 수 있다.

Pixel Value¶

일반적으로 이미지를 Load하면 3차원 행렬형태로 생성이 됩니다. (100,300,3) 이러한 형태로 (행, 열, 색정보)를 의미합니다.

>>> import cv2
>>> import numpy as np

>>> img = cv2.imread('lena.jpg')

위와 같이 Load후에 특정 pixel을 값에 접근을 하려면 아래와 같이 접근할 수 있습니다.

>>> px = img[100,200]
>>> print px
[157 100 190]

즉, 100(행), 200(열)을 색값이 157(B), 100(G), 190(R) 인 것을 확인 할 수 있습니다. 만일 Blue값만을 확인하고 싶을 경우에는 아래와 같이 입력합니다.

>>> b = img[100,200,0]
>>> print b
157

세번째 Array값 중 0번째는 Blue, 1번째는 Green, 2번째는 Red를 의미합니다. 위와 같은 방법으로 특정 pixel의 값을 변경할 수도 있습니다.

>>> img[100,200] = [255, 255, 255]

위와 같이 입력을 하면 100,200의 색 값을 흰색으로 변경할 수 있습니다.

일반적으로 특정 Pixel값을 변경하기 위해서는 아래와 같이 사용합니다.(Numpy 사용 방법)

>>> img.item(10,10,2) # Red값
59

>>> img.itemset((10,10,2), 100) #Red값을 100으로 변경
>>> img.item(10,10,2)
100

이미지의 기본 속성¶

이미지를 Load한 후에 해당 이미지의 기본적인 정보를 확인해야 합니다. 행과 열의 갯수가 몇개인지, 몇개의 Channel로 구성이되어 있는지가 기본입니다. 이를 확인하기 위해서 img.shape 를 사용하면 tuple형태로 (행, 열, channel) 정보를 Return합니다.

>>> img.shape
(206, 207, 3)

전체 pixcel수의 확인은 img.size 로 확인이 가능합니다.

>>> img.size
42642

이미지의 Datatype은 img.dtype 으로 확인이 가능합니다.

>>> img.dtype
dtype('uint8')

이미지 ROI¶

이미지 작업시에는 특정 pixel단위 보다는 특정 영역단위로 작업을 하게 됩니다. 이것을 Region of Image(ROI)라고 합니다. ROI 설정은 Numpy의 indexing방법을 사용합니다. 만일 아래와 같이 특정 영역에 어떤 물체가 있다는 것을 알고 있으면 그 영역을 설정해서 Copy를 할 수도 있습니다.

>>> img = cv2.imread('baseball-player.jpg')
>>> ball = img[409:454, 817:884] # img[행의 시작점: 행의 끝점, 열의 시작점: 열의 끝점]
>>> img[470:515,817:884] = ball # 동일 영역에 Copy
>>> cv2.imshow('img', img)
>>> cv2.waitKey(0)
>>> cv2.destroyAllWindows()

Original

Result

이미지 Channels¶

Color Image는 3개의 채널 B,G,R로 구성이 되어 있습니다. 이것을 각 채널별로 분리할 수 있습니다.

>>> b, g, r= cv2.split(img)
>>> img = cv2.merge((r,g,b))

또는 Numpy indexing 접근 방법으로 표현할 수도 있습니다

>>> b = img[:,:,0] # 0 : Blue, 1 : Green, 2 : Red

특정 Channel의 값을 변경하려면 아래와 같이 입력합니다.

>>> img[:,:,2] = 0 #Red Channel을 0으로 변경. Red 제거하는 효과.

Goal¶

• 이미지의 더하기, 빼기, 비트연산에 대해서 알 수 있다.
• cv2.add() , cv2.addWdighted() 함수에 대해서 알 수 있다.

이미지 더하기¶

예제로 OpenCV와 Numpy의 결과가 어떻게 다른지 보겠습니다.

Original 1

Original 2

OpenCV Add

Numpy Add

이미지 Blending¶

이미지를 서로 합칠 때 가중치를 두어 합치는 방법입니다.

a 값이 0 -> 1로 변함에 따라서 이미지가 전환된다.

아래 예제는 trackbar의 값을 조정함에 따라서 이미지가 변환되는 예제입니다.

Sample Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

#-*- coding:utf-8 -*-
import cv2
import numpy as np

img1 = cv2.imread('images/flower1.jpg')
img2 = cv2.imread('images/flower2.jpg')

def nothing(x):
    pass

cv2.namedWindow('image')
cv2.createTrackbar('W', 'image', 0, 100, nothing)

while True:

    w = cv2.getTrackbarPos('W','image')

    dst = cv2.addWeighted(img1,float(100-w) * 0.01, img2,float(w) * 0.01,0)

    cv2.imshow('dst', dst)

    if cv2.waitKey(1) &0xFF == 27:
        break;

cv2.destroyAllWindows()

Result

비트연산¶

비트연산은 AND, OR, NOT, XOR연산을 말한다. 비트연산은 이미지에서 특정 영역을 추출할 때 유용하게 사용된다. 예를 들면 이미지에서 바탕을 제거하고, 2개의 이미지를 합치는 경우입니다.

아래는 OpenCV Logo에서 바탕을 제거하고, 이미지에 추가하는 예제입니다.

Sample Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

#-*- coding:utf-8 -*-
import cv2
import numpy as np

img1 = cv2.imread('images/logo.png')
img2 = cv2.imread('images/lena.jpg')

# 삽입할 이미지의 row, col, channel정보
rows, cols, channels = img1.shape

# 대상 이미지에서 삽입할 이미지의 영역을 추출
roi = img2[0:rows, 0:cols]

#mask를 만들기 위해서 img1을 gray로 변경후 binary image로 전환
#mask는 logo부분이 흰색(255), 바탕은 검은색(0)
#mask_inv는 logo부분이 검은색(0), 바탕은 흰색(255)

img2gray = cv2.cvtColor(img1, cv2.COLOR_BGR2GRAY)
ret, mask = cv2.threshold(img2gray, 10, 255, cv2.THRESH_BINARY)
mask_inv = cv2.bitwise_not(mask)

#bitwise_and 연산자는 둘다 0이 아닌 경우만 값을 통과 시킴.
#즉 mask가 검정색이 아닌 경우만 통과가 되기때문에 mask영역 이외는 모두 제거됨.
#아래 img1_fg의 경우는 bg가 제거 되고 fg(logo부분)만 남게 됨.
#img2_bg는 roi영역에서 logo부분이 제거되고 bg만 남게 됨.
img1_fg = cv2.bitwise_and(img1, img1, mask=mask)
img2_bg = cv2.bitwise_and(roi, roi, mask=mask_inv)

#2개의 이미지를 합치면 바탕은 제거되고 logo부분만 합쳐짐.
dst = cv2.add(img1_fg, img2_bg)

#합쳐진 이미지를 원본 이미지에 추가.
img2[0:rows, 0:cols] = dst

cv2.imshow('res', img2)
cv2.waitKey(0)
cv2.destroyAllWindows()

Result

참고로 이미지 처리시 많이 사용되는 cv2.threshold() 함수에 대해서 다음 장에서 알아보겠습니다.

Goal¶

• 디지털 영상의 표현 방법에 대해서 알 수 있다.
• Color-space중 Binary Image, Grayscale, RGB, HSV에 대해서 알 수 있다.
• 각 Color-space 변환 방법에 대해서 알 수 있다.
• 동영상에서 간단한 Object Tracking을 할 수 있다.
• cv2.cvtColor() , cv2.inRange() 함수에 대해서 알 수 있다.

Digital Image¶

Pixel 표현 방법

Digital Image의 유형¶

Binary Image¶

Binary Image는 pixel당 1bit로 표현하는 영상을 의미합니다. 즉 흰색과 검은색으로만 표현이 되는 영상입니다.

Binary Image

위 이미지에서 좌측 상단의 이미지가 원본 이미지 입니다. 원본 이미지를 thresholding처리를 하여 binary image로 변환한 결과가 우측 상단의 이미지 입니다. 우측 하단의 이미지는 화면에 표현할 때 사용하는 방법으로 binary image의 밀도를 조절하여 밝기를 표현 하는 방법입니다. 이를 dithering 이라고 합니다.

Grayscale Image¶

Grayscale Image는 Pixel당 8bit, 즉 256단계의 명암(빛의 세기)을 표현할 수 있는 이미지입니다.

Grayscale Image(출처 위키피디아 )

Color Image¶

Color 이미지는 pixel의 색을 표현하기 위해서 pixel당 24bit를 사용합니다. 총 16,777,216 가지의 색을 표현할 수 있습니다. 이것을 일반적으로 True color image라고 합니다. pixel은 RGB 각각을 위해서 8bit를 사용하게 됩니다. OpenCV에서는 BGR로 표현을 하기 때문에 Blue->(255,0,0), Green->(0,255,0), Red->(0,0,255), White->(255,255,255), Black->(0,0,0)으로 표현할 수 있습니다.

각 pixel당 3Byte를 사용하기 때문에 용량이 큽니다. 이를 해결하기 위해서 lookup table을 사용하여, 해당 pixel에는 index만 을 저장하기도 합니다.

Indexed Color Image

RGB Color-space¶

RGB 모델은 빛의 삼원색인 빨간색, 초록색, 파란색을 기본 색으로 사용을 합니다. 정육면체 모델 형태로 표현할 수 있습니다.

HSV Color-space¶

이미지 처리에서 가장 많이 사용되는 형태의 Color 모델입니다. 하나의 모델에서 색과 채도, 명도를 모두 알 수 있습니다. 원뿔 형태의 모델로 표현이 됩니다.

HSV 모델

HSV의 의미는 다음과 같습니다.

• H(ue) : 색상. 일반적인 색을 의미함. 원추모형에서 각도로 표현이 됨.(0: Red, 120도 : Green, 240: Blue)
• S(aturation) : 채도. 색읜 순수성을 의미하며 일반적으로 짙다, 흐리다로 표현이 됨. 중심에서 바깥쪽으로 이동하면 채도가 높음.
• V(alue) : 명도. 색의 밝고 어두운 정도. 수직축의 깊이로 표현. 어둡다 밝다로 표현이 됨.

Color-space 변환¶

OpenCV에는 150여가지 변환 방법이 있습니다. 아래는 변환 방법을 확인하는 코드 입니다.

>>> import cv2
>>> flags = [i for i in dir(cv2) if i.startswith('COLOR_')]
>>> print flags

그 중에 서 많이 사용되는 BGR<->Gray, BGR<->HSV에 대해서 알아 보겠습니다. 변환을 위해서 사용하는 함수는 cv2.cvtColor() 함수 입니다.

cv2.cvtColor(src, code)¶

Params src:	image
Params code:	변환 코드

BGR->Grayscale로 변환하기 위해서는 cv2.COLOR_BGR2GRAY 를 사용합니다. BGR->HSV로 변환하기 위해서는 cv2.COLOR_BGR2HSV 를 사용합니다.

Object Tracking¶

다음 예제는 단순한 Object Tracking입니다. 영상에서 파란색 부분을 찿아서 binary image로 보여줍니다.

• Video로 부터 Frame을 읽어 들입니다.
• frame을 HSV로 변환을 합니다.
• 변환한 이미지에서 blue 영역을 찾아서 mask를 생성합니다.
• frame에 mask를 적용하여 이미지를 보여 줍니다.

Code는 아래와 같습니다.

Sample Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

#-*- coding: utf-8 -*-
import cv2
import numpy as np

# Camera 객체를 생성 후 사이즈르 320 X 240 으로 조정.
cap = cv2.VideoCapture(0)
cap.set(3,320)
cap.set(4,240)

while(1):
    # camera에서 frame capture.
    ret, frame = cap.read()

    if ret:

        # BGR->HSV로 변환
        hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)

        # blue 영역의 from ~ to
        lower_blue = np.array([110, 50, 50])
        upper_blue = np.array([130, 255, 255])

        #이미지에서 blue영역
        mask = cv2.inRange(hsv, lower_blue, upper_blue)

        #bit연산자를 통해서 blue영역만 남김.
        res = cv2.bitwise_and(frame, frame, mask = mask)

        cv2.imshow('frame', frame)
        cv2.imshow('mask', mask)
        cv2.imshow('res', res)

    if cv2.waitKey(1) & 0xFF == 27:
        break

cap.release()
cv2.destroyAllWindows()

Result

참고로 HSV의 색 영역을 확인하는 방법은 아래와 같습니다.

>>> green = np.uint8[[[0,255,0]]]
>>> green_hsv = cv2.cvtColor(green, cv2.COLOR_BGR2HSV)
>>> print green_hsv
[[[60, 255, 255]]]

위 결과에서 [H-10,100,100]과 [H+10,255,255]와 같이 상하한선을 정하여 색 영역 범위를 확인할 수 있습니다.

Goal¶

• 이미지 이진화의 방법인 Simple thresholding, Adaptive thresholding, Otsu’s thresholding에 대해서 알 수 있다.
• cv2.threshold() , cv2.adaptiveThreshold() 함수에 대해서 알 수 있다.

기본 임계처리¶

이진화 처리는 간단하지만, 쉽지 않은 문제를 가지고 있다. 이진화란 영상을 흑/백으로 분류하여 처리하는 것을 말합니다. 이때 기준이 되는 임계값을 어떻게 결정할 것인지가 중요한 문제가 됩니다. 임계값보다 크면 백, 작으면 흑이 됩니다. 기본 임계처리는 사용자가 고정된 임계값을 결정하고 그 결과를 보여주는 단순한 형태입니다.

이때 사용하는 함수가 cv2.threshold() 입니다.

cv2.threshold(src, thresh, maxval, type) → retval, dst¶

Parameters:	src – input image로 single-channel 이미지.(grayscale 이미지) thresh – 임계값 maxval – 임계값을 넘었을 때 적용할 value type – thresholding type

thresholding type은 아래와 같습니다.

• cv2.THRESH_BINARY
• cv2.THRESH_BINARY_INV
• cv2.THRESH_TRUNC
• cv2.THRESH_TOZERO
• cv2.THRESH_TOZERO_INV

아래 예제는 각 type별 thresholding 결과입니다.

Sample Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

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

img = cv2.imread('gradient.jpg',0)

ret, thresh1 = cv2.threshold(img,127,255, cv2.THRESH_BINARY)
ret, thresh2 = cv2.threshold(img,127,255, cv2.THRESH_BINARY_INV)
ret, thresh3 = cv2.threshold(img,127,255, cv2.THRESH_TRUNC)
ret, thresh4 = cv2.threshold(img,127,255, cv2.THRESH_TOZERO)
ret, thresh5 = cv2.threshold(img,127,255, cv2.THRESH_TOZERO_INV)

titles =['Original','BINARY','BINARY_INV','TRUNC','TOZERO','TOZERO_INV']
images = [img,thresh1,thresh2,thresh3,thresh4,thresh5]

for i in xrange(6):
	plt.subplot(2,3,i+1),plt.imshow(images[i],'gray')
	plt.title(titles[i])
	plt.xticks([]),plt.yticks([])

plt.show()

Result

적응 임계처리¶

이전 Section에서의 결과를 보면 한가지 문제점이 있습니다. 임계값을 이미지 전체에 적용하여 처리하기 때문에 하나의 이미지에 음영이 다르면 일부 영역이 모두 흰색 또는 검정색으로 보여지게 됩니다.

이런 문제를 해결하기 위해서 이미지의 작은 영역별로 thresholding을 하는 것입니다. 이때 사용하는 함수가 cv2.adaptiveThreshold() 입니다.

cv2.adaptiveThreshold(src, maxValue, adaptiveMethod, thresholdType, blockSize, C)¶

Parameters:	src – grayscale image maxValue – 임계값 adaptiveMethod – thresholding value를 결정하는 계산 방법 thresholdType – threshold type blockSize – thresholding을 적용할 영역 사이즈 C – 평균이나 가중평균에서 차감할 값

Adaptive Method는 아래와 같습니다.

• cv2.ADAPTIVE_THRESH_MEAN_C : 주변영역의 평균값으로 결정
• cv2.ADAPTIVE_THRESH_GAUSSIAN_C :

Sample Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

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

img = cv2.imread('images/dave.png',0)
# img = cv2.medianBlur(img,5)

ret, th1 = cv2.threshold(img,127,255,cv2.THRESH_BINARY)



th2 = cv2.adaptiveThreshold(img,255,cv2.ADAPTIVE_THRESH_MEAN_C,\
cv2.THRESH_BINARY,15,2)
th3 = cv2.adaptiveThreshold(img,255,cv2.ADAPTIVE_THRESH_GAUSSIAN_C,\
cv2.THRESH_BINARY,15,2)

titles = ['Original','Global','Mean','Gaussian']

images = [img,th1,th2,th3]

for i in xrange(4):
	plt.subplot(2,2,i+1),plt.imshow(images[i],'gray')
	plt.title(titles[i])
	plt.xticks([]),plt.yticks([])

plt.show()

Result

Otsu의 이진화¶

지금까지 thresholding처리를 하면서 임계값을 사용자가 결정하여 parameter로 전달하였습니다. 그렇다면 그 임계값을 어떻게 정의해야 할까요? 가장 일반적인 방법은 trial and error방식으로 결정했습니다. 그러나 bimodal image (히스토그램으로 분석하면 2개의 peak가 있는 이미지)의 경우는 히스토그램에서 임계값을 어느정도 정확히 계산 할 수 있습니다. Otsu의 이진화(Otsu’s Binarization)란 bimodal image에서 임계값을 자동으로 계산해주는 것을 말합니다.

적용 방법은 cv2.threshold() 함수의 flag에 추가로 cv2.THRESH_STSU 를 적용하면 됩니다. 이때 임계값은 0으로 전달하면 됩니다.

아래 예제는 global threshold값, Otsu thresholding적용, Gaussian blur를 통해 nosise를 제거한 후 Otsu thresholding적용 결과 입니다.

Sample Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

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

img = cv2.imread('images/noise.png',0)

# global thresholding
ret1, th1 = cv2.threshold(img, 127, 255, cv2.THRESH_BINARY)

ret2, th2 = cv2.threshold(img, 0, 255, cv2.THRESH_BINARY+cv2.THRESH_OTSU)

blur = cv2.GaussianBlur(img,(5,5),0)

ret3, th3 = cv2.threshold(img, 0, 255, cv2.THRESH_BINARY+cv2.THRESH_OTSU)

# plot all the images and their histograms
images = [img, 0, th1, img, 0, th2, blur, 0, th3]

titles = ['Original Noisy Image','Histogram','Global Thresholding (v=127)', 'Original Noisy Image','Histogram',"Otsu's Thresholding", 'Gaussian filtered Image','Histogram',"Otsu's Thresholding"]

for i in xrange(3):
	plt.subplot(3,3,i*3+1),plt.imshow(images[i*3],'gray')
	plt.title(titles[i*3]), plt.xticks([]), plt.yticks([])
	plt.subplot(3,3,i*3+2),plt.hist(images[i*3].ravel(),256)
	plt.title(titles[i*3+1]), plt.xticks([]), plt.yticks([])
	plt.subplot(3,3,i*3+3),plt.imshow(images[i*3+2],'gray')
	plt.title(titles[i*3+2]), plt.xticks([]), plt.yticks([])

plt.show()

Result

Goal¶

• 기하학적 변형에 대해서 알 수 있다.
• cv2.getPerspectiveTransform() 함수에 대해서 알 수 있다.

Transformations¶

변환이란 수학적으로 표현하면 아래와 같습니다.

• 좌표 x를 좌표 x’로 변환하는 함수

예로는 사이즈 변경(Scaling), 위치변경(Translation), 회전(Rotaion) 등이 있습니다. 변환의 종류에는 몇가지 분류가 있습니다.

• 강체변환(Ridid-Body) : 크기 및 각도가 보존(ex; Translation, Rotation)
• 유사변환(Similarity) : 크기는 변하고 각도는 보존(ex; Scaling)
• 선형변환(Linear) : Vector 공간에서의 이동. 이동변환은 제외.
• Affine : 선형변환과 이동변환까지 포함. 선의 수평성은 유지.(ex;사각형->평행사변형)
• Perspective : Affine변환에 수평성도 유지되지 않음. 원근변환

Scaling¶

Scaling은 이미지의 사이즈가 변하는 것 입니다. OpenCV에서는 cv2.resize() 함수를 사용하여 적용할 수 있습니다. 사이즈가 변하면 pixel사이의 값을 결정을 해야 하는데, 이때 사용하는 것을 보간법(Interpolation method)입니다. 많이 사용되는 보간법은 사이즈를 줄일 때는 cv2.INTER_AREA , 사이즈를 크게할 때는 cv2.INTER_CUBIC , cv2.INTER_LINEAR 을 사용합니다.

cv2.resize(img, dsize, fx, fy, interpolation)¶

Parameters:	img – Image dsize – Manual Size. 가로, 세로 형태의 tuple(ex; (100,200)) fx – 가로 사이즈의 배수. 2배로 크게하려면 2. 반으로 줄이려면 0.5 fy – 세로 사이즈의 배수 interpolation – 보간법

Sample Code

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

#-*- coding:utf-8 -*- import cv2 import numpy as np img = cv2.imread('images/logo.png') # 행 : Height, 열:width height, width = img.shape[:2] # 이미지 축소 shrink = cv2.resize(img, None, fx=0.5, fy=0.5, interpolation=cv2.INTER_AREA) # Manual Size지정 zoom1 = cv2.resize(img, (width*2, height*2), interpolation=cv2.INTER_CUBIC) # 배수 Size지정 zoom2 = cv2.resize(img, None, fx=2, fy=2, interpolation=cv2.INTER_CUBIC) cv2.imshow('Origianl', img) cv2.imshow('Shrink', shrink) cv2.imshow('Zoom1', zoom1) cv2.imshow('Zoom2', zoom2) cv2.waitKey(0) cv2.destroyAllWindows()

Result

Original

Shrink

Zoom

Translation¶

Translation은 이미지의 위치를 변경하는 변환입니다.

cv2.warpAffine(src, M, dsize)¶

Parameters:	src – Image M – 변환 행렬 dsize (tuple) – output image size(ex; (width=columns, height=rows)

Warning

width은 column의 수 이고, height는 row의 수 입니다.

여기서 변환행렬은 2X3의 이차원 행렬입니다. [[1,0,x축이동],[0,1,y축이동]] 형태의 float32 type의 numpy array입니다.

Sample Code

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

#-*- coding:utf-8 -*- import cv2 import numpy as np img = cv2.imread('images/logo.png') rows, cols = img.shape[:2] # 변환 행렬, X축으로 10, Y축으로 20 이동 M = np.float32([[1,0,10],[0,1,20]]) dst = cv2.warpAffine(img, M,(cols, rows)) cv2.imshow('Original', img) cv2.imshow('Translation', dst) cv2.waitKey(0) cv2.destroyAllWindows()

Result

Result

Rotation¶

물체를 평면상의 한 점을 중심으로 𝜃 만큼 회전하는 변환 입니다. 양의 각도는 시계반대방향으로 회전을 합니다. 역시 변환 행렬이 필요한데, 변환 행렬을 생성하는 함수가 cv2.getRotationMatrix2D() 함수입니다.

cv2.getRotationMatrix2D(center, angle, scale) → M¶

Parameters:	center – 이미지의 중심 좌표 angle – 회전 각도 scale – scale factor

위 결과에서 나온 변환행렬을 cv2.warpAffine() 함수에 적용합니다.

Sample Code

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

#-*- coding:utf-8 -*- import cv2 img = cv2.imread('images/logo.png') rows, cols = img.shape[:2] # 이미지의 중심점을 기준으로 90도 회전 하면서 0.5배 Scale M= cv2.getRotationMatrix2D((cols/2, rows/2),90, 0.5) dst = cv2.warpAffine(img, M,(cols, rows)) cv2.imshow('Original', img) cv2.imshow('Rotation', dst) cv2.waitKey(0) cv2.destroyAllWindows()

Result

Affine Transformation¶

Affine Transformation은 선의 평행성은 유지가 되면서 이미지를 변환하는 작업입니다. 이동, 확대, Scale, 반전까지 포함된 변환입니다. Affine 변환을 위해서는 3개의 Match가 되는 점이 있으면 변환행렬을 구할 수 있습니다.

Sample Code

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

#-*- coding:utf-8 -*- import cv2 import numpy as np from matplotlib import pyplot as plt img = cv2.imread('images/chessboard.jpg') rows, cols, ch = img.shape pts1 = np.float32([[200,100],[400,100],[200,200]]) pts2 = np.float32([[200,300],[400,200],[200,400]]) # pts1의 좌표에 표시. Affine 변환 후 이동 점 확인. cv2.circle(img, (200,100), 10, (255,0,0),-1) cv2.circle(img, (400,100), 10, (0,255,0),-1) cv2.circle(img, (200,200), 10, (0,0,255),-1) M = cv2.getAffineTransform(pts1, pts2) dst = cv2.warpAffine(img, M, (cols,rows)) plt.subplot(121),plt.imshow(img),plt.title('image') plt.subplot(122),plt.imshow(dst),plt.title('Affine') plt.show()

Result

Perspective Transformation¶

Perspective(원근법) 변환은 직선의 성질만 유지가 되고, 선의 평행성은 유지가 되지 않는 변환입니다. 기차길은 서로 평행하지만 원근변환을 거치면 평행성은 유지 되지 못하고 하나의 점에서 만나는 것 처럼 보입니다.(반대의 변환도 가능)

4개의 Point의 Input값과이동할 output Point 가 필요합니다.

변환 행렬을 구하기 위해서는 cv2.getPerspectiveTransform() 함수가 필요하며, cv2.warpPerspective() 함수에 변환행렬값을 적용하여 최종 결과 이미지를 얻을 수 있습니다.

아래의 예는 원근법이 적용된 효과를 제거하는 예제입니다.

Sample Code

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

#-*- coding:utf-8 -*- import cv2 import numpy as np from matplotlib import pyplot as plt img = cv2.imread('images/perspective.jpg') # [x,y] 좌표점을 4x2의 행렬로 작성 # 좌표점은 좌상->좌하->우상->우하 pts1 = np.float32([[504,1003],[243,1525],[1000,1000],[1280,1685]]) # 좌표의 이동점 pts2 = np.float32([[10,10],[10,1000],[1000,10],[1000,1000]]) # pts1의 좌표에 표시. perspective 변환 후 이동 점 확인. cv2.circle(img, (504,1003), 20, (255,0,0),-1) cv2.circle(img, (243,1524), 20, (0,255,0),-1) cv2.circle(img, (1000,1000), 20, (0,0,255),-1) cv2.circle(img, (1280,1685), 20, (0,0,0),-1) M = cv2.getPerspectiveTransform(pts1, pts2) dst = cv2.warpPerspective(img, M, (1100,1100)) plt.subplot(121),plt.imshow(img),plt.title('image') plt.subplot(122),plt.imshow(dst),plt.title('Perspective') plt.show()

Result

Goal¶

• 다양한 Filter를 이용하여 Blur 이미지를 만들 수 있다.
• 사용자 정의 Filter를 적용할 수 있다.

Image Filtering¶

이미지도 음성 신호처럼 주파수로 표현할 수 있습니다. 일반적으로 고주파는 밝기의 변화가 많은 곳, 즉 경계선 영역에서 나타나며, 일반적인 배경은 저주파로 나타납니다. 이것을 바탕으로 고주파를 제거하면 Blur처리가 되며, 저주파를 제거하면 대상의 영역을 확인할 수 있습니다.

Low-pass filter(LPF)와 High-pass filter(HPF)를 이용하여, LPF를 적용하면 노이즈제거나 blur처리를 할 수 있으며, HPF를 적용하면 경계선을 찾을 수 있습니다.

OpenCV에서는 cv2.filter2D() 함수를 이용하여 이미지에 kernel(filter)를 적용하여 이미지를 Filtering할 수 있습니다. kernel은 행렬을 의미하는데 kernel의 크기가 크면 이미지 전체가 blur처리가 많이 됩니다. 일반적으로 5X5행렬을 아래와 같이 생성하여 적용합니다.

Filter가 적용되는 방법은

• 이미지의 각 pixel에 kernel을 적용합니다.
• 위 kernel을 예로들면 각 pixel에 5X5윈도우를 올려 놓고, 그 영역안에 포함되는 값의 Sum을 한 후에 25로 나눕니다.
• 그 결과는 해당 윈도우 영역안의 평균값이 되고, 그 값을 해당 pixel에 적용하는 방식입니다.

아래 trackbar를 이용하여 kernel사이즈를 조정하면서 결과를 확인할 수 있는 예제입니다.

Sample Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

#-*- coding:utf-8 -*-
import cv2
import numpy as np

def nothing(x):
    pass

img = cv2.imread('images/lena.jpg')

cv2.namedWindow('image')
cv2.createTrackbar('K','image',1,20, nothing)

while(1):
    if cv2.waitKey(1) & 0xFF == 27:
        break
    k = cv2.getTrackbarPos('K','image')

    #(0,0)이면 에러가 발생함으로 1로 치환
    if k == 0:
        k = 1

    # trackbar에 의해서 (1,1) ~ (20,20) kernel생성
    kernel = np.ones((k,k),np.float32)/(k*2)
    dst = cv2.filter2D(img,-1,kernel)

    cv2.imshow('image',dst)

cv2.destroyAllWindows()

Result

5X5 Kernel적용 결과

Image Blurring¶

Image Blurring은 low-pass filter를 이미지에 적용하여 얻을 수 있습니다. 고주파영역을 제거함으로써 노이즈를 제거하거나 경계선을 흐리게 할 수 있습니다. OpenCV에는 4가지 형태의 blurring 방법을 제공하고 있습니다.

* CV_8U : 8-bit unsigned integer: uchar ( 0..255 )
* CV_8S : 8-bit signed integer: schar ( -128..127 )
* CV_16U : 16-bit unsigned integer: ushort ( 0..65535 )
* CV_16S : 16-bit signed integer: short ( -32768..32767 )
* CV_32S : 32-bit signed integer: int ( -2147483648..2147483647 )
* CV_32F : 32-bit floating-point number: float ( -FLT_MAX..FLT_MAX, INF, NAN )
* CV_64F : 64-bit floating-point number: double ( -DBL_MAX..DBL_MAX, INF, NAN )

Median Filtering¶

kernel window와 pixel의 값들을 정렬한 후에 중간값을 선택하여 적용합니다. salt-and-pepper noise 제거에 가장 효과적입니다. 예를 들면 아래와 같이 kernel window을 적용시킨 결과가 다음과 같다면

크기순으로 정렬을 하면 33,54,67,84,102,163,189,212,224입니다. 이중에 중간값인 102가 중앙값으로 결정이 됩니다.(중앙에 있는 189가 102로 변경됨.)

cv2.medianBlur(src, ksize)¶

Parameters:	src – 1,3,4 channel image. depth가 CV_8U, CV_16U, or CV_32F 이면 ksize는 3또는5, CV_8U이면 더 큰 ksize가능 ksize – 1보다 큰 홀수

Bilateral Filtering¶

지금까지의 Blur처리는 경계선까지 Blur처리가 되어, 경계선이 흐려지게 됩니다. Bilateral Filtering(양방향 필터)은 경계선을 유지하면서 Gaussian Blur처리를 해주는 방법입니다.

Gaussian 필터를 적용하고, 또 하나의 Gaussian 필터를 주변 pixel까지 고려하여 적용하는 방식입니다.

cv2.bilateralFilter(src, d, sigmaColor, sigmaSpace)¶

Parameters:	src – 8-bit, 1 or 3 Channel image d – filtering시 고려할 주변 pixel 지름 sigmaColor – Color를 고려할 공간. 숫자가 크면 멀리 있는 색도 고려함. sigmaSpace – 숫자가 크면 멀리 있는 pixel도 고려함.

아래 지금까지 설명한 Blur처리 방법을 적용한 예제입니다.

Sample Code

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32

#-*-coding:utf-8 -*- import cv2 import numpy as np from matplotlib import pyplot as plt img = cv2.imread('images/lena.jpg') # pyplot를 사용하기 위해서 BGR을 RGB로 변환. b,g,r = cv2.split(img) img = cv2.merge([r,g,b]) # 일반 Blur dst1 = cv2.blur(img,(7,7)) # GaussianBlur dst2 = cv2.GaussianBlur(img,(5,5),0) # Median Blur dst3 = cv2.medianBlur(img,9) # Bilateral Filtering dst4 = cv2.bilateralFilter(img,9,75,75) images = [img,dst1,dst2,dst3,dst4] titles=['Original','Blur(7X7)','Gaussian Blur(5X5)','Median Blur','Bilateral'] for i in xrange(5): plt.subplot(3,2,i+1),plt.imshow(images[i]),plt.title(titles[i]) plt.xticks([]),plt.yticks([]) plt.show()

Result

위 결과 이미지를 확대해서 보면 Gaussian과 Bilateral를 비교해보면 윤곽선에서 차이가 나타나는 것을 알 수 있습니다.

Theory¶

Morphologicla Transformation은 이미지를 Segmentation하여 단순화, 제거, 보정을 통해서 형태를 파악하는 목적으로 사용이 됩니다. 일반적으로 binary나 grayscale image에 사용이 됩니다. 사용하는 방법으로는 Dilation(팽창), Erosion(침식), 그리고 2개를 조합한 Opening과 Closing이 있습니다. 여기에는 2가지 Input값이 있는데, 하나는 원본 이미지이고 또 다른 하나는 structuring element입니다.

Erosion¶

각 Pixel에 structuring element를 적용하여 하나라도 0이 있으면 대상 pixel을 제거하는 방법입니다. 아래 그림은 대상 이미지에 십자형 structuring element를 적용한 결과 입니다.

Erosion(출처: KOCW )

위 그림에서 가운데 있는 십자형 Structuring Element를 Original Image에 적용을 합니다. 원본의 각 pixel에 적용을 하여 겹치는 부분이 없는 부분이 하나라도 있으면 그 중심 pixel을 제거하는 방식입니다. 최종적으로 우측의 분홍색 영역만 남게 됩니다. 이 방법은 작은 Object를 제거하는 효과가 있습니다.

cv2.erode(src, kernel, dst, anchor, iterations, borderType, borderValue)¶

Parameters:	src – the depth should be one of CV_8U, CV_16U, CV_16S, CV_32F or CV_64F. kernel – structuring element. cv2.getStructuringElemet() 함수로 만들 수 있음. anchor – structuring element의 중심. default (-1,-1)로 중심점. iterations – erosion 적용 반복 횟수

Dilation¶

Erosion과 반대로 대상을 확장한 후 작은 구멍을 채우는 방법입니다. Erosion과 마찬가지로 각 pixel에 structuring element를 적용합니다. 대상 pixel에 대해서 OR 연산을 수행합니다. 즉 겹치는 부분이 하나라도 있으면 이미지를 확장합니다.

위 그림은 십자형 structuring element를 원본이미지에 OR 연산을 적용합니다. 최종적으로 확장된 이미지를 얻을 수 있습니다. 결과적으로 경계가 부드러워 지고, 구멍이 메꿔지는 효과를 얻을 수 있습니다.

cv2.dilation(src, kernel, dst, anchor, iterations, borderType, borderValue)¶

Parameters:	src – the depth should be one of CV_8U, CV_16U, CV_16S, CV_32F or CV_64F. kernel – structuring element. cv2.getStructuringElemet() 함수로 만들 수 있음. anchor – structuring element의 중심. default (-1,-1)로 중심점. iterations – dilation 적용 반복 횟수

Opening & Closing¶

Opening과 Closing은 Erosion과 Dilation의 조합 결과 입니다. 차이는 어느 것을 먼저 적용을 하는 차이 입니다.

• Opeing : Erosion적용 후 Dilation 적용. 작은 Object나 돌기 제거에 적합
• Closing : Dilation적용 후 Erosion 적용. 전체적인 윤곽 파악에 적합

cv2.morphologyEx(src, op, kernel[, dst[, anchor[, iterations[, borderType[, borderValue]]]]]) → dst¶

Parameters:

src – Source image. The number of channels can be arbitrary. The depth should be one of CV_8U, CV_16U, CV_16S, CV_32F` or ``CV_64F. op – Type of a morphological operation that can be one of the following: MORPH_OPEN - an opening operation MORPH_CLOSE - a closing operation MORPH_GRADIENT - a morphological gradient. Dilation과 erosion의 차이. MORPH_TOPHAT - “top hat”. Opeining과 원본 이미지의 차이 MORPH_BLACKHAT - “black hat”. Closing과 원본 이미지의 차이 kernel – structuring element. cv2.getStructuringElemet() 함수로 만들 수 있음. anchor – structuring element의 중심. default (-1,-1)로 중심점. iterations – erosion and dilation 적용 횟수 borderType – Pixel extrapolation method. See borderInterpolate for details. borderValue – Border value in case of a constant border. The default value has a special meaning.

Structuring Element¶

사각형 모양의 structuring element는 numpy를 이용해서 만들 수 있습니다.

>>> import numpy as np
>>> kernel = np.ones((5,5), np.uini8)

하지만 원, 타원모양이 필요한 경우에는 OpenCV에서 제공하는 cv2.getStructuringElement() 함수를 이용해서 만들 수 있습니다.

>>> cv2.getStructuringElement(cv2.MORPH_REC,(5,5))
array([ [1, 1, 1, 1, 1],
        [1, 1, 1, 1, 1],
        [1, 1, 1, 1, 1],
        [1, 1, 1, 1, 1],
        [1, 1, 1, 1, 1]], dtype=uint8)

>>> cv2.getStructuringElement(cv2.MORP_ELLIPSE,(5,5))
array([[0, 0, 1, 0, 0],
       [1, 1, 1, 1, 1],
       [1, 1, 1, 1, 1],
       [1, 1, 1, 1, 1],
       [0, 0, 1, 0, 0]], dtype=uint8)

cv2.getStructuringElement(shape, ksize[, anchor]) → retval¶

Parameters:	shape – Element의 모양. MORPH_RET : 사각형 모양 MORPH_ELLIPSE : 타원형 모양 MORPH_CROSS : 십자 모양 ksize – structuring element 사이즈

아래 지금까지 배운 Morphological 변환에 대한 예제입니다.

Sample Code

#-*- coding:utf-8 -*-

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

dotImage = cv2.imread('images/dot_image.png')
holeImage = cv2.imread('images/hole_image.png')
orig = cv2.imread('images/morph_origin.png')


kernel = cv2.getStructuringElement(cv2.MORPH_RECT,(5,5))
# kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE,(5,5))
# kernel = cv2.getStructuringElement(cv2.MORPH_CROSS,(5,5))

erosion = cv2.erode(dotImage,kernel,iterations = 1)
dilation = cv2.dilate(holeImage,kernel,iterations = 1)

opening = cv2.morphologyEx(dotImage, cv2.MORPH_OPEN, kernel)
closing = cv2.morphologyEx(holeImage, cv2.MORPH_CLOSE,kernel)
gradient = cv2.morphologyEx(orig, cv2.MORPH_GRADIENT, kernel)
tophat = cv2.morphologyEx(orig, cv2.MORPH_TOPHAT, kernel)
blackhat = cv2.morphologyEx(orig, cv2.MORPH_BLACKHAT, kernel)

images =[dotImage, erosion, opening, holeImage, dilation, closing, gradient, tophat, blackhat]
titles =['Dot Image','Erosion','Opening','Hole Image', 'Dilation','Closing', 'Gradient', 'Tophat','Blackhot']

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

plt.show()

Result

Goal¶

• Edge Detection에 대해서 알 수 있다.

Gradient(기울기)는 스칼라장(즉, 공간)에서 최대의 증가율을 나타내는 벡터장(방향과 힘)을 뜻합니다.

어렵죠? 영상처리에서 gradient는 영상의 edge 및 그 방향을 찾는 용도로 활용이 되는데요. 이미지 (x,y)에서의 벡터값(크기와 방향, 즉 밝기와 밝기의 변화하는 방향)을 구해서 해당 pixel이 edge에 얼마나 가까운지, 그리고 그 방향이 어디인지 쉽게 알수 있게 합니다. (일반적으로 이미지의 Gradient를 생각해보시면 밝기의 변화와 그 방향을 알 수 있습니다.)

아래 설명할 방법들은 Gradient를 이용해서 이미지의 edge를 검출하는 방법입니다.

Sobel & Scharr Filter¶

Gaussian smoothing과 미분을 이용한 방법입니다. 그래서 노이즈가 있는 이미지에 적용하면 좋습니다. X축과 Y축을 미분하는 방법으로 경계값을 계산합니다.

직선을 미분하면 상수, 곡선을 미분하면 또 다른 방정식이 나오는 성질을 이용하여 edge에 대한 선을 그려주는 기능을 합니다. X축 미분은 수평선(수직선이 남음), Y축 미분은 수직선(수평선이 남음)을 미분하여 경계가 사라지는 효과가 있습니다. 미분시 소실되는 표본의 정보가 많을 수 있어 aperture_size 값을 이용하여 소실되는 정도를 조절할 수 있습니다.

만약 ksize가 -1이면 3x3 Scharr filter가 적용이 되어 Sobel의 3x3보다 좀 더 나은 결과를 보여 줍니다.

cv2.Sobel(src, ddepth, dx, dy[, dst[, ksize[, scale[, delta[, borderType]]]]]) → dst

Parameters:	src – input image ddepth – output image의 depth, -1이면 input image와 동일. dx – x축 미분 차수. dy – y축 미분 차수. ksize – kernel size(ksize x ksize)

cv2.Scharr(src, ddepth, dx, dy[, dst[, scale[, delta[, borderType]]]]) → dst

cv2.Sobel() 함수와 동일하나 ksize가 sobel의 3x3 보다 좀더 정확하게 적용이 됩니다.

Laplacian 함수¶

이미지의 가로와 세로에 대한 Gradient를 2차 미분한 값입니다. Sobel filter에 미분의 정도가 더해진 것과 비슷합니다.(dx와 dy가 2인 경우) blob(주위의 pixel과 확연한 picel차이를 나타내는 덩어리)검출에 많이 사용됩니다.

cv2.Laplacian(src, ddepth[, dst[, ksize[, scale[, delta[, borderType]]]]]) → dst

Parameters:	src – source image ddepth – output iamge의 depth.

Canny Edge Detection¶

가장 유명한 Edge Detection방법입니다. 여러 단계의 Algorithm을 통해서 경계를 찾아 냅니다.

1. Noise Reduction

   이미지의 Noise를 제거합니다. 이때 5x5의 Gaussian filter를 이용합니다.

2. Edge Gradient Detection

   이미지에서 Gradient의 방향과 강도를 확인합니다. 경계값에서는 주변과 색이 다르기 때문에 미분값이 급속도로 변하게 됩니다. 이를 통해 경계값 후보군을 선별합니다.

3. Non-maximum Suppression

   이미지의 pixel을 Full scan하여 Edge가 아닌 pixel은 제거합니다.

4. Hysteresis Thresholding

   이제 지금까지 Edge로 판단된 pixel이 진짜 edge인지 판별하는 작업을 합니다. max val과 minVal(임계값)을 설정하여 maxVal 이상은 강한 Edge, min과 max사이는 약한 edge로 설정합니다. 이제 약한 edge가 진짜 edge인지 확인하기 위해서 강한 edge와 연결이 되어 있으면 edge로 판단하고, 그러지 않으면 제거합니다.

이와 같은 일련의 작업을 통해서 경계값만을 남겨두고 제거합니다.

cv2.Canny(image, threshold1, threshold2[, edges[, apertureSize[, L2gradient]]]) → edges

Parameters:	image – 8-bit input image threshold1 – Hysteresis Thredsholding 작업에서의 min 값 threshold2 – Hysteresis Thredsholding 작업에서의 max 값

아래는 지금까지 설명한 edge detection방법에 대한 예제입니다.

Sample Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

#-*- coding:utf-8 -*-
import cv2
import numpy as np
from matplotlib import pyplot as plt

img = cv2.imread('images/dave.png')
canny = cv2.Canny(img,30,70)

laplacian = cv2.Laplacian(img,cv2.CV_8U)
sobelx = cv2.Sobel(img,cv2.CV_8U,1,0,ksize=3)
sobely = cv2.Sobel(img,cv2.CV_8U,0,1,ksize=3)

images = [img,laplacian, sobelx, sobely, canny]
titles = ['Origianl', 'Laplacian', 'Sobel X', 'Sobel Y','Canny']

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

plt.show()

Result

Goal¶

• Image Pyramid에 대해서 알 수 있다.
• cv2.pyrUp() 와 cv2.pyrDown() 에 대해서 알 수 있다.

Theory¶

일반적으로는 고정된 이미지 사이즈를 작업을 하지만, 때때로 동일한 이미지에 대해서 다양한 사이즈를 가지고 작업을 해야 하는 경우가 있습니다. 만일, 이미지에서 얼굴을 찾을 경우에 얼굴의 사이즈를 확신할 수 없습니다. 이럴 경우에는 원본 이미지에 대한 다양한 사이즈에서 얼굴을 찾는다면 좀더 정확하고 확실한 이미지를 찾을 수 있습니다. 이 처럼 동일 이미지의 서로 다른 사이즈의 set을 Image Pyramids라고 합니다(가장 아래에 가장 큰 해상도를 놓고 점점 줄여가면서 쌓아가는 형태입니다.)

Image Pyramid의 종류는 1) Gaussian Pyramids 와 2) Laplacian Pyramids 가 있습니다.

Gaussian Pyramid의 High Level(낮은 해상도. Pyramid의 상단)은 Lower level에서 row와 column을 연속적으로 제거하면서 생성됩니다. M x N 사이지의 이미지는 M/2 X N/2 가 적용되연 1/4사이즈로 줄어들게 됩니다.

Sample Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

#-*-coding:utf-8 -*-
import cv2

img = cv2.imread('images/lena.jpg')


lower_reso = cv2.pyrDown(img) # 원본 이미지의 1/4 사이즈
higher_reso = cv2.pyrUp(img) #원본 이미지의 4배 사이즈

cv2.imshow('img', img)
cv2.imshow('lower', lower_reso)
cv2.imshow('higher', higher_reso)

cv2.waitKey(0)

cv2.destroyAllWindows()

Result

Laplacian Pyramid는 Gaussian Pyramid에서 만들어 집니다. cv2.pyrDown() 과 cv2.pyrUp() 함수를 사용하여 축소, 확장을 하면 원본과 동일한 이미지를 얻을 수 없습니다.(계산하면서 약간의 차이가 발생합니다.)

예를 들면 원본 이미지의 shape가 (225,400,3)을 cv2.pyrDown() 을 적용하면 행과 열이 2배씩 줄게 되고 소수점은 반올림이 되어 (113,200,3)이 됩니다. 이것을 다시 cv2.pyrUp() 을 시키면 (226,400,3) 이 되어 원본 이미지와 1row차이가 발생합니다. 이것을 resize를 통해서 동일한 shape로 만든 후에 2 배열을 차이를 구하면 아래와 같이 외곽선이 남게 됩니다.(짝수 해상도도 동일한 결과가 나옵니다.)

>>> import cv2
>>> img = cv2.imread('lena.jpg')
>>> img.shape
(225, 400, 3)
>>> GAD = cv2.pyrDown(img)
>>> GAD.shape
(113, 200, 3)
>>> GAU = cv2.pyrUp(GAD)
>>> GAU.shape
(226, 400, 3)
>>> temp = cv2.resize(GAU, (400, 255))
>>> res = cv2.subtract(img, temp)
>>> cv2.imshow(res)
>>> cv2.waitKey(0)

Result

이미지 Pyramid를 이용하면 이미지 결합을 자연스럽게 처리할 수 있습니다. 작업 순서는 아래와 같습니다.

1. 2개의 이미지를 각각 Load함.
2. 각 이미지에 대해서 적당한 Gaussian Pyramid를 생성함.
3. Gaussian Pyramid를 이용하여 Laplacian Pyramid를 생성함.
4. 각 단계의 Laplicain Pyramid를 이용하여 각 이미지의 좌측과 우측을 결함.
5. 결함한 결과중 가장 작은 이미지를 확대하면서 동일 사이즈의 결합결과와 Add하여 외곽선을 선명하게 처리함.

위 작업단계 순서대로 2개의 이미지를 결함한 예제입니다.

#-*- coding:utf-8 -*-
import cv2
import numpy as np
from matplotlib import pyplot as plt
# 1단계
A = cv2.imread('images/apple.jpg')
B = cv2.imread('images/orange.jpg')

# 2단계
# A 이미지에 대한 Gaussian Pyramid를 생성
# 점점 작아지는 Pyramid
G = A.copy()
gpA = [G]
for i in xrange(6):
    G = cv2.pyrDown(G)
    gpA.append(G)

# B 이미지에 대한 Gaussian Pyramid 생성
# 점점 작아지는 Pyramid
G = B.copy()
gpB = [G]
for i in xrange(6):
    G = cv2.pyrDown(G)
    gpB.append(G)

# 3단계
# A 이미지에 대한 Laplacian Pyramid 생성
lpA = [gpA[5]] # n번째 추가된 Gaussian Image
for i in xrange(5,0,-1):
    GE = cv2.pyrUp(gpA[i]) #n번째 추가된 Gaussian Image를 Up Scale함.
    temp = cv2.resize(gpA[i-1], (GE.shape[:2][1], GE.shape[:2][0])) # 행렬의 크기를 동일하게 만듬.
    L = cv2.subtract(temp,GE) # n-1번째 이미지에서 n번째 Up Sacle한 이미지 차이 -> Laplacian Pyramid
    lpA.append(L)

# A 이미지와 동일하게 B 이미지도 Laplacian Pyramid 생성
lpB = [gpB[5]]
for i in xrange(5,0,-1):
    GE = cv2.pyrUp(gpB[i])
    temp = cv2.resize(gpB[i - 1], (GE.shape[:2][1], GE.shape[:2][0]))
    L = cv2.subtract(temp, GE)
    # L = cv2.subtract(gpB[i-1],GE)
    lpB.append(L)

# 4단계
# Laplician Pyramid를 누적으로 좌측과 우측으로 재결함
LS = []
for la,lb in zip(lpA,lpB):
    rows,cols,dpt = la.shape
    ls = np.hstack((la[:,0:cols/2], lb[:,cols/2:]))
    LS.append(ls)


# 5단계
ls_ = LS[0] # 좌측과 우측이 결합된 가장 작은 이미지
for i in xrange(1,6):
    ls_ = cv2.pyrUp(ls_) # Up Sacle
    temp = cv2.resize(LS[i],(ls_.shape[:2][1], ls_.shape[:2][0])) # 외곽선만 있는 이미지
    ls_ = cv2.add(ls_, temp) # UP Sacle된 이미지에 외곽선을 추가하여 선명한 이미지로 생성

# 원본 이미지를 그대로 붙인 경우
real = np.hstack((A[:,:cols/2],B[:,cols/2:]))

cv2.imshow('real', real)
cv2.imshow('blending', ls_)
cv2.destroyAllWindows()

위 예제에서 5단계의 역할에 대해서 알아보기 위하여 마지막 i = 5 일경우의 각 이미지의 결과는 아래와 같습니다.

cv2.pyUp(ls_) 수행 전의 _ls 이미지

cv2.pyUp(ls_) 수행 후의 _ls 이미지

temp 이미지. 잘 보이지 않지만 외곽선만 남아 있는 결과.

Up Sacle된 결과와 외곽선 이미지가 결함한 최종 결과

위와 같은 단계를 거쳐 부드럽게 2개의 이미지가 결합이 되었습니다. 단순하게 원본이미지를 결합한 결과는 아래와 같습니다.

단순 결합 결과

Goal¶

• Contours에 대해서 알 수 있다
• cv2.findContours() , cv2.drawContours() 함수에 대해서 알 수 있다.

Contours¶

Contours란 동일한 색 또는 동일한 강도를 가지고 있는 영역의 경계선을 연결한 선입니다. 우리가 자주 보는 것으로는 등고선이나 일기예보에서 볼 수 있습니다.

등고선(Contours Line)(출처 위키피디아 )

대상의 외형을 파악하는데 유용하게 사용이 됩니다.

• 정확도를 높히기 위해서 Binary Image를 사용합니다. threshold나 canny edge를 선처리로 수행합니다.
• cv2.findContours() 함수는 원본 이미지를 직접 수정하기 때문에, 원본 이미지를 보존 하려면 Copy해서 사용해야 합니다.
• OpenCV에서는 contours를 찾는 것은 검은색 배경에서 하얀색 대상을 찾는 것과 비슷합니다. 그래서 대상은 흰색, 배경은 검은색으로 해야 합니다.

Find & Draw Contours¶

OpenCV에서 contours를 찾고, 그리기 위해서 아래 2개의 함수를 사용합니다.

cv2.findContours(image, mode, method[, contours[, hierarchy[, offset]]]) → image, contours, hierarchy

Parameters:

image – 8-bit single-channel image. binary image. mode – contours를 찾는 방법 cv2.RETR_EXTERNAL : contours line중 가장 바같쪽 Line만 찾음. cv2.RETR_LIST : 모든 contours line을 찾지만, hierachy 관계를 구성하지 않음. cv2.RETR_CCOMP : 모든 contours line을 찾으며, hieracy관계는 2-level로 구성함. cv2.RETR_TREE : 모든 contours line을 찾으며, 모든 hieracy관계를 구성함. method – contours를 찾을 때 사용하는 근사치 방법 cv2.CHAIN_APPROX_NONE : 모든 contours point를 저장. cv2.CHAIN_APPROX_SIMPLE : contours line을 그릴 수 있는 point 만 저장. (ex; 사각형이면 4개 point) cv2.CHAIN_APPROX_TC89_L1 : contours point를 찾는 algorithm cv2.CHAIN_APPROX_TC89_KCOS : contours point를 찾는 algorithm

Returns:

image, contours , hierachy

Method에 대해서 설명을 하면 아래 예제의 결과에서 처럼 사각형의 contours line을 그릴 때, cv2.CHAIN_APPROX_NONE 는 모든 point를 저장하고 cv2.CHAIN_APPROX_SIMPLE 는 4개의 point만을 저장하여 메모리를 절약합니다.

>>> contours[0].shape #cv2.CHAIN_APPROX_SIMPLE(4 point)
(4, 1, 2)

>>> contours[0].shape #cv2.CHAIN_APPROX_NONE(750 point)
(750, 1, 2)

mode에 대해서는 Hierachy를 설명할 때 같이 설명하도록 하겠습니다.

cv2.drawContours(image, contours, contourIdx, color[, thickness[, lineType[, hierarchy[, maxLevel[, offset]]]]]) → dst

Parameters:	image – 원본 이미지 contours – contours정보. contourIdx – contours list type에서 몇번째 contours line을 그릴 것인지. -1 이면 전체 color – contours line color thickness – contours line의 두께. 음수이면 contours line의 내부를 채움.
Returns:	image에 contours가 그려진 결과

아래는 예제와 결과입니다.

Sample Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

#-*- coding:utf-8 -*-
import cv2
import numpy as np

img = cv2.imread('images/rectangle.jpg')
imgray = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)

#threshold를 이용하여 binary image로 변환
ret, thresh = cv2.threshold(imgray,127,255,0)

#contours는 point의 list형태. 예제에서는 사각형이 하나의 contours line을 구성하기 때문에 len(contours) = 1. 값은 사각형의 꼭지점 좌표.
#hierachy는 contours line의 계층 구조
image, contours, hierachy = cv2.findContours(thresh, cv2.RETR_TREE,cv2.CHAIN_APPROX_SIMPLE)
image = cv2.drawContours(img, contours, -1, (0,255,0), 3)

cv2.imshow('image', image)
cv2.waitKey(0)
cv2.destroyAllWindows()

Result

Goal¶

• Contours의 특징(영역, 중심점, bounding box 등)을 찾을 수 있습니다.
• Contours 특징을 찾는 다양한 함수에 대해서 알 수 있습니다.

Moments¶

Image Moment는 대상을 구분할 수 있는 특징을 의미합니다.. 특징으로는 Area, Perimeter, 중심점 등이 있습니다. Image Moments는 대상을 구분한 후, 다른 대상과 구분하기 위해 대상을 설명(describe)하는 자료로 사용됩니다.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

#-*- coding:utf-8 -*-
import cv2
import numpy as np

img = cv2.imread('images/rectangle.jpg')
imgray = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)
ret, thresh = cv2.threshold(imgray,127,255,0)

image, contours, hierachy = cv2.findContours(thresh, cv2.RETR_TREE,cv2.CHAIN_APPROX_SIMPLE)

# 첫번째 contours의 moment 특징 추출
cnt = contours[0]
M = cv2.moments(cnt)

print M.items()

>>> [('mu02', 35950058.66666663), ('mu03', 1.52587890625e-05), ('m11', 884446080.0), ('nu02', 0.03873697916666662), ('m12', 113614624853.33333), ('mu21', 1.9073486328125e-05), ('mu20', 166374058.6666665), ('nu20', 0.17927170868347322), ('m30', 570292325120.0), ('nu21', 1.1775050154231546e-16), ('mu11', 0.0), ('mu12', 3.814697265625e-06), ('nu11', 0.0), ('nu12', 2.3550100308463093e-17), ('m02', 463733162.6666666), ('m03', 63472543680.0), ('m00', 30464.0), ('m01', 3609984.0), ('mu30', 0.0001220703125), ('nu30', 7.53603209870819e-16), ('nu03', 9.420040123385237e-17), ('m10', 7463680.0), ('m20', 1994975658.6666665), ('m21', 236404615552.0)]

위 Dictionary Data에는 contours의 특징을 찾을 수 있는 기본 정보들이 있습니다(총 24개). 예를 들면 Contour의 중심값을 찾기 위해서는 아래 값을 사용하면 됩니다.

>>> cx = int(M['m10']/M['m00'])
>>> cy = int(M['m01']/M['m00'])

>>> cv2.contourArea(cnt)
30464.0

>>> cv2.arcLength(cnt, True)
750.0
>>> cv2.arcLength(cnt, False)
494.0

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

#-*- coding:utf-8 -*-
import cv2
import numpy as np
from matplotlib import pyplot as plt

img = cv2.imread('images/bad_rect.png')
img1 = img.copy()
img2 = img.copy()

imgray = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)
ret, thresh = cv2.threshold(imgray,127,255,0)

image, contours, hierachy = cv2.findContours(thresh, cv2.RETR_TREE,cv2.CHAIN_APPROX_SIMPLE)

cnt = contours[0]

# 적용하는 숫자가 커질 수록 Point의 갯수는 감소
epsilon1 = 0.01*cv2.arcLength(cnt, True)
epsilon2 = 0.1*cv2.arcLength(cnt, True)

approx1 = cv2.approxPolyDP(cnt, epsilon1, True)
approx2 = cv2.approxPolyDP(cnt, epsilon2, True)

cv2.drawContours(img, [cnt],0,(0,255,0),3) # 215개의 Point
cv2.drawContours(img1, [approx1], 0,(0,255,0), 3) # 21개의 Point
cv2.drawContours(img2, [approx2], 0,(0,255,0), 3) # 4개의 Point

titles = ['Original', '1%', '10%']
images = [img, img1, img2]

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

plt.show()