Jinho Tech

꽤 전에 완성을 했었는데 블로그에 올린다는 것을 완전히 까먹고 있었다.

전에 얼굴 탐지 및 전처리, 데이터 크롤링 등등의 글들을 올렸었는데, 

그 이후 조금의 삽질 과정이 있었고 결국 완성했다. 

얼굴 인식도 잘 되고 모자이크 처리도 잘 된다. 하지만...

컴퓨터 성능이 안 좋아서 그런지, 랜드마크를 추출하는데 시간이 오래 걸려서 그런지

프레임이 매우 매우 낮다. 이 문제가 나중에 해결된다면 업데이트하겠다.

얼굴 인식은 아래와 같이 진행된다.  

1. 데이터베이스에 인식하고 싶은 사람의 얼굴 랜드마크를 저장.

2. 실시간으로 사람 얼굴을 탐지하고 그 얼굴의 랜드마크를 추출.

3. 데이터베이스에 있는 랜드마크와 새로 추출된 랜드마크의 거리를 측정.

4. 제일 짧은 거리가 0.45 이하라면 그 사람으로 인식, 아니라면 모르는 사람이라고 인식.

5. 인식된 사람이라면 그대로 내버려 두고, 모르는 사람이라면 모자이크 처리를 함.

아래는 그 코드이다.

사용한 라이브러리)

# 라이브러리
import dlib, cv2
import numpy as np
import matplotlib.pyplot as plt
from PIL import ImageFont, ImageDraw, Image
import tensorflow.keras 
from tensorflow.keras import backend as K

detector = dlib.get_frontal_face_detector()
sp = dlib.shape_predictor('models/shape_predictor_68_face_landmarks.dat')
facerec = dlib.face_recognition_model_v1('models/dlib_face_recognition_resnet_model_v1.dat')

함수들)

# 얼굴 탐지
def find_faces(img):
    dets = detector(img, 1)
    
    if len(dets) == 0:
        return np.empty(0), np.empty(0), np.empty(0)
    
    rects, shapes = [], []
    shapes_np = np.zeros((len(dets), 68, 2), dtype=np.int)
    for k, d in enumerate(dets):
        rect = ((d.left(), d.top()), (d.right(), d.bottom()))
        rects.append(rect)

        shape = sp(img, d)
        
        # convert dlib shape to numpy array
        for i in range(0, 68):
            shapes_np[k][i] = (shape.part(i).x, shape.part(i).y)

        shapes.append(shape)
        
    return rects, shapes, shapes_np

# 랜드마크 추출
def encode_faces(img, shapes):
    face_descriptors = []
    for shape in shapes:
        face_descriptor = facerec.compute_face_descriptor(img, shape)
        face_descriptors.append(np.array(face_descriptor))

    return np.array(face_descriptors)

데이터베이스 생성)

# 인식하고 싶은 사람들 이미지 지정
# 여기는 사용자가 원하는 대로 바꾸면 된다. 
img_paths = {
     '진호': 'user_img/jinho.jpg',
     '태호': 'user_img/taeho.jpg',
     '아이린': 'user_img/irene.jpg',
     '조이': 'user_img/joy.jpeg',
     '창모': 'user_img/changmo.jpg',
     '홍철': 'user_img/hongchul.jpg',
     '명수': 'user_img/myungsoo.jpg'
}

# 인식하고 싶은 사람들의 얼굴 랜드마크 추출후 저장
descs = []

for name, img_path in img_paths.items(): 
    img = cv2.imread(img_path)
    _, img_shapes, _ = find_faces(img)
    descs.append([name, encode_faces(img, img_shapes)[0]])
    
np.save('user_img/descs.npy', descs)
print(descs)

실시간 얼굴 인식과 모자이크 처리)

cam = cv2.VideoCapture(0) # 노트북 웹캠 사용
cam.set(3, 640) # 너비
cam.set(4, 480) # 높이
font = cv2.FONT_HERSHEY_SIMPLEX # 폰트

while True:
    
    ret, img = cam.read() 
    img = cv2.flip(img, 1) # 좌우 대칭
#    img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
    rects, shapes, _ = find_faces(img) # 얼굴 찾기
    descriptors = encode_faces(img, shapes) # 인코딩
    
    for i, desc in enumerate(descriptors):
        x = rects[i][0][0] # 얼굴 X 좌표
        y = rects[i][0][1] # 얼굴 Y 좌표
        w = rects[i][1][1]-rects[i][0][1] # 얼굴 너비 
        h = rects[i][1][0]-rects[i][0][0] # 얼굴 높이
        
        # 추출된 랜드마크와 데이터베이스의 랜드마크들 중 제일 짧은 거리를 찾는 부분
        descs1 = sorted(descs, key=lambda x: np.linalg.norm([desc] - x[1]))
        dist = np.linalg.norm([desc] - descs1[0][1], axis=1)
        
        if dist < 0.45: # 그 거리가 0.45보다 작다면 그 사람으로 판단 
            name = descs1[0][0]
        else:           # 0.45보다 크다면 모르는 사람으로 판단 -> 모자이크 처리
            name = "누구?"
            mosaic_img = cv2.resize(img[y:y+h, x:x+w], dsize=(0, 0), fx=0.04, fy=0.04) # 축소
            mosaic_img = cv2.resize(mosaic_img, (w, h), interpolation=cv2.INTER_AREA)  # 확대
            img[y:y+h, x:x+w] = mosaic_img # 인식된 얼굴 영역 모자이크 처리 

        cv2.rectangle(img, (x, y), (x+w, y+h), (0,255,0), 2) # 얼굴 영역 박스 
        cv2.putText(img, str(dist)[1:6], (x+5,y+h-5), font, 2, (0,0,255), 4) # 사진에 거리 출력

#     영어
#     cv2.putText(img, name, (x+5,y-5), font, 2, (255,255,255), 4)

#     한글
    img = Image.fromarray(img)
    draw = ImageDraw.Draw(img)
    draw.text((x+5,y-50), name, font=ImageFont.truetype("./batang.ttc", 60), fill=(255,255,255))
    img = np.array(img)
        
    cv2.imshow('camera', img)
    
    k = cv2.waitKey(10) & 0xff # 'ESC' 키 누르면 종료
    if k == 27:
        break
        
cam.release()
cv2.destroyAllWindows()

실시간 X 그냥 얼굴 인식과 모자이크 처리)

img = cv2.imread('test_img/inf.jpg')

rects, shapes, _ = find_faces(img) # 얼굴 찾기
descriptors = encode_faces(img, shapes) # 인코딩

for i, desc in enumerate(descriptors):
    x = rects[i][0][0] # 얼굴 X 좌표
    y = rects[i][0][1] # 얼굴 Y 좌표
    w = rects[i][1][1]-rects[i][0][1] # 얼굴 너비 
    h = rects[i][1][0]-rects[i][0][0] # 얼굴 높이        
        
    # 추출된 랜드마크와 데이터베이스의 랜드마크들 중 제일 짧은 거리를 찾는 부분
    descs1 = sorted(descs, key=lambda x: np.linalg.norm([desc] - x[1]))
    dist = np.linalg.norm([desc] - descs1[0][1], axis=1)

    if dist < 0.45: # 그 거리가 0.45보다 작다면 그 사람으로 판단 
        name = descs1[0][0]
    else:           # 0.45보다 크다면 모르는 사람으로 판단 -> 모자이크 처리
        name = "누구?"
        mosaic_img = cv2.resize(img[y:y+h, x:x+w], dsize=(0, 0), fx=0.04, fy=0.04) # 축소
        mosaic_img = cv2.resize(mosaic_img, (w, h), interpolation=cv2.INTER_AREA) # 확대
        img[y:y+h, x:x+w] = mosaic_img # 인식된 얼굴 영역 모자이크 처리
        
    cv2.rectangle(img, (x, y), (x+w, y+h), (0,255,0), 2) # 얼굴 영역 박스 
    cv2.putText(img, str(dist)[1:6], (x+5,y+h+10), font, 1, (0,0,255), 4) # 사진에 거리 출력
    
#     영어
#     cv2.putText(img, name, (x+5,y-5), font, 2, (255,255,255), 4)

#     한글
    img = Image.fromarray(img)
    draw = ImageDraw.Draw(img)
    draw.text((x+5,y-30), name, font=ImageFont.truetype("./batang.ttc", 30), fill=(255,255,255))
    img = np.array(img)

img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)        
plt.imshow(img)

일단 모델 파일 3개를 아래 주소를 통해 다운로드해야 된다.

github.com/davisking/dlib-models/raw/master/shape_predictor_68_face_landmarks.dat.bz2

github.com/kairess/simple_face_recognition/raw/master/models/dlib_face_recognition_resnet_model_v1.dat

github.com/kimjinho1/Real-time-face-recognition-and-mosaic-using-deep-learning/raw/master/models/dlib_face_recognition_resnet_model_v1.dat

그리고 데이터베이스 생성 부분에서 본인의 파일 상황에 맞게 img_paths 안에 이름과 파일 경로를 바꿔줄 필요가 있다. 

결과 사진)

데이터베이스에 박명수, 노홍철, 창모, 조이 등등의 사진이 있었는데 딱 지정된 사람의 얼굴만 인식하고

다른 사람들의 얼굴은 모드 모자이크 처리한 것을 볼 수 있다.

github: https://github.com/kimjinho1/Real-time-face-recognition-and-mosaic-using-deep-learning/blob/master/real-time_face_recognition_and_mosaic.ipynb

이걸 맨 처음에 올렸어야 했는데 나중에 생각나서 뒤늦게 올리게 되었다.

import numpy as np
import cv2

cap = cv2.VideoCapture(0) # 노트북 웹캠을 카메라로 사용
cap.set(3,640) # 너비
cap.set(4,480) # 높이

ret, frame = cap.read() # 사진 촬영
frame = cv2.flip(frame, 1) # 좌우 대칭

cv2.imwrite('self camera test.jpg', frame) # 사진 저장
    
cap.release()
cv2.destroyAllWindows()

위의 코드를 실행하면 self camera test.jpg라는 파일이 저장된다.

파일을 열어보면 아래와 같이 정상적으로 셀카가 찍히는 것을 확인할 수 있다. 

내 얼굴 데이터를 모으려면 핸드폰으로 직접 사진을 찍어야 되는데 그게 너무 귀찮을 것 같아서 만들게 되었다.

github: https://github.com/kimjinho1/Real-time-face-recognition-and-mosaic-using-deep-learning/blob/master/0.%20opencv_self_camera.ipynb

저번에는 실시간으로 얼굴 탐지를 하고 탐지된 얼굴들을 모두 모자이크 처리했었다.

이번에는 럭키짱의 강건마 이미지를 사용해 모자이크 처리를 해볼 것이다.

전에 했던 내용은 설명하지 않을 것이니 이해가 안 되는 사람은 이전 글을 참고하도록 하자!

3.1 OpenCV를 이용한 실시간 얼굴 모자이크 처리: https://jinho-study.tistory.com/231

아래는 전체 코드를 정리한 코드이다.

import numpy as np
import cv2

xml = 'haarcascades/haarcascade_frontalface_default.xml'
face_cascade = cv2.CascadeClassifier(xml)

mosaic_img = cv2.imread('image/mosaic.png') # 럭키짱의 강건마 이미지를 저장

cap = cv2.VideoCapture(0) # 노트북 웹캠을 카메라로 사용
cap.set(3,640) # 너비
cap.set(4,480) # 높이

while(True):
    ret, frame = cap.read() 
    frame = cv2.flip(frame, 1) # 좌우 대칭
    gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)

    faces = face_cascade.detectMultiScale(gray,1.05,5)
    print("Number of faces detected: " + str(len(faces)))

    if len(faces):
        for (x,y,w,h) in faces:
            """ 탐지된 얼굴 영역을 강건마 이미지로 바꾸는 코드"""
            # 탐지된 얼굴 영역에 맞도록 강건마 이미지의 높이와 너비를 바꿔줌.
            t = cv2.resize(mosaic_img, dsize=(h, w), interpolation=cv2.cv2.INTER_LINEAR)
            frame[y:y+h, x:x+w] = t # 탐지된 얼굴 영역을 강건마 이미지로 모자이크 처리

            """ 사람의 어깨선과 머리선이 강건마 이미지와 딱 맞게 이어지도록 구현한 코드
                문제는 나한테만 딱 맞는다... """
#             wi, hi = int(w*0.08/2), int(h*0.23/2)
#             t = cv2.resize(mosaic_img, dsize=(w+wi*2, h+hi*2), interpolation=cv2.cv2.INTER_LINEAR)
#             frame[y-hi:y+h+hi, x-wi:x+w+wi] = t

    cv2.imshow('result', frame)
        
    k = cv2.waitKey(30) & 0xff
    if k == 27: # Esc 키를 누르면 종료
        break

cap.release()
cv2.destroyAllWindows()

모자이크 처리하는 기능을 조금 다르게 2개를 구현했는데 위는 탐지된 얼굴 영역을 강건마 이미지로 바꿔주고,

아래는 사람의 어깨선과 머리선이 강건마 이미지와 딱 맞게 이어지도록 강건만 이미지의 크기를 바꿔줬다.

근데 문제는 나한테만 딱 맞는다...

위의 코드를 실행하면 아래와 같이 실시간으로 탐지된 얼굴이 강건마로 잘 바뀌고 있는 것을 확인할 수 있다. 

내 얼굴 기준으로는 말 그대로 기적의 비율을 보여준다.

여러 명 있어도 아주 잘 된다.

github: https://github.com/kimjinho1/Real-time-specific-object-mosaic-using-deep-learning/blob/master/3.2%20Real-time_face_mosaic_with_lucky-jjang.ipynb

저번에는 실시간 얼굴 탐지를 했었다. 이번에는 실시간으로 얼굴 탐지를 하고 탐지된 모든 얼굴 영역을

각각 탐지된 얼굴 이미지를 축소-확대한 이미지로 대체하는 방식으로 모자이크 처리를 해볼 것이다.  

전에 했던 내용은 설명하지 않을 것이니 이해가 안 되는 사람은 이전 글을 참고하도록 하자!

2. OpenCV를 이용한 실시간 얼굴 탐지: https://jinho-study.tistory.com/230

아래는 전체 코드를 정리한 코드이다.

import numpy as np
import cv2

xml = 'haarcascades/haarcascade_frontalface_default.xml'
face_cascade = cv2.CascadeClassifier(xml)

cap = cv2.VideoCapture(0) # 노트북 웹캠을 카메라로 사용
cap.set(3,640) # 너비
cap.set(4,480) # 높이

while(True):
    ret, frame = cap.read() 
    frame = cv2.flip(frame, 1) # 좌우 대칭
    gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)

    faces = face_cascade.detectMultiScale(gray,1.05,5) 
    print("Number of faces detected: " + str(len(faces)))

    if len(faces):
        for (x,y,w,h) in faces:
            face_img = frame[y:y+h, x:x+w] # 탐지된 얼굴 이미지 crop
            face_img = cv2.resize(face_img, dsize=(0, 0), fx=0.04, fy=0.04) # 축소
            face_img = cv2.resize(face_img, (w, h), interpolation=cv2.INTER_AREA) # 확대
            frame[y:y+h, x:x+w] = face_img # 탐지된 얼굴 영역 모자이크 처리

    cv2.imshow('result', frame)
        
    k = cv2.waitKey(30) & 0xff
    if k == 27: # Esc 키를 누르면 종료
        break

cap.release()
cv2.destroyAllWindows()

얼굴 영역에 박스를 치는 코드가 빠졌고, 모자이크 처리를 해주는 코드 4줄이 추가되었다. 

face_img = frame[y:y+h, x:x+w]  -> 탐지된 얼굴 영역의 이미지를 face_img에 저장

face_img = cv2.resize(face_img, dsize=(0, 0), fx=0.04, fy=0.04) -> face_img의 높이와 너비를 0.04배 해줌

face_img = cv2.resize(face_img, (w, h), interpolation=cv2.INTER_AREA) -> face_img를 원래 비율로 되돌려준다. 이 과정에서 이미지가 깨짐

frame[y:y+h, x:x+w] = face_img -> 탐지된 얼굴 영역을 face_img로 바꿔줌

위의 코드를 실행하면 아래와 같이 실시간으로 탐지된 얼굴이 잘 모자이크 되고 있는 것을 확인할 수 있다. 

github: https://github.com/kimjinho1/Real-time-specific-object-mosaic-using-deep-learning/blob/master/3.1%20Real-time_face_mosaic.ipynb

저번에는 단순히 이미지로 얼굴을 탐지했었다. 이번에는 노트북 웹캠을 통해 실시간으로 얼굴 탐지를 해볼 것이다. 

전에 했던 내용은 설명하지 않을 것이니 이해가 안 되는 사람은 이전 글을 참고하도록 하자!

1. OpenCV를 이용한 얼굴 탐지: https://jinho-study.tistory.com/229?category=926937

아래는 전체 코드를 정리한 코드이다.

import numpy as np
import cv2

xml = 'haarcascades/haarcascade_frontalface_default.xml'
face_cascade = cv2.CascadeClassifier(xml)

cap = cv2.VideoCapture(0) # 노트북 웹캠을 카메라로 사용
cap.set(3,640) # 너비
cap.set(4,480) # 높이

while(True):
    ret, frame = cap.read()
    frame = cv2.flip(frame, 1) # 좌우 대칭
    gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)

    faces = face_cascade.detectMultiScale(gray,1.05, 5)
    print("Number of faces detected: " + str(len(faces)))

    if len(faces):
        for (x,y,w,h) in faces:
            cv2.rectangle(frame,(x,y),(x+w,y+h),(255,0,0),2)
        
    cv2.imshow('result', frame)
    
    k = cv2.waitKey(30) & 0xff
    if k == 27: # Esc 키를 누르면 종료
        break

cap.release()
cv2.destroyAllWindows()

얼굴 탐지하는 부분은 전과 똑같고, 추가된 부분은 cv2.VideoCapture, cap.set, cv2.flip, while 문과 break이다.

cv2.VideoCapture는 비디오 캡처 객체를 생성해 주는데, 안의 숫자는 장치 인덱스(어떤 카메라를 사용할 것인가)이다. 1개만 부착되어 있으면 0, 2개 이상이면 첫 번째 웹캠은 0, 두 번째 웹캠은 1로 지정하면 된다. 난 노트북 웹캠을 사용할 것이기 때문에 그냥 0이면 된다.

cap.set은 프레임의 크기를 설정해준다.

cv2.flip은 이미지를 좌우, 상하 대칭을 해준다. 안에 인자가 1이면 좌우, 2이면 상하 대칭이다. cv2.flip은 필수는 아니다.

위의 코드를 실행하면 아래와 같이 실시간으로 얼굴 탐지를 할 수 있다. Esc키를 누르면 종료된다.

github: https://github.com/kimjinho1/Real-time-specific-object-mosaic-using-deep-learning/blob/master/2.%20Real-time_face_detection.ipynb

요즘 실시간 특정 객체 모자이크 프로그램을 구현해보고 있는데, 관련 내용들과 코드를 하나씩 천천히 올리게 될 것 같다.

맨 첫 번째 과정은 얼굴 탐지이다. 얼굴 탐지를 하기 위해선 opencv에 있는 haarcascades 파일이 필요한데

아래 github에서 다운로드 가능하다.

https://github.com/opencv/opencv/tree/master/data/haarcascades

필요한 라이브러리: Numpy, OpenCV, matplotlib

우선 라이브러리를 import 한다. matplotlib은 이미지 확인용이라 필수는 아닙니다!

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

그다음은 얼굴 탐지를 할 이미지를 불러온다. 저는 기생충의 기정, 기우의 이미지를 사용했습니다. 

image = cv2.imread('image/bong.png')
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

plt.imshow(gray, cmap='gray')
plt.xticks([]), plt.yticks([])
plt.show()

위의 코드를 실행하면 아래와 같이 이미지를 무사히 불러온 것을 확인할 수 있다.

그다음은 haarcascades 파일을 사용해서 얼굴 탐지를 해보자.

haarcascades 파일에는 다양한 xml 파일이 들어 있는데 이것들을 사용해서 사람의 얼굴, 눈, 전신 등등을 탐지할 수 있다.

우리의 목표는 얼굴 탐지이므로 haarcascade_frontalface_default.xml 파일을 사용하도록 하자.

xml = 'haarcascades/haarcascade_frontalface_default.xml'
face_cascade = cv2.CascadeClassifier(xml)
faces = face_cascade.detectMultiScale(gray, 1.2, 5)

print("Number of faces detected: " + str(len(faces)))

위의 코드를 실행하면 아래와 같이 사람 얼굴 2개를 탐지했음을 확인할 수 있다.

현재 faces 변수 안에는 아래와 같이 x, y축 좌표값과 얼굴의 높이와 너비인 w, h 값이 리스트 형태로 들어있다. 

마지막으로 이상한 곳을 얼굴로 탐지하지 않고 정확하게 탐지했는지 확인을 해보자. 

cv2.rectangle과 faces에 들어있는 x, y, w, h 값을 통해 이미지에 박스를 치는 방식으로 확인을 한다.

if len(faces):
    for (x,y,w,h) in faces:
        cv2.rectangle(image,(x,y),(x+w,y+h),(255,0,0),2)

plt.imshow(cv2.cvtColor(image, cv2.COLOR_BGR2RGB), cmap='gray')
plt.xticks([]), plt.yticks([]) 
plt.show()

위의 코드를 실행하면 아래와 같이 기정과 기우의 얼굴을 정확하게 탐지했음을 확인할 수 있다.

아래는 전체 코드를 정리한 코드이다. 이 코드를 보면 얼굴 탐지가 정말 짧은 코드로 가능하다는 것을 알 수 있다.

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

image = cv2.imread('image/bong.png')
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

xml = 'haarcascades/haarcascade_frontalface_default.xml'
face_cascade = cv2.CascadeClassifier(xml)
faces = face_cascade.detectMultiScale(gray, 1.2, 5)

print("Number of faces detected: " + str(len(faces)))

if len(faces):
    for (x,y,w,h) in faces:
        cv2.rectangle(image,(x,y),(x+w,y+h),(255,0,0),2)

plt.imshow(cv2.cvtColor(image, cv2.COLOR_BGR2RGB), cmap='gray')
plt.xticks([]), plt.yticks([]) 
plt.show()

github: https://github.com/kimjinho1/Real-time-specific-object-mosaic-using-deep-learning/blob/master/1.%20Face_detection.ipynb