[v0.11]영상처리_이미지 연산 (합성, 알파 블렌딩, 마스킹)

220102 작성

<본 블로그는 귀퉁이 서재님의 블로그를 참고해서 공부하며 작성하였습니다>

https://bkshin.tistory.com/entry/OpenCV-9-%EC%9D%B4%EB%AF%B8%EC%A7%80-%EC%97%B0%EC%82%B0?category=1148027 

OpenCV - 9. 이미지 연산 (합성, 알파 블렌딩, 마스킹)

 

 

 

 

1. 이미지 연산

: 한 픽셀이 가질 수 있는 값의 범위는 0~255

 

cv2.add(src1, src2, dest, mask, dtype)

: src1과 src2 더하기

- src1 : 첫 번째 입력 이미지

- src2 : 두 번째 입력 이미지

- dest(optional) : 출력 영상

- mask(optional) : mask 값이 0이 아닌 픽셀만 연산

- dtype(optional) : 출력 데이터 타입(dtype)

 

cv2.subtract(src1, src2, dest, mask, dtype)

: src1에서 src2 빼기

- cv2.add()와 파라미터 동일

 

cv2.multiply(src1, src2, dest, scale, dtype)

: src1과 src2 곱하기

- scale(optional) : 연산 결과에 추가 연산할 값

 

cv2.divide(src1, src2, dest, scale, dtype)

: src1을 src2로 나누기

- cv2.multiply()와 파라미터 동일

# 이미지의 사칙 연산
import cv2
import numpy as np

# ---① 연산에 사용할 배열 생성
a = np.uint8([[200, 50]]) 
b = np.uint8([[100, 100]])

#---② NumPy 배열 직접 연산
add1 = a + b
sub1 = a - b
mult1 = a * 2
div1 = a / 3

# ---③ OpenCV API를 이용한 연산
add2 = cv2.add(a, b)
sub2 = cv2.subtract(a, b)
mult2 = cv2.multiply(a , 2)
div2 = cv2.divide(a, 3)

#---④ 각 연산 결과 출력
print("numpy-----OpenCV API")
print(add1, add2)
print(sub1, sub2)
print(mult1, mult2)
print(div1, div2)

numpy--------------OpenCV API
[[ 44 150]]             [[255 150]]
[[100 206]]             [[100   0]]
[[144 100]]             [[255 100]]
[[66.66666667 16.66666667]] [[67 17]]

 

1) numpy

add1 :

[ 200 + 100 = 300 -> 300 - 255 - 1 = 44 , 50 + 100 = 150]

unit8 타입의 값의 범위는 0 ~ 255이므로 255를 넘는 값은 다시 0부터 카운팅

sub1 : 

[ 200 - 100 = 100, 50 - 100 = -50 -> -50 + 255 + 1 = 206 ]

mult1 :

[ 200 * 2 = 400 -> 400 - 255 - 1 = 144, 50 * 2= 100 ]

div1 :

[ 200 / 3 = 66.666, 50 / 3 = 16.6666]

 

2) OpenCV API

add2 :

[ 200 + 100 = 300 -> 255 , 50 + 100 = 150 ]

cv2.add() 함수를 활용하면 255를 초과하는 모든 값은 255로 반환

sub2 : 

[ 200 - 100 = 100, 50 - 100 = -50 -> 0 ]

OpenCV에서는 0보다 작은 모든 값을 0으로 반환

mult2 :

[ 200 * 2 = 400 -> 255, 50 * 2= 100 ]

div2 :

[ 200 / 3 = 66.666 -> 67, 50 / 3 = 16.6666 -> 17]

곱하기와 나누기 연산도 255를 초과하거나 0보다 작은 값을 갖지 않고, 소수점은 갖지 않음

 

+) mask의 값

# mask와 누적 할당 연산
import cv2
import numpy as np

#---① 연산에 사용할 배열 생성
a = np.array([[1, 2]], dtype=np.uint8)
b = np.array([[10, 20]], dtype=np.uint8)
#---② 2번째 요소가 0인 마스크 배열 생성 
mask = np.array([[1, 0]], dtype=np.uint8)

#---③ 누적 할당과의 비교 연산
c1 = cv2.add(a, b, None, mask)
print(c1)
c2 = cv2.add(a, b, b.copy(), mask)
print(c2, b)
c3 = cv2.add(a, b, b, mask)
print(c3, b)

mask의 값

[[11  0]]
[[11 20]] [[10 20]]
[[11 20]] [[11 20]]

 

1) cv2.add(a, b, None, mask)

[ 1 + 10 = 11, 0]

배열이 [1, 0]인 mask를 지정 -> mask 값이 0이 아닌 위치에 있는 픽셀만 연산

 

2) cv2.add(a, b, b.copy(), mask)

[ 1 + 10 = 11, 0]    [ 10, 20 ]

 

3) cv2.add(a, b, b, mask)

[ 1 + 10 = 11, 0]    [ 11, 20 ]

a와 b의 첫 번째 요소만 더하여 b의 첫 번째 요소에 적용

 

 

 

2. 이미지 합성

: numpy의 합 연산을 수행하면 픽셀 값이 255가 넘는 경우 초과 값만을 가짐 -> 이미지가 검은색에 가깝게

: cv2.add() 연산을 하면 대부분의 픽셀 값이 255 가까이 몰리는 현상이 발생 -> 영상이 전체적으로 하얗게 

# 이미지 단순 합성

import cv2
import numpy as np
import matplotlib.pylab as plt

# ---① 연산에 사용할 이미지 읽기
img1 = cv2.imread('img/wing_wall.jpg')
img2 = cv2.imread('img/yate.jpg')

# ---② 이미지 덧셈
img3 = img1 + img2  # 더하기 연산
img4 = cv2.add(img1, img2) # OpenCV 함수

imgs = {'img1':img1, 'img2':img2, 'img1+img2': img3, 'cv.add(img1, img2)': img4}

# ---③ 이미지 출력
for i, (k, v) in enumerate(imgs.items()):
    plt.subplot(2,2, i + 1)
    plt.imshow(v[:,:,::-1])
    plt.title(k)
    plt.xticks([]); plt.yticks([])

plt.show()

numpy 와 opencv 의 이미지 합성

 

-> numpy 는 거뭇하게

-> openCV는 하얗게

 

+) 알파 블렌딩

: 두 이미지를 제대로 합성하려면 각각의 이미지에 가중치를 주고 합해야 한다

: 가중치를 조정할 수 있는데, 이 가중치를 알파(alpha) 값

: 새로운 이미지 알파(alpha)를 활용하여 합성 결과 픽셀 값 g(x)를 구하는 공식

가중치 alpha 공식

cv2.addWeight(img1, alpha, img2, beta, gamma)
- img1, img2 : 합성할 두 이미지
- alpha : img1에 지정할 가중치(알파 값)
- beta : img2에 지정할 가중치, 흔히 (1-alpha) 적용
- gamma : 연산 결과에 가감할 상수, 흔히 0 적용

# 알파 블렌딩
import cv2
import numpy as np

alpha = 0.5 # 합성에 사용할 알파 값

#---① 합성에 사용할 영상 읽기
img1 = cv2.imread('img/wing_wall.jpg')
img2 = cv2.imread('img/yate.jpg')

# ---② NumPy 배열에 수식을 직접 연산해서 알파 블렌딩 적용
blended = img1 * alpha + img2 * (1-alpha)
blended = blended.astype(np.uint8) # 소수점 발생을 제거하기 위함
cv2.imshow('img1 * alpha + img2 * (1-alpha)', blended)

# ---③ addWeighted() 함수로 알파 블렌딩 적용
dst = cv2.addWeighted(img1, alpha, img2, (1-alpha), 0) 
cv2.imshow('cv2.addWeighted', dst)

cv2.waitKey(0)
cv2.destroyAllWindows()

numpy와 cv2.addWeight 함수 활용한 이미지 합성

 

+) 트랙바이용

# 트랙바로 알파 블렌딩
import cv2
import numpy as np

win_name = 'Alpha blending'     # 창 이름
trackbar_name = 'fade'          # 트렉바 이름

# ---① 트렉바 이벤트 핸들러 함수
def onChange(x):
    alpha = x/100
    dst = cv2.addWeighted(img1, 1-alpha, img2, alpha, 0) 
    cv2.imshow(win_name, dst)


# ---② 합성 영상 읽기
img1 = cv2.imread('img/wing_wall.jpg')
img2 = cv2.imread('img/yate.jpg')

# ---③ 이미지 표시 및 트렉바 붙이기
cv2.imshow(win_name, img1)
cv2.createTrackbar(trackbar_name, win_name, 0, 100, onChange)

cv2.waitKey()
cv2.destroyAllWindows()

트랙바를 이용해 alpha 값 자유롭게 활용하기

 

 

 

 

3. 비트와이즈 연산

: 두 이미지를 합성할 때 특정 영역만 선택하거나 특정 영역만 제외하는 등의 선별적인 연산

 

cv2.bitwise_and(img1, img2, mask=None)

: 각 픽셀에 대해 AND 연산

 

cv2.bitwise_or(img1, img2, mask=None)

: 각 픽셀에 대해 OR 연산

 

cv2.bitwise_xor(img1, img2, mask=None)

: 각 픽셀에 대해 XOR 연산

 

cv2.bitwise_not(img1, img2, mask=None)

: 각 픽셀에 대해 NOT 연산

- img1, img2는 연산을 할 이미지

- 두 이미지는 동일한 shape를 가지기

- mask는 0이 아닌 픽셀만 연산

출처 :&nbsp;https://antakkaum.tistory.com/593

# 비트와이즈 연산
import numpy as np, cv2
import matplotlib.pylab as plt

#--① 연산에 사용할 이미지 생성
img1 = np.zeros( ( 200,400), dtype=np.uint8)
img2 = np.zeros( ( 200,400), dtype=np.uint8)
img1[:, :200] = 255         # 왼쪽은 흰색(255), 오른쪽은 검정색(0)
img2[100:200, :] = 255      # 위쪽은 검정색(0), 아래쪽은 흰색(255)

#--② 비트와이즈 연산
bitAnd = cv2.bitwise_and(img1, img2)
bitOr = cv2.bitwise_or(img1, img2)
bitXor = cv2.bitwise_xor(img1, img2)
bitNot = cv2.bitwise_not(img1)

#--③ Plot으로 결과 출력
imgs = {'img1':img1, 'img2':img2, 'and':bitAnd, 
          'or':bitOr, 'xor':bitXor, 'not(img1)':bitNot}
for i, (title, img) in enumerate(imgs.items()):
    plt.subplot(3,2,i+1)
    plt.title(title)
    plt.imshow(img, 'gray')
    plt.xticks([]); plt.yticks([])

plt.show()

비트 연산자

 

1) and

: 1 + 0 = 0    : 1 + 0 = 0

: 1 + 1 = 1    : 1 + 0 = 0

 

2) or

: 1 + 0 = 1    : 0 + 0 = 0

: 1 + 1 = 1    : 0 + 1 = 1

 

3) xor

: 1 + 0 = 1    : 0 + 0 = 0

: 1 + 1 = 0    : 0 + 1 = 1

 

4) not (img1)

: img1과 반대로

 

 

+) bitwize로 원하는 부분만 떼기

# bitwise_and 연산으로 마스킹하기

import numpy as np, cv2
import matplotlib.pylab as plt

#--① 이미지 읽기
img = cv2.imread('img/lena.png')

#--② 마스크 만들기
mask = np.zeros_like(img)
cv2.circle(mask, (260,210), 100, (255,255,255), -1)
#cv2.circle(대상이미지, (원점x, 원점y), 반지름, (색상), 채우기)

#--③ 마스킹
masked = cv2.bitwise_and(img, mask)

#--④ 결과 출력
cv2.imshow('original', img)
cv2.imshow('mask', mask)
cv2.imshow('masked', masked)
cv2.waitKey()
cv2.destroyAllWindows()

bitwise_and 한 이미지

-> AND 연산은 True(0이 아닌 값)와 True(0이 아닌 값)가 합해진 부분만 True가 출력

 

 

 

 

4. 두 이미지의 차이

diff = cv2.absdiff(img1, img2)
- img1, img2 : 입력 이미지
- diff : 두 이미지의 차의 절대 값

# 두 이미지의 차를 통해 도면의 차이 찾아내기
import numpy as np, cv2

#--① 연산에 필요한 영상을 읽고 그레이스케일로 변환
img1 = cv2.imread('img/robot_arm1.jpg')
img2 = cv2.imread('img/robot_arm0.jpg')
img1_gray = cv2.cvtColor(img1, cv2.COLOR_BGR2GRAY)
img2_gray = cv2.cvtColor(img2, cv2.COLOR_BGR2GRAY)

#--② 두 영상의 절대값 차 연산
diff = cv2.absdiff(img1_gray, img2_gray)

#--③ 차 영상을 극대화 하기 위해 쓰레시홀드 처리 및 컬러로 변환
_, diff = cv2.threshold(diff, 1, 255, cv2.THRESH_BINARY)
diff_red = cv2.cvtColor(diff, cv2.COLOR_GRAY2BGR)
diff_red[:,:,2] = 0

#--④ 두 번째 이미지에 변화 부분 표시
spot = cv2.bitwise_xor(img2, diff_red)

#--⑤ 결과 영상 출력
cv2.imshow('img1', img1)
cv2.imshow('img2', img2)
cv2.imshow('diff', diff)
cv2.imshow('spot', spot)
cv2.waitKey()
cv2.destroyAllWindows()

두 이미지의 차이 찾아내기

- 회색조로 변환된 두 이미지의 차이 구하기

- 차이를 뚜렷하게 하기 위해 cv2.threshold() 사용하여 1보다 큰 값은 255로, 그렇지 않은 경우 0으로 바꾸기

- 색상 표현하기 위해 cv2.cvtColor() 사용하여 색상 스케일의 차원 변경 후 빨간색으로 변경

- cv2.bitwise_xor() 으로 차이 있는 곳이 빨간 영역으로 표시

 

 

 

5. 이미지 합성과 마스킹

: 두 이미지를 합성 -> 일반적으로 하나의 이미지는 배경과 전경(배경이 아닌 실제 이미지)

: BGRA 색상 형식으로 표현할 때,

배경은 A(알파, alpha)가 0이고, 전경은 A가 255 ( A가 0이면 투명하고, 255면 불투명 )

# 투명 배경 PNG 파일을 이용한 합성

import cv2
import numpy as np

#--① 합성에 사용할 영상 읽기, 전경 영상은 4채널 png 파일
img_fg = cv2.imread('img/opencv_logo.png', cv2.IMREAD_UNCHANGED)
img_bg = cv2.imread('img/clover.jpg')

#--② 알파채널을 이용해서 마스크와 역마스크 생성
_, mask = cv2.threshold(img_fg[:,:,3], 1, 255, cv2.THRESH_BINARY)
mask_inv = cv2.bitwise_not(mask)

#--③ 전경 영상 크기로 배경 영상에서 ROI 잘라내기
img_fg = cv2.cvtColor(img_fg, cv2.COLOR_BGRA2BGR)
h, w = img_fg.shape[:2]
roi = img_bg[10:10+h, 10:10+w ]

#--④ 마스크 이용해서 오려내기
masked_fg = cv2.bitwise_and(img_fg, img_fg, mask=mask)
masked_bg = cv2.bitwise_and(roi, roi, mask=mask_inv)

#--⑥ 이미지 합성
added = masked_fg + masked_bg
img_bg[10:10+h, 10:10+w] = added

cv2.imshow('mask', mask)
cv2.imshow('mask_inv', mask_inv)
cv2.imshow('masked_fg', masked_fg)
cv2.imshow('masked_bg', masked_bg)
cv2.imshow('added', added)
cv2.imshow('result', img_bg)
cv2.waitKey()
cv2.destroyAllWindows()

이미지 합성!

- _, mask = cv2.threshod(img_fg[:, :, 3], 1, 255, cv2.THRESH_BINARY)를 호출하여 배경과 전경을 분리하는 마스크

- mask_inv = cv2.bitwise_not(mask)이므로 mask_inv는 mask의 반대 (즉, 배경은 흰색, 전경은 검은색)

 

 

 

+) 색상 별로 추출

cv2.inRange(hsv, lower, upper)

: hsv의 모든 값 중 lower와 upper 범위 사이에 있는 값은 255, 나머지 값은 0으로 변환

# HSV 색상으로 마스킹

import cv2
import numpy as np
import matplotlib.pylab as plt

#--① 큐브 영상 읽어서 HSV로 변환
img = cv2.imread("img/cube.JPG")
hsv = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)

#--② 색상별 영역 지정
blue1 = np.array([90, 50, 50])
blue2 = np.array([120, 255,255])
green1 = np.array([45, 50,50])
green2 = np.array([75, 255,255])
red1 = np.array([0, 50,50])
red2 = np.array([15, 255,255])
red3 = np.array([165, 50,50])
red4 = np.array([180, 255,255])
yellow1 = np.array([20, 50,50])
yellow2 = np.array([35, 255,255])

# --③ 색상에 따른 마스크 생성
mask_blue = cv2.inRange(hsv, blue1, blue2)
mask_green = cv2.inRange(hsv, green1, green2)
mask_red = cv2.inRange(hsv, red1, red2)
mask_red2 = cv2.inRange(hsv, red3, red4)
mask_yellow = cv2.inRange(hsv, yellow1, yellow2)

#--④ 색상별 마스크로 색상만 추출
res_blue = cv2.bitwise_and(img, img, mask=mask_blue)
res_green = cv2.bitwise_and(img, img, mask=mask_green)
res_red1 = cv2.bitwise_and(img, img, mask=mask_red)
res_red2 = cv2.bitwise_and(img, img, mask=mask_red2)
res_red = cv2.bitwise_or(res_red1, res_red2)
res_yellow = cv2.bitwise_and(img, img, mask=mask_yellow)

#--⑤ 결과 출력
imgs = {'original': img, 'blue':res_blue, 'green':res_green, 
                            'red':res_red, 'yellow':res_yellow}
for i, (k, v) in enumerate(imgs.items()):
    plt.subplot(2,3, i+1)
    plt.title(k)
    plt.imshow(v[:,:,::-1])
    plt.xticks([]); plt.yticks([])
plt.show()

색상별 이미지

흠 왜 초록이 안되는거징

 

 

 

 

+) 색상을 이용한 마스킹 방식을 크로마키(chroma key)

# 크로마키 마스킹과 합성

import cv2
import numpy as np
import matplotlib.pylab as plt

#--① 크로마키 배경 영상과 합성할 배경 영상 읽기
img1 = cv2.imread('img/sample.jpeg')
img2 = cv2.imread('img/wing_wall.jpg')

#--② ROI 선택을 위한 좌표 계산
height1, width1 = img1.shape[:2]
height2, width2 = img2.shape[:2]
x = (width2 - width1)//2
y = height2 - height1
w = x + width1
h = y + height1

#--③ 크로마키 배경 영상에서 크로마키 영역을 10픽셀 정도로 지정
chromakey = img1[:10, :10, :]
offset = 20

#--④ 크로마키 영역과 영상 전체를 HSV로 변경
hsv_chroma = cv2.cvtColor(chromakey, cv2.COLOR_BGR2HSV)
hsv_img = cv2.cvtColor(img1, cv2.COLOR_BGR2HSV)

#--⑤ 크로마키 영역의 H값에서 offset 만큼 여유를 두어서 범위 지정
# offset 값은 여러차례 시도 후 결정
#chroma_h = hsv_chroma[0]
chroma_h = hsv_chroma[:,:,0]
lower = np.array([chroma_h.min()-offset, 100, 100])
upper = np.array([chroma_h.max()+offset, 255, 255])

#--⑥ 마스크 생성 및 마스킹 후 합성
mask = cv2.inRange(hsv_img, lower, upper)
mask_inv = cv2.bitwise_not(mask)
roi = img2[y:h, x:w]
fg = cv2.bitwise_and(img1, img1, mask=mask_inv)
bg = cv2.bitwise_and(roi, roi, mask=mask)
img2[y:h, x:w] = fg + bg

#--⑦ 결과 출력
cv2.imshow('chromakey', img1)
cv2.imshow('added', img2)
cv2.waitKey()
cv2.destroyAllWindows()

나중에 적절한 색상 선택으로 다시 도전..!

 

 

 

 

+)  cv2.seamlessClone() 함수 이미지 합성!

dst = cv2.seamlessClone(src, dst, mask, coords, flags, output)

: 알파 값이나 마스크를 신경 쓰지 않아도됨

: mask는 img1의 전체 영역을 255로 채워서 해당 영역 전부가 합성의 대상임을 표현

- src : 입력 이미지, 일반적으로 전경
- dst : 대상 이미지, 일반적으로 배경
- mask : 마스크, src에서 합성하고자 하는 영역은 255, 나머지는 0
- coords : src가 놓이기 원하는 dst의 좌표 (중앙)
- flags : 합성 방식

• 입력 원본을 유지하는 cv2.NORMAL_CLONE
• 입력과 대상을 혼합하는 cv2.MIXED_CLONE

- output(optional) : 합성 결과

# SeamlessClone을 활용한 이미지 합성
import cv2
import numpy as np
import matplotlib.pylab as plt
 
#--① 합성 대상 영상 읽기
img1 = cv2.imread("img/flower1.jpg")
img2= cv2.imread("img/hand.jpg")

#--② 마스크 생성, 합성할 이미지 전체 영역을 255로 셋팅
mask = np.full_like(img1, 255)
 
#--③ 합성 대상 좌표 계산(img2의 중앙)
height, width = img2.shape[:2]
center = (width//2, height//2)
 
#--④ seamlessClone 으로 합성 
normal = cv2.seamlessClone(img1, img2, mask, center, cv2.NORMAL_CLONE)
mixed = cv2.seamlessClone(img1, img2, mask, center, cv2.MIXED_CLONE)

#--⑤ 결과 출력
cv2.imshow('normal', normal)
cv2.imshow('mixed', mixed)
cv2.waitKey()
cv2.destroyAllWindows()

cv2.seamlessClone() 활용 이미지

-> 왼쪽 cv2.NORMAL_CLONE 일 때는 꽃은 선명하지만 주변의 피부가 다소 뭉개짐

-> 오른쪽 cv2.MIXED_CLONE 일 때는 꽃은 다소 흐리지만 주변 피부와 잘 매칭이 되게 합성

 

 

 

 

 

 

후. .길었따