OpenCV 강좌, 카메라 왜곡 보정과 캘리브레이션

안녕하세요! 이번 강좌에서는 OpenCV를 활용하여 카메라 왜곡을 보정하는 방법과 카메라 캘리브레이션에 대해 자세히 알아보겠습니다. 컴퓨터 비전 분야에서 카메라 보정은 다양한 응용프로그램에서 중요한 역할을 합니다. 다채로운 이미지를 정확하게 처리하기 위해서는 왜곡된 이미지를 올바르게 보정할 필요가 있습니다. 그럼 이 과정을 시작해보겠습니다.

1. 카메라 왜곡 개념

카메라 왜곡은 물체의 이미지를 왜곡시키는 여러 요인으로 인해 발생합니다. 이 요인은 다음과 같습니다:

  • 렌즈 왜곡: 주로 볼록 렌즈나 오목 렌즈의 사용으로 인해 발생합니다. 이러한 왜곡은 실물의 모양을 변형시키고, 이는 대칭적이지 않은 형태를 만들어냅니다.
  • 소실점 효과: 이미지를 생성할 때, 다양한 각도와 거리에서 물체가 표현되기 때문에 소실점 효과가 발생할 수 있습니다.
  • 카메라와 물체 간의 거리: 카메라가 물체와 얼마나 멀리 떨어져 있는지에 따라 왜곡 정도가 달라질 수 있습니다.

2. 카메라 왜곡 보정의 필요성

카메라 왜곡을 보정하는 것은 여러 가지 컴퓨터 비전 작업에서 필수적입니다. 이를 통해 우리가 바라는 이미지의 정확한 형태를 얻을 수 있습니다.

  • 측정 정확도 향상: 왜곡이 있는 이미지를 사용하여 물체의 크기나 거리 등을 측정하기 어려울 수 있습니다. 보정을 통해 측정의 정확도를 높일 수 있습니다.
  • 정확한 이미지 분석: 객체 인식, 이미지 스티칭, 3D 재구성 등에서는 왜곡된 이미지를 사용하면 결과에 영향을 줄 수 있습니다.
  • 시각적 품질 향상: 특히 게임, 영화 제작 등의 분야에서는 시각적 품질이 중요합니다. 왜곡을 보정하여 보다 자연스럽고 매끄러운 이미지를 만들어낼 수 있습니다.

3. OpenCV를 이용한 카메라 캘리브레이션

카메라 캘리브레이션은 카메라의 내부 파라미터와 외부 파라미터를 계산하여 왜곡을 보정하는 과정입니다. OpenCV에서는 이 과정을 수행하기 위한 다양한 함수를 제공하고 있습니다.

3.1. 카메라 캘리브레이션을 위한 준비

먼저, 카메라 캘리브레이션을 위해 장치, 촬영할 이미지, 그리고 체스보드 패턴이 필요합니다. 체스보드 패턴은 코너 포인트를 찾는데 도움을 주며, 다음과 같은 규칙에 따라 만들어질 수 있습니다:

  • 검정과 흰색이 번갈아 가며 배열된 정사각형으로 이루어져야 합니다.
  • 정사각형의 크기는 일관되게 유지해야 하며, 각 정사각형의 크기는 캘리브레이션 후 조정할 파라미터를 위한 기준으로 사용됩니다.

3.2. 캘리브레이션 과정

  1. 체스보드 이미지를 여러 장 촬영합니다. 각 이미지는 서로 다른 각도와 위치에서 촬영해야 합니다.
  2. 촬영한 이미지를 통해 코너 포인트를 찾아냅니다.
  3. 찾은 코너 포인트를 이용해 카메라의 내부 및 외부 파라미터를 계산합니다.
  4. 계산된 파라미터를 사용하여 이미지 왜곡을 보정합니다.

3.3. OpenCV 코드 예제

아래는 Python과 OpenCV를 사용하여 카메라 캘리브레이션을 수행하는 간단한 예제 코드입니다.

import numpy as np
import cv2
import glob

# 체스보드 내의 정사각형 수
CHECKERBOARD = (7, 6)

# 3D 포인트와 2D 포인트 저장
objp = np.zeros((CHECKERBOARD[0] * CHECKERBOARD[1], 3), np.float32)
objp[:, :2] = np.mgrid[0:CHECKERBOARD[0], 0:CHECKERBOARD[1]].T.reshape(-1, 2)

# 3D 포인트 및 2D 포인트를 담을 리스트 설정
objpoints = []  # 3D 포인트
imgpoints = []  # 2D 포인트

# 이미지 파일을 찾는다
images = glob.glob('path/to/your/images/*.jpg')

# 각 이미지에 대해 반복
for fname in images:
    img = cv2.imread(fname)
    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

    # 코너 찾기
    ret, corners = cv2.findChessboardCorners(gray, CHECKERBOARD, None)

    # 코너가 발견되었다면
    if ret:
        objpoints.append(objp)
        imgpoints.append(corners)

# 카메라 보정
ret, mtx, dist, rvecs, tvecs = cv2.calibrateCamera(objpoints, imgpoints, gray.shape[::-1], None, None)

# 보정된 이미지 저장하기
img = cv2.imread('path/to/your/test/image.jpg')
dst = cv2.undistort(img, mtx, dist, None, mtx)

cv2.imwrite('calibrated_image.jpg', dst)

print("카메라 보정 완료! 보정된 이미지를 확인해주세요.")

4. 카메라 왜곡 보정 결과 확인하기

위의 코드에서 우리는 카메라 모델(mtx)과 왜곡 계수(dist)를 구한 후, cv2.undistort() 함수를 사용하여 원본 이미지를 보정했습니다. 보정 작업이 완료되면, 결과 이미지를 확인하여 왜곡이 얼마나 잘 보정되었는지 살펴보십시오. 또한, 왜곡이 있는 원본 이미지와 비교하여 어떤 변화가 있었는지를 확인하는 것이 좋습니다.

4.1. 왜곡 전후 이미지 비교

아래는 왜곡 전후 이미지를 비교하는 방법을 나타내는 코드입니다.

import matplotlib.pyplot as plt

# 이미지를 표시합니다
original_image = cv2.imread('path/to/your/test/image.jpg')
calibrated_image = cv2.imread('calibrated_image.jpg')

# 이미지를 표시
plt.subplot(1, 2, 1)
plt.title('Before Correction')
plt.imshow(cv2.cvtColor(original_image, cv2.COLOR_BGR2RGB))

plt.subplot(1, 2, 2)
plt.title('After Correction')
plt.imshow(cv2.cvtColor(calibrated_image, cv2.COLOR_BGR2RGB))

plt.show()

5. 결론

이번 강좌를 통해 OpenCV를 사용하여 카메라 왜곡 보정과 캘리브레이션의 기본 개념과 방법을 익히셨기를 바랍니다. 카메라 캘리브레이션은 실제 컴퓨터 비전 프로젝트에서 매우 중요한 절차이며, 왜곡이 없는 정확한 이미지를 얻기 위해 필수적입니다.

OpenCV는 이 과정을 간편하게 수행할 수 있는 훌륭한 도구입니다. 앞으로도 OpenCV를 활용하여 다양한 컴퓨터 비전 응용 프로그램을 개발하시기 바랍니다. 질문이 있으시면 댓글로 남겨주세요!

OpenCV 강좌, 외곽선 활용한 도형 인식과 라벨링

OpenCV(Open Source Computer Vision Library)는 컴퓨터 비전 관련 작업을 용이하게 수행하기 위해 설계된 라이브러리입니다. 본 강좌에서는 OpenCV를 사용하여 이미지를 처리하고 도형을 인식하며 이를 라벨링하는 방법에 대해 다루겠습니다. 외곽선 추출 방법과 도형 인식 기술을 통해 다양한 도형을 자동으로 식별할 수 있습니다. 이 글에서는 주로 Python을 사용하여 설명하겠습니다.

목차

1. OpenCV 소개

OpenCV는 2000년에 인텔에서 처음 개발된 라이브러리로, 오늘날 데이터 분석과 머신러닝을 포함한 다양한 분야에서 널리 사용되고 있습니다. 이미지와 비디오 처리 작업을 수행하는 데 강력한 도구를 제공하여 연구 및 상용 제품에 활용되고 있습니다. OpenCV는 C++, Python, Java 등 여러 프로그래밍 언어를 지원합니다.

2. 환경 설정

OpenCV를 사용하기 위해서는 먼저 Python 환경을 설정해야 합니다. 다음은 필요한 패키지 설치 방법입니다.

pip install opencv-python
pip install opencv-python-headless
pip install numpy

설치가 완료되면, 기본적인 OpenCV 기능을 사용할 준비가 완료됩니다.

3. 기본 개념

도형 인식 및 라벨링을 설명하기 위해, 몇 가지 기본 알고리즘과 개념을 이해해야 합니다. 우리는 외곽선 추출(contour extraction), 도형의 형태(circular, rectangular), 그리고 라벨링(Labeling) 과정에 대해 다룰 것입니다.

3.1 외곽선 (Contour)

외곽선이란 2D 이미지에서 피사체를 정의하는 경계선입니다. OpenCV에서는 cv2.findContours() 함수를 통해 처리할 수 있습니다.

3.2 도형 인식

도형 인식은 특히 면적과 외곽선을 기반으로 도형을 분류하는 작업입니다. 일반적으로 원, 사각형, 다각형 등을 인식하는 데 사용됩니다.

3.3 라벨링

라벨링이란 인식된 도형에 이름을 붙이는 과정입니다. 생성된 외곽선 정보를 바탕으로 각 도형에 의해 이름 붙여지는 프로세스입니다.

4. 외곽선 추출

이제 OpenCV를 활용하여 이미지를 불러오고 외곽선을 추출하는 방법을 알아보겠습니다. 함수를 사용하여 이미지를 전처리한 후 외곽선을 찾을 수 있습니다. 예제 코드입니다.

import cv2
import numpy as np

# 이미지 읽기
image = cv2.imread('shapes.png')
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

# 경계 검출을 위한 바이너리 이미지로 변환
_, thresh = cv2.threshold(gray, 127, 255, cv2.THRESH_BINARY)

# 외곽선 찾기
contours, _ = cv2.findContours(thresh, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)

# 외곽선 그리기
cv2.drawContours(image, contours, -1, (0, 255, 0), 2)

# 결과 표시
cv2.imshow('Contours', image)
cv2.waitKey(0)
cv2.destroyAllWindows()

이 코드는 입력 이미지에서 외곽선을 검출하고 이를 녹색으로 강조하여 표시합니다. cv2.threshold() 를 사용하여 이미지를 이진화한 후, cv2.findContours()를 호출하여 외곽선을 찾습니다.

5. 도형 인식

외곽선이 추출된 후, 각 도형의 형태를 분석하여 인식할 수 있습니다. 아래 코드는 각 외곽선의 형태를 식별하고 이에 따라 도형의 이름을 출력하는 방법을 보여줍니다.

for contour in contours:
    # 외곽선의 면적
    area = cv2.contourArea(contour)

    # 작은 외곽선 무시
    if area < 100:
        continue

    # 외곽선을 근사하여 도형의 꼭짓점 수 계산
    epsilon = 0.02 * cv2.arcLength(contour, True)
    approx = cv2.approxPolyDP(contour, epsilon, True)

    # 도형 인식
    if len(approx) == 3:
        cv2.putText(image, 'Triangle', tuple(approx[0][0]), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 0, 0), 2)
    elif len(approx) == 4:
        # 면적비율로 사각형인지 확인
        x, y, w, h = cv2.boundingRect(contour)
        aspectRatio = float(w) / h
        if aspectRatio >= 0.95 and aspectRatio <= 1.05:
            cv2.putText(image, 'Square', (x, y), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 0, 0), 2)
        else:
            cv2.putText(image, 'Rectangle', (x, y), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 0, 0), 2)
    elif len(approx) == 5:
        cv2.putText(image, 'Pentagon', tuple(approx[0][0]), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 0, 0), 2)
    elif len(approx) == 6:
        cv2.putText(image, 'Hexagon', tuple(approx[0][0]), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 0, 0), 2)
    else:
        cv2.putText(image, 'Circle', (int(contour[0][0][0]), int(contour[0][0][1])), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 0, 0), 2)

이 코드는 각 도형을 외곽선의 꼭짓점 수와 면적 비율을 바탕으로 식별합니다. 삼각형, 사각형, 원 등의 도형을 인식하고 해당 이름을 이미지에 추가하여 표시합니다.

6. 라벨링

라벨링 작업은 인식된 도형에 대한 정보를 사용자가 이해할 수 있는 형태로 표현하는 것입니다. 우리는 각 도형의 위치와 형태를 기반으로 이름을 붙였습니다. 위의 코드에서도 이미지를 표시할 때 도형 이름을 적어줌으로써 라벨링을 수행했습니다.

7. 실제 코드 예제

전체 코드를 하나로 묶으면 다음과 같습니다. 주어진 이미지에서 도형을 인식하고 라벨링하는 전체적인 프로세스를 구현하였습니다.

import cv2
import numpy as np

# 이미지 읽기
image = cv2.imread('shapes.png')
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

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

for contour in contours:
    area = cv2.contourArea(contour)
    if area < 100:
        continue
    epsilon = 0.02 * cv2.arcLength(contour, True)
    approx = cv2.approxPolyDP(contour, epsilon, True)
    
    # 도형 인식 및 라벨링
    if len(approx) == 3:
        cv2.putText(image, 'Triangle', tuple(approx[0][0]), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 0, 0), 2)
    elif len(approx) == 4:
        x, y, w, h = cv2.boundingRect(contour)
        aspectRatio = float(w) / h
        if aspectRatio >= 0.95 and aspectRatio <= 1.05:
            cv2.putText(image, 'Square', (x, y), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 0, 0), 2)
        else:
            cv2.putText(image, 'Rectangle', (x, y), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 0, 0), 2)
    elif len(approx) == 5:
        cv2.putText(image, 'Pentagon', tuple(approx[0][0]), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 0, 0), 2)
    elif len(approx) == 6:
        cv2.putText(image, 'Hexagon', tuple(approx[0][0]), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 0, 0), 2)
    else:
        cv2.putText(image, 'Circle', (int(contour[0][0][0]), int(contour[0][0][1])), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 0, 0), 2)

# 결과 표시
cv2.imshow('Shapes', image)
cv2.waitKey(0)
cv2.destroyAllWindows()

8. 결론

이번 강좌에서는 OpenCV를 이용하여 외곽선을 추출하고 도형을 인식하며 라벨링하는 방법을 살펴보았습니다. OpenCV의 다양한 기능을 활용하여 더욱 복잡한 이미지 처리와 분석 작업을 수행할 수 있습니다. 앞으로 더 많은 예제와 기술을 통해 여러분의 컴퓨터 비전 지식을 확장해 나가기를 바랍니다.

자세한 내용은 OpenCV의 공식 문서 및 커뮤니티 자료를 참조하시기 바랍니다.

감사합니다.

OpenCV 강좌, PyTorch 모델을 OpenCV로 로드하여 실행하기

저자: 조광형

작성일: 2024년 11월 26일

1. 서론

OpenCV(Open Source Computer Vision Library)는 컴퓨터 비전 및 머신러닝을 위한 라이브러리로,
다양한 이미지 및 비디오 처리 기술을 제공합니다. PyTorch는 머신러닝 라이브러리로, 특히 딥러닝 모델의
개발과 학습에 많이 사용됩니다. 본 강좌에서는 PyTorch로 학습한 모델을 OpenCV를 통해 로드하여
실시간으로 실행하는 방법에 대해 설명하겠습니다.

2. 요구 사항

이 강좌를 진행하기 위해 필요한 요구 사항은 다음과 같습니다:

  • Python 3.x 버전
  • OpenCV 라이브러리
  • PyTorch 라이브러리
  • NumPy

Python과 필요한 라이브러리를 설치하려면 다음과 같은 명령어를 사용할 수 있습니다:

pip install opencv-python torchvision torch numpy

3. PyTorch 모델 학습하기

우선 PyTorch를 사용하여 간단한 CNN 모델을 학습시킵니다. 여기서는 MNIST 데이터셋을 사용하여 숫자 이미지를 분류하는 모델을 만들어 보겠습니다.


import torch
import torch.nn as nn
import torch.optim as optim
from torchvision import datasets, transforms

# 데이터셋 로드 및 전처리
transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.5,), (0.5,))
])

train_dataset = datasets.MNIST(root='./data', train=True, download=True, transform=transform)
train_loader = torch.utils.data.DataLoader(dataset=train_dataset, batch_size=64, shuffle=True)

# 모델 정의
class SimpleCNN(nn.Module):
    def __init__(self):
        super(SimpleCNN, self).__init__()
        self.conv1 = nn.Conv2d(1, 32, kernel_size=3)
        self.pool = nn.MaxPool2d(kernel_size=2)
        self.conv2 = nn.Conv2d(32, 64, kernel_size=3)
        self.fc1 = nn.Linear(64 * 6 * 6, 128)
        self.fc2 = nn.Linear(128, 10)
    
    def forward(self, x):
        x = self.pool(torch.relu(self.conv1(x)))
        x = self.pool(torch.relu(self.conv2(x)))
        x = x.view(-1, 64 * 6 * 6)
        x = torch.relu(self.fc1(x))
        return self.fc2(x)

# 모델 인스턴스 생성 및 손실 함수 및 최적화 알고리즘 정의
model = SimpleCNN()
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

# 모델 학습
model.train()
for epoch in range(5):  # 5 에포크 동안 학습
    for images, labels in train_loader:
        optimizer.zero_grad()
        outputs = model(images)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()
    
    print(f'Epoch [{epoch+1}/5], Loss: {loss.item():.4f}')

# 모델 저장
torch.save(model.state_dict(), 'mnist_cnn.pth')
            

위 코드는 MNIST 데이터셋을 로드하여 간단한 CNN 모델을 정의하고 학습시키는 코드입니다.
모델이 학습한 후, ‘mnist_cnn.pth’ 파일로 모델을 저장합니다.

4. OpenCV에서 PyTorch 모델 로드하기

저장한 PyTorch 모델을 OpenCV에서 접근하려면, 먼저 모델을 로드하고 OpenCV 형식으로 변환해야 합니다.
OpenCV에서 사용하려면 ONNX(Open Neural Network Exchange) 형식으로 변환해야 합니다. 아래 코드를
사용하여 모델을 ONNX 형식으로 변환합니다.


dummy_input = torch.randn(1, 1, 28, 28)  # MNIST의 이미지 크기
torch.onnx.export(model, dummy_input, 'mnist_cnn.onnx')
            

위 코드는 모델을 ONNX 형식으로 변환하는 과정입니다. 이제 OpenCV를 사용하여 이 ONNX 모델을 로드할 수 있습니다.

5. OpenCV를 사용하여 ONNX 모델 실행하기

OpenCV에서 ONNX 모델을 로드하고 실행하는 방법은 다음과 같습니다. OpenCV의 dnn 모듈을 사용하여
모델을 로드하고 이미지를 입력으로 사용하여 예측할 수 있습니다.


import cv2
import numpy as np

# 모델 로드
net = cv2.dnn.readNetFromONNX('mnist_cnn.onnx')

# 이미지 전처리
image = cv2.imread('test_image.png', cv2.IMREAD_GRAYSCALE)
image = cv2.resize(image, (28, 28))
image = image.astype(np.float32) / 255.0
image = np.expand_dims(image, axis=0)
image = np.expand_dims(image, axis=0)
image = np.array(image, dtype=np.float32)

# 모델에 입력
blob = cv2.dnn.blobFromImage(image)
net.setInput(blob)
output = net.forward()

# 결과 출력
predicted_class = np.argmax(output, axis=1)
print(f'Predicted class: {predicted_class[0]}')
            

위 코드는 OpenCV를 사용하여 ONNX 모델을 로드하고, 주어진 이미지를 전처리한 후 모델을 통해
예측 결과를 출력합니다. 이미지가 MNIST 데이터셋의 크기에 맞게 전처리되었는지 확인하세요.

6. 실시간 이미지 처리

OpenCV를 사용하여 웹캠에서 실시간으로 이미지를 처리하고 예측하는 방법도 알아보겠습니다.
아래 코드는 웹캠에서 이미지를 캡처하고, 모델을 사용하여 숫자를 인식하는 예제입니다.


cap = cv2.VideoCapture(0)  # 웹캠 캡처 시작

while True:
    ret, frame = cap.read()
    if not ret:
        break
    
    # 이미지 전처리
    gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
    resized = cv2.resize(gray, (28, 28))
    normed = resized.astype(np.float32) / 255.0
    blob = cv2.dnn.blobFromImage(normed)
    
    # 모델에 입력
    net.setInput(blob)
    output = net.forward()
    predicted_class = np.argmax(output, axis=1)[0]
    
    # 예측 결과 표시
    cv2.putText(frame, f'Predicted: {predicted_class}', (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 
                1, (0, 255, 0), 2, cv2.LINE_AA)
    
    cv2.imshow('Webcam', frame)
    
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

cap.release()
cv2.destroyAllWindows()
            

위 코드는 웹캠으로부터 프레임을 가져오고 각 프레임에 대해 전처리를 수행하여 모델을 통해
예측을 수행하고, 예측된 숫자를 화면에 표시합니다.
‘q’ 키를 눌러서 종료할 수 있습니다.

7. 결론

이번 강좌에서는 PyTorch로 학습한 CNN 모델을 OpenCV에서 로드하여 실행하는 방법을 알아보았습니다.
ONNX 형식으로 모델을 변환하고, OpenCV의 DNN 모듈을 활용하여 실시간 이미지 처리에 활용할 수 있음을
배웠습니다. 이러한 방식으로 기존의 다양한 머신러닝 모델을 OpenCV와 통합하여 이미지나 비디오 처리
작업에 활용할 수 있습니다. 향후 더 복잡한 모델 및 다양한 데이터셋으로의 확장을 고려해 보세요.

OpenCV 강좌, HSV 및 YUV 색상 공간

OpenCV는 컴퓨터 비전과 이미지 처리에 필요한 다양한 기능을 제공하는 오픈 소스 라이브러리입니다. 이 강좌에서는 OpenCV에서 사용되는 다양한 색상 공간 중 HSV(Hue, Saturation, Value)와 YUV 색상 공간에 대해 깊이 있게 다루겠습니다. 색상 공간은 이미지의 색상을 정의하는 방법으로, 이미지 처리 및 분석에서 중요한 역할을 합니다.

색상 공간이란?

색상 공간은 색상의 조합을 표현하는 체계입니다. 일반적으로 RGB(red, green, blue) 색상 공간이 많이 사용되지만, 특정 작업(예: 색상 기반 필터링)에서는 HSV와 YUV와 같은 다른 색상 공간이 더 유용할 수 있습니다. 색상 공간을 변경함으로써 특정 색상 범위를 더 쉽게 추출할 수 있습니다.

HSV 색상 공간

HSV 색상 공간은 색상을 다음 세 가지 성분으로 나누어 설명합니다:

  • Hue (H): 색상의 종류를 나타내며, 0°부터 360°까지의 각도로 표현됩니다. 빨강, 초록, 파랑 등의 색상이 각각 특정 각도로 매핑됩니다.
  • Saturation (S): 색상의 선명도를 나타내며, 0%에서 100%까지의 비율로 표현됩니다. 0%는 회색 (무채색), 100%는 선명한 색을 의미합니다.
  • Value (V): 색상의 밝기를 나타내며, 0에서 255까지의 값을 가집니다. 0은 완전히 어두운 색, 255는 완전히 밝은 색을 의미합니다.

HSV 색상 공간은 RGB 색상 공간보다 색상 선택과 조정이 용이하고 시각적으로 직관적입니다.

HSV 변환 예제

OpenCV를 사용하여 이미지를 HSV 색상 공간으로 변환하는 방법을 살펴보겠습니다. 아래의 예제 코드는 이미지를 읽고, RGB에서 HSV로 변환한 후 결과를 표시합니다.


import cv2
import numpy as np

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

# BGR에서 HSV로 변환
hsv_image = cv2.cvtColor(image, cv2.COLOR_BGR2HSV)

# 원본 이미지와 HSV 이미지 표시
cv2.imshow('Original Image', image)
cv2.imshow('HSV Image', hsv_image)

cv2.waitKey(0)
cv2.destroyAllWindows()
  

YUV 색상 공간

YUV 색상 공간은 TV 전송, 압축 및 신호 처리를 위해 설계된 색상 공간으로, 다음 세 가지 요소로 구성됩니다:

  • Y: 밝기 성분(루미넌스)으로, 이미지의 밝기를 나타냅니다.
  • U: 색상 성분 중 하나로, 색상의 푸른색 성분을 나타냅니다.
  • V: 색상 성분 중 다른 하나로, 색상의 빨간색 성분을 나타냅니다.

YUV 색상 공간은 압축률과 전송 품질을 높이기 위해 설계된 것이기 때문에 영상 신호 처리에서 널리 사용됩니다.

YUV 변환 예제

다음은 OpenCV를 사용하여 이미지를 YUV 색상 공간으로 변환하는 방법입니다. 아래 코드는 이미지를 읽고 BGR에서 YUV로 변환한 후 결과를 표시합니다.


# BGR에서 YUV로 변환
yuv_image = cv2.cvtColor(image, cv2.COLOR_BGR2YUV)

# 원본 이미지와 YUV 이미지 표시
cv2.imshow('Original Image', image)
cv2.imshow('YUV Image', yuv_image)

cv2.waitKey(0)
cv2.destroyAllWindows()
  

HSV 및 YUV 색상 공간의 활용

HSV와 YUV 색상 공간은 색상 기반의 객체 인식 및 추적을 수행하는 데 매우 유용합니다. 예를 들어 특정 색상의 물체를 추적하고 싶다면 다음과 같은 작업을 수행할 수 있습니다:

  • 특정 색상의 범위를 정의하여 이미지에서 필터링
  • 색상의 분포를 분석하여 객체의 위치 및 크기 파악
  • 비디오 스트리밍 중 실시간 객체 추적

색상 필터링 예제

아래 예제에서는 특정 색상(예: 빨간색) 범위 내의 픽셀을 추출하는 방법을 보여줍니다. 이 예제를 통해 HSV 색상 공간을 사용하여 특정 색상의 물체를 필터링하는 방법을 배울 수 있습니다.


# 색상 범위 정의 (예: 빨간색)
lower_red = np.array([0, 100, 100])
upper_red = np.array([10, 255, 255])

# 마스크 생성
mask = cv2.inRange(hsv_image, lower_red, upper_red)

# 마스크 적용
result = cv2.bitwise_and(image, image, mask=mask)

# 결과 표시
cv2.imshow('Mask', mask)
cv2.imshow('Filtered Red', result)

cv2.waitKey(0)
cv2.destroyAllWindows()
  

결론

이 글에서는 OpenCV를 활용한 HSV 및 YUV 색상 공간에 대해 다루었습니다. 색상 공간을 변경함으로써 이미지 처리에서의 색상 기반 작업이 얼마나 간편해지는지를 살펴보았습니다. HSV와 YUV 색상 공간은 색상 표현과 필터링을 용이하게 하여 다양한 컴퓨터 비전 프로젝트에서 널리 활용됩니다. 이 강좌를 통해 색상 공간의 기본 개념과 OpenCV 실습을 결합하여 이해도를 높일 수 있기를 바랍니다.

참고 문헌

OpenCV 강좌, Lucas-Kanade vs Farneback 방식 비교

비디오 처리 및 컴퓨터 비전 분야에서 움직임을 추적하는 것은 매우 중요한 작업입니다. 이 과정에서 주로 사용하는 알고리즘 중 두 가지는 Lucas-Kanade 방법과 Farneback 방법입니다. 이 글에서는 각각의 방법에 대해 자세히 설명하고, 각각의 장단점과 실제 사용 예제를 비교해 보겠습니다.

1. Lucas-Kanade 방법

Lucas-Kanade는 Optical Flow의 일종으로, 짧은 시간 간격 동안의 이미지에서의 픽셀 이동을 추정하는 기법입니다. 이 방법은 주로 아주 작은 움직임을 추적하는 데 유용합니다. Lucas-Kanade 방법은 다음과 같은 가정을 기반으로 합니다:

  • 인접한 픽셀에서의 밝기 변화는 크게 변하지 않는다.
  • 작은 움직임에 대해 서로 인접한 픽셀의 속도가 비슷하다.

1.1 이론적 배경

Lucas-Kanade 방법은 이미지에서의 미분을 이용하여 밝기 변화와 픽셀 이동 사이의 관계를 수학적으로 표현합니다. 이 관계는 다음과 같은 형태로 표현될 수 있습니다:

∂I/∂x * u + ∂I/∂y * v + ∂I/∂t = 0

여기서 I는 이미지 밝기, uv는 각 픽셀에서의 x, y 방향 속도를 나타냅니다.

1.2 OpenCV를 이용한 Lucas-Kanade 구현

OpenCV에서는 Lucas-Kanade 방법을 쉽게 구현할 수 있는 함수인 cv2.calcOpticalFlowFarneback을 제공합니다. 다음은 파이썬을 사용하여 Lucas-Kanade Optical Flow를 구현하는 예제입니다:

import cv2
import numpy as np

# 비디오 캡처
cap = cv2.VideoCapture('input_video.mp4')

# 첫 번째 프레임 읽기
ret, old_frame = cap.read()
old_gray = cv2.cvtColor(old_frame, cv2.COLOR_BGR2GRAY)

# 특성 포인트 찾기
p0 = cv2.goodFeaturesToTrack(old_gray, mask=None, maxCorners=100, qualityLevel=0.3, minDistance=7, blockSize=7)

# 마스크 생성
mask = np.zeros_like(old_frame)

while True:
    ret, frame = cap.read()
    if not ret:
        break
    
    frame_gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)

    # Lucas-Kanade 방법으로 Optical Flow 계산
    p1, st, err = cv2.calcOpticalFlowPyrLK(old_gray, frame_gray, p0, None)

    # 추적된 포인트를 그리기
    if p1 is not None:
        for i, (new, old) in enumerate(zip(p1, p0)):
            a, b = new.ravel()
            c, d = old.ravel()
            mask = cv2.line(mask, (a, b), (c, d), (0, 255, 0), 2)
            frame = cv2.circle(frame, (a, b), 5, (0, 0, 255), -1)

    img = cv2.add(frame, mask)

    cv2.imshow('Frame', img)
    old_gray = frame_gray.copy()
    p0 = p1[st == 1]

    if cv2.waitKey(30) & 0xFF == 27:
        break

cap.release()
cv2.destroyAllWindows()

2. Farneback 방법

Farneback 방법은 Optical Flow를 계산하는 또 다른 기법으로, 이미지 블록 분석을 통해 밀집한 흐름을 찾습니다. 이 방법은 각 픽셀에 대해 입력 이미지의 다항식을 맞추고, 이를 통해 흐름 벡터를 계산하는 방식입니다.

2.1 이론적 배경

Farneback 방법은 각 이미지 블록의 다항식逼近을 사용하여 흐름 벡터를 계산합니다. 이 방법의 핵심은 이미지 간의 변화를 매우 세밀하게 추적할 수 있다는 점입니다.

2.2 OpenCV를 이용한 Farneback 구현

OpenCV의 cv2.calcOpticalFlowFarneback 함수를 사용하여 Farneback Optical Flow를 쉽게 구현할 수 있습니다. 다음은 Farneback Optical Flow를 계산하는 예제입니다:

import cv2
import numpy as np

# 비디오 캡처
cap = cv2.VideoCapture('input_video.mp4')

# 첫 번째 프레임 읽기
ret, old_frame = cap.read()
old_gray = cv2.cvtColor(old_frame, cv2.COLOR_BGR2GRAY)

# 마스크 생성
h, w = old_gray.shape
mask = np.zeros_like(old_frame)

while True:
    ret, frame = cap.read()
    if not ret:
        break

    frame_gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)

    # Farneback 방법으로 Optical Flow 계산
    flow = cv2.calcOpticalFlowFarneback(old_gray, frame_gray, None, 0.5, 3, 15, 3, 5, 1.2, 0)

    # 벡터화 처리
    for y in range(0, h, 10):
        for x in range(0, w, 10):
            fx, fy = flow[y, x]
            cv2.arrowedLine(mask, (x, y), (int(x + fx), int(y + fy)), (0, 255, 0), 1, tipLength=0.3)

    img = cv2.add(frame, mask)

    cv2.imshow('Frame', img)
    old_gray = frame_gray.copy()

    if cv2.waitKey(30) & 0xFF == 27:
        break

cap.release()
cv2.destroyAllWindows()

3. Lucas-Kanade vs Farneback: 비교

이 두 방법은 각기 다른 상황에서 강점과 약점을 가집니다. 다음은 두 방법의 비교입니다:

특징 Lucas-Kanade Farneback
속도 빠름, 작은 영역에 적합 느림, 전체 영역에 적합
정확도 작은 움직임에 더 정확함 복잡한 움직임, 전체 흐름에서 정확함
사용 용도 특징 점 추적 등 밀도 추적, 전체 흐름 시각화 등

4. 결론

Lucas-Kanade와 Farneback 방법 모두 Optical Flow를 계산하는 데 유용하지만, 각자의 장단점이 있습니다. Lucas-Kanade 방법은 속도와 작은 움직임에 더 적합하고, Farneback 방법은 더 복잡한 움직임을 다루는 데 강점을 가지고 있습니다. 사용자들은 상황에 맞게 각각의 방법을 선택하여 사용할 수 있습니다.

이러한 Optical Flow 기법을 사용하여 비디오 분석, 객체 추적, 움직임 기반 인터페이스 등을 구현할 수 있습니다. OpenCV의 강력한 기능을 활용하여 다양한 프로젝트에 적용해 보며 컴퓨터 비전의 재미를 느껴보시길 바랍니다.