🎯 프로젝트 목표

웹캠이나 이미지에서 얼굴을 감지하고, 누구의 얼굴인지 인식하는 시스템을 만들어볼게요.

🧩 필요한 도구

1. Python
2. OpenCV
3. dlib (얼굴 랜드마크 검출용)
4. face_recognition 라이브러리

📝 구현 단계

1단계: 환경 설정

# 필요한 라이브러리 설치
pip install opencv-python
pip install dlib  # 설치가 어려울 수 있어요, 공식 문서 참고하세요!
pip install face_recognition
      

2단계: 얼굴 감지 구현

import cv2
import numpy as np

# 얼굴 감지기 로드
face_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_frontalface_default.xml')

# 이미지 로드
img = cv2.imread('test_image.jpg')
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

# 얼굴 감지
faces = face_cascade.detectMultiScale(gray, 1.1, 4)

# 감지된 얼굴에 사각형 그리기
for (x, y, w, h) in faces:
    cv2.rectangle(img, (x, y), (x+w, y+h), (255, 0, 0), 2)

# 결과 표시
cv2.imshow('Detected Faces', img)
cv2.waitKey(0)
      

이 코드는 Haar Cascade 분류기를 사용해 이미지에서 얼굴을 감지하고 사각형으로 표시해요!

3단계: 얼굴 인식 기능 추가

import face_recognition
import cv2
import numpy as np

# 알려진 얼굴 이미지 로드 및 인코딩
known_image = face_recognition.load_image_file("known_person.jpg")
known_encoding = face_recognition.face_encodings(known_image)[0]

# 테스트할 이미지 로드
unknown_image = face_recognition.load_image_file("unknown.jpg")

# 얼굴 위치 찾기
face_locations = face_recognition.face_locations(unknown_image)
face_encodings = face_recognition.face_encodings(unknown_image, face_locations)

# 결과 이미지 준비 (OpenCV 형식으로 변환)
image = cv2.cvtColor(unknown_image, cv2.COLOR_RGB2BGR)

# 각 얼굴 확인
for (top, right, bottom, left), face_encoding in zip(face_locations, face_encodings):
    # 알려진 얼굴과 비교
    matches = face_recognition.compare_faces([known_encoding], face_encoding)
    name = "Unknown"
    
    # 일치하는 얼굴이 있으면 이름 표시
    if True in matches:
        name = "Known Person"
    
    # 얼굴에 사각형 그리기
    cv2.rectangle(image, (left, top), (right, bottom), (0, 255, 0), 2)
    
    # 이름 표시
    cv2.putText(image, name, (left, top - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)

# 결과 표시
cv2.imshow('Face Recognition', image)
cv2.waitKey(0)
      

이 코드는 face_recognition 라이브러리를 사용해 얼굴을 인식하고, 미리 등록된 얼굴과 비교해요!

4단계: 실시간 웹캠 얼굴 인식으로 확장

import face_recognition
import cv2
import numpy as np

# 알려진 얼굴 로드 및 인코딩
known_face_encodings = []
known_face_names = []

# 예시: 한 명의 얼굴 추가
image_of_person = face_recognition.load_image_file("person.jpg")
person_face_encoding = face_recognition.face_encodings(image_of_person)[0]
known_face_encodings.append(person_face_encoding)
known_face_names.append("Person Name")

# 웹캠 시작
video_capture = cv2.VideoCapture(0)

while True:
    # 비디오에서 한 프레임 가져오기
    ret, frame = video_capture.read()
    
    # 처리 속도를 높이기 위해 프레임 크기 줄이기
    small_frame = cv2.resize(frame, (0, 0), fx=0.25, fy=0.25)
    
    # BGR에서 RGB로 변환 (face_recognition은 RGB 사용)
    rgb_small_frame = cv2.cvtColor(small_frame, cv2.COLOR_BGR2RGB)
    
    # 얼굴 위치와 인코딩 찾기
    face_locations = face_recognition.face_locations(rgb_small_frame)
    face_encodings = face_recognition.face_encodings(rgb_small_frame, face_locations)
    
    face_names = []
    for face_encoding in face_encodings:
        # 알려진 얼굴과 비교
        matches = face_recognition.compare_faces(known_face_encodings, face_encoding)
        name = "Unknown"
        
        # 가장 유사한 얼굴 찾기
        face_distances = face_recognition.face_distance(known_face_encodings, face_encoding)
        best_match_index = np.argmin(face_distances)
        if matches[best_match_index]:
            name = known_face_names[best_match_index]
        
        face_names.append(name)
    
    # 결과 표시
    for (top, right, bottom, left), name in zip(face_locations, face_names):
        # 축소된 프레임에서 원래 크기로 좌표 변환
        top *= 4
        right *= 4
        bottom *= 4
        left *= 4
        
        # 얼굴에 사각형 그리기
        cv2.rectangle(frame, (left, top), (right, bottom), (0, 255, 0), 2)
        
        # 이름 표시
        cv2.putText(frame, name, (left, top - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)
    
    # 결과 화면 표시
    cv2.imshow('Video', frame)
    
    # 'q'를 누르면 종료
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

# 자원 해제
video_capture.release()
cv2.destroyAllWindows()
      

이제 웹캠으로 실시간 얼굴 인식이 가능해요! 친구들이나 가족의 얼굴을 등록해서 테스트해보세요!

🎯 프로젝트 목표

이미지나 비디오에서 여러 객체(사람, 자동차, 동물 등)를 감지하고 분류하는 시스템 개발

🧩 필요한 도구

1. Python
2. OpenCV
3. TensorFlow/Keras 또는 PyTorch
4. 사전 학습된 모델(YOLO, SSD, Faster R-CNN 등)

📝 구현 단계

1단계: YOLO 모델 설치 및 설정

YOLO(You Only Look Once)는 실시간 객체 검출에 매우 효과적인 알고리즘이에요. 여기서는 YOLOv3를 사용할게요.

# 필요한 라이브러리 설치
pip install opencv-python
pip install numpy

# YOLO 가중치 파일 다운로드 (터미널에서 실행)
# wget https://pjreddie.com/media/files/yolov3.weights
# 또는 직접 웹사이트에서 다운로드
      

2단계: 객체 검출 구현

import cv2
import numpy as np

# YOLO 모델 로드
net = cv2.dnn.readNet("yolov3.weights", "yolov3.cfg")
layer_names = net.getLayerNames()
output_layers = [layer_names[i[0] - 1] for i in net.getUnconnectedOutLayers()]

# COCO 데이터셋의 클래스 이름 로드
with open("coco.names", "r") as f:
    classes = [line.strip() for line in f.readlines()]

# 이미지 로드
img = cv2.imread("test_image.jpg")
height, width, channels = img.shape

# 이미지를 YOLO 입력 형식으로 변환
blob = cv2.dnn.blobFromImage(img, 0.00392, (416, 416), (0, 0, 0), True, crop=False)
net.setInput(blob)
outs = net.forward(output_layers)

# 감지된 객체 정보 저장
class_ids = []
confidences = []
boxes = []

# 감지 결과 처리
for out in outs:
    for detection in out:
        scores = detection[5:]
        class_id = np.argmax(scores)
        confidence = scores[class_id]
        
        # 신뢰도가 0.5 이상인 객체만 처리
        if confidence > 0.5:
            # 객체 위치 계산
            center_x = int(detection[0] * width)
            center_y = int(detection[1] * height)
            w = int(detection[2] * width)
            h = int(detection[3] * height)
            
            # 사각형 좌표 계산
            x = int(center_x - w / 2)
            y = int(center_y - h / 2)
            
            # 결과 저장
            boxes.append([x, y, w, h])
            confidences.append(float(confidence))
            class_ids.append(class_id)

# 중복 감지 제거 (Non-Maximum Suppression)
indexes = cv2.dnn.NMSBoxes(boxes, confidences, 0.5, 0.4)

# 결과 시각화
colors = np.random.uniform(0, 255, size=(len(classes), 3))
for i in range(len(boxes)):
    if i in indexes:
        x, y, w, h = boxes[i]
        label = str(classes[class_ids[i]])
        confidence = confidences[i]
        color = colors[class_ids[i]]
        
        # 객체에 사각형 그리기
        cv2.rectangle(img, (x, y), (x + w, y + h), color, 2)
        
        # 레이블 표시
        cv2.putText(img, f"{label} {confidence:.2f}", (x, y - 10), 
                    cv2.FONT_HERSHEY_SIMPLEX, 0.5, color, 2)

# 결과 표시
cv2.imshow("Object Detection", img)
cv2.waitKey(0)
cv2.destroyAllWindows()
      

이 코드는 YOLO 모델을 사용해 이미지에서 객체를 검출하고 분류해요! COCO 데이터셋에 있는 80개 클래스를 인식할 수 있어요.

3단계: 실시간 비디오에서 객체 검출

import cv2
import numpy as np
import time

# YOLO 모델 로드
net = cv2.dnn.readNet("yolov3.weights", "yolov3.cfg")
layer_names = net.getLayerNames()
output_layers = [layer_names[i[0] - 1] for i in net.getUnconnectedOutLayers()]

# COCO 데이터셋의 클래스 이름 로드
with open("coco.names", "r") as f:
    classes = [line.strip() for line in f.readlines()]

# 랜덤 색상 생성
colors = np.random.uniform(0, 255, size=(len(classes), 3))

# 웹캠 시작
cap = cv2.VideoCapture(0)
font = cv2.FONT_HERSHEY_SIMPLEX
starting_time = time.time()
frame_id = 0

while True:
    # 비디오에서 한 프레임 가져오기
    _, frame = cap.read()
    frame_id += 1
    height, width, channels = frame.shape
    
    # 이미지를 YOLO 입력 형식으로 변환
    blob = cv2.dnn.blobFromImage(frame, 0.00392, (416, 416), (0, 0, 0), True, crop=False)
    net.setInput(blob)
    outs = net.forward(output_layers)
    
    # 감지된 객체 정보 저장
    class_ids = []
    confidences = []
    boxes = []
    
    # 감지 결과 처리
    for out in outs:
        for detection in out:
            scores = detection[5:]
            class_id = np.argmax(scores)
            confidence = scores[class_id]
            
            # 신뢰도가 0.5 이상인 객체만 처리
            if confidence > 0.5:
                # 객체 위치 계산
                center_x = int(detection[0] * width)
                center_y = int(detection[1] * height)
                w = int(detection[2] * width)
                h = int(detection[3] * height)
                
                # 사각형 좌표 계산
                x = int(center_x - w / 2)
                y = int(center_y - h / 2)
                
                # 결과 저장
                boxes.append([x, y, w, h])
                confidences.append(float(confidence))
                class_ids.append(class_id)
    
    # 중복 감지 제거 (Non-Maximum Suppression)
    indexes = cv2.dnn.NMSBoxes(boxes, confidences, 0.5, 0.4)
    
    # 결과 시각화
    for i in range(len(boxes)):
        if i in indexes:
            x, y, w, h = boxes[i]
            label = str(classes[class_ids[i]])
            confidence = confidences[i]
            color = colors[class_ids[i]]
            
            # 객체에 사각형 그리기
            cv2.rectangle(frame, (x, y), (x + w, y + h), color, 2)
            
            # 레이블 표시
            cv2.putText(frame, f"{label} {confidence:.2f}", (x, y - 10), font, 0.5, color, 2)
    
    # FPS 계산 및 표시
    elapsed_time = time.time() - starting_time
    fps = frame_id / elapsed_time
    cv2.putText(frame, f"FPS: {fps:.2f}", (10, 30), font, 1, (0, 0, 255), 2)
    
    # 결과 표시
    cv2.imshow("Object Detection", frame)
    
    # 'q'를 누르면 종료
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

# 자원 해제
cap.release()
cv2.destroyAllWindows()
      

이제 웹캠으로 실시간 객체 검출이 가능해요! 다양한 물체를 카메라 앞에 가져와서 테스트해보세요!

4단계: 성능 개선 및 확장

기본 구현이 완료되었다면, 다음과 같은 방법으로 시스템을 개선할 수 있어요:

1. YOLOv4나 YOLOv5 같은 더 최신 모델 사용하기
2. GPU 가속을 활용해 처리 속도 높이기
3. 특정 객체만 추적하는 기능 추가하기
4. 객체 간 관계 분석하기 (예: "사람이 의자에 앉아있다")
5. 객체 수 세기 및 통계 기능 추가하기