17_video_processing.py

  1"""
  217. 비디오 처리
  3- VideoCapture (카메라, 파일)
  4- VideoWriter (비디오 저장)
  5- 프레임 처리
  6- 백그라운드 차감
  7- 광학 흐름 (Optical Flow)
  8"""
  9
 10import cv2
 11import numpy as np
 12
 13
 14def video_capture_basics():
 15    """비디오 캡처 기초"""
 16    print("=" * 50)
 17    print("VideoCapture 기초")
 18    print("=" * 50)
 19
 20    print("\n카메라 캡처:")
 21    print("  cap = cv2.VideoCapture(0)  # 기본 카메라")
 22    print("  cap = cv2.VideoCapture(1)  # 두 번째 카메라")
 23
 24    print("\n파일 캡처:")
 25    print("  cap = cv2.VideoCapture('video.mp4')")
 26    print("  cap = cv2.VideoCapture('rtsp://...')  # 스트리밍")
 27
 28    print("\n주요 속성:")
 29    properties = [
 30        ('CAP_PROP_FRAME_WIDTH', '프레임 너비'),
 31        ('CAP_PROP_FRAME_HEIGHT', '프레임 높이'),
 32        ('CAP_PROP_FPS', '초당 프레임 수'),
 33        ('CAP_PROP_FRAME_COUNT', '총 프레임 수'),
 34        ('CAP_PROP_POS_FRAMES', '현재 프레임 위치'),
 35        ('CAP_PROP_POS_MSEC', '현재 시간 (ms)'),
 36    ]
 37
 38    for prop, desc in properties:
 39        print(f"  cv2.{prop}: {desc}")
 40
 41    # 시뮬레이션 비디오 생성
 42    print("\n시뮬레이션 비디오 생성 중...")
 43    frames = []
 44    for i in range(30):
 45        frame = np.zeros((480, 640, 3), dtype=np.uint8)
 46        frame[:] = [100, 100, 100]
 47        cv2.circle(frame, (100 + i * 15, 240), 30, (0, 255, 0), -1)
 48        cv2.putText(frame, f'Frame {i}', (10, 30),
 49                   cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 255, 255), 2)
 50        frames.append(frame)
 51
 52    cv2.imwrite('video_frame_sample.jpg', frames[15])
 53    print("샘플 프레임 저장: video_frame_sample.jpg")
 54
 55
 56def video_writer_demo():
 57    """비디오 저장 데모"""
 58    print("\n" + "=" * 50)
 59    print("VideoWriter (비디오 저장)")
 60    print("=" * 50)
 61
 62    # 프레임 생성
 63    width, height = 640, 480
 64    fps = 30.0
 65
 66    # 코덱 설정
 67    # fourcc = cv2.VideoWriter_fourcc(*'XVID')  # AVI
 68    fourcc = cv2.VideoWriter_fourcc(*'mp4v')  # MP4
 69
 70    print(f"비디오 설정: {width}x{height}, {fps}fps")
 71
 72    # VideoWriter 생성
 73    out = cv2.VideoWriter('output_video.mp4', fourcc, fps, (width, height))
 74
 75    if not out.isOpened():
 76        print("VideoWriter를 열 수 없습니다.")
 77        return
 78
 79    # 프레임 작성
 80    for i in range(90):  # 3초
 81        frame = np.zeros((height, width, 3), dtype=np.uint8)
 82        frame[:] = [50, 50, 50]
 83
 84        # 움직이는 원
 85        x = int(100 + 5 * i)
 86        y = int(240 + 100 * np.sin(i * 0.1))
 87        cv2.circle(frame, (x, y), 40, (0, 200, 0), -1)
 88
 89        # 프레임 번호
 90        cv2.putText(frame, f'Frame: {i}', (10, 30),
 91                   cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 255, 255), 2)
 92
 93        out.write(frame)
 94
 95    out.release()
 96    print("비디오 저장 완료: output_video.mp4")
 97
 98    print("\n지원 코덱:")
 99    codecs = [
100        ("'XVID'", '.avi', 'MPEG-4'),
101        ("'mp4v'", '.mp4', 'MPEG-4'),
102        ("'avc1'", '.mp4', 'H.264 (macOS)'),
103        ("'MJPG'", '.avi', 'Motion JPEG'),
104    ]
105    for code, ext, desc in codecs:
106        print(f"  cv2.VideoWriter_fourcc(*{code}) → {ext} ({desc})")
107
108
109def frame_processing_demo():
110    """프레임 처리 데모"""
111    print("\n" + "=" * 50)
112    print("프레임 처리")
113    print("=" * 50)
114
115    # 시뮬레이션 프레임
116    frame = np.zeros((480, 640, 3), dtype=np.uint8)
117    frame[:] = [150, 150, 150]
118    cv2.rectangle(frame, (200, 150), (440, 330), (0, 100, 200), -1)
119    cv2.circle(frame, (320, 240), 50, (200, 100, 0), -1)
120
121    # 다양한 처리
122    # 1. 그레이스케일
123    gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
124
125    # 2. 블러
126    blurred = cv2.GaussianBlur(frame, (15, 15), 0)
127
128    # 3. 엣지
129    edges = cv2.Canny(gray, 50, 150)
130
131    # 4. 컬러 조정
132    hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
133    hsv[:, :, 1] = cv2.add(hsv[:, :, 1], 50)  # 채도 증가
134    enhanced = cv2.cvtColor(hsv, cv2.COLOR_HSV2BGR)
135
136    print("프레임 처리 예제:")
137    print("  1. 그레이스케일 변환")
138    print("  2. 가우시안 블러")
139    print("  3. Canny 엣지 검출")
140    print("  4. 색상 보정 (HSV)")
141
142    cv2.imwrite('frame_original.jpg', frame)
143    cv2.imwrite('frame_gray.jpg', gray)
144    cv2.imwrite('frame_blurred.jpg', blurred)
145    cv2.imwrite('frame_edges.jpg', edges)
146    cv2.imwrite('frame_enhanced.jpg', enhanced)
147
148    print("\n실시간 처리 템플릿:")
149    code = '''
150while True:
151    ret, frame = cap.read()
152    if not ret:
153        break
154
155    # 프레임 처리
156    processed = your_processing_function(frame)
157
158    cv2.imshow('Video', processed)
159    if cv2.waitKey(1) & 0xFF == ord('q'):
160        break
161'''
162    print(code)
163
164
165def background_subtraction_demo():
166    """배경 차감 데모"""
167    print("\n" + "=" * 50)
168    print("배경 차감 (Background Subtraction)")
169    print("=" * 50)
170
171    # 시뮬레이션 프레임들 (배경 + 움직이는 객체)
172    background = np.zeros((480, 640, 3), dtype=np.uint8)
173    background[:] = [120, 120, 120]
174    cv2.rectangle(background, (100, 300), (250, 400), (80, 80, 80), -1)  # 고정 객체
175
176    # 배경 차감기 생성
177    # MOG2: Mixture of Gaussians
178    bg_subtractor_mog2 = cv2.createBackgroundSubtractorMOG2(
179        history=500,
180        varThreshold=16,
181        detectShadows=True
182    )
183
184    # KNN
185    bg_subtractor_knn = cv2.createBackgroundSubtractorKNN(
186        history=500,
187        dist2Threshold=400,
188        detectShadows=True
189    )
190
191    print("배경 차감기:")
192    print("  1. MOG2 (Mixture of Gaussians)")
193    print("     - 복잡한 배경에 효과적")
194    print("     - 그림자 검출 가능")
195    print("")
196    print("  2. KNN (K-Nearest Neighbors)")
197    print("     - 비정형 분포에 효과적")
198    print("     - 조명 변화에 강건")
199
200    # 시뮬레이션 (움직이는 원)
201    for i in range(30):
202        frame = background.copy()
203        x = 100 + i * 15
204        cv2.circle(frame, (x, 200), 40, (0, 200, 0), -1)
205
206        # 배경 차감 적용
207        fg_mask_mog2 = bg_subtractor_mog2.apply(frame)
208        fg_mask_knn = bg_subtractor_knn.apply(frame)
209
210        if i == 15:  # 중간 프레임 저장
211            cv2.imwrite('bg_frame.jpg', frame)
212            cv2.imwrite('bg_mask_mog2.jpg', fg_mask_mog2)
213            cv2.imwrite('bg_mask_knn.jpg', fg_mask_knn)
214
215    print("\n파라미터:")
216    print("  history: 학습에 사용할 과거 프레임 수")
217    print("  varThreshold (MOG2): 픽셀-모델 거리 임계값")
218    print("  dist2Threshold (KNN): 거리 임계값")
219    print("  detectShadows: 그림자 검출 여부")
220
221    print("\n후처리:")
222    print("  - 모폴로지 연산 (노이즈 제거)")
223    print("  - 컨투어 검출 (객체 추출)")
224    print("  - 바운딩 박스 그리기")
225
226
227def optical_flow_demo():
228    """광학 흐름 데모"""
229    print("\n" + "=" * 50)
230    print("광학 흐름 (Optical Flow)")
231    print("=" * 50)
232
233    # 두 프레임 생성 (움직임 시뮬레이션)
234    frame1 = np.zeros((300, 400), dtype=np.uint8)
235    frame1[:] = 100
236    cv2.circle(frame1, (100, 150), 30, 200, -1)
237    cv2.rectangle(frame1, (250, 100), (320, 200), 180, -1)
238
239    frame2 = np.zeros((300, 400), dtype=np.uint8)
240    frame2[:] = 100
241    cv2.circle(frame2, (130, 150), 30, 200, -1)  # 오른쪽으로 이동
242    cv2.rectangle(frame2, (250, 130), (320, 230), 180, -1)  # 아래로 이동
243
244    # Lucas-Kanade (sparse)
245    print("1. Lucas-Kanade (Sparse Optical Flow)")
246    print("   - 특정 점들의 움직임 추적")
247    print("   - 빠름, 특징점 기반")
248
249    # 특징점 검출
250    p0 = cv2.goodFeaturesToTrack(frame1, maxCorners=100, qualityLevel=0.3,
251                                  minDistance=7, blockSize=7)
252
253    if p0 is not None:
254        # 광학 흐름 계산
255        p1, status, err = cv2.calcOpticalFlowPyrLK(
256            frame1, frame2, p0, None,
257            winSize=(15, 15),
258            maxLevel=2,
259            criteria=(cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, 10, 0.03)
260        )
261
262        # 좋은 점만 선택
263        good_old = p0[status == 1]
264        good_new = p1[status == 1]
265
266        # 시각화
267        result_lk = cv2.cvtColor(frame2, cv2.COLOR_GRAY2BGR)
268        for old, new in zip(good_old, good_new):
269            a, b = new.ravel().astype(int)
270            c, d = old.ravel().astype(int)
271            cv2.line(result_lk, (a, b), (c, d), (0, 255, 0), 2)
272            cv2.circle(result_lk, (a, b), 5, (0, 0, 255), -1)
273
274        cv2.imwrite('optflow_lk.jpg', result_lk)
275        print(f"   추적된 점: {len(good_new)}")
276
277    # Farneback (dense)
278    print("\n2. Farneback (Dense Optical Flow)")
279    print("   - 모든 픽셀의 움직임 계산")
280    print("   - 느림, 전체 움직임 파악")
281
282    flow = cv2.calcOpticalFlowFarneback(
283        frame1, frame2, None,
284        pyr_scale=0.5,
285        levels=3,
286        winsize=15,
287        iterations=3,
288        poly_n=5,
289        poly_sigma=1.2,
290        flags=0
291    )
292
293    # 흐름을 색상으로 시각화
294    hsv = np.zeros((frame1.shape[0], frame1.shape[1], 3), dtype=np.uint8)
295    hsv[..., 1] = 255
296
297    mag, ang = cv2.cartToPolar(flow[..., 0], flow[..., 1])
298    hsv[..., 0] = ang * 180 / np.pi / 2
299    hsv[..., 2] = cv2.normalize(mag, None, 0, 255, cv2.NORM_MINMAX)
300
301    result_fb = cv2.cvtColor(hsv, cv2.COLOR_HSV2BGR)
302
303    cv2.imwrite('optflow_frame1.jpg', frame1)
304    cv2.imwrite('optflow_frame2.jpg', frame2)
305    cv2.imwrite('optflow_farneback.jpg', result_fb)
306
307    print(f"   흐름 벡터 shape: {flow.shape}")
308
309    print("\n광학 흐름 활용:")
310    print("  - 움직임 검출")
311    print("  - 객체 추적")
312    print("  - 비디오 압축")
313    print("  - 동작 인식")
314
315
316def video_tracking_demo():
317    """객체 추적 데모"""
318    print("\n" + "=" * 50)
319    print("객체 추적 (Object Tracking)")
320    print("=" * 50)
321
322    print("OpenCV 추적기 종류:")
323    trackers = [
324        ('BOOSTING', '오래된 방식, 느림'),
325        ('MIL', 'Multiple Instance Learning'),
326        ('KCF', 'Kernelized Correlation Filters, 빠름'),
327        ('TLD', 'Tracking-Learning-Detection'),
328        ('MEDIANFLOW', '예측 가능한 움직임에 좋음'),
329        ('GOTURN', 'Deep Learning 기반'),
330        ('MOSSE', '매우 빠름'),
331        ('CSRT', '정확, 다소 느림'),
332    ]
333
334    for name, desc in trackers:
335        print(f"  cv2.Tracker{name}_create(): {desc}")
336
337    print("\n추적기 사용 템플릿:")
338    code = '''
339# 추적기 생성
340tracker = cv2.TrackerKCF_create()
341# tracker = cv2.TrackerCSRT_create()  # 더 정확
342
343# 초기 바운딩 박스 설정
344bbox = (x, y, w, h)  # 또는 cv2.selectROI()
345tracker.init(first_frame, bbox)
346
347# 추적 루프
348while True:
349    ret, frame = cap.read()
350    success, bbox = tracker.update(frame)
351
352    if success:
353        x, y, w, h = [int(v) for v in bbox]
354        cv2.rectangle(frame, (x, y), (x+w, y+h), (0, 255, 0), 2)
355    else:
356        cv2.putText(frame, "Tracking failure", (10, 30),
357                   cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 0, 255), 1)
358'''
359    print(code)
360
361
362def performance_tips():
363    """성능 최적화 팁"""
364    print("\n" + "=" * 50)
365    print("비디오 처리 성능 최적화")
366    print("=" * 50)
367
368    print("""
3691. 프레임 크기 줄이기
370   - 처리 전: frame = cv2.resize(frame, None, fx=0.5, fy=0.5)
371   - 검출 후 원본에 결과 매핑
372
3732. 프레임 스킵
374   - 매 프레임 처리 불필요
375   - frame_count % skip_frames == 0 일 때만 처리
376
3773. ROI (Region of Interest) 활용
378   - 전체 프레임 대신 관심 영역만 처리
379   - roi = frame[y:y+h, x:x+w]
380
3814. 멀티스레딩/멀티프로세싱
382   - 캡처와 처리 분리
383   - Queue로 프레임 전달
384
3855. GPU 가속 (CUDA)
386   - cv2.cuda.GpuMat()
387   - cv2.cuda 모듈 함수 사용
388
3896. 캡처 버퍼 설정
390   - cap.set(cv2.CAP_PROP_BUFFERSIZE, 1)
391   - 지연 최소화
392""")
393
394
395def main():
396    """메인 함수"""
397    # VideoCapture 기초
398    video_capture_basics()
399
400    # VideoWriter
401    video_writer_demo()
402
403    # 프레임 처리
404    frame_processing_demo()
405
406    # 배경 차감
407    background_subtraction_demo()
408
409    # 광학 흐름
410    optical_flow_demo()
411
412    # 객체 추적
413    video_tracking_demo()
414
415    # 성능 팁
416    performance_tips()
417
418    print("\n비디오 처리 데모 완료!")
419
420
421if __name__ == '__main__':
422    main()