객체 추적은 말 그대로 영상 속에서 특정 물체를 계속 따라가는 기술이야. 생각해봐, 유튜브에서 스포츠 경기 볼 때 공이나 선수를 자동으로 따라가는 카메라 있잖아? 바로 그게 객체 추적 기술이야! 🎾

일반적인 객체 검출(Object Detection)은 매 프레임마다 "이게 뭐지?"를 새로 판단하는 거라면, 객체 추적은 "아, 저거 아까 그거네!"하고 연속성을 유지하면서 따라가는 거지. 훨씬 효율적이고 빠르지! ⚡

본격적으로 코딩하기 전에 OpenCV부터 설치해야겠지? Python 환경에서 진행할 건데, 정말 간단해! 😎

# Python 3.7 이상 권장
pip install opencv-python
pip install opencv-contrib-python
pip install numpy

# 선택사항 (영상 처리 성능 향상)
pip install imutils

설치가 잘 됐는지 확인해볼까?

import cv2
print(cv2.__version__)

# 4.5.0 이상이면 OK!

OpenCV는 여러 가지 추적 알고리즘을 제공하는데, 각각 장단점이 있어. 상황에 맞게 골라 쓰면 돼! 🎨

자, 이제 진짜 코딩 시작이야! 가장 기본적인 단일 객체 추적부터 해보자. 웹캠으로 실시간 추적하는 코드야! 📹

import cv2
import sys

# 추적기 생성 함수
def create_tracker(tracker_type):
    """
    원하는 추적 알고리즘을 선택하는 함수
    """
    if tracker_type == 'BOOSTING':
        tracker = cv2.legacy.TrackerBoosting_create()
    elif tracker_type == 'MIL':
        tracker = cv2.legacy.TrackerMIL_create()
    elif tracker_type == 'KCF':
        tracker = cv2.TrackerKCF_create()
    elif tracker_type == 'CSRT':
        tracker = cv2.TrackerCSRT_create()
    elif tracker_type == 'MedianFlow':
        tracker = cv2.legacy.TrackerMedianFlow_create()
    elif tracker_type == 'MOSSE':
        tracker = cv2.legacy.TrackerMOSSE_create()
    elif tracker_type == 'TLD':
        tracker = cv2.legacy.TrackerTLD_create()
    else:
        tracker = None
        print('잘못된 추적기 이름입니다!')
    
    return tracker

# 메인 실행 코드
def main():
    # 추적 알고리즘 선택 (KCF 추천!)
    tracker_type = 'KCF'
    
    # 비디오 캡처 객체 생성 (0은 기본 웹캠)
    video = cv2.VideoCapture(0)
    
    # 웹캠이 제대로 열렸는지 확인
    if not video.isOpened():
        print("웹캠을 열 수 없습니다!")
        sys.exit()
    
    # 첫 프레임 읽기
    ok, frame = video.read()
    if not ok:
        print('프레임을 읽을 수 없습니다!')
        sys.exit()
    
    # 추적할 객체 영역 선택 (마우스로 드래그)
    bbox = cv2.selectROI("객체 선택", frame, False)
    print(f"선택된 영역: {bbox}")
    
    # 추적기 초기화
    tracker = create_tracker(tracker_type)
    ok = tracker.init(frame, bbox)
    
    print("추적 시작! ESC를 누르면 종료됩니다.")
    
    # 메인 루프
    while True:
        # 프레임 읽기
        ok, frame = video.read()
        if not ok:
            break
        
        # 추적 업데이트
        ok, bbox = tracker.update(frame)
        
        # 추적 성공 여부에 따라 표시
        if ok:
            # 추적 성공 - 초록색 박스
            p1 = (int(bbox[0]), int(bbox[1]))
            p2 = (int(bbox[0] + bbox[2]), int(bbox[1] + bbox[3]))
            cv2.rectangle(frame, p1, p2, (0, 255, 0), 2, 1)
            
            # 상태 텍스트
            cv2.putText(frame, "Tracking", (10, 30), 
                       cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 255, 0), 2)
        else:
            # 추적 실패 - 빨간색 경고
            cv2.putText(frame, "Tracking Failed!", (10, 30), 
                       cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 0, 255), 2)
        
        # 추적기 정보 표시
        cv2.putText(frame, f"Tracker: {tracker_type}", (10, 60), 
                   cv2.FONT_HERSHEY_SIMPLEX, 0.6, (255, 255, 255), 2)
        
        # FPS 계산 및 표시 (선택사항)
        cv2.putText(frame, "Press ESC to exit", (10, frame.shape[0] - 10), 
                   cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 255), 1)
        
        # 화면 출력
        cv2.imshow("Object Tracking", frame)
        
        # ESC 키로 종료
        k = cv2.waitKey(1) & 0xff
        if k == 27:
            break
    
    # 정리
    video.release()
    cv2.destroyAllWindows()
    print("추적 종료!")

if __name__ == '__main__':
    main()

웹캠 말고 저장된 비디오 파일에서도 추적할 수 있어! 이번엔 좀 더 실용적인 예제를 만들어볼게. 🎥

import cv2
import time

def track_video_file(video_path, tracker_type='CSRT'):
    """
    비디오 파일에서 객체를 추적하는 함수
    
    Args:
        video_path: 비디오 파일 경로
        tracker_type: 사용할 추적 알고리즘
    """
    
    # 비디오 파일 열기
    video = cv2.VideoCapture(video_path)
    
    if not video.isOpened():
        print(f"비디오 파일을 열 수 없습니다: {video_path}")
        return
    
    # 비디오 정보 가져오기
    fps = int(video.get(cv2.CAP_PROP_FPS))
    width = int(video.get(cv2.CAP_PROP_FRAME_WIDTH))
    height = int(video.get(cv2.CAP_PROP_FRAME_HEIGHT))
    total_frames = int(video.get(cv2.CAP_PROP_FRAME_COUNT))
    
    print(f"비디오 정보:")
    print(f"  - 해상도: {width}x{height}")
    print(f"  - FPS: {fps}")
    print(f"  - 총 프레임: {total_frames}")
    
    # 첫 프레임 읽기
    ok, frame = video.read()
    if not ok:
        print("첫 프레임을 읽을 수 없습니다!")
        return
    
    # 추적 영역 선택
    print("\n추적할 객체를 마우스로 선택하세요!")
    bbox = cv2.selectROI("객체 선택 (SPACE: 확인, ESC: 취소)", frame, False)
    cv2.destroyWindow("객체 선택 (SPACE: 확인, ESC: 취소)")
    
    # 추적기 생성 및 초기화
    if tracker_type == 'KCF':
        tracker = cv2.TrackerKCF_create()
    elif tracker_type == 'CSRT':
        tracker = cv2.TrackerCSRT_create()
    elif tracker_type == 'MOSSE':
        tracker = cv2.legacy.TrackerMOSSE_create()
    else:
        print(f"지원하지 않는 추적기: {tracker_type}")
        return
    
    tracker.init(frame, bbox)
    
    # 결과 저장을 위한 VideoWriter (선택사항)
    output_path = 'tracked_output.mp4'
    fourcc = cv2.VideoWriter_fourcc(*'mp4v')
    out = cv2.VideoWriter(output_path, fourcc, fps, (width, height))
    
    # 추적 통계
    frame_count = 0
    success_count = 0
    start_time = time.time()
    
    print(f"\n추적 시작! (알고리즘: {tracker_type})")
    print("Q 키를 누르면 종료됩니다.\n")
    
    # 메인 추적 루프
    while True:
        ok, frame = video.read()
        if not ok:
            break
        
        frame_count += 1
        
        # 추적 업데이트
        timer = cv2.getTickCount()
        ok, bbox = tracker.update(frame)
        fps_current = cv2.getTickFrequency() / (cv2.getTickCount() - timer)
        
        # 결과 그리기
        if ok:
            success_count += 1
            # 추적 성공 - 초록색 박스
            p1 = (int(bbox[0]), int(bbox[1]))
            p2 = (int(bbox[0] + bbox[2]), int(bbox[1] + bbox[3]))
            cv2.rectangle(frame, p1, p2, (0, 255, 0), 3)
            
            # 중심점 표시
            center_x = int(bbox[0] + bbox[2]/2)
            center_y = int(bbox[1] + bbox[3]/2)
            cv2.circle(frame, (center_x, center_y), 5, (0, 255, 0), -1)
            
            # 궤적 그리기 (선택사항)
            cv2.putText(frame, "TRACKING", (p1[0], p1[1]-10), 
                       cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 255, 0), 2)
        else:
            # 추적 실패
            cv2.putText(frame, "LOST", (50, 80), 
                       cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 3)
        
        # 정보 오버레이
        info_text = [
            f"Tracker: {tracker_type}",
            f"Frame: {frame_count}/{total_frames}",
            f"FPS: {int(fps_current)}",
            f"Success Rate: {success_count/frame_count*100:.1f}%"
        ]
        
        y_offset = 30
        for i, text in enumerate(info_text):
            cv2.putText(frame, text, (10, y_offset + i*30), 
                       cv2.FONT_HERSHEY_SIMPLEX, 0.6, (255, 255, 255), 2)
        
        # 진행률 바
        progress = frame_count / total_frames
        bar_width = int(width * 0.8)
        bar_height = 20
        bar_x = int(width * 0.1)
        bar_y = height - 40
        
        cv2.rectangle(frame, (bar_x, bar_y), 
                     (bar_x + bar_width, bar_y + bar_height), 
                     (50, 50, 50), -1)
        cv2.rectangle(frame, (bar_x, bar_y), 
                     (bar_x + int(bar_width * progress), bar_y + bar_height), 
                     (0, 255, 0), -1)
        
        # 화면 출력
        cv2.imshow("Video Tracking", frame)
        
        # 결과 저장
        out.write(frame)
        
        # 키 입력 처리
        key = cv2.waitKey(1) & 0xFF
        if key == ord('q') or key == ord('Q'):
            print("\n사용자가 종료했습니다.")
            break
        elif key == ord('p'):  # 일시정지
            cv2.waitKey(-1)
    
    # 종료 처리
    elapsed_time = time.time() - start_time
    
    print(f"\n=== 추적 완료 ===")
    print(f"총 처리 시간: {elapsed_time:.2f}초")
    print(f"평균 FPS: {frame_count/elapsed_time:.2f}")
    print(f"추적 성공률: {success_count/frame_count*100:.1f}%")
    print(f"결과 저장: {output_path}")
    
    video.release()
    out.release()
    cv2.destroyAllWindows()

# 실행 예제
if __name__ == '__main__':
    # 비디오 파일 경로 지정
    video_file = 'sample_video.mp4'  # 여기에 실제 파일 경로 입력
    
    # CSRT는 정확도가 높지만 느림
    # KCF는 속도와 정확도의 균형이 좋음
    # MOSSE는 매우 빠르지만 정확도는 낮음
    
    track_video_file(video_file, tracker_type='CSRT')

하나만 추적하는 건 재미없지! 여러 개를 동시에 추적해보자. 이게 진짜 실전이야! 🎪

import cv2
import numpy as np

class MultiObjectTracker:
    """
    여러 객체를 동시에 추적하는 클래스
    """
    
    def __init__(self, tracker_type='KCF'):
        self.tracker_type = tracker_type
        self.trackers = []
        self.colors = []
        self.object_ids = []
        self.next_id = 1
    
    def create_tracker(self):
        """새로운 추적기 생성"""
        if self.tracker_type == 'KCF':
            return cv2.TrackerKCF_create()
        elif self.tracker_type == 'CSRT':
            return cv2.TrackerCSRT_create()
        elif self.tracker_type == 'MOSSE':
            return cv2.legacy.TrackerMOSSE_create()
        else:
            return cv2.TrackerKCF_create()
    
    def add_tracker(self, frame, bbox):
        """
        새로운 추적 객체 추가
        
        Args:
            frame: 현재 프레임
            bbox: 추적할 영역 (x, y, w, h)
        """
        tracker = self.create_tracker()
        ok = tracker.init(frame, bbox)
        
        if ok:
            self.trackers.append(tracker)
            # 랜덤 색상 생성 (각 객체마다 다른 색)
            color = tuple(np.random.randint(0, 255, 3).tolist())
            self.colors.append(color)
            self.object_ids.append(self.next_id)
            self.next_id += 1
            print(f"객체 #{self.object_ids[-1]} 추가됨!")
            return True
        return False
    
    def update(self, frame):
        """
        모든 추적기 업데이트
        
        Returns:
            성공한 추적 결과 리스트
        """
        results = []
        
        for i in range(len(self.trackers)):
            ok, bbox = self.trackers[i].update(frame)
            
            if ok:
                results.append({
                    'id': self.object_ids[i],
                    'bbox': bbox,
                    'color': self.colors[i],
                    'success': True
                })
            else:
                results.append({
                    'id': self.object_ids[i],
                    'bbox': None,
                    'color': self.colors[i],
                    'success': False
                })
        
        return results
    
    def remove_failed_trackers(self, results):
        """실패한 추적기 제거"""
        indices_to_remove = []
        
        for i, result in enumerate(results):
            if not result['success']:
                indices_to_remove.append(i)
        
        # 역순으로 제거 (인덱스 꼬임 방지)
        for i in sorted(indices_to_remove, reverse=True):
            print(f"객체 #{self.object_ids[i]} 추적 실패로 제거됨")
            del self.trackers[i]
            del self.colors[i]
            del self.object_ids[i]
    
    def get_count(self):
        """현재 추적 중인 객체 수"""
        return len(self.trackers)


def multi_object_tracking_demo():
    """
    다중 객체 추적 데모
    """
    
    # 웹캠 열기
    video = cv2.VideoCapture(0)
    
    if not video.isOpened():
        print("웹캠을 열 수 없습니다!")
        return
    
    # 다중 추적기 초기화
    mot = MultiObjectTracker(tracker_type='KCF')
    
    print("\n=== 다중 객체 추적 시작 ===")
    print("사용법:")
    print("  S 키: 새로운 객체 추가")
    print("  D 키: 실패한 추적기 제거")
    print("  C 키: 모든 추적기 초기화")
    print("  Q 키: 종료")
    print("=" * 40)
    
    # 추적 궤적 저장 (선택사항)
    trajectories = {}
    
    while True:
        ok, frame = video.read()
        if not ok:
            break
        
        # 모든 추적기 업데이트
        if mot.get_count() > 0:
            results = mot.update(frame)
            
            # 결과 그리기
            for result in results:
                if result['success']:
                    bbox = result['bbox']
                    obj_id = result['id']
                    color = result['color']
                    
                    # 바운딩 박스
                    p1 = (int(bbox[0]), int(bbox[1]))
                    p2 = (int(bbox[0] + bbox[2]), int(bbox[1] + bbox[3]))
                    cv2.rectangle(frame, p1, p2, color, 3)
                    
                    # 객체 ID 표시
                    label = f"ID: {obj_id}"
                    cv2.putText(frame, label, (p1[0], p1[1]-10), 
                               cv2.FONT_HERSHEY_SIMPLEX, 0.6, color, 2)
                    
                    # 중심점
                    center_x = int(bbox[0] + bbox[2]/2)
                    center_y = int(bbox[1] + bbox[3]/2)
                    cv2.circle(frame, (center_x, center_y), 4, color, -1)
                    
                    # 궤적 저장
                    if obj_id not in trajectories:
                        trajectories[obj_id] = []
                    trajectories[obj_id].append((center_x, center_y))
                    
                    # 궤적 그리기 (최근 30개 점)
                    if len(trajectories[obj_id]) > 1:
                        points = trajectories[obj_id][-30:]
                        for i in range(1, len(points)):
                            cv2.line(frame, points[i-1], points[i], color, 2)
        
        # 정보 패널
        info_panel_height = 120
        panel = np.zeros((info_panel_height, frame.shape[1], 3), dtype=np.uint8)
        panel[:] = (40, 40, 40)
        
        cv2.putText(panel, f"Tracking Objects: {mot.get_count()}", 
                   (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (255, 255, 255), 2)
        cv2.putText(panel, "Press 'S' to add new object", 
                   (10, 60), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (200, 200, 200), 1)
        cv2.putText(panel, "Press 'D' to remove failed | 'C' to clear all | 'Q' to quit", 
                   (10, 85), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (200, 200, 200), 1)
        
        # 패널과 프레임 합치기
        display = np.vstack([panel, frame])
        
        cv2.imshow("Multi-Object Tracking", display)
        
        # 키 입력 처리
        key = cv2.waitKey(1) & 0xFF
        
        if key == ord('s') or key == ord('S'):
            # 새 객체 추가
            print("\n추적할 객체를 선택하세요!")
            bbox = cv2.selectROI("객체 선택", frame, False)
            cv2.destroyWindow("객체 선택")
            
            if bbox[2] > 0 and bbox[3] > 0:  # 유효한 선택인지 확인
                mot.add_tracker(frame, bbox)
        
        elif key == ord('d') or key == ord('D'):
            # 실패한 추적기 제거
            if mot.get_count() > 0:
                results = mot.update(frame)
                mot.remove_failed_trackers(results)
        
        elif key == ord('c') or key == ord('C'):
            # 모든 추적기 초기화
            mot = MultiObjectTracker(tracker_type='KCF')
            trajectories = {}
            print("\n모든 추적기가 초기화되었습니다!")
        
        elif key == ord('q') or key == ord('Q'):
            break
    
    video.release()
    cv2.destroyAllWindows()
    print("\n추적 종료!")


if __name__ == '__main__':
    multi_object_tracking_demo()

이번엔 좀 다른 접근! 특정 색상을 가진 객체를 자동으로 찾아서 추적하는 방법이야. 빨간 공이나 노란 차 같은 걸 추적할 때 유용해! 🎨

import cv2
import numpy as np

class ColorBasedTracker:
    """
    색상 기반 객체 추적 클래스
    """
    
    def __init__(self, color_name='red'):
        self.color_name = color_name
        self.lower_bound, self.upper_bound = self.get_color_range(color_name)
        self.kernel = np.ones((5, 5), np.uint8)
    
    def get_color_range(self, color_name):
        """
        색상별 HSV 범위 정의
        """
        color_ranges = {
            'red': ([0, 120, 70], [10, 255, 255]),  # 빨강
            'red2': ([170, 120, 70], [180, 255, 255]),  # 빨강 (추가 범위)
            'blue': ([100, 150, 0], [140, 255, 255]),  # 파랑
            'green': ([40, 40, 40], [80, 255, 255]),  # 초록
            'yellow': ([20, 100, 100], [30, 255, 255]),  # 노랑
            'orange': ([10, 100, 100], [20, 255, 255]),  # 주황
            'purple': ([140, 50, 50], [160, 255, 255]),  # 보라
        }
        
        if color_name in color_ranges:
            lower, upper = color_ranges[color_name]
            return np.array(lower), np.array(upper)
        else:
            # 기본값 (빨강)
            return np.array([0, 120, 70]), np.array([10, 255, 255])
    
    def detect_color(self, frame):
        """
        프레임에서 특정 색상 영역 검출
        
        Returns:
            mask: 이진 마스크
            contours: 검출된 윤곽선들
        """
        # BGR을 HSV로 변환
        hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
        
        # 색상 범위로 마스크 생성
        mask = cv2.inRange(hsv, self.lower_bound, self.upper_bound)
        
        # 빨강은 HSV에서 두 범위를 사용
        if self.color_name == 'red':
            lower2 = np.array([170, 120, 70])
            upper2 = np.array([180, 255, 255])
            mask2 = cv2.inRange(hsv, lower2, upper2)
            mask = cv2.bitwise_or(mask, mask2)
        
        # 노이즈 제거 (모폴로지 연산)
        mask = cv2.erode(mask, self.kernel, iterations=2)
        mask = cv2.dilate(mask, self.kernel, iterations=2)
        
        # 윤곽선 찾기
        contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, 
                                       cv2.CHAIN_APPROX_SIMPLE)
        
        return mask, contours
    
    def get_largest_contour(self, contours, min_area=500):
        """
        가장 큰 윤곽선 찾기
        
        Args:
            contours: 윤곽선 리스트
            min_area: 최소 면적 (작은 노이즈 제거)
        
        Returns:
            가장 큰 윤곽선의 바운딩 박스 (x, y, w, h)
        """
        if len(contours) == 0:
            return None
        
        # 면적 기준으로 정렬
        valid_contours = [c for c in contours if cv2.contourArea(c) > min_area]
        
        if len(valid_contours) == 0:
            return None
        
        largest_contour = max(valid_contours, key=cv2.contourArea)
        x, y, w, h = cv2.boundingRect(largest_contour)
        
        return (x, y, w, h), largest_contour


def color_tracking_demo():
    """
    색상 기반 추적 데모
    """
    
    # 추적할 색상 선택
    print("추적할 색상을 선택하세요:")
    print("1: 빨강(red)")
    print("2: 파랑(blue)")
    print("3: 초록(green)")
    print("4: 노랑(yellow)")
    
    choice = input("선택 (1-4): ").strip()
    
    color_map = {'1': 'red', '2': 'blue', '3': 'green', '4': 'yellow'}
    color_name = color_map.get(choice, 'red')
    
    # 추적기 초기화
    tracker = ColorBasedTracker(color_name)
    
    # 웹캠 열기
    video = cv2.VideoCapture(0)
    
    if not video.isOpened():
        print("웹캠을 열 수 없습니다!")
        return
    
    print(f"\n{color_name.upper()} 색상 추적 시작!")
    print("Q 키를 누르면 종료됩니다.\n")
    
    # 궤적 저장
    trajectory = []
    max_trajectory_length = 50
    
    while True:
        ok, frame = video.read()
        if not ok:
            break
        
        # 색상 검출
        mask, contours = tracker.detect_color(frame)
        
        # 가장 큰 객체 찾기
        result = tracker.get_largest_contour(contours)
        
        if result is not None:
            bbox, contour = result
            x, y, w, h = bbox
            
            # 바운딩 박스 그리기
            cv2.rectangle(frame, (x, y), (x+w, y+h), (0, 255, 0), 3)
            
            # 윤곽선 그리기
            cv2.drawContours(frame, [contour], -1, (0, 255, 255), 2)
            
            # 중심점
            center_x = x + w // 2
            center_y = y + h // 2
            cv2.circle(frame, (center_x, center_y), 5, (0, 0, 255), -1)
            
            # 궤적 저장
            trajectory.append((center_x, center_y))
            if len(trajectory) > max_trajectory_length:
                trajectory.pop(0)
            
            # 궤적 그리기
            for i in range(1, len(trajectory)):
                thickness = int(np.sqrt(max_trajectory_length / float(i + 1)) * 2.5)
                cv2.line(frame, trajectory[i-1], trajectory[i], 
                        (0, 255, 0), thickness)
            
            # 정보 표시
            area = cv2.contourArea(contour)
            cv2.putText(frame, f"Tracking: {color_name.upper()}", 
                       (x, y-30), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 255, 0), 2)
            cv2.putText(frame, f"Area: {int(area)}", 
                       (x, y-10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)
        else:
            cv2.putText(frame, f"No {color_name.upper()} object detected", 
                       (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 0, 255), 2)
        
        # 마스크 시각화 (작은 창으로)
        mask_display = cv2.cvtColor(mask, cv2.COLOR_GRAY2BGR)
        mask_small = cv2.resize(mask_display, (320, 240))
        
        # 프레임에 마스크 오버레이
        frame[10:250, 10:330] = mask_small
        cv2.rectangle(frame, (10, 10), (330, 250), (255, 255, 255), 2)
        cv2.putText(frame, "Color Mask", (15, 30), 
                   cv2.FONT_HERSHEY_SIMPLEX, 0.6, (255, 255, 255), 2)
        
        # 화면 출력
        cv2.imshow("Color-Based Tracking", frame)
        
        # 종료 키
        if cv2.waitKey(1) & 0xFF == ord('q'):
            break
    
    video.release()
    cv2.destroyAllWindows()


def interactive_color_picker():
    """
    대화형 색상 범위 선택 도구
    HSV 값을 실시간으로 조정하면서 최적의 범위를 찾을 수 있어!
    """
    
    def nothing(x):
        pass
    
    video = cv2.VideoCapture(0)
    
    # 트랙바 윈도우 생성
    cv2.namedWindow('Color Picker')
    
    # HSV 범위 트랙바
    cv2.createTrackbar('H Low', 'Color Picker', 0, 179, nothing)
    cv2.createTrackbar('H High', 'Color Picker', 179, 179, nothing)
    cv2.createTrackbar('S Low', 'Color Picker', 0, 255, nothing)
    cv2.createTrackbar('S High', 'Color Picker', 255, 255, nothing)
    cv2.createTrackbar('V Low', 'Color Picker', 0, 255, nothing)
    cv2.createTrackbar('V High', 'Color Picker', 255, 255, nothing)
    
    print("\n=== 대화형 색상 선택기 ===")
    print("트랙바를 조정해서 원하는 색상 범위를 찾으세요!")
    print("Q 키를 누르면 현재 값이 출력되고 종료됩니다.\n")
    
    while True:
        ok, frame = video.read()
        if not ok:
            break
        
        # 트랙바 값 읽기
        h_low = cv2.getTrackbarPos('H Low', 'Color Picker')
        h_high = cv2.getTrackbarPos('H High', 'Color Picker')
        s_low = cv2.getTrackbarPos('S Low', 'Color Picker')
        s_high = cv2.getTrackbarPos('S High', 'Color Picker')
        v_low = cv2.getTrackbarPos('V Low', 'Color Picker')
        v_high = cv2.getTrackbarPos('V High', 'Color Picker')
        
        # HSV 변환
        hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
        
        # 마스크 생성
        lower = np.array([h_low, s_low, v_low])
        upper = np.array([h_high, s_high, v_high])
        mask = cv2.inRange(hsv, lower, upper)
        
        # 결과 적용
        result = cv2.bitwise_and(frame, frame, mask=mask)
        
        # 화면 출력
        cv2.imshow('Original', frame)
        cv2.imshow('Mask', mask)
        cv2.imshow('Result', result)
        
        if cv2.waitKey(1) & 0xFF == ord('q'):
            print("\n=== 선택된 HSV 범위 ===")
            print(f"Lower: [{h_low}, {s_low}, {v_low}]")
            print(f"Upper: [{h_high}, {s_high}, {v_high}]")
            break
    
    video.release()
    cv2.destroyAllWindows()


if __name__ == '__main__':
    # 일반 색상 추적 실행
    color_tracking_demo()
    
    # 또는 색상 범위 찾기 도구 실행
    # interactive_color_picker()

추적 코드를 더 빠르고 효율적으로 만드는 방법들을 알려줄게! 실전에서 정말 중요한 부분이야. 🚀

# 원본 프레임을 작게 리사이즈하면 처리 속도가 크게 향상돼!
def resize_frame(frame, width=640):
    """
    프레임 크기를 조정하면서 비율 유지
    """
    height = int(frame.shape[0] * (width / frame.shape[1]))
    return cv2.resize(frame, (width, height))

# 사용 예
frame = resize_frame(frame, width=640)  # 640px로 축소

# 전체 프레임이 아닌 관심 영역만 처리하기
def expand_roi(bbox, frame_shape, expand_ratio=1.5):
    """
    바운딩 박스를 확장해서 ROI 생성
    객체가 빠르게 움직여도 놓치지 않아!
    """
    x, y, w, h = bbox
    
    # 중심점 계산
    center_x = x + w // 2
    center_y = y + h // 2
    
    # 확장된 크기
    new_w = int(w * expand_ratio)
    new_h = int(h * expand_ratio)
    
    # 새로운 좌표 (프레임 범위 내로 제한)
    new_x = max(0, center_x - new_w // 2)
    new_y = max(0, center_y - new_h // 2)
    new_x2 = min(frame_shape[1], new_x + new_w)
    new_y2 = min(frame_shape[0], new_y + new_h)
    
    return (new_x, new_y, new_x2 - new_x, new_y2 - new_y)

# 사용 예
roi = expand_roi(bbox, frame.shape, expand_ratio=1.5)
roi_frame = frame[roi[1]:roi[1]+roi[3], roi[0]:roi[0]+roi[2]]

import threading
import queue

class VideoStream:
    """
    별도 스레드에서 프레임을 읽어서 버퍼링
    메인 루프의 처리 속도가 향상돼!
    """
    
    def __init__(self, src=0, queue_size=128):
        self.stream = cv2.VideoCapture(src)
        self.stopped = False
        self.queue = queue.Queue(maxsize=queue_size)
        
        # 스레드 시작
        self.thread = threading.Thread(target=self.update, args=())
        self.thread.daemon = True
        self.thread.start()
    
    def update(self):
        """백그라운드에서 프레임 읽기"""
        while True:
            if self.stopped:
                return
            
            if not self.queue.full():
                ok, frame = self.stream.read()
                if not ok:
                    self.stop()
                    return
                self.queue.put(frame)
    
    def read(self):
        """큐에서 프레임 가져오기"""
        return self.queue.get()
    
    def stop(self):
        """스트림 중지"""
        self.stopped = True
        self.thread.join()
    
    def __del__(self):
        self.stream.release()

# 사용 예
vs = VideoStream(src=0)
time.sleep(1.0)  # 카메라 워밍업

while True:
    frame = vs.read()
    # 프레임 처리...
    
vs.stop()

# 모든 프레임을 처리하지 않고 N개마다 처리
frame_skip = 2  # 2프레임마다 1번 처리
frame_count = 0

while True:
    ok, frame = video.read()
    frame_count += 1
    
    # 프레임 스킵
    if frame_count % frame_skip != 0:
        continue
    
    # 추적 업데이트
    ok, bbox = tracker.update(frame)
    # ...

이론만 배우면 재미없지! 실제로 활용할 수 있는 프로젝트를 만들어보자. 🎯

import cv2
import numpy as np
from datetime import datetime
import os

class IntrusionDetectionSystem:
    """
    특정 영역에 객체가 침입하면 경고하고 녹화하는 시스템
    """
    
    def __init__(self, detection_zone):
        """
        Args:
            detection_zone: 감지 영역 [(x1,y1), (x2,y2), ...]
        """
        self.detection_zone = np.array(detection_zone, dtype=np.int32)
        self.is_recording = False
        self.video_writer = None
        self.alert_count = 0
        
        # 녹화 폴더 생성
        self.output_dir = 'intrusion_recordings'
        if not os.path.exists(self.output_dir):
            os.makedirs(self.output_dir)
    
    def is_inside_zone(self, point):
        """점이 감지 영역 안에 있는지 확인"""
        result = cv2.pointPolygonTest(self.detection_zone, point, False)
        return result >= 0
    
    def start_recording(self, frame_size, fps=20):
        """침입 감지시 녹화 시작"""
        if not self.is_recording:
            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
            filename = f"{self.output_dir}/intrusion_{timestamp}.mp4"
            
            fourcc = cv2.VideoWriter_fourcc(*'mp4v')
            self.video_writer = cv2.VideoWriter(
                filename, fourcc, fps, frame_size
            )
            self.is_recording = True
            print(f"🚨 침입 감지! 녹화 시작: {filename}")
    
    def stop_recording(self):
        """녹화 중지"""
        if self.is_recording and self.video_writer is not None:
            self.video_writer.release()
            self.is_recording = False
            print("✅ 녹화 종료")
    
    def draw_zone(self, frame, color=(0, 255, 255), thickness=2):
        """감지 영역 그리기"""
        cv2.polylines(frame, [self.detection_zone], True, color, thickness)
        
        # 영역 내부를 반투명하게
        overlay = frame.copy()
        cv2.fillPoly(overlay, [self.detection_zone], color)
        cv2.addWeighted(overlay, 0.2, frame, 0.8, 0, frame)
        
        # 텍스트
        cv2.putText(frame, "DETECTION ZONE", 
                   tuple(self.detection_zone[0]), 
                   cv2.FONT_HERSHEY_SIMPLEX, 0.7, color, 2)


def intrusion_detection_demo():
    """침입 감지 시스템 데모"""
    
    video = cv2.VideoCapture(0)
    
    if not video.isOpened():
        print("웹캠을 열 수 없습니다!")
        return
    
    # 첫 프레임으로 감지 영역 설정
    ok, frame = video.read()
    height, width = frame.shape[:2]
    
    # 화면 중앙에 사각형 감지 영역 설정
    margin = 100
    detection_zone = [
        (margin, margin),
        (width - margin, margin),
        (width - margin, height - margin),
        (margin, height - margin)
    ]
    
    # 시스템 초기화
    ids = IntrusionDetectionSystem(detection_zone)
    
    # 배경 제거기 (움직임 감지용)
    bg_subtractor = cv2.createBackgroundSubtractorMOG2(
        history=500, varThreshold=50, detectShadows=True
    )
    
    print("\n=== 침입 감지 시스템 시작 ===")
    print("감지 영역 내에 움직임이 감지되면 자동으로 녹화됩니다!")
    print("Q 키를 누르면 종료됩니다.\n")
    
    frame_count = 0
    no_intrusion_frames = 0
    recording_timeout = 100  # 침입이 없으면 100프레임 후 녹화 중지
    
    while True:
        ok, frame = video.read()
        if not ok:
            break
        
        frame_count += 1
        
        # 배경 제거로 움직임 감지
        fg_mask = bg_subtractor.apply(frame)
        
        # 노이즈 제거
        kernel = np.ones((5, 5), np.uint8)
        fg_mask = cv2.morphologyEx(fg_mask, cv2.MORPH_OPEN, kernel)
        fg_mask = cv2.morphologyEx(fg_mask, cv2.MORPH_CLOSE, kernel)
        
        # 윤곽선 찾기
        contours, _ = cv2.findContours(fg_mask, cv2.RETR_EXTERNAL, 
                                       cv2.CHAIN_APPROX_SIMPLE)
        
        intrusion_detected = False
        
        # 각 윤곽선 검사
        for contour in contours:
            area = cv2.contourArea(contour)
            
            # 작은 노이즈 무시
            if area < 1000:
                continue
            
            # 바운딩 박스
            x, y, w, h = cv2.boundingRect(contour)
            center = (x + w//2, y + h//2)
            
            # 감지 영역 내부인지 확인
            if ids.is_inside_zone(center):
                intrusion_detected = True
                
                # 침입 객체 표시
                cv2.rectangle(frame, (x, y), (x+w, y+h), (0, 0, 255), 3)
                cv2.circle(frame, center, 5, (0, 0, 255), -1)
                cv2.putText(frame, "INTRUDER!", (x, y-10), 
                           cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 0, 255), 2)
        
        # 침입 감지 처리
        if intrusion_detected:
            no_intrusion_frames = 0
            ids.alert_count += 1
            
            # 녹화 시작
            if not ids.is_recording:
                ids.start_recording((width, height))
            
            # 경고 표시
            cv2.putText(frame, "!!! INTRUSION DETECTED !!!", 
                       (width//2 - 200, 50), 
                       cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 3)
        else:
            no_intrusion_frames += 1
            
            # 일정 시간 침입이 없으면 녹화 중지
            if no_intrusion_frames > recording_timeout and ids.is_recording:
                ids.stop_recording()
        
        # 감지 영역 그리기
        zone_color = (0, 0, 255) if intrusion_detected else (0, 255, 255)
        ids.draw_zone(frame, color=zone_color)
        
        # 상태 정보
        status_text = "RECORDING" if ids.is_recording else "MONITORING"
        status_color = (0, 0, 255) if ids.is_recording else (0, 255, 0)
        cv2.putText(frame, f"Status: {status_text}", (10, 30), 
                   cv2.FONT_HERSHEY_SIMPLEX, 0.7, status_color, 2)
        cv2.putText(frame, f"Alerts: {ids.alert_count}", (10, 60), 
                   cv2.FONT_HERSHEY_SIMPLEX, 0.7, (255, 255, 255), 2)
        
        # 녹화 중이면 파일에 저장
        if ids.is_recording:
            ids.video_writer.write(frame)
            # 녹화 표시
            cv2.circle(frame, (width - 30, 30), 10, (0, 0, 255), -1)
        
        # 화면 출력
        cv2.imshow("Intrusion Detection System", frame)
        cv2.imshow("Motion Mask", fg_mask)
        
        # 종료 키
        if cv2.waitKey(1) & 0xFF == ord('q'):
            break
    
    # 정리
    ids.stop_recording()
    video.release()
    cv2.destroyAllWindows()
    
    print(f"\n총 침입 감지 횟수: {ids.alert_count}")


if __name__ == '__main__':
    intrusion_detection_demo()

코딩하다 보면 문제가 생기기 마련이야. 자주 발생하는 문제들과 해결 방법을 정리해봤어! 🔧

# 기존 OpenCV 제거
pip uninstall opencv-python opencv-contrib-python

# 최신 버전 재설치
pip install opencv-contrib-python

# 또는 특정 버전 설치
pip install opencv-contrib-python==4.5.5.64

# 다른 카메라 인덱스 시도
for i in range(5):
    cap = cv2.VideoCapture(i)
    if cap.isOpened():
        print(f"카메라 {i}번이 작동합니다!")
        cap.release()
    else:
        print(f"카메라 {i}번 없음")

# DirectShow 백엔드 사용 (Windows)
cap = cv2.VideoCapture(0, cv2.CAP_DSHOW)

# V4L2 백엔드 사용 (Linux)
cap = cv2.VideoCapture(0, cv2.CAP_V4L2)

# 더 강력한 노이즈 제거
kernel = np.ones((7, 7), np.uint8)
mask = cv2.morphologyEx(mask, cv2.MORPH_OPEN, kernel, iterations=2)
mask = cv2.morphologyEx(mask, cv2.MORPH_CLOSE, kernel, iterations=2)

배운 걸 활용해서 만들 수 있는 재미있는 프로젝트들을 소개할게! 포트폴리오나 사이드 프로젝트로 딱이야. 💡

와! 여기까지 정말 긴 여정이었어. 고생 많았어! 👏

우리는 OpenCV를 이용한 객체 추적의 기초부터 실전 프로젝트까지 모든 걸 다뤄봤어. 단일 객체 추적, 다중 객체 추적, 색상 기반 추적, 그리고 칼만 필터를 이용한 예측까지! 이제 너도 충분히 실전 프로젝트를 만들 수 있을 거야. 💪

기억해야 할 핵심 포인트:

1. 상황에 맞는 알고리즘 선택
• 속도가 중요하면: MOSSE, KCF
• 정확도가 중요하면: CSRT
• 균형이 필요하면: KCF

2. 성능 최적화는 필수
• 프레임 크기 조정
• ROI 활용
• 멀티스레딩
• 프레임 스킵

3. 실패 대응 전략
• 추적 실패 감지
• 자동 재초기화
• 예측 알고리즘 활용

4. 실전 프로젝트로 연습
• 작은 프로젝트부터 시작
• 점진적으로 기능 추가
• 포트폴리오 구축

컴퓨터 비전은 정말 빠르게 발전하는 분야야. 오늘 배운 내용이 기초가 되어서 더 고급 기술들을 배울 수 있을 거야. YOLO, Mask R-CNN, Transformer 기반 추적 등 탐험할 게 정말 많아! 🚀

혹시 막히는 부분이 있거나 더 배우고 싶은 게 있다면, OpenCV 공식 문서나 GitHub의 오픈소스 프로젝트들을 참고해봐. 그리고 재능넷 같은 플랫폼에서 실전 프로젝트를 경험해보는 것도 정말 좋은 방법이야!

자, 이제 너의 차례야! 오늘 배운 걸 바탕으로 멋진 프로젝트를 만들어봐. 시작이 반이라고, 일단 코드를 작성하고 실행해보는 게 가장 중요해. 실패해도 괜찮아, 그게 바로 배움의 과정이니까! 😊

화이팅! 너라면 충분히 할 수 있어! 🎉