😏:Aruco Marker

ArUco 마커 거리측정 실습 가이드

이 가이드는 OpenCV를 사용하여 ArUco 마커를 이용한 거리 측정 시스템을 구축하는 방법을 단계별로 안내합니다.

개요

ArUco 마커는 증강현실과 컴퓨터 비전에서 널리 사용되는 정사각형 마커로, 각 마커는 고유한 ID를 가지며 카메라로 쉽게 인식할 수 있습니다. 이 실습에서는 카메라 켈리브레이션부터 거리 측정까지의 전체 과정을 다룹니다.

사전 준비사항

필요한 라이브러리 설치

pip install opencv-python==4.6.0.66
pip install opencv-contrib-python==4.6.0.66
pip install numpy

체스보드 패턴 준비

• 9x6 내부 코너를 가진 체스보드 패턴 인쇄 : https://calib.io/pages/camera-calibration-pattern-generator

• 평평한 표면에 부착 (중요: 휘어지면 안됨)

• 권장 크기: A4 용지 크기

ArUco 마커 준비

• 5x4 ArUco 마커 인쇄 (온라인 생성기 사용 가능)

• 정확한 크기 측정 (예: 5cm x 5cm)

1단계: 카메라 켈리브레이션용 사진 촬영

카메라 켈리브레이션을 위해서는 다양한 각도와 위치에서 촬영한 체스보드 이미지가 필요합니다.

촬영 스크립트 작성

import cv2
import os

# 카메라 초기화
cap = cv2.VideoCapture(0)

# 이미지 저장 경로 설정
save_path = "calibration_images"
if not os.path.exists(save_path):
    os.makedirs(save_path)

image_count = 0

print("체스보드를 다양한 각도로 촬영하세요.")
print("'s' 키를 눌러 저장, 'q' 키를 눌러 종료")

while True:
    ret, frame = cap.read()
    if not ret:
        break
    
    # 화면에 이미지 표시
    cv2.imshow('Camera Calibration', frame)
    
    key = cv2.waitKey(1) & 0xFF
    
    # 's' 키를 누르면 이미지 저장
    if key == ord('s'):
        filename = f"{save_path}/calib_{image_count:02d}.jpg"
        cv2.imwrite(filename, frame)
        print(f"이미지 저장됨: {filename}")
        image_count += 1
    
    # 'q' 키를 누르면 종료
    elif key == ord('q'):
        break

cap.release()
cv2.destroyAllWindows()
print(f"총 {image_count}장의 이미지가 저장되었습니다.")

촬영 가이드라인

필수 조건

• 최소 10-15장의 이미지 필요 (20장 권장)

• 다양한 각도에서 촬영 (0°, 15°, 30°, 45° 등)

• 화면 전체에 체스보드가 보이도록 촬영

• 화면 모서리 부분도 포함하여 촬영

피해야 할 것

• 흐릿하거나 움직임이 있는 사진

• 조명이 너무 어둡거나 밝은 사진

• 체스보드가 휘어진 상태로 촬영된 사진

2단계: 카메라 켈리브레이션 진행

촬영된 이미지들을 사용하여 카메라의 내부 매개변수와 왜곡 계수를 계산합니다.

켈리브레이션 스크립트

import cv2
import numpy as np
import glob
import pickle

# 체스보드 설정
CHECKERBOARD = (9, 6)  # 내부 코너 수 (가로, 세로)
criteria = (cv2.TERM_CRITERIA_EPS + cv2.TERM_CRITERIA_MAX_ITER, 30, 0.001)

# 3D 점 준비
objp = np.zeros((CHECKERBOARD[0] * CHECKERBOARD[1], 3), np.float32)
objp[:, :2] = np.mgrid[0:CHECKERBOARD[0], 0:CHECKERBOARD[1]].T.reshape(-1, 2)

# 점들을 저장할 배열
objpoints = []  # 3D 점
imgpoints = []  # 2D 점

# 켈리브레이션 이미지 로드
images = glob.glob('calibration_images/*.jpg')
print(f"총 {len(images)}장의 이미지를 처리합니다.")

successful_images = 0
failed_images = []

for fname in images:
    img = cv2.imread(fname)
    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    
    # 체스보드 코너 찾기
    ret, corners = cv2.findChessboardCorners(gray, CHECKERBOARD, None)
    
    if ret:
        successful_images += 1
        objpoints.append(objp)
        
        # 코너 정밀도 향상
        corners2 = cv2.cornerSubPix(gray, corners, (11, 11), (-1, -1), criteria)
        imgpoints.append(corners2)
        
        # 코너 시각화 (선택사항)
        img_with_corners = cv2.drawChessboardCorners(img, CHECKERBOARD, corners2, ret)
        cv2.imshow('Corners', img_with_corners)
        cv2.waitKey(100)
    else:
        failed_images.append(fname)
        print(f"코너를 찾을 수 없음: {fname}")

cv2.destroyAllWindows()
print(f"성공적으로 처리된 이미지: {successful_images}장")
print(f"실패한 이미지: {len(failed_images)}장")

if successful_images < 10:
    print("경고: 켈리브레이션을 위해 최소 10장의 이미지가 필요합니다.")
    exit()

# 카메라 켈리브레이션 수행
print("카메라 켈리브레이션을 수행하는 중...")
ret, mtx, dist, rvecs, tvecs = cv2.calibrateCamera(objpoints, imgpoints, gray.shape[::-1], None, None)

# 결과 출력
print(f"켈리브레이션 완료!")
print(f"재투영 오차 (RMS): {ret:.4f}")
print(f"카메라 매트릭스:\n{mtx}")
print(f"왜곡 계수:\n{dist}")

# 결과 저장
calibration_data = {
    'camera_matrix': mtx,
    'distortion_coefficients': dist,
    'rotation_vectors': rvecs,
    'translation_vectors': tvecs,
    'rms_error': ret
}

with open('camera_calibration.pkl', 'wb') as f:
    pickle.dump(calibration_data, f)

print("켈리브레이션 데이터가 'camera_calibration.pkl'에 저장되었습니다.")

# 왜곡 보정 테스트
test_img = cv2.imread(images[0])
h, w = test_img.shape[:2]
newcameramtx, roi = cv2.getOptimalNewCameraMatrix(mtx, dist, (w, h), 1, (w, h))

# 왜곡 보정 적용
dst = cv2.undistort(test_img, mtx, dist, None, newcameramtx)

# 결과 비교 표시
comparison = np.hstack((test_img, dst))
cv2.imshow('Original vs Undistorted', comparison)
cv2.waitKey(0)
cv2.destroyAllWindows()

켈리브레이션 품질 확인

좋은 켈리브레이션의 지표

• RMS 오차가 1.0 미만

• 이미지 왜곡이 눈에 띄게 개선됨

• 직선이 실제로 직선으로 보임

켈리브레이션 개선 방법

• 더 많은 이미지 촬영

• 다양한 거리에서 촬영

• 화면 전체 영역을 고르게 커버

3단계: ArUco 마커 인식

켈리브레이션된 카메라를 사용하여 ArUco 마커를 인식하고 포즈를 추정합니다.

ArUco 마커 인식 스크립트

import cv2
import numpy as np
import pickle

# 켈리브레이션 데이터 로드
with open('camera_calibration.pkl', 'rb') as f:
    calibration_data = pickle.load(f)

camera_matrix = calibration_data['camera_matrix']
dist_coeffs = calibration_data['distortion_coefficients']

# ArUco 설정
aruco_dict = cv2.aruco.Dictionary_get(cv2.aruco.DICT_4X4_50)
parameters = cv2.aruco.DetectorParameters_create()

# 마커 크기 (실제 크기, 단위: 미터)
marker_size = 0.05  # 5cm = 0.05m

# 카메라 초기화
cap = cv2.VideoCapture(0)

print("ArUco 마커 인식을 시작합니다.")
print("'q' 키를 눌러 종료")

while True:
    ret, frame = cap.read()
    if not ret:
        break
    
    # 왜곡 보정
    frame = cv2.undistort(frame, camera_matrix, dist_coeffs, None, camera_matrix)
    
    # 그레이스케일 변환
    gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
    
    # ArUco 마커 검출
    corners, ids, rejected = cv2.aruco.detectMarkers(gray, aruco_dict, parameters=parameters)
    
    if ids is not None:
        # 마커 그리기
        cv2.aruco.drawDetectedMarkers(frame, corners, ids)
        
        # 포즈 추정
        rvecs, tvecs, _ = cv2.aruco.estimatePoseSingleMarkers(
            corners, marker_size, camera_matrix, dist_coeffs)
        
        for i in range(len(ids)):
            # 좌표축 그리기
            cv2.aruco.drawAxis(frame, camera_matrix, dist_coeffs, 
                             rvecs[i], tvecs[i], 0.03)
            
            # 마커 중심점 계산
            marker_center = np.mean(corners[i][0], axis=0).astype(int)
            
            # 거리 계산 (유클리드 거리)
            distance = np.linalg.norm(tvecs[i][0])
            
            # 정보 표시
            cv2.putText(frame, f"ID: {ids[i][0]}", 
                       (marker_center[0] - 50, marker_center[1] - 50),
                       cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 255, 0), 2)
            
            cv2.putText(frame, f"Distance: {distance:.2f}m", 
                       (marker_center[0] - 50, marker_center[1] - 20),
                       cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 255, 0), 2)
            
            # 마커 중심에 원 그리기
            cv2.circle(frame, tuple(marker_center), 5, (0, 0, 255), -1)
    
    # 결과 표시
    cv2.imshow('ArUco Marker Detection', frame)
    
    # 종료 조건
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

cap.release()
cv2.destroyAllWindows()

ArUco 마커 인식 최적화

인식 성능 향상 방법

• 적절한 조명 환경 유지

• 마커가 화면에 평행하게 위치

• 마커와 카메라 간 적절한 거리 유지

문제 해결

• 마커가 인식되지 않는 경우: 조명 확인, 마커 상태 점검

• 거리 값이 부정확한 경우: 켈리브레이션 재수행, 마커 크기 재측정

4단계: 거리에 따른 경고문 출력

측정된 거리를 바탕으로 경고 시스템을 구현합니다.

거리 기반 경고 시스템 스크립트

import cv2
import numpy as np
import pickle
import time

# 켈리브레이션 데이터 로드
with open('camera_calibration.pkl', 'rb') as f:
    calibration_data = pickle.load(f)

camera_matrix = calibration_data['camera_matrix']
dist_coeffs = calibration_data['distortion_coefficients']

# ArUco 설정
aruco_dict = cv2.aruco.Dictionary_get(cv2.aruco.DICT_4X4_50)
parameters = cv2.aruco.DetectorParameters_create()

# 마커 크기 (실제 크기, 단위: 미터)
marker_size = 0.05  # 5cm

# 거리 임계값 설정 (미터)
WARNING_DISTANCES = {
    'DANGER': 0.2,    # 20cm 이하 - 위험
    'CAUTION': 0.5,   # 50cm 이하 - 주의
    'SAFE': 1.0       # 1m 이상 - 안전
}

# 경고 색상 설정
WARNING_COLORS = {
    'DANGER': (0, 0, 255),    # 빨간색
    'CAUTION': (0, 165, 255), # 주황색
    'SAFE': (0, 255, 0)       # 초록색
}

# 카메라 초기화
cap = cv2.VideoCapture(0)

# 알림 관련 변수
last_warning_time = 0
warning_interval = 2.0  # 2초마다 경고음

def get_warning_level(distance):
    """거리에 따른 경고 레벨 반환"""
    if distance <= WARNING_DISTANCES['DANGER']:
        return 'DANGER'
    elif distance <= WARNING_DISTANCES['CAUTION']:
        return 'CAUTION'
    else:
        return 'SAFE'

def draw_warning_overlay(frame, warning_level, distance):
    """경고 오버레이 그리기"""
    height, width = frame.shape[:2]
    
    # 경고 메시지 설정
    if warning_level == 'DANGER':
        message = "DANGER! TOO CLOSE!"
        font_scale = 2.0
    elif warning_level == 'CAUTION':
        message = "CAUTION! BE CAREFUL!"
        font_scale = 1.5
    else:
        message = "SAFE DISTANCE"
        font_scale = 1.0
    
    color = WARNING_COLORS[warning_level]
    
    # 배경 사각형 그리기
    overlay = frame.copy()
    cv2.rectangle(overlay, (0, 0), (width, 100), color, -1)
    cv2.addWeighted(overlay, 0.3, frame, 0.7, 0, frame)
    
    # 텍스트 크기 계산
    text_size = cv2.getTextSize(message, cv2.FONT_HERSHEY_SIMPLEX, font_scale, 3)[0]
    text_x = (width - text_size[0]) // 2
    text_y = 60
    
    # 텍스트 그리기 (검은색 외곽선)
    cv2.putText(frame, message, (text_x-2, text_y-2), 
               cv2.FONT_HERSHEY_SIMPLEX, font_scale, (0, 0, 0), 5)
    cv2.putText(frame, message, (text_x, text_y), 
               cv2.FONT_HERSHEY_SIMPLEX, font_scale, (255, 255, 255), 3)
    
    # 거리 정보 표시
    distance_text = f"Distance: {distance:.2f}m"
    cv2.putText(frame, distance_text, (20, height - 30), 
               cv2.FONT_HERSHEY_SIMPLEX, 1.0, color, 2)

def play_warning_sound(warning_level):
    """경고음 출력 (시스템에 따라 다를 수 있음)"""
    global last_warning_time
    current_time = time.time()
    
    if current_time - last_warning_time > warning_interval:
        if warning_level == 'DANGER':
            # 연속 비프음 (위험)
            print("\a" * 3)  # 시스템 알림음
        elif warning_level == 'CAUTION':
            # 단일 비프음 (주의)
            print("\a")
        
        last_warning_time = current_time

print("거리 기반 경고 시스템을 시작합니다.")
print("경고 레벨:")
print(f"- 위험 (빨강): {WARNING_DISTANCES['DANGER']}m 이하")
print(f"- 주의 (주황): {WARNING_DISTANCES['CAUTION']}m 이하")
print(f"- 안전 (초록): {WARNING_DISTANCES['SAFE']}m 이상")
print("'q' 키를 눌러 종료")

while True:
    ret, frame = cap.read()
    if not ret:
        break
    
    # 왜곡 보정
    frame = cv2.undistort(frame, camera_matrix, dist_coeffs, None, camera_matrix)
    
    # 그레이스케일 변환
    gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
    
    # ArUco 마커 검출
    corners, ids, rejected = cv2.aruco.detectMarkers(gray, aruco_dict, parameters=parameters)
    
    if ids is not None:
        # 마커 그리기
        cv2.aruco.drawDetectedMarkers(frame, corners, ids)
        
        # 포즈 추정
        rvecs, tvecs, _ = cv2.aruco.estimatePoseSingleMarkers(
            corners, marker_size, camera_matrix, dist_coeffs)
        
        # 가장 가까운 마커 찾기
        min_distance = float('inf')
        closest_marker_idx = 0
        
        for i in range(len(ids)):
            distance = np.linalg.norm(tvecs[i][0])
            if distance < min_distance:
                min_distance = distance
                closest_marker_idx = i
            
            # 좌표축 그리기
            cv2.aruco.drawAxis(frame, camera_matrix, dist_coeffs, 
                             rvecs[i], tvecs[i], 0.03)
            
            # 마커 중심점과 ID 표시
            marker_center = np.mean(corners[i][0], axis=0).astype(int)
            cv2.putText(frame, f"ID: {ids[i][0]}", 
                       (marker_center[0] - 30, marker_center[1] + 30),
                       cv2.FONT_HERSHEY_SIMPLEX, 0.6, (255, 255, 255), 2)
        
        # 가장 가까운 마커에 대한 경고 처리
        warning_level = get_warning_level(min_distance)
        
        # 경고 오버레이 그리기
        draw_warning_overlay(frame, warning_level, min_distance)
        
        # 경고음 출력
        if warning_level in ['DANGER', 'CAUTION']:
            play_warning_sound(warning_level)
    
    else:
        # 마커가 없을 때 메시지 표시
        cv2.putText(frame, "No ArUco marker detected", (20, 50),
                   cv2.FONT_HERSHEY_SIMPLEX, 1.0, (0, 0, 255), 2)
    
    # 사용법 안내
    cv2.putText(frame, "Press 'q' to quit", (20, frame.shape[0] - 10),
               cv2.FONT_HERSHEY_SIMPLEX, 0.6, (255, 255, 255), 1)
    
    # 결과 표시
    cv2.imshow('Distance Warning System', frame)
    
    # 종료 조건
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

cap.release()
cv2.destroyAllWindows()
print("거리 경고 시스템을 종료합니다.")

경고 시스템 커스터마이징

거리 임계값 조정

# 용도에 맞게 임계값 변경
WARNING_DISTANCES = {
    'DANGER': 0.1,    # 10cm - 매우 위험
    'CAUTION': 0.3,   # 30cm - 주의 필요
    'SAFE': 0.8       # 80cm - 안전 거리
}

추가 기능 구현 아이디어

• 로그 파일에 거리 데이터 기록

• 네트워크를 통한 원격 알림

• 다중 마커 동시 모니터링

• 거리 변화율 기반 경고

문제 해결 가이드

일반적인 문제들

마커가 인식되지 않는 경우

• 조명 상태 확인 (너무 밝거나 어두우면 안됨)

• 마커의 물리적 상태 점검 (구겨지거나 더러워짐)

• 카메라 포커스 조정

• ArUco 딕셔너리 타입 확인

거리 측정이 부정확한 경우

• 카메라 켈리브레이션 재수행

• 마커 크기 재측정 (정확한 물리적 크기 필요)

• 켈리브레이션 시 사용한 이미지 품질 확인

성능이 느린 경우

• 이미지 해상도 낮추기

• 카메라 FPS 조정

• 불필요한 처리 과정 제거

정확도 향상 방법

켈리브레이션 품질 개선

• 더 많은 켈리브레이션 이미지 사용 (20장 이상)

• 다양한 각도와 거리에서 촬영

• 고해상도 이미지 사용

마커 인식 정확도 향상

• 고품질 마커 인쇄 (선명하고 대비가 뚜렷함)

• 적절한 마커 크기 선택 (너무 작거나 크지 않게)

• 균일한 조명 환경 조성

참고 자료

OpenCV 공식 문서

• ArUco 마커 검출
• 카메라 켈리브레이션

추가 학습 자료

• PyImageSearch ArUco 튜토리얼
• 실시간 거리 계산 가이드

GitHub 레포지토리

• 원본 소스 코드
• OpenCV Python 샘플