🛠️ 개발 환경 세팅하기

자, 이제 본격적으로 시작해볼까? 먼저 OpenCV를 설치해야 해. Python을 사용한다면 정말 간단해! 커피 한 잔 마시는 시간이면 충분하거든. ☕

가장 기본적인 설치 방법은 pip를 사용하는 거야. 터미널이나 명령 프롬프트를 열고 다음 명령어를 입력하면 돼:

pip install opencv-python

만약 추가 기능(특허 알고리즘 포함)이 필요하다면 contrib 버전을 설치할 수도 있어:

pip install opencv-contrib-python

설치가 완료되었는지 확인하려면 Python 인터프리터를 열고 다음을 입력해봐:

import cv2
print(cv2.__version__)

버전 번호가 출력되면 성공이야! 🎉 보통 4.x 버전대가 나올 거야. 2024년 기준으로 OpenCV 4.8 이상이면 최신 기능들을 모두 사용할 수 있어.

추가로 필요한 라이브러리들도 설치해두자:

pip install numpy matplotlib

NumPy는 배열 연산에 필수고, Matplotlib은 이미지를 시각화할 때 유용해. OpenCV와 찰떡궁합이지! 🥞

📸 첫 번째 이미지 불러오기

드디어 코딩을 시작할 시간이야! 가장 기본적인 작업부터 해보자. 이미지를 불러와서 화면에 표시하는 거야. 생각보다 정말 간단해! 😊

import cv2

# 이미지 읽기
img = cv2.imread('example.jpg')

# 이미지가 제대로 로드되었는지 확인
if img is None:
    print("이미지를 찾을 수 없습니다!")
else:
    # 이미지 표시
    cv2.imshow('My First Image', img)
    
    # 키 입력 대기 (0은 무한 대기)
    cv2.waitKey(0)
    
    # 모든 창 닫기
    cv2.destroyAllWindows()

이 코드를 실행하면 새 창이 열리면서 이미지가 표시될 거야. 아무 키나 누르면 창이 닫혀. 간단하지? 🎨

여기서 중요한 포인트 몇 가지를 짚어볼게:

이미지를 저장하는 것도 엄청 쉬워:

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

# 품질 지정해서 저장 (JPEG의 경우 0-100)
cv2.imwrite('output_high.jpg', img, [cv2.IMWRITE_JPEG_QUALITY, 95])

이제 이미지의 기본 정보를 확인해보자:

# 이미지 크기 (높이, 너비, 채널)
print(f"이미지 크기: {img.shape}")

# 전체 픽셀 수
print(f"전체 픽셀: {img.size}")

# 데이터 타입
print(f"데이터 타입: {img.dtype}")

일반적으로 컬러 이미지는 (높이, 너비, 3) 형태의 3차원 배열이야. 마지막 3은 BGR 채널을 의미해. 그레이스케일 이미지는 (높이, 너비) 형태의 2차원 배열이고! 📊

🎨 색상 공간 변환의 마법

이미지 처리에서 색상 공간 변환은 정말 중요해! 같은 이미지라도 어떤 색상 공간으로 표현하느냐에 따라 처리 방법이 완전히 달라지거든. 마치 같은 음악을 다른 악기로 연주하는 것처럼 말이야! 🎵

가장 많이 사용하는 색상 공간들을 살펴보자:

실제 코드로 변환해보자:

import cv2
import numpy as np

# 원본 이미지 읽기
img = cv2.imread('example.jpg')

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

# BGR을 HSV로 변환
img_hsv = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)

# BGR을 그레이스케일로 변환
img_gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

# BGR을 LAB로 변환
img_lab = cv2.cvtColor(img, cv2.COLOR_BGR2LAB)

# 여러 이미지 동시에 표시
cv2.imshow('Original', img)
cv2.imshow('HSV', img_hsv)
cv2.imshow('Grayscale', img_gray)
cv2.waitKey(0)
cv2.destroyAllWindows()

특정 색상 범위를 검출하는 실용적인 예제를 보자:

# 파란색 객체 검출하기
img = cv2.imread('example.jpg')
hsv = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)

# 파란색의 HSV 범위 정의
lower_blue = np.array([100, 50, 50])
upper_blue = np.array([130, 255, 255])

# 마스크 생성
mask = cv2.inRange(hsv, lower_blue, upper_blue)

# 원본 이미지에 마스크 적용
result = cv2.bitwise_and(img, img, mask=mask)

cv2.imshow('Original', img)
cv2.imshow('Mask', mask)
cv2.imshow('Result', result)
cv2.waitKey(0)
cv2.destroyAllWindows()

이 코드는 이미지에서 파란색 부분만 추출해내! 자율주행 자동차가 파란 표지판을 인식하거나, 공장에서 특정 색상의 제품을 분류할 때 이런 기술을 사용해. 🚗

🔧 기본 이미지 조작 기법

이제 이미지를 자유자재로 다뤄보자! 크기 조절, 회전, 자르기 같은 기본 조작들은 거의 모든 이미지 처리 프로젝트에서 필수적이야. 마치 요리할 때 재료를 손질하는 것처럼 말이야! 👨‍🍳

📏 이미지 크기 조절 (Resize)

이미지 크기를 조절하는 건 정말 자주 사용하는 기능이야. 딥러닝 모델에 입력하기 전에 크기를 통일하거나, 썸네일을 만들 때 필수지!

import cv2

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

# 방법 1: 절대 크기 지정
resized = cv2.resize(img, (800, 600))  # (너비, 높이)

# 방법 2: 비율로 조절
scale_percent = 50  # 50%로 축소
width = int(img.shape[1] * scale_percent / 100)
height = int(img.shape[0] * scale_percent / 100)
resized = cv2.resize(img, (width, height))

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

🔄 이미지 회전 (Rotation)

이미지를 회전시키는 방법도 여러 가지야. 간단한 90도 회전부터 임의 각도 회전까지!

# 90도 회전 (간단한 방법)
rotated_90 = cv2.rotate(img, cv2.ROTATE_90_CLOCKWISE)
rotated_180 = cv2.rotate(img, cv2.ROTATE_180)
rotated_270 = cv2.rotate(img, cv2.ROTATE_90_COUNTERCLOCKWISE)

# 임의 각도 회전 (복잡하지만 유연함)
height, width = img.shape[:2]
center = (width // 2, height // 2)

# 회전 행렬 생성 (중심점, 각도, 스케일)
rotation_matrix = cv2.getRotationMatrix2D(center, 45, 1.0)

# 회전 적용
rotated = cv2.warpAffine(img, rotation_matrix, (width, height))

# 회전 후 잘리지 않게 하려면
cos = np.abs(rotation_matrix[0, 0])
sin = np.abs(rotation_matrix[0, 1])
new_width = int((height * sin) + (width * cos))
new_height = int((height * cos) + (width * sin))

rotation_matrix[0, 2] += (new_width / 2) - center[0]
rotation_matrix[1, 2] += (new_height / 2) - center[1]

rotated_full = cv2.warpAffine(img, rotation_matrix, (new_width, new_height))

✂️ 이미지 자르기 (Cropping)

이미지 자르기는 NumPy 배열 슬라이싱으로 정말 간단하게 할 수 있어!

# 이미지는 NumPy 배열이므로 슬라이싱 가능
# img[y1:y2, x1:x2]
cropped = img[100:400, 200:500]

# 중앙 부분만 자르기
h, w = img.shape[:2]
center_crop = img[h//4:3*h//4, w//4:3*w//4]

# 정사각형으로 자르기 (중앙 기준)
size = min(h, w)
start_h = (h - size) // 2
start_w = (w - size) // 2
square_crop = img[start_h:start_h+size, start_w:start_w+size]

🔀 이미지 뒤집기 (Flip)

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

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

# 좌우+상하 반전 (180도 회전과 동일)
flipped_both = cv2.flip(img, -1)

🎭 필터와 블러링의 세계

이미지 필터링은 이미지 처리의 꽃이라고 할 수 있어! 인스타그램 필터부터 의료 영상 분석까지, 필터링 기술은 정말 다양하게 활용돼. 기본적인 개념은 간단해 - 각 픽셀과 주변 픽셀들을 특정 방식으로 조합하는 거야! 🌸

🌫️ 블러링 (Blurring)

블러링은 이미지를 부드럽게 만들거나 노이즈를 제거할 때 사용해. 여러 종류가 있는데, 각각 특징이 달라!

import cv2
import numpy as np

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

# 1. 평균 블러 (Average Blur)
# 가장 간단한 방법. 주변 픽셀의 평균값 사용
avg_blur = cv2.blur(img, (5, 5))  # 5x5 커널

# 2. 가우시안 블러 (Gaussian Blur)
# 가장 많이 사용! 중심에 가까울수록 가중치가 높음
gaussian_blur = cv2.GaussianBlur(img, (5, 5), 0)

# 3. 미디언 블러 (Median Blur)
# 소금-후추 노이즈 제거에 탁월
median_blur = cv2.medianBlur(img, 5)

# 4. 양방향 필터 (Bilateral Filter)
# 에지는 보존하면서 블러 적용. 피부 보정에 최고!
bilateral = cv2.bilateralFilter(img, 9, 75, 75)

🔍 샤프닝 (Sharpening)

블러의 반대 개념! 이미지를 더 선명하게 만들어줘. 흐릿한 사진을 살릴 때 유용하지.

# 샤프닝 커널 정의
kernel = np.array([[-1, -1, -1],
                   [-1,  9, -1],
                   [-1, -1, -1]])

# 커널 적용
sharpened = cv2.filter2D(img, -1, kernel)

# 언샤프 마스킹 (Unsharp Masking) - 더 자연스러운 방법
gaussian = cv2.GaussianBlur(img, (0, 0), 3)
unsharp = cv2.addWeighted(img, 1.5, gaussian, -0.5, 0)

🎯 에지 검출 (Edge Detection)

에지 검출은 이미지에서 경계선을 찾아내는 기술이야. 객체의 윤곽을 파악하거나 형태를 분석할 때 필수적이지!

# 1. Sobel 에지 검출
# X 방향 에지
sobelx = cv2.Sobel(img, cv2.CV_64F, 1, 0, ksize=5)

# Y 방향 에지
sobely = cv2.Sobel(img, cv2.CV_64F, 0, 1, ksize=5)

# 두 방향 결합
sobel_combined = cv2.magnitude(sobelx, sobely)

# 2. Laplacian 에지 검출
laplacian = cv2.Laplacian(img, cv2.CV_64F)

# 3. Canny 에지 검출 (가장 인기!)
# 먼저 그레이스케일로 변환
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

# 노이즈 제거를 위한 블러
blurred = cv2.GaussianBlur(gray, (5, 5), 0)

# Canny 적용
edges = cv2.Canny(blurred, 50, 150)

# 임계값 조절로 민감도 조정
edges_sensitive = cv2.Canny(blurred, 30, 100)  # 더 많은 에지
edges_less = cv2.Canny(blurred, 100, 200)  # 더 적은 에지

# 실전 예제: 문서 스캔 효과
def document_scan_effect(img):
    # 그레이스케일 변환
    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    
    # 노이즈 제거
    denoised = cv2.fastNlMeansDenoising(gray)
    
    # 적응형 임계값으로 이진화
    binary = cv2.adaptiveThreshold(
        denoised, 255, 
        cv2.ADAPTIVE_THRESH_GAUSSIAN_C, 
        cv2.THRESH_BINARY, 11, 2
    )
    
    return binary

# 사용
scanned = document_scan_effect(img)
cv2.imshow('Scanned Document', scanned)
cv2.waitKey(0)

🌈 히스토그램과 색상 분석

히스토그램은 이미지의 픽셀 값 분포를 보여주는 그래프야. 이미지가 너무 어둡거나 밝은지, 대비가 충분한지 등을 한눈에 파악할 수 있어. 사진 보정의 핵심 도구지! 📊

📈 히스토그램 계산과 시각화

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

# 이미지 읽기
img = cv2.imread('example.jpg')

# 그레이스케일 히스토그램
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
hist_gray = cv2.calcHist([gray], [0], None, [256], [0, 256])

# 컬러 히스토그램 (각 채널별)
colors = ('b', 'g', 'r')
plt.figure(figsize=(12, 4))

for i, color in enumerate(colors):
    hist = cv2.calcHist([img], [i], None, [256], [0, 256])
    plt.plot(hist, color=color, label=f'{color.upper()} channel')

plt.xlabel('Pixel Value')
plt.ylabel('Frequency')
plt.legend()
plt.title('Color Histogram')
plt.show()

⚖️ 히스토그램 평활화 (Equalization)

히스토그램 평활화는 이미지의 대비를 개선하는 강력한 기법이야. 어두운 사진을 밝게 만들거나 전체적인 톤을 균일하게 만들 수 있어!

# 그레이스케일 히스토그램 평활화
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
equalized = cv2.equalizeHist(gray)

# 전후 비교
cv2.imshow('Original', gray)
cv2.imshow('Equalized', equalized)
cv2.waitKey(0)

# 컬러 이미지의 히스토그램 평활화
# 방법 1: 각 채널별로 평활화 (색상 왜곡 발생)
b, g, r = cv2.split(img)
b_eq = cv2.equalizeHist(b)
g_eq = cv2.equalizeHist(g)
r_eq = cv2.equalizeHist(r)
equalized_bgr = cv2.merge([b_eq, g_eq, r_eq])

# 방법 2: YCrCb 색공간 사용 (더 자연스러움)
ycrcb = cv2.cvtColor(img, cv2.COLOR_BGR2YCrCb)
ycrcb[:, :, 0] = cv2.equalizeHist(ycrcb[:, :, 0])
equalized_ycrcb = cv2.cvtColor(ycrcb, cv2.COLOR_YCrCb2BGR)

🎨 적응형 히스토그램 평활화 (CLAHE)

CLAHE(Contrast Limited Adaptive Histogram Equalization)는 일반 평활화보다 훨씬 자연스러운 결과를 만들어! 이미지를 작은 타일로 나눠서 각각 평활화하기 때문에 지역적인 대비가 잘 살아나거든. 😊

# CLAHE 객체 생성
clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8, 8))

# 그레이스케일에 적용
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
clahe_gray = clahe.apply(gray)

# 컬러 이미지에 적용 (YCrCb 사용)
ycrcb = cv2.cvtColor(img, cv2.COLOR_BGR2YCrCb)
ycrcb[:, :, 0] = clahe.apply(ycrcb[:, :, 0])
clahe_color = cv2.cvtColor(ycrcb, cv2.COLOR_YCrCb2BGR)

# 결과 비교
cv2.imshow('Original', img)
cv2.imshow('CLAHE', clahe_color)
cv2.waitKey(0)

🔍 히스토그램 역투영 (Back Projection)

히스토그램 역투영은 특정 객체의 색상 분포를 학습해서 비슷한 색상을 가진 영역을 찾아내는 기법이야. 객체 추적에 유용해!

# ROI(관심 영역)에서 히스토그램 계산
roi = img[100:200, 100:200]  # 추적하고 싶은 객체 영역
hsv_roi = cv2.cvtColor(roi, cv2.COLOR_BGR2HSV)
roi_hist = cv2.calcHist([hsv_roi], [0, 1], None, [180, 256], [0, 180, 0, 256])

# 히스토그램 정규화
cv2.normalize(roi_hist, roi_hist, 0, 255, cv2.NORM_MINMAX)

# 전체 이미지에서 역투영
hsv = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)
backproj = cv2.calcBackProject([hsv], [0, 1], roi_hist, [0, 180, 0, 256], 1)

# 디스크 커널로 필터링
disc = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (5, 5))
backproj = cv2.filter2D(backproj, -1, disc)

# 임계값 적용
_, thresh = cv2.threshold(backproj, 50, 255, cv2.THRESH_BINARY)

cv2.imshow('Back Projection', backproj)
cv2.imshow('Threshold', thresh)
cv2.waitKey(0)

🎨 고급 이미지 처리 기법

이제 좀 더 고급 기술들을 배워보자! 이미지 세그멘테이션, 템플릿 매칭, 특징점 검출 같은 기법들은 실제 프로젝트에서 정말 유용하게 쓰여. 🚀

🎯 템플릿 매칭 (Template Matching)

템플릿 매칭은 큰 이미지에서 작은 템플릿 이미지를 찾는 기법이야. 게임 자동화, UI 테스트, 객체 위치 찾기 등에 활용돼!

import cv2
import numpy as np

# 원본 이미지와 템플릿 읽기
img = cv2.imread('screenshot.jpg')
template = cv2.imread('button.jpg')

# 템플릿 크기
h, w = template.shape[:2]

# 6가지 매칭 방법
methods = [
    cv2.TM_CCOEFF, cv2.TM_CCOEFF_NORMED,
    cv2.TM_CCORR, cv2.TM_CCORR_NORMED,
    cv2.TM_SQDIFF, cv2.TM_SQDIFF_NORMED
]

# TM_CCOEFF_NORMED 사용 (가장 일반적)
result = cv2.matchTemplate(img, template, cv2.TM_CCOEFF_NORMED)

# 최대/최소값과 위치 찾기
min_val, max_val, min_loc, max_loc = cv2.minMaxLoc(result)

# TM_SQDIFF 계열은 최소값이 최적, 나머지는 최대값이 최적
if cv2.TM_SQDIFF or cv2.TM_SQDIFF_NORMED:
    top_left = min_loc
else:
    top_left = max_loc

bottom_right = (top_left[0] + w, top_left[1] + h)

# 찾은 위치에 사각형 그리기
cv2.rectangle(img, top_left, bottom_right, (0, 255, 0), 2)

print(f"매칭 점수: {max_val:.4f}")
cv2.imshow('Template Matching', img)
cv2.waitKey(0)

🔍 다중 객체 템플릿 매칭

def find_multiple_templates(img, template, threshold=0.8):
    """이미지에서 템플릿과 일치하는 모든 위치 찾기"""
    
    h, w = template.shape[:2]
    result = cv2.matchTemplate(img, template, cv2.TM_CCOEFF_NORMED)
    
    # 임계값 이상인 위치 찾기
    locations = np.where(result >= threshold)
    
    # 중복 제거를 위한 리스트
    rectangles = []
    for pt in zip(*locations[::-1]):
        rectangles.append([int(pt[0]), int(pt[1]), w, h])
    
    # 겹치는 사각형 그룹화
    rectangles, weights = cv2.groupRectangles(rectangles, 1, 0.2)
    
    return rectangles

# 사용 예제
img = cv2.imread('coins.jpg')
template = cv2.imread('coin_template.jpg')

matches = find_multiple_templates(img, template, threshold=0.7)

print(f"찾은 객체: {len(matches)}개")

for (x, y, w, h) in matches:
    cv2.rectangle(img, (x, y), (x+w, y+h), (0, 255, 0), 2)
    cv2.putText(img, 'Match', (x, y-10),
               cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)

cv2.imshow('Multiple Matches', img)
cv2.waitKey(0)

✨ 특징점 검출 (Feature Detection)

특징점 검출은 이미지에서 독특한 점들을 찾아내는 기술이야. 이미지 매칭, 파노라마 생성, 3D 재구성 등에 필수적이지!

# 1. SIFT (Scale-Invariant Feature Transform)
# 크기와 회전에 불변
sift = cv2.SIFT_create()
keypoints, descriptors = sift.detectAndCompute(img, None)

# 특징점 그리기
img_sift = cv2.drawKeypoints(img, keypoints, None, 
                             flags=cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS)

# 2. ORB (Oriented FAST and Rotated BRIEF)
# SIFT보다 빠르고 무료!
orb = cv2.ORB_create(nfeatures=500)
keypoints, descriptors = orb.detectAndCompute(img, None)

img_orb = cv2.drawKeypoints(img, keypoints, None, color=(0, 255, 0))

# 3. FAST (Features from Accelerated Segment Test)
# 매우 빠른 코너 검출
fast = cv2.FastFeatureDetector_create()
keypoints = fast.detect(img, None)

img_fast = cv2.drawKeypoints(img, keypoints, None, color=(255, 0, 0))

print(f"SIFT 특징점: {len(keypoints)}개")

cv2.imshow('Feature Detection', img_sift)
cv2.waitKey(0)

🔗 특징점 매칭

def match_features(img1, img2):
    """두 이미지의 특징점을 매칭"""
    
    # ORB 검출기 생성
    orb = cv2.ORB_create()
    
    # 특징점과 디스크립터 계산
    kp1, des1 = orb.detectAndCompute(img1, None)
    kp2, des2 = orb.detectAndCompute(img2, None)
    
    # BFMatcher (Brute Force Matcher) 생성
    bf = cv2.BFMatcher(cv2.NORM_HAMMING, crossCheck=True)
    
    # 매칭
    matches = bf.match(des1, des2)
    
    # 거리순 정렬
    matches = sorted(matches, key=lambda x: x.distance)
    
    # 상위 N개 매칭 그리기
    img_matches = cv2.drawMatches(img1, kp1, img2, kp2, matches[:50],
                                   None, flags=cv2.DrawMatchesFlags_NOT_DRAW_SINGLE_POINTS)
    
    return img_matches, len(matches)

# 사용
img1 = cv2.imread('object1.jpg', 0)
img2 = cv2.imread('object2.jpg', 0)

result, num_matches = match_features(img1, img2)

print(f"매칭된 특징점: {num_matches}개")
cv2.imshow('Feature Matching', result)
cv2.waitKey(0)

🎓 실전 프로젝트 예제

이론은 충분히 배웠으니 이제 실전 프로젝트를 만들어보자! 실제로 사용할 수 있는 완성도 높은 예제들을 준비했어. 이걸 기반으로 자신만의 프로젝트를 만들어봐! 💪

📝 프로젝트 1: 문서 스캐너

스마트폰으로 찍은 문서 사진을 깔끔하게 스캔한 것처럼 만들어주는 프로그램이야!

import cv2
import numpy as np

def order_points(pts):
    """4개 점을 좌상, 우상, 우하, 좌하 순서로 정렬"""
    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):
    """4점 원근 변환"""
    rect = order_points(pts)
    (tl, tr, br, bl) = rect
    
    # 새로운 이미지의 너비 계산
    widthA = np.sqrt(((br[0] - bl[0]) ** 2) + ((br[1] - bl[1]) ** 2))
    widthB = np.sqrt(((tr[0] - tl[0]) ** 2) + ((tr[1] - tl[1]) ** 2))
    maxWidth = max(int(widthA), int(widthB))
    
    # 새로운 이미지의 높이 계산
    heightA = np.sqrt(((tr[0] - br[0]) ** 2) + ((tr[1] - br[1]) ** 2))
    heightB = np.sqrt(((tl[0] - bl[0]) ** 2) + ((tl[1] - bl[1]) ** 2))
    maxHeight = max(int(heightA), int(heightB))
    
    # 목표 점 설정
    dst = np.array([
        [0, 0],
        [maxWidth - 1, 0],
        [maxWidth - 1, maxHeight - 1],
        [0, maxHeight - 1]], dtype="float32")
    
    # 원근 변환 행렬 계산 및 적용
    M = cv2.getPerspectiveTransform(rect, dst)
    warped = cv2.warpPerspective(image, M, (maxWidth, maxHeight))
    
    return warped

def scan_document(image_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)
    blurred = cv2.GaussianBlur(gray, (5, 5), 0)
    
    # 에지 검출
    edged = cv2.Canny(blurred, 75, 200)
    
    # 윤곽선 찾기
    contours, _ = cv2.findContours(edged.copy(), cv2.RETR_LIST, 
                                    cv2.CHAIN_APPROX_SIMPLE)
    contours = sorted(contours, key=cv2.contourArea, reverse=True)[:5]
    
    # 4개 꼭짓점을 가진 윤곽선 찾기
    screenCnt = None
    for c in contours:
        peri = cv2.arcLength(c, True)
        approx = cv2.approxPolyDP(c, 0.02 * peri, True)
        
        if len(approx) == 4:
            screenCnt = approx
            break
    
    if screenCnt is None:
        print("문서 윤곽을 찾을 수 없습니다!")
        return None
    
    # 원본 크기로 좌표 변환
    screenCnt = screenCnt.reshape(4, 2) * ratio
    
    # 원근 변환 적용
    warped = four_point_transform(orig, screenCnt)
    
    # 그레이스케일 변환 및 임계값 처리
    warped_gray = cv2.cvtColor(warped, cv2.COLOR_BGR2GRAY)
    scanned = cv2.adaptiveThreshold(warped_gray, 255, 
                                     cv2.ADAPTIVE_THRESH_GAUSSIAN_C,
                                     cv2.THRESH_BINARY, 11, 2)
    
    return scanned

# 사용
result = scan_document('document.jpg')
if result is not None:
    cv2.imshow('Scanned Document', result)
    cv2.imwrite('scanned_output.jpg', result)
    cv2.waitKey(0)
    cv2.destroyAllWindows()

🎮 프로젝트 2: 가상 페인팅

웹캠으로 색깔 있는 물체를 추적해서 공중에 그림을 그리는 프로그램이야! 정말 재미있어! 🎨

import cv2
import numpy as np

class VirtualPainter:
    def __init__(self):
        self.cap = cv2.VideoCapture(0)
        self.canvas = None
        self.prev_x, self.prev_y = 0, 0
        
        # 색상 범위 (HSV) - 파란색 마커 예시
        self.lower_color = np.array([100, 50, 50])
        self.upper_color = np.array([130, 255, 255])
        
        # 브러시 색상
        self.brush_color = (0, 255, 0)
        self.brush_thickness = 5
        
    def find_marker(self, frame):
        """색상 마커 찾기"""
        hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
        mask = cv2.inRange(hsv, self.lower_color, self.upper_color)
        
        # 노이즈 제거
        mask = cv2.erode(mask, None, iterations=2)
        mask = cv2.dilate(mask, None, iterations=2)
        
        # 윤곽선 찾기
        contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, 
                                        cv2.CHAIN_APPROX_SIMPLE)
        
        if len(contours) > 0:
            # 가장 큰 윤곽선 선택
            c = max(contours, key=cv2.contourArea)
            ((x, y), radius) = cv2.minEnclosingCircle(c)
            
            if radius > 10:
                return int(x), int(y), True
        
        return 0, 0, False
    
    def run(self):
        """메인 루프"""
        ret, frame = self.cap.read()
        if ret:
            frame = cv2.flip(frame, 1)
            self.canvas = np.zeros_like(frame)
        
        while True:
            ret, frame = self.cap.read()
            if not ret:
                break
            
            frame = cv2.flip(frame, 1)
            
            # 마커 찾기
            x, y, found = self.find_marker(frame)
            
            if found:
                # 마커 위치 표시
                cv2.circle(frame, (x, y), 10, (0, 255, 255), -1)
                
                # 그리기
                if self.prev_x != 0 and self.prev_y != 0:
                    cv2.line(self.canvas, (self.prev_x, self.prev_y), 
                            (x, y), self.brush_color, self.brush_thickness)
                
                self.prev_x, self.prev_y = x, y
            else:
                self.prev_x, self.prev_y = 0, 0
            
            # 캔버스와 프레임 합성
            result = cv2.addWeighted(frame, 0.7, self.canvas, 0.3, 0)
            
            # 안내 메시지
            cv2.putText(result, 'Press C to clear, Q to quit', (10, 30),
                       cv2.FONT_HERSHEY_SIMPLEX, 0.7, (255, 255, 255), 2)
            
            cv2.imshow('Virtual Painter', result)
            
            # 키 입력 처리
            key = cv2.waitKey(1) & 0xFF
            if key == ord('q'):
                break
            elif key == ord('c'):
                self.canvas = np.zeros_like(frame)
        
        self.cap.release()
        cv2.destroyAllWindows()

# 실행
painter = VirtualPainter()
painter.run()

📊 프로젝트 3: 실시간 객체 카운터

웹캠으로 특정 객체의 개수를 실시간으로 세는 프로그램이야. 재고 관리, 사람 수 세기 등에 활용할 수 있어!

import cv2
import numpy as np

class ObjectCounter:
    def __init__(self):
        self.cap = cv2.VideoCapture(0)
        self.background = None
        self.count = 0
        
    def get_background(self, num_frames=30):
        """배경 학습"""
        print("배경을 학습중입니다...")
        
        for i in range(num_frames):
            ret, frame = self.cap.read()
            if not ret:
                continue
            
            gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
            gray = cv2.GaussianBlur(gray, (21, 21), 0)
            
            if self.background is None:
                self.background = gray
                continue
            
            # 누적 평균
            cv2.accumulateWeighted(gray, self.background, 0.5)
        
        print("배경 학습 완료!")
    
    def count_objects(self, frame):
        """프레임에서 객체 개수 세기"""
        gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
        gray = cv2.GaussianBlur(gray, (21, 21), 0)
        
        # 배경 차이 계산
        diff = cv2.absdiff(self.background.astype("uint8"), gray)
        
        # 임계값 처리
        thresh = cv2.threshold(diff, 25, 255, cv2.THRESH_BINARY)[1]
        
        # 노이즈 제거
        thresh = cv2.dilate(thresh, None, iterations=2)
        
        # 윤곽선 찾기
        contours, _ = cv2.findContours(thresh.copy(), cv2.RETR_EXTERNAL,
                                        cv2.CHAIN_APPROX_SIMPLE)
        
        count = 0
        for contour in contours:
            # 작은 윤곽선 무시
            if cv2.contourArea(contour) < 500:
                continue
            
            count += 1
            
            # 경계 상자 그리기
            (x, y, w, h) = cv2.boundingRect(contour)
            cv2.rectangle(frame, (x, y), (x + w, y + h), (0, 255, 0), 2)
            cv2.putText(frame, f"#{count}", (x, y - 10),
                       cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)
        
        return frame, count, thresh
    
    def run(self):
        """메인 루프"""
        # 배경 학습
        self.get_background()
        
        while True:
            ret, frame = self.cap.read()
            if not ret:
                break
            
            frame = cv2.flip(frame, 1)
            
            # 객체 카운팅
            result, count, thresh = self.count_objects(frame)
            
            # 정보 표시
            cv2.putText(result, f'Objects: {count}', (10, 30),
                       cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 2)
            cv2.putText(result, 'Press R to reset background, Q to quit', 
                       (10, 60), cv2.FONT_HERSHEY_SIMPLEX, 0.5, 
                       (255, 255, 255), 1)
            
            # 화면 표시
            cv2.imshow('Object Counter', result)
            cv2.imshow('Threshold', thresh)
            
            # 키 입력 처리
            key = cv2.waitKey(1) & 0xFF
            if key == ord('q'):
                break
            elif key == ord('r'):
                self.background = None
                self.get_background()
        
        self.cap.release()
        cv2.destroyAllWindows()

# 실행
counter = ObjectCounter()
counter.run()

🎯 마무리하며

와! 여기까지 정말 긴 여정이었어! 🎉 OpenCV의 기초부터 실전 프로젝트까지 함께 달려왔네. 이미지 처리와 컴퓨터 비전은 정말 매력적인 분야야. 배우면 배울수록 할 수 있는 게 많아지거든!

우리가 배운 내용을 정리해보자면:

🚀 다음 단계

OpenCV 기초를 마스터했다면 이제 어디로 가야 할까?

💼 실전 활용

배운 내용을 실제로 활용해보자! 재능넷 같은 플랫폼에서 이런 기술을 활용할 수 있어:

📖 추천 리소스

계속 공부하고 싶다면 이런 자료들을 참고해봐:

🎓 마지막 조언

컴퓨터 비전은 이론도 중요하지만 실습이 더 중요해! 책이나 강의로만 배우지 말고 직접 코드를 짜보고, 실패하고, 다시 시도해봐. 그 과정에서 진짜 실력이 늘어나거든. 😊

작은 프로젝트부터 시작해서 점점 복잡한 것으로 나아가면 돼. 완벽하지 않아도 괜찮아! 일단 만들어보고, 개선하고, 공유하면서 성장하는 거야.

그리고 커뮤니티에 참여하는 것도 잊지 마! Stack Overflow, Reddit, GitHub에서 질문하고 답변하면서 함께 성장할 수 있어. 혼자 하는 것보다 훨씬 재미있고 빠르게 배울 수 있거든! 🌟

OpenCV는 정말 강력한 도구야. 이걸로 세상을 바꿀 수 있는 멋진 프로젝트를 만들 수 있어. 자율주행차, 의료 진단, 보안 시스템, 예술 작품... 가능성은 무한해!

자, 이제 당신 차례야! 배운 것을 활용해서 멋진 프로젝트를 만들어봐. 그리고 재능넷에서 당신의 재능을 세상과 나눠봐. 응원할게! 화이팅! 💪🚀