🚀 컴퓨터 비전, 왜 지금 배워야 할까?

요즘 우리 주변을 둘러보면 컴퓨터 비전 기술이 정말 많이 사용되고 있어. 스마트폰으로 사진 찍을 때 자동으로 얼굴을 인식하는 기능, 인스타그램 필터, 자율주행 자동차, 심지어 병원에서 X-ray 사진을 분석하는 것까지! 이 모든 게 컴퓨터 비전 기술이야. 😊

그런데 이런 멋진 기술을 배우려면 어디서부터 시작해야 할까? 바로 Python의 OpenCV와 Pillow라는 두 가지 강력한 라이브러리야. 이 두 친구들은 이미지 처리의 양대 산맥이라고 할 수 있지. 오늘은 이 두 라이브러리를 활용해서 실제로 어떻게 컴퓨터 비전 프로젝트를 만들 수 있는지 자세히 알아볼 거야!

📚 OpenCV vs Pillow: 어떤 걸 선택해야 할까?

많은 사람들이 처음 이미지 처리를 배울 때 가장 먼저 하는 질문이 바로 이거야. "OpenCV랑 Pillow 중에 뭘 써야 해?" 사실 이 질문은 "치킨이랑 피자 중에 뭐가 더 맛있어?"라고 묻는 것과 비슷해. 둘 다 좋은데 용도가 다르거든! 🍕🍗

간단하게 정리하면, Pillow는 이미지 편집과 가공에 특화되어 있고, OpenCV는 실시간 비디오 처리와 고급 컴퓨터 비전 작업에 최적화되어 있어. 그럼 각각의 특징을 자세히 살펴볼까?

🛠️ 설치부터 시작하기

자, 이제 본격적으로 시작해볼까? 먼저 필요한 라이브러리들을 설치해야 해. Python이 이미 설치되어 있다고 가정하고 진행할게. 터미널이나 명령 프롬프트를 열고 다음 명령어를 입력해보자!

pip install Pillow

pip install opencv-python
pip install opencv-contrib-python

pip install numpy
pip install matplotlib

🎬 Pillow로 시작하는 이미지 처리

Pillow는 정말 직관적이고 사용하기 쉬워. 마치 포토샵을 코드로 다루는 느낌이랄까? 😄 기본적인 작업부터 차근차근 배워보자.

이미지 불러오기와 기본 정보 확인

from PIL import Image
import os

# 이미지 불러오기
img = Image.open('example.jpg')

# 이미지 기본 정보 확인
print(f"이미지 크기: {img.size}")  # (width, height)
print(f"이미지 모드: {img.mode}")  # RGB, RGBA, L 등
print(f"이미지 포맷: {img.format}")  # JPEG, PNG 등

# 이미지 표시 (기본 이미지 뷰어로 열림)
img.show()

여기서 img.mode는 이미지의 색상 모드를 나타내. RGB는 일반적인 컬러 이미지, RGBA는 투명도가 있는 이미지, L은 흑백 이미지를 의미해. 이 정보는 나중에 이미지를 처리할 때 정말 중요하니까 꼭 기억해둬!

이미지 크기 조절 (리사이징)

from PIL import Image

# 원본 이미지 불러오기
original = Image.open('photo.jpg')

# 방법 1: 특정 크기로 조절
resized = original.resize((800, 600))

# 방법 2: 비율 유지하며 조절 (썸네일)
thumbnail = original.copy()
thumbnail.thumbnail((400, 400))  # 최대 크기 지정

# 방법 3: 비율 계산해서 조절
width, height = original.size
new_width = 1000
new_height = int(height * (new_width / width))
proportional = original.resize((new_width, new_height), Image.LANCZOS)

# 저장하기
resized.save('resized_photo.jpg', quality=95)
thumbnail.save('thumbnail.jpg', quality=90)

이미지 자르기와 회전

from PIL import Image

img = Image.open('landscape.jpg')

# 이미지 자르기 (crop)
# 좌표: (left, top, right, bottom)
cropped = img.crop((100, 100, 500, 400))

# 이미지 회전
rotated_90 = img.rotate(90, expand=True)  # expand=True로 잘림 방지
rotated_45 = img.rotate(45, fillcolor='white')  # 빈 공간 색상 지정

# 좌우 반전
flipped_lr = img.transpose(Image.FLIP_LEFT_RIGHT)

# 상하 반전
flipped_tb = img.transpose(Image.FLIP_TOP_BOTTOM)

# 저장
cropped.save('cropped.jpg')
rotated_90.save('rotated.jpg')
flipped_lr.save('flipped.jpg')

자르기 기능은 특히 웹사이트에서 프로필 사진을 정사각형으로 만들 때 많이 사용해. 사용자가 업로드한 이미지의 중앙 부분을 자동으로 잘라내는 기능을 구현할 수 있지!

필터와 효과 적용하기

from PIL import Image, ImageFilter, ImageEnhance

img = Image.open('photo.jpg')

# 블러 효과
blurred = img.filter(ImageFilter.BLUR)
gaussian_blur = img.filter(ImageFilter.GaussianBlur(radius=5))

# 샤프닝 (선명하게)
sharpened = img.filter(ImageFilter.SHARPEN)

# 엣지 검출
edges = img.filter(ImageFilter.FIND_EDGES)

# 엠보싱 효과
embossed = img.filter(ImageFilter.EMBOSS)

# 밝기 조절
enhancer = ImageEnhance.Brightness(img)
brighter = enhancer.enhance(1.5)  # 1.5배 밝게
darker = enhancer.enhance(0.7)    # 0.7배 어둡게

# 대비 조절
contrast_enhancer = ImageEnhance.Contrast(img)
high_contrast = contrast_enhancer.enhance(2.0)

# 채도 조절
color_enhancer = ImageEnhance.Color(img)
saturated = color_enhancer.enhance(1.5)  # 채도 증가
desaturated = color_enhancer.enhance(0.5)  # 채도 감소

# 흑백 변환
grayscale = img.convert('L')

# 저장
blurred.save('blurred.jpg')
sharpened.save('sharpened.jpg')
grayscale.save('grayscale.jpg')

def vintage_filter(img):
    # 채도 낮추기
    color = ImageEnhance.Color(img)
    img = color.enhance(0.7)
    
    # 대비 높이기
    contrast = ImageEnhance.Contrast(img)
    img = contrast.enhance(1.3)
    
    # 약간 어둡게
    brightness = ImageEnhance.Brightness(img)
    img = brightness.enhance(0.9)
    
    return img

# 사용하기
original = Image.open('photo.jpg')
vintage = vintage_filter(original)
vintage.save('vintage_photo.jpg')

텍스트와 도형 그리기

from PIL import Image, ImageDraw, ImageFont

# 새 이미지 생성 또는 기존 이미지 불러오기
img = Image.new('RGB', (800, 600), color='white')
# 또는: img = Image.open('background.jpg')

# Draw 객체 생성
draw = ImageDraw.Draw(img)

# 사각형 그리기
draw.rectangle([(100, 100), (300, 200)], fill='lightblue', outline='blue', width=3)

# 원 그리기
draw.ellipse([(400, 100), (600, 300)], fill='lightcoral', outline='red', width=3)

# 선 그리기
draw.line([(100, 400), (700, 400)], fill='green', width=5)

# 텍스트 추가 (기본 폰트)
draw.text((100, 450), "Hello, Pillow!", fill='black')

# 텍스트 추가 (커스텀 폰트)
try:
    font = ImageFont.truetype("arial.ttf", 40)
    draw.text((100, 500), "Custom Font!", fill='navy', font=font)
except:
    print("폰트 파일을 찾을 수 없습니다. 기본 폰트를 사용합니다.")
    draw.text((100, 500), "Custom Font!", fill='navy')

# 저장
img.save('drawing.jpg')

텍스트 기능은 워터마크를 추가하거나 이미지에 설명을 넣을 때 정말 유용해. 예를 들어, 재능넷에서 포트폴리오 이미지를 만들 때 자동으로 로고나 저작권 표시를 넣을 수 있지! 🎯

🔬 OpenCV로 들어가는 컴퓨터 비전의 세계

자, 이제 본격적으로 OpenCV의 세계로 들어가보자! OpenCV는 Pillow보다 훨씬 강력하고 복잡한 기능들을 제공해. 처음에는 좀 어렵게 느껴질 수 있지만, 차근차근 따라오면 금방 익숙해질 거야. 😊

OpenCV 기본 사용법

import cv2
import numpy as np

# 이미지 불러오기
img = cv2.imread('image.jpg')

# 이미지가 제대로 로드되었는지 확인
if img is None:
    print("이미지를 불러올 수 없습니다!")
else:
    print(f"이미지 크기: {img.shape}")  # (height, width, channels)
    
# 이미지 표시
cv2.imshow('Original Image', img)
cv2.waitKey(0)  # 키 입력 대기
cv2.destroyAllWindows()  # 모든 윈도우 닫기

# 이미지 저장
cv2.imwrite('output.jpg', img)

# BGR을 RGB로 변환
rgb_img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)

# RGB를 BGR로 변환
bgr_img = cv2.cvtColor(img, cv2.COLOR_RGB2BGR)

색상 공간 변환

import cv2

img = cv2.imread('photo.jpg')

# 그레이스케일 변환
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

# HSV 색상 공간으로 변환 (색상 기반 작업에 유용)
hsv = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)

# LAB 색상 공간으로 변환 (조명 보정에 유용)
lab = cv2.cvtColor(img, cv2.COLOR_BGR2LAB)

# 저장
cv2.imwrite('gray.jpg', gray)
cv2.imwrite('hsv.jpg', hsv)

색상 공간 변환은 특정 작업을 할 때 정말 중요해. 예를 들어, 특정 색상의 물체를 찾고 싶다면 HSV 색상 공간이 RGB보다 훨씬 효과적이야. HSV는 Hue(색상), Saturation(채도), Value(명도)로 구성되어 있어서 색상을 더 직관적으로 다룰 수 있거든!

이미지 크기 조절과 변형

import cv2

img = cv2.imread('image.jpg')
height, width = img.shape[:2]

# 방법 1: 특정 크기로 조절
resized = cv2.resize(img, (800, 600))

# 방법 2: 비율로 조절
scale_percent = 50  # 50%로 축소
new_width = int(width * scale_percent / 100)
new_height = int(height * scale_percent / 100)
resized_percent = cv2.resize(img, (new_width, new_height))

# 방법 3: 보간법 지정
resized_inter = cv2.resize(img, (800, 600), interpolation=cv2.INTER_CUBIC)

# 회전
center = (width // 2, height // 2)
rotation_matrix = cv2.getRotationMatrix2D(center, 45, 1.0)  # 45도 회전
rotated = cv2.warpAffine(img, rotation_matrix, (width, height))

# 좌우 반전
flipped_horizontal = cv2.flip(img, 1)

# 상하 반전
flipped_vertical = cv2.flip(img, 0)

# 상하좌우 반전
flipped_both = cv2.flip(img, -1)

# 저장
cv2.imwrite('resized.jpg', resized)
cv2.imwrite('rotated.jpg', rotated)

이미지 필터링과 블러링

import cv2
import numpy as np

img = cv2.imread('photo.jpg')

# 가우시안 블러 (자연스러운 블러)
gaussian = cv2.GaussianBlur(img, (15, 15), 0)

# 미디언 블러 (노이즈 제거에 효과적)
median = cv2.medianBlur(img, 5)

# 양방향 필터 (경계선 보존하며 블러)
bilateral = cv2.bilateralFilter(img, 9, 75, 75)

# 샤프닝 (선명하게)
kernel_sharpen = np.array([[-1,-1,-1],
                           [-1, 9,-1],
                           [-1,-1,-1]])
sharpened = cv2.filter2D(img, -1, kernel_sharpen)

# 엣지 검출 - Canny
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
edges = cv2.Canny(gray, 100, 200)

# 엣지 검출 - Sobel
sobelx = cv2.Sobel(gray, cv2.CV_64F, 1, 0, ksize=5)
sobely = cv2.Sobel(gray, cv2.CV_64F, 0, 1, ksize=5)

# 모폴로지 연산 (침식과 팽창)
kernel = np.ones((5,5), np.uint8)
erosion = cv2.erode(img, kernel, iterations=1)
dilation = cv2.dilate(img, kernel, iterations=1)

# 저장
cv2.imwrite('gaussian_blur.jpg', gaussian)
cv2.imwrite('edges.jpg', edges)
cv2.imwrite('sharpened.jpg', sharpened)

필터링은 이미지 처리의 핵심이야! 각 필터는 특정 목적에 최적화되어 있어. 예를 들어, 가우시안 블러는 배경을 흐리게 해서 피사체를 강조할 때 좋고, Canny 엣지 검출은 물체의 윤곽을 찾을 때 사용해. 실제로 자율주행 자동차에서 차선을 인식할 때도 엣지 검출을 사용한다고! 🚗

👤 얼굴 인식: OpenCV의 꽃

자, 이제 정말 재미있는 부분이야! 얼굴 인식은 OpenCV의 가장 인기 있는 기능 중 하나야. Haar Cascade라는 사전 학습된 모델을 사용하면 놀랍도록 쉽게 얼굴을 인식할 수 있어. 😮

기본 얼굴 인식

import cv2

# Haar Cascade 분류기 로드
face_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_frontalface_default.xml')
eye_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_eye.xml')

# 이미지 불러오기
img = cv2.imread('people.jpg')
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

# 얼굴 검출
faces = face_cascade.detectMultiScale(
    gray,
    scaleFactor=1.1,    # 이미지 피라미드 스케일
    minNeighbors=5,     # 최소 이웃 수 (높을수록 정확하지만 검출률 낮음)
    minSize=(30, 30)    # 최소 얼굴 크기
)

print(f"검출된 얼굴 수: {len(faces)}")

# 검출된 얼굴에 사각형 그리기
for (x, y, w, h) in faces:
    # 얼굴 영역에 사각형 그리기
    cv2.rectangle(img, (x, y), (x+w, y+h), (255, 0, 0), 2)
    
    # 얼굴 영역에서 눈 검출
    roi_gray = gray[y:y+h, x:x+w]
    roi_color = img[y:y+h, x:x+w]
    
    eyes = eye_cascade.detectMultiScale(roi_gray)
    for (ex, ey, ew, eh) in eyes:
        cv2.rectangle(roi_color, (ex, ey), (ex+ew, ey+eh), (0, 255, 0), 2)

# 결과 저장 및 표시
cv2.imwrite('detected_faces.jpg', img)
cv2.imshow('Face Detection', img)
cv2.waitKey(0)
cv2.destroyAllWindows()

실시간 웹캠 얼굴 인식

import cv2

# 웹캠 열기
cap = cv2.VideoCapture(0)

# Haar Cascade 로드
face_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_frontalface_default.xml')

while True:
    # 프레임 읽기
    ret, frame = cap.read()
    
    if not ret:
        print("웹캠을 읽을 수 없습니다.")
        break
    
    # 그레이스케일 변환
    gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
    
    # 얼굴 검출
    faces = face_cascade.detectMultiScale(gray, 1.3, 5)
    
    # 검출된 얼굴 표시
    for (x, y, w, h) in faces:
        cv2.rectangle(frame, (x, y), (x+w, y+h), (255, 0, 0), 2)
        cv2.putText(frame, 'Face', (x, y-10), 
                   cv2.FONT_HERSHEY_SIMPLEX, 0.9, (255, 0, 0), 2)
    
    # 프레임 표시
    cv2.imshow('Face Detection', frame)
    
    # 'q' 키를 누르면 종료
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

# 리소스 해제
cap.release()
cv2.destroyAllWindows()

실시간 얼굴 인식은 정말 신기하지? 이 코드를 실행하면 웹캠에 비친 얼굴을 실시간으로 인식해서 사각형으로 표시해줘. 화상회의 앱이나 보안 시스템에서 이런 기술을 사용하고 있어! 🎥

얼굴에 모자이크 처리하기

import cv2

def pixelate_face(image, blocks=10):
    """얼굴 영역을 모자이크 처리하는 함수"""
    # 이미지 크기 가져오기
    (h, w) = image.shape[:2]
    
    # 임시로 작게 축소
    temp = cv2.resize(image, (blocks, blocks), interpolation=cv2.INTER_LINEAR)
    
    # 다시 원래 크기로 확대 (모자이크 효과)
    output = cv2.resize(temp, (w, h), interpolation=cv2.INTER_NEAREST)
    
    return output

# 이미지 불러오기
img = cv2.imread('person.jpg')
face_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_frontalface_default.xml')

# 그레이스케일 변환
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

# 얼굴 검출
faces = face_cascade.detectMultiScale(gray, 1.3, 5)

# 각 얼굴에 모자이크 적용
for (x, y, w, h) in faces:
    # 얼굴 영역 추출
    face_region = img[y:y+h, x:x+w]
    
    # 모자이크 처리
    pixelated = pixelate_face(face_region, blocks=10)
    
    # 원본 이미지에 적용
    img[y:y+h, x:x+w] = pixelated

# 결과 저장
cv2.imwrite('pixelated_faces.jpg', img)

개인정보 보호가 중요한 요즘, 이런 모자이크 기능은 정말 유용해. 유튜브 영상이나 블로그 사진에서 얼굴을 가릴 때 자동으로 처리할 수 있지. 재능넷 같은 플랫폼에서 포트폴리오를 올릴 때도 고객의 얼굴을 보호하는 데 사용할 수 있어!

🎯 객체 탐지와 추적

얼굴 인식을 배웠으니, 이제 더 나아가서 다양한 객체를 탐지하고 추적하는 방법을 알아보자! 이건 자율주행, 보안 시스템, 스포츠 분석 등 정말 많은 분야에서 사용되는 기술이야. 🎯

색상 기반 객체 탐지

import cv2
import numpy as np

# 이미지 또는 비디오 불러오기
cap = cv2.VideoCapture(0)  # 웹캠 사용
# 또는: img = cv2.imread('image.jpg')

while True:
    ret, frame = cap.read()
    if not ret:
        break
    
    # HSV 색상 공간으로 변환
    hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
    
    # 빨간색 범위 정의 (HSV)
    # 빨간색은 0도와 180도 근처에 있어서 두 범위로 나눔
    lower_red1 = np.array([0, 100, 100])
    upper_red1 = np.array([10, 255, 255])
    lower_red2 = np.array([160, 100, 100])
    upper_red2 = np.array([180, 255, 255])
    
    # 마스크 생성
    mask1 = cv2.inRange(hsv, lower_red1, upper_red1)
    mask2 = cv2.inRange(hsv, lower_red2, upper_red2)
    mask = mask1 + mask2
    
    # 노이즈 제거
    kernel = np.ones((5, 5), np.uint8)
    mask = cv2.morphologyEx(mask, cv2.MORPH_OPEN, kernel)
    mask = cv2.morphologyEx(mask, cv2.MORPH_CLOSE, kernel)
    
    # 윤곽선 찾기
    contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
    
    # 가장 큰 윤곽선 찾기
    if contours:
        largest_contour = max(contours, key=cv2.contourArea)
        
        # 면적이 충분히 큰 경우만 처리
        if cv2.contourArea(largest_contour) > 500:
            # 바운딩 박스 그리기
            x, y, w, h = cv2.boundingRect(largest_contour)
            cv2.rectangle(frame, (x, y), (x+w, y+h), (0, 255, 0), 2)
            
            # 중심점 표시
            cx = x + w // 2
            cy = y + h // 2
            cv2.circle(frame, (cx, cy), 5, (255, 0, 0), -1)
            
            # 텍스트 표시
            cv2.putText(frame, 'Red Object', (x, y-10),
                       cv2.FONT_HERSHEY_SIMPLEX, 0.9, (0, 255, 0), 2)
    
    # 결과 표시
    cv2.imshow('Original', frame)
    cv2.imshow('Mask', mask)
    
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

cap.release()
cv2.destroyAllWindows()

윤곽선 검출과 도형 인식

import cv2
import numpy as np

img = cv2.imread('shapes.jpg')
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

# 이진화
_, thresh = cv2.threshold(gray, 127, 255, cv2.THRESH_BINARY)

# 윤곽선 찾기
contours, hierarchy = cv2.findContours(thresh, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)

def detect_shape(contour):
    """윤곽선으로부터 도형 종류 판별"""
    # 윤곽선 근사화
    epsilon = 0.04 * cv2.arcLength(contour, True)
    approx = cv2.approxPolyDP(contour, epsilon, True)
    
    # 꼭짓점 개수로 도형 판별
    vertices = len(approx)
    
    if vertices == 3:
        return "Triangle"
    elif vertices == 4:
        # 사각형인지 정사각형인지 구분
        x, y, w, h = cv2.boundingRect(approx)
        aspect_ratio = float(w) / h
        if 0.95 <= aspect_ratio <= 1.05:
            return "Square"
        else:
            return "Rectangle"
    elif vertices == 5:
        return "Pentagon"
    elif vertices > 5:
        # 원형도 검사
        area = cv2.contourArea(contour)
        perimeter = cv2.arcLength(contour, True)
        circularity = 4 * np.pi * area / (perimeter * perimeter)
        if circularity > 0.8:
            return "Circle"
        else:
            return "Polygon"
    return "Unknown"

# 각 윤곽선 분석
for contour in contours:
    # 너무 작은 윤곽선은 무시
    if cv2.contourArea(contour) < 100:
        continue
    
    # 도형 종류 판별
    shape = detect_shape(contour)
    
    # 윤곽선 그리기
    cv2.drawContours(img, [contour], -1, (0, 255, 0), 2)
    
    # 중심점 계산
    M = cv2.moments(contour)
    if M["m00"] != 0:
        cx = int(M["m10"] / M["m00"])
        cy = int(M["m01"] / M["m00"])
        
        # 도형 이름 표시
        cv2.putText(img, shape, (cx-50, cy),
                   cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 0, 0), 2)

cv2.imwrite('detected_shapes.jpg', img)
cv2.imshow('Shape Detection', img)
cv2.waitKey(0)
cv2.destroyAllWindows()

도형 인식은 생각보다 많은 곳에 사용돼. 예를 들어, 공장에서 제품의 불량을 검사하거나, 문서에서 특정 기호를 찾거나, 게임에서 물체를 인식하는 데 활용할 수 있어. 정말 실용적이지? 😊

모션 감지 (움직임 탐지)

import cv2
import numpy as np

cap = cv2.VideoCapture(0)

# 첫 번째 프레임 읽기
ret, frame1 = cap.read()
ret, frame2 = cap.read()

while True:
    # 두 프레임의 차이 계산
    diff = cv2.absdiff(frame1, frame2)
    gray = cv2.cvtColor(diff, cv2.COLOR_BGR2GRAY)
    
    # 블러 적용 (노이즈 감소)
    blur = cv2.GaussianBlur(gray, (5, 5), 0)
    
    # 이진화
    _, thresh = cv2.threshold(blur, 20, 255, cv2.THRESH_BINARY)
    
    # 팽창 (작은 구멍 메우기)
    dilated = cv2.dilate(thresh, None, iterations=3)
    
    # 윤곽선 찾기
    contours, _ = cv2.findContours(dilated, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
    
    # 움직임이 감지된 영역 표시
    for contour in contours:
        if cv2.contourArea(contour) < 1000:  # 작은 움직임 무시
            continue
        
        x, y, w, h = cv2.boundingRect(contour)
        cv2.rectangle(frame1, (x, y), (x+w, y+h), (0, 255, 0), 2)
        cv2.putText(frame1, "Motion Detected", (10, 30),
                   cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 2)
    
    # 결과 표시
    cv2.imshow('Motion Detection', frame1)
    cv2.imshow('Threshold', thresh)
    
    # 프레임 업데이트
    frame1 = frame2
    ret, frame2 = cap.read()
    
    if cv2.waitKey(30) & 0xFF == ord('q'):
        break

cap.release()
cv2.destroyAllWindows()

모션 감지는 보안 카메라의 핵심 기능이야! 움직임이 있을 때만 녹화를 시작하거나 알림을 보낼 수 있어. 집에 CCTV를 설치한다면 이런 기능을 직접 구현해볼 수 있겠지? 🏠🔒

🎨 실전 프로젝트: 이미지 처리 애플리케이션 만들기

이제까지 배운 내용을 종합해서 실제로 사용할 수 있는 프로젝트를 만들어보자! 여기서는 몇 가지 실용적인 예제를 소개할게.

프로젝트 1: 자동 배경 제거 도구

import cv2
import numpy as np
from PIL import Image

def remove_background(image_path, output_path):
    """배경을 자동으로 제거하는 함수"""
    # 이미지 읽기
    img = cv2.imread(image_path)
    
    # GrabCut 알고리즘을 위한 마스크 생성
    mask = np.zeros(img.shape[:2], np.uint8)
    
    # 배경과 전경 모델
    bgd_model = np.zeros((1, 65), np.float64)
    fgd_model = np.zeros((1, 65), np.float64)
    
    # 관심 영역 설정 (이미지 중앙 80%)
    height, width = img.shape[:2]
    rect = (int(width*0.1), int(height*0.1), 
            int(width*0.8), int(height*0.8))
    
    # GrabCut 실행
    cv2.grabCut(img, mask, rect, bgd_model, fgd_model, 5, cv2.GC_INIT_WITH_RECT)
    
    # 마스크 수정 (확실한 전경과 가능한 전경만 남김)
    mask2 = np.where((mask == 2) | (mask == 0), 0, 1).astype('uint8')
    
    # 마스크 적용
    result = img * mask2[:, :, np.newaxis]
    
    # 배경을 흰색으로
    white_background = np.ones_like(img) * 255
    white_background = white_background * (1 - mask2[:, :, np.newaxis])
    result = result + white_background
    
    # 저장
    cv2.imwrite(output_path, result)
    
    # Pillow로 PNG 투명 배경 버전도 생성
    result_rgb = cv2.cvtColor(result, cv2.COLOR_BGR2RGB)
    pil_img = Image.fromarray(result_rgb)
    
    # 흰색을 투명하게
    pil_img = pil_img.convert("RGBA")
    datas = pil_img.getdata()
    
    new_data = []
    for item in datas:
        # 흰색 픽셀을 투명하게
        if item[0] > 240 and item[1] > 240 and item[2] > 240:
            new_data.append((255, 255, 255, 0))
        else:
            new_data.append(item)
    
    pil_img.putdata(new_data)
    pil_img.save(output_path.replace('.jpg', '_transparent.png'))
    
    print(f"배경 제거 완료! {output_path}에 저장되었습니다.")

# 사용 예시
remove_background('person.jpg', 'person_no_bg.jpg')

프로젝트 2: 문서 스캐너

import cv2
import numpy as np

def order_points(pts):
    """네 점을 좌상, 우상, 우하, 좌하 순서로 정렬"""
    rect = np.zeros((4, 2), dtype="float32")
    
    # 좌상과 우하 찾기
    s = pts.sum(axis=1)
    rect[0] = pts[np.argmin(s)]
    rect[2] = pts[np.argmax(s)]
    
    # 우상과 좌하 찾기
    diff = np.diff(pts, axis=1)
    rect[1] = pts[np.argmin(diff)]
    rect[3] = pts[np.argmax(diff)]
    
    return rect

def four_point_transform(image, pts):
    """투시 변환으로 문서를 정면에서 본 것처럼 변환"""
    rect = order_points(pts)
    (tl, tr, br, bl) = rect
    
    # 새 이미지의 너비 계산
    width_a = np.sqrt(((br[0] - bl[0]) ** 2) + ((br[1] - bl[1]) ** 2))
    width_b = np.sqrt(((tr[0] - tl[0]) ** 2) + ((tr[1] - tl[1]) ** 2))
    max_width = max(int(width_a), int(width_b))
    
    # 새 이미지의 높이 계산
    height_a = np.sqrt(((tr[0] - br[0]) ** 2) + ((tr[1] - br[1]) ** 2))
    height_b = np.sqrt(((tl[0] - bl[0]) ** 2) + ((tl[1] - bl[1]) ** 2))
    max_height = max(int(height_a), int(height_b))
    
    # 목표 점들
    dst = np.array([
        [0, 0],
        [max_width - 1, 0],
        [max_width - 1, max_height - 1],
        [0, max_height - 1]], dtype="float32")
    
    # 투시 변환 행렬 계산 및 적용
    M = cv2.getPerspectiveTransform(rect, dst)
    warped = cv2.warpPerspective(image, M, (max_width, max_height))
    
    return warped

def scan_document(image_path, output_path):
    """문서를 스캔하는 함수"""
    # 이미지 읽기
    image = cv2.imread(image_path)
    orig = image.copy()
    
    # 크기 조정 (처리 속도 향상)
    ratio = image.shape[0] / 500.0
    image = cv2.resize(image, (int(image.shape[1] / ratio), 500))
    
    # 그레이스케일 변환
    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
    
    # 가우시안 블러
    gray = cv2.GaussianBlur(gray, (5, 5), 0)
    
    # 엣지 검출
    edged = cv2.Canny(gray, 75, 200)
    
    # 윤곽선 찾기
    contours, _ = cv2.findContours(edged.copy(), cv2.RETR_LIST, cv2.CHAIN_APPROX_SIMPLE)
    contours = sorted(contours, key=cv2.contourArea, reverse=True)[:5]
    
    # 사각형 윤곽선 찾기
    screen_cnt = None
    for c in contours:
        peri = cv2.arcLength(c, True)
        approx = cv2.approxPolyDP(c, 0.02 * peri, True)
        
        if len(approx) == 4:
            screen_cnt = approx
            break
    
    if screen_cnt is None:
        print("문서를 찾을 수 없습니다!")
        return
    
    # 원본 이미지 크기로 좌표 변환
    screen_cnt = screen_cnt.reshape(4, 2) * ratio
    
    # 투시 변환 적용
    warped = four_point_transform(orig, screen_cnt)
    
    # 그레이스케일 변환 및 이진화 (스캔 효과)
    warped = cv2.cvtColor(warped, cv2.COLOR_BGR2GRAY)
    warped = cv2.adaptiveThreshold(warped, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C,
                                   cv2.THRESH_BINARY, 11, 2)
    
    # 저장
    cv2.imwrite(output_path, warped)
    print(f"문서 스캔 완료! {output_path}에 저장되었습니다.")
    
    return warped

# 사용 예시
scanned = scan_document('document_photo.jpg', 'scanned_document.jpg')

문서 스캐너는 정말 실용적인 프로젝트야! 스마트폰으로 찍은 문서 사진을 깔끔한 스캔 이미지로 변환할 수 있어. 각도가 틀어진 사진도 자동으로 보정해주니까 정말 편리하지? 📄✨

프로젝트 3: 실시간 필터 카메라

import cv2
import numpy as np

class FilterCamera:
    def __init__(self):
        self.cap = cv2.VideoCapture(0)
        self.current_filter = 'none'
        
    def apply_filter(self, frame, filter_name):
        """다양한 필터 적용"""
        if filter_name == 'none':
            return frame
        
        elif filter_name == 'grayscale':
            gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
            return cv2.cvtColor(gray, cv2.COLOR_GRAY2BGR)
        
        elif filter_name == 'sepia':
            kernel = np.array([[0.272, 0.534, 0.131],
                             [0.349, 0.686, 0.168],
                             [0.393, 0.769, 0.189]])
            return cv2.transform(frame, kernel)
        
        elif filter_name == 'negative':
            return cv2.bitwise_not(frame)
        
        elif filter_name == 'blur':
            return cv2.GaussianBlur(frame, (15, 15), 0)
        
        elif filter_name == 'sharpen':
            kernel = np.array([[-1,-1,-1],
                             [-1, 9,-1],
                             [-1,-1,-1]])
            return cv2.filter2D(frame, -1, kernel)
        
        elif filter_name == 'edge':
            gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
            edges = cv2.Canny(gray, 100, 200)
            return cv2.cvtColor(edges, cv2.COLOR_GRAY2BGR)
        
        elif filter_name == 'cartoon':
            # 카툰 효과
            gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
            gray = cv2.medianBlur(gray, 5)
            edges = cv2.adaptiveThreshold(gray, 255,
                                         cv2.ADAPTIVE_THRESH_MEAN_C,
                                         cv2.THRESH_BINARY, 9, 9)
            
            color = cv2.bilateralFilter(frame, 9, 300, 300)
            cartoon = cv2.bitwise_and(color, color, mask=edges)
            return cartoon
        
        elif filter_name == 'vintage':
            # 빈티지 효과
            kernel = np.array([[0.393, 0.769, 0.189],
                             [0.349, 0.686, 0.168],
                             [0.272, 0.534, 0.131]])
            vintage = cv2.transform(frame, kernel)
            vintage = cv2.addWeighted(vintage, 0.8, frame, 0.2, 0)
            return vintage
        
        return frame
    
    def run(self):
        """카메라 실행"""
        filters = ['none', 'grayscale', 'sepia', 'negative', 'blur',
                  'sharpen', 'edge', 'cartoon', 'vintage']
        filter_index = 0
        
        print("필터 카메라 시작!")
        print("스페이스바: 필터 변경")
        print("s: 사진 저장")
        print("q: 종료")
        
        while True:
            ret, frame = self.cap.read()
            if not ret:
                break
            
            # 필터 적용
            filtered = self.apply_filter(frame, filters[filter_index])
            
            # 현재 필터 이름 표시
            cv2.putText(filtered, f"Filter: {filters[filter_index]}", 
                       (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 
                       1, (0, 255, 0), 2)
            
            # 화면 표시
            cv2.imshow('Filter Camera', filtered)
            
            # 키 입력 처리
            key = cv2.waitKey(1) & 0xFF
            
            if key == ord('q'):
                break
            elif key == ord(' '):  # 스페이스바
                filter_index = (filter_index + 1) % len(filters)
                print(f"필터 변경: {filters[filter_index]}")
            elif key == ord('s'):
                filename = f'photo_{filters[filter_index]}.jpg'
                cv2.imwrite(filename, filtered)
                print(f"사진 저장: {filename}")
        
        self.cap.release()
        cv2.destroyAllWindows()

# 사용 예시
camera = FilterCamera()
camera.run()

이 필터 카메라는 인스타그램 같은 앱의 기본 원리를 보여줘! 실시간으로 다양한 필터를 적용하고 사진을 저장할 수 있어. 이걸 기반으로 더 복잡한 효과들을 추가할 수도 있지. 정말 재미있는 프로젝트야! 📸✨

⚡ 성능 최적화와 실무 팁

이미지 처리는 계산량이 많아서 성능 최적화가 정말 중요해. 특히 실시간 처리나 대용량 이미지를 다룰 때는 더욱 그렇지. 실무에서 바로 쓸 수 있는 최적화 기법들을 알려줄게! 🚀

이미지 크기 최적화

import cv2
import time

def process_with_resize(image_path, target_width=800):
    """이미지 크기를 줄여서 처리 속도 향상"""
    # 원본 이미지 읽기
    img = cv2.imread(image_path)
    original_height, original_width = img.shape[:2]
    
    # 비율 계산
    ratio = original_width / target_width
    target_height = int(original_height / ratio)
    
    # 시작 시간
    start_time = time.time()
    
    # 크기 조정
    resized = cv2.resize(img, (target_width, target_height))
    
    # 처리 (예: 얼굴 인식)
    face_cascade = cv2.CascadeClassifier(
        cv2.data.haarcascades + 'haarcascade_frontalface_default.xml'
    )
    gray = cv2.cvtColor(resized, cv2.COLOR_BGR2GRAY)
    faces = face_cascade.detectMultiScale(gray, 1.3, 5)
    
    # 원본 크기로 좌표 변환
    for (x, y, w, h) in faces:
        x_orig = int(x * ratio)
        y_orig = int(y * ratio)
        w_orig = int(w * ratio)
        h_orig = int(h * ratio)
        cv2.rectangle(img, (x_orig, y_orig), 
                     (x_orig+w_orig, y_orig+h_orig), (255, 0, 0), 2)
    
    # 처리 시간 계산
    elapsed_time = time.time() - start_time
    print(f"처리 시간: {elapsed_time:.2f}초")
    
    return img

# 사용 예시
result = process_with_resize('large_image.jpg', target_width=800)
cv2.imwrite('result.jpg', result)

멀티스레딩으로 배치 처리

import cv2
import os
from concurrent.futures import ThreadPoolExecutor, as_completed
from PIL import Image

def process_single_image(input_path, output_folder, operation='resize'):
    """단일 이미지 처리 함수"""
    try:
        filename = os.path.basename(input_path)
        output_path = os.path.join(output_folder, filename)
        
        if operation == 'resize':
            # Pillow로 리사이징
            img = Image.open(input_path)
            img.thumbnail((800, 800))
            img.save(output_path, quality=85)
            
        elif operation == 'grayscale':
            # OpenCV로 흑백 변환
            img = cv2.imread(input_path)
            gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
            cv2.imwrite(output_path, gray)
            
        elif operation == 'watermark':
            # 워터마크 추가
            img = Image.open(input_path)
            from PIL import ImageDraw, ImageFont
            draw = ImageDraw.Draw(img)
            
            # 워터마크 텍스트
            text = "© Your Name"
            try:
                font = ImageFont.truetype("arial.ttf", 30)
            except:
                font = ImageFont.load_default()
            
            # 우측 하단에 배치
            width, height = img.size
            draw.text((width-200, height-50), text, 
                     fill=(255, 255, 255, 128), font=font)
            
            img.save(output_path, quality=90)
        
        return f"완료: {filename}"
    
    except Exception as e:
        return f"오류: {filename} - {str(e)}"

def batch_process_images(input_folder, output_folder, operation='resize', max_workers=4):
    """여러 이미지를 병렬로 처리"""
    # 출력 폴더 생성
    os.makedirs(output_folder, exist_ok=True)
    
    # 이미지 파일 목록
    image_extensions = ['.jpg', '.jpeg', '.png', '.bmp']
    image_files = [
        os.path.join(input_folder, f)
        for f in os.listdir(input_folder)
        if os.path.splitext(f)[1].lower() in image_extensions
    ]
    
    print(f"총 {len(image_files)}개의 이미지를 처리합니다...")
    
    # 멀티스레딩으로 처리
    with ThreadPoolExecutor(max_workers=max_workers) as executor:
        # 작업 제출
        futures = {
            executor.submit(process_single_image, img_path, output_folder, operation): img_path
            for img_path in image_files
        }
        
        # 완료된 작업 처리
        completed = 0
        for future in as_completed(futures):
            result = future.result()
            completed += 1
            print(f"[{completed}/{len(image_files)}] {result}")
    
    print("모든 이미지 처리 완료!")

# 사용 예시
batch_process_images(
    input_folder='input_images',
    output_folder='output_images',
    operation='resize',
    max_workers=4  # CPU 코어 수에 맞게 조정
)

멀티스레딩은 여러 이미지를 동시에 처리할 때 정말 효과적이야! 4개의 워커를 사용하면 처리 속도가 거의 4배 가까이 빨라질 수 있어. 대량의 이미지를 처리해야 하는 전자상거래 사이트나 사진 편집 서비스에서 필수적인 기술이지. 💪

메모리 효율적인 이미지 처리

import cv2
import numpy as np
from PIL import Image
import gc

def memory_efficient_processing(image_paths, output_folder):
    """메모리를 효율적으로 사용하는 이미지 처리"""
    for i, img_path in enumerate(image_paths):
        try:
            # 이미지 읽기
            img = cv2.imread(img_path)
            
            if img is None:
                print(f"이미지를 읽을 수 없습니다: {img_path}")
                continue
            
            # 처리 작업
            # 1. 크기 조정
            height, width = img.shape[:2]
            if width > 1920:
                scale = 1920 / width
                new_width = 1920
                new_height = int(height * scale)
                img = cv2.resize(img, (new_width, new_height))
            
            # 2. 필터 적용
            img = cv2.GaussianBlur(img, (5, 5), 0)
            
            # 3. 저장
            output_path = f"{output_folder}/processed_{i}.jpg"
            cv2.imwrite(output_path, img, [cv2.IMWRITE_JPEG_QUALITY, 85])
            
            # 메모리 해제
            del img
            
            # 주기적으로 가비지 컬렉션 실행
            if i % 10 == 0:
                gc.collect()
            
            print(f"처리 완료: {i+1}/{len(image_paths)}")
            
        except Exception as e:
            print(f"오류 발생: {img_path} - {str(e)}")
            continue

def process_large_image_in_chunks(image_path, output_path, chunk_size=1000):
    """대용량 이미지를 청크 단위로 처리"""
    # 이미지 정보 읽기
    img = cv2.imread(image_path)
    height, width = img.shape[:2]
    
    # 결과 이미지 생성
    result = np.zeros_like(img)
    
    # 청크 단위로 처리
    for y in range(0, height, chunk_size):
        for x in range(0, width, chunk_size):
            # 청크 영역 계산
            y_end = min(y + chunk_size, height)
            x_end = min(x + chunk_size, width)
            
            # 청크 추출
            chunk = img[y:y_end, x:x_end]
            
            # 처리 (예: 샤프닝)
            kernel = np.array([[-1,-1,-1], [-1,9,-1], [-1,-1,-1]])
            processed_chunk = cv2.filter2D(chunk, -1, kernel)
            
            # 결과에 저장
            result[y:y_end, x:x_end] = processed_chunk
            
            print(f"처리 중: {y}/{height}, {x}/{width}")
    
    # 저장
    cv2.imwrite(output_path, result)
    print("대용량 이미지 처리 완료!")

# 사용 예시
image_list = ['img1.jpg', 'img2.jpg', 'img3.jpg']
memory_efficient_processing(image_list, 'output')

캐싱으로 반복 작업 최적화

import cv2
import pickle
import hashlib
import os

class ImageCache:
    """이미지 처리 결과를 캐싱하는 클래스"""
    
    def __init__(self, cache_dir='cache'):
        self.cache_dir = cache_dir
        os.makedirs(cache_dir, exist_ok=True)
    
    def get_cache_key(self, image_path, operation, params):
        """캐시 키 생성"""
        # 파일 내용 기반 해시
        with open(image_path, 'rb') as f:
            file_hash = hashlib.md5(f.read()).hexdigest()
        
        # 작업과 파라미터를 포함한 키
        key_string = f"{file_hash}_{operation}_{str(params)}"
        return hashlib.md5(key_string.encode()).hexdigest()
    
    def get(self, image_path, operation, params):
        """캐시에서 결과 가져오기"""
        cache_key = self.get_cache_key(image_path, operation, params)
        cache_file = os.path.join(self.cache_dir, f"{cache_key}.pkl")
        
        if os.path.exists(cache_file):
            with open(cache_file, 'rb') as f:
                return pickle.load(f)
        return None
    
    def set(self, image_path, operation, params, result):
        """결과를 캐시에 저장"""
        cache_key = self.get_cache_key(image_path, operation, params)
        cache_file = os.path.join(self.cache_dir, f"{cache_key}.pkl")
        
        with open(cache_file, 'wb') as f:
            pickle.dump(result, f)
    
    def clear(self):
        """캐시 전체 삭제"""
        for file in os.listdir(self.cache_dir):
            os.remove(os.path.join(self.cache_dir, file))
        print("캐시가 삭제되었습니다.")

def detect_faces_with_cache(image_path, cache=None):
    """캐싱을 사용한 얼굴 인식"""
    operation = 'face_detection'
    params = {'scale': 1.3, 'neighbors': 5}
    
    # 캐시 확인
    if cache:
        cached_result = cache.get(image_path, operation, params)
        if cached_result is not None:
            print("캐시에서 결과를 가져왔습니다!")
            return cached_result
    
    # 실제 처리
    print("이미지를 처리하고 있습니다...")
    img = cv2.imread(image_path)
    face_cascade = cv2.CascadeClassifier(
        cv2.data.haarcascades + 'haarcascade_frontalface_default.xml'
    )
    
    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    faces = face_cascade.detectMultiScale(gray, 1.3, 5)
    
    # 결과를 캐시에 저장
    if cache:
        cache.set(image_path, operation, params, faces)
    
    return faces

# 사용 예시
cache = ImageCache()

# 첫 번째 호출 (실제 처리)
faces1 = detect_faces_with_cache('photo.jpg', cache)
print(f"검출된 얼굴: {len(faces1)}개")

# 두 번째 호출 (캐시에서 가져옴)
faces2 = detect_faces_with_cache('photo.jpg', cache)
print(f"검출된 얼굴: {len(faces2)}개")

캐싱은 같은 이미지를 반복해서 처리할 때 엄청난 시간을 절약해줘! 특히 웹 서비스에서 사용자가 같은 이미지를 여러 번 요청할 때 유용하지. 첫 번째는 처리하는 데 시간이 걸리지만, 두 번째부터는 거의 즉시 결과를 반환할 수 있어. ⚡

🔧 문제 해결과 디버깅

이미지 처리를 하다 보면 여러 가지 문제에 부딪히게 돼. 여기서는 자주 발생하는 문제들과 해결 방법을 알아볼게!

일반적인 오류와 해결책

import cv2
import os

def safe_imread(image_path):
    """안전하게 이미지 읽기"""
    # 파일 존재 확인
    if not os.path.exists(image_path):
        print(f"파일이 존재하지 않습니다: {image_path}")
        return None
    
    # 이미지 읽기
    img = cv2.imread(image_path)
    
    if img is None:
        # 다른 방법으로 시도
        try:
            from PIL import Image
            import numpy as np
            
            pil_img = Image.open(image_path)
            img = cv2.cvtColor(np.array(pil_img), cv2.COLOR_RGB2BGR)
            print("Pillow로 이미지를 읽었습니다.")
        except Exception as e:
            print(f"이미지를 읽을 수 없습니다: {e}")
            return None
    
    return img

# 사용 예시
img = safe_imread('photo.jpg')
if img is not None:
    print(f"이미지 크기: {img.shape}")

import cv2
import numpy as np

def imread_korean(filename):
    """한글 경로를 처리할 수 있는 imread"""
    try:
        # numpy로 파일 읽기
        stream = open(filename, "rb")
        bytes_data = bytearray(stream.read())
        numpy_array = np.asarray(bytes_data, dtype=np.uint8)
        
        # OpenCV로 디코딩
        img = cv2.imdecode(numpy_array, cv2.IMREAD_COLOR)
        return img
    except Exception as e:
        print(f"오류: {e}")
        return None

def imwrite_korean(filename, img):
    """한글 경로로 이미지 저장"""
    try:
        # 이미지 인코딩
        extension = filename.split('.')[-1]
        result, encoded_img = cv2.imencode(f'.{extension}', img)
        
        if result:
            # 파일로 저장
            with open(filename, mode='w+b') as f:
                encoded_img.tofile(f)
            return True
        return False
    except Exception as e:
        print(f"오류: {e}")
        return False

# 사용 예시
img = imread_korean('한글경로/사진.jpg')
if img is not None:
    imwrite_korean('한글경로/결과.jpg', img)

import cv2

def safe_color_convert(img, conversion):
    """안전한 색상 공간 변환"""
    try:
        # 이미지가 None인지 확인
        if img is None:
            print("이미지가 None입니다.")
            return None
        
        # 이미지 차원 확인
        if len(img.shape) < 2:
            print("잘못된 이미지 형식입니다.")
            return None
        
        # 이미 그레이스케일인 경우
        if len(img.shape) == 2 and conversion == cv2.COLOR_BGR2GRAY:
            print("이미 그레이스케일 이미지입니다.")
            return img
        
        # 변환 수행
        converted = cv2.cvtColor(img, conversion)
        return converted
        
    except cv2.error as e:
        print(f"색상 변환 오류: {e}")
        return None

# 사용 예시
img = cv2.imread('photo.jpg')
gray = safe_color_convert(img, cv2.COLOR_BGR2GRAY)

성능 프로파일링

import cv2
import time
import cProfile
import pstats

def profile_function(func):
    """함수 실행 시간 측정 데코레이터"""
    def wrapper(*args, **kwargs):
        start_time = time.time()
        result = func(*args, **kwargs)
        end_time = time.time()
        print(f"{func.__name__} 실행 시간: {end_time - start_time:.4f}초")
        return result
    return wrapper

@profile_function
def process_image_method1(img):
    """방법 1: 기본 처리"""
    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    blurred = cv2.GaussianBlur(gray, (5, 5), 0)
    edges = cv2.Canny(blurred, 50, 150)
    return edges

@profile_function
def process_image_method2(img):
    """방법 2: 최적화된 처리"""
    # 크기 축소
    small = cv2.resize(img, None, fx=0.5, fy=0.5)
    gray = cv2.cvtColor(small, cv2.COLOR_BGR2GRAY)
    blurred = cv2.GaussianBlur(gray, (5, 5), 0)
    edges = cv2.Canny(blurred, 50, 150)
    # 원래 크기로 복원
    edges = cv2.resize(edges, (img.shape[1], img.shape[0]))
    return edges

def detailed_profiling():
    """상세한 프로파일링"""
    img = cv2.imread('large_image.jpg')
    
    # cProfile 사용
    profiler = cProfile.Profile()
    profiler.enable()
    
    # 처리 실행
    result = process_image_method1(img)
    
    profiler.disable()
    
    # 결과 출력
    stats = pstats.Stats(profiler)
    stats.sort_stats('cumulative')
    stats.print_stats(10)  # 상위 10개 함수

# 사용 예시
img = cv2.imread('test.jpg')
result1 = process_image_method1(img)
result2 = process_image_method2(img)

# 상세 프로파일링
detailed_profiling()

🌟 실무 활용 사례와 수익화

이제까지 배운 기술들을 실제로 어떻게 활용하고 수익화할 수 있는지 알아보자! 재능넷 같은 플랫폼에서 이미지 처리 서비스를 제공하는 것도 좋은 방법이야. 💰

수익화 아이디어

포트폴리오 프로젝트 예시

"""
완성도 높은 이미지 처리 웹 서비스 예시
Flask를 사용한 간단한 API 서버
"""

from flask import Flask, request, send_file, jsonify
import cv2
import numpy as np
from PIL import Image
import io
import base64

app = Flask(__name__)

@app.route('/api/remove-background', methods=['POST'])
def remove_background_api():
    """배경 제거 API"""
    try:
        # 이미지 받기
        file = request.files['image']
        img = Image.open(file.stream)
        img_array = np.array(img)
        
        # OpenCV로 변환
        img_bgr = cv2.cvtColor(img_array, cv2.COLOR_RGB2BGR)
        
        # 배경 제거 처리
        mask = np.zeros(img_bgr.shape[:2], np.uint8)
        bgd_model = np.zeros((1, 65), np.float64)
        fgd_model = np.zeros((1, 65), np.float64)
        
        height, width = img_bgr.shape[:2]
        rect = (int(width*0.1), int(height*0.1), 
                int(width*0.8), int(height*0.8))
        
        cv2.grabCut(img_bgr, mask, rect, bgd_model, fgd_model, 
                   5, cv2.GC_INIT_WITH_RECT)
        
        mask2 = np.where((mask == 2) | (mask == 0), 0, 1).astype('uint8')
        result = img_bgr * mask2[:, :, np.newaxis]
        
        # 결과를 이미지로 변환
        result_rgb = cv2.cvtColor(result, cv2.COLOR_BGR2RGB)
        result_img = Image.fromarray(result_rgb)
        
        # 바이트로 변환
        img_io = io.BytesIO()
        result_img.save(img_io, 'PNG')
        img_io.seek(0)
        
        return send_file(img_io, mimetype='image/png')
        
    except Exception as e:
        return jsonify({'error': str(e)}), 400

@app.route('/api/detect-faces', methods=['POST'])
def detect_faces_api():
    """얼굴 인식 API"""
    try:
        file = request.files['image']
        img = Image.open(file.stream)
        img_array = np.array(img)
        img_bgr = cv2.cvtColor(img_array, cv2.COLOR_RGB2BGR)
        
        # 얼굴 검출
        face_cascade = cv2.CascadeClassifier(
            cv2.data.haarcascades + 'haarcascade_frontalface_default.xml'
        )
        gray = cv2.cvtColor(img_bgr, cv2.COLOR_BGR2GRAY)
        faces = face_cascade.detectMultiScale(gray, 1.3, 5)
        
        # 결과 반환
        faces_list = [
            {'x': int(x), 'y': int(y), 'width': int(w), 'height': int(h)}
            for (x, y, w, h) in faces
        ]
        
        return jsonify({
            'face_count': len(faces),
            'faces': faces_list
        })
        
    except Exception as e:
        return jsonify({'error': str(e)}), 400

@app.route('/api/apply-filter', methods=['POST'])
def apply_filter_api():
    """필터 적용 API"""
    try:
        file = request.files['image']
        filter_type = request.form.get('filter', 'none')
        
        img = Image.open(file.stream)
        
        if filter_type == 'grayscale':
            img = img.convert('L').convert('RGB')
        elif filter_type == 'sepia':
            img_array = np.array(img)
            kernel = np.array([[0.393, 0.769, 0.189],
                             [0.349, 0.686, 0.168],
                             [0.272, 0.534, 0.131]])
            img_array = cv2.transform(img_array, kernel)
            img = Image.fromarray(np.uint8(img_array))
        
        # 결과 반환
        img_io = io.BytesIO()
        img.save(img_io, 'JPEG', quality=90)
        img_io.seek(0)
        
        return send_file(img_io, mimetype='image/jpeg')
        
    except Exception as e:
        return jsonify({'error': str(e)}), 400

if __name__ == '__main__':
    app.run(debug=True, host='0.0.0.0', port=5000)

이런 API 서버를 만들면 웹사이트나 모바일 앱에서 쉽게 이미지 처리 기능을 사용할 수 있어! 재능넷에서 이런 서비스를 제공하면 많은 수요가 있을 거야. 특히 소규모 쇼핑몰이나 스타트업에서 필요로 하는 기능들이거든. 🚀

📚 학습 로드맵과 추가 자료

컴퓨터 비전은 정말 넓고 깊은 분야야. 여기서 배운 내용은 시작에 불과해! 더 깊이 공부하고 싶다면 다음 로드맵을 따라가보자. 🎓

유용한 학습 자료

🎯 마무리하며

와! 정말 긴 여정이었지? 😊 우리는 Pillow와 OpenCV의 기초부터 실전 프로젝트, 성능 최적화, 그리고 수익화 방법까지 정말 많은 내용을 다뤘어.

이미지 처리와 컴퓨터 비전은 정말 매력적인 분야야. 우리가 매일 사용하는 스마트폰 카메라, 소셜 미디어 필터, 자율주행 자동차, 의료 진단 시스템 등 모든 곳에 이 기술이 사용되고 있어. 그리고 앞으로도 계속 발전할 거야!

처음에는 어렵게 느껴질 수 있지만, 하나씩 차근차근 따라하다 보면 어느새 멋진 프로젝트를 만들고 있는 자신을 발견하게 될 거야. 실패를 두려워하지 말고, 많이 실험하고 연습해봐. 그게 가장 빠른 학습 방법이거든! 💪

재능넷 같은 플랫폼을 활용하면 배운 기술을 실제 프로젝트에 적용하면서 수익도 창출할 수 있어. 작은 프로젝트부터 시작해서 점차 규모를 키워나가면 돼. 누구나 처음에는 초보자였다는 걸 기억해!

이 글이 여러분의 컴퓨터 비전 여정에 좋은 출발점이 되었으면 좋겠어. 궁금한 점이 있거나 막히는 부분이 있다면 언제든 커뮤니티에 질문하고, 다른 개발자들과 소통하면서 함께 성장해나가자! 🚀

자, 이제 여러분의 차례야! 오늘 배운 내용을 바탕으로 첫 번째 프로젝트를 시작해보는 건 어때? 작은 것부터 시작해서 점점 발전시켜 나가다 보면, 어느새 전문가가 되어 있을 거야!

행운을 빌어! 화이팅! 🎉✨