18_camera_calibration.py

  1"""
  218. 카메라 캘리브레이션
  3- 카메라 내부 파라미터
  4- 왜곡 보정
  5- 체스보드 검출
  6- 스테레오 비전 기초
  7"""
  8
  9import cv2
 10import numpy as np
 11
 12
 13def camera_model_concept():
 14    """카메라 모델 개념"""
 15    print("=" * 50)
 16    print("카메라 모델 개념")
 17    print("=" * 50)
 18
 19    print("\n1. 핀홀 카메라 모델")
 20    print("   - 3D 점 → 2D 이미지 투영")
 21    print("   - 원근 투영 (Perspective Projection)")
 22
 23    print("\n2. 카메라 내부 파라미터 (Intrinsic)")
 24    print("""
 25   K = | fx  0  cx |
 26       |  0 fy  cy |
 27       |  0  0   1 |
 28
 29   fx, fy: 초점 거리 (픽셀 단위)
 30   cx, cy: 주점 (principal point, 이미지 중심)
 31""")
 32
 33    print("3. 카메라 외부 파라미터 (Extrinsic)")
 34    print("   - R: 회전 행렬 (3x3)")
 35    print("   - t: 평행 이동 벡터 (3x1)")
 36    print("   - 월드 좌표 → 카메라 좌표 변환")
 37
 38    print("\n4. 투영 행렬")
 39    print("   P = K[R|t]")
 40    print("   p = P * X  (동차 좌표계)")
 41
 42    print("\n5. 왜곡 계수 (Distortion Coefficients)")
 43    print("   - k1, k2, k3: 방사 왜곡 (radial)")
 44    print("   - p1, p2: 접선 왜곡 (tangential)")
 45    print("   - dist_coeffs = [k1, k2, p1, p2, k3]")
 46
 47
 48def create_chessboard_image():
 49    """체스보드 이미지 생성"""
 50    # 체스보드 패턴
 51    rows, cols = 7, 9
 52    square_size = 40
 53
 54    img = np.zeros((rows * square_size, cols * square_size, 3), dtype=np.uint8)
 55    img[:] = [255, 255, 255]
 56
 57    for i in range(rows):
 58        for j in range(cols):
 59            if (i + j) % 2 == 1:
 60                x1, y1 = j * square_size, i * square_size
 61                x2, y2 = x1 + square_size, y1 + square_size
 62                cv2.rectangle(img, (x1, y1), (x2, y2), (0, 0, 0), -1)
 63
 64    return img
 65
 66
 67def chessboard_detection_demo():
 68    """체스보드 코너 검출 데모"""
 69    print("\n" + "=" * 50)
 70    print("체스보드 코너 검출")
 71    print("=" * 50)
 72
 73    # 체스보드 이미지 생성
 74    chessboard = create_chessboard_image()
 75
 76    # 약간의 원근 변환 적용 (실제 촬영 시뮬레이션)
 77    h, w = chessboard.shape[:2]
 78    src_pts = np.float32([[0, 0], [w, 0], [w, h], [0, h]])
 79    dst_pts = np.float32([[20, 30], [w-30, 20], [w-20, h-10], [10, h-30]])
 80    M = cv2.getPerspectiveTransform(src_pts, dst_pts)
 81    warped = cv2.warpPerspective(chessboard, M, (w, h), borderValue=(200, 200, 200))
 82
 83    # 그레이스케일 변환
 84    gray = cv2.cvtColor(warped, cv2.COLOR_BGR2GRAY)
 85
 86    # 코너 검출 파라미터
 87    # 내부 코너 수 (검은색-흰색 교차점)
 88    pattern_size = (8, 6)  # 가로 8, 세로 6 코너
 89
 90    # 코너 검출
 91    found, corners = cv2.findChessboardCorners(
 92        gray, pattern_size,
 93        flags=cv2.CALIB_CB_ADAPTIVE_THRESH + cv2.CALIB_CB_NORMALIZE_IMAGE
 94    )
 95
 96    print(f"패턴 크기: {pattern_size}")
 97    print(f"코너 검출 성공: {found}")
 98
 99    if found:
100        # 서브픽셀 정밀도로 개선
101        criteria = (cv2.TERM_CRITERIA_EPS + cv2.TERM_CRITERIA_MAX_ITER, 30, 0.001)
102        corners = cv2.cornerSubPix(gray, corners, (11, 11), (-1, -1), criteria)
103
104        print(f"검출된 코너 수: {len(corners)}")
105
106        # 결과 시각화
107        result = warped.copy()
108        cv2.drawChessboardCorners(result, pattern_size, corners, found)
109
110        cv2.imwrite('chessboard_input.jpg', warped)
111        cv2.imwrite('chessboard_corners.jpg', result)
112        print("이미지 저장 완료")
113
114    print("\n검출 플래그:")
115    print("  CALIB_CB_ADAPTIVE_THRESH: 적응적 이진화")
116    print("  CALIB_CB_NORMALIZE_IMAGE: 이미지 정규화")
117    print("  CALIB_CB_FAST_CHECK: 빠른 체크 (실패 시 조기 종료)")
118
119
120def camera_calibration_simulation():
121    """카메라 캘리브레이션 시뮬레이션"""
122    print("\n" + "=" * 50)
123    print("카메라 캘리브레이션 시뮬레이션")
124    print("=" * 50)
125
126    # 체스보드 파라미터
127    pattern_size = (8, 6)
128    square_size = 1.0  # 실제 사각형 크기 (단위: cm, mm 등)
129
130    # 3D 객체 점 (체스보드 평면, z=0)
131    objp = np.zeros((pattern_size[0] * pattern_size[1], 3), np.float32)
132    objp[:, :2] = np.mgrid[0:pattern_size[0], 0:pattern_size[1]].T.reshape(-1, 2)
133    objp *= square_size
134
135    print(f"객체 점 (3D): {objp.shape}")
136    print(f"첫 번째 점: {objp[0]}")
137    print(f"마지막 점: {objp[-1]}")
138
139    # 시뮬레이션용 여러 이미지에서 검출된 점들
140    objpoints = []  # 3D 점들
141    imgpoints = []  # 2D 점들
142
143    # 시뮬레이션 (실제로는 여러 각도에서 촬영한 이미지 사용)
144    chessboard = create_chessboard_image()
145    gray = cv2.cvtColor(chessboard, cv2.COLOR_BGR2GRAY)
146
147    found, corners = cv2.findChessboardCorners(gray, pattern_size)
148
149    if found:
150        objpoints.append(objp)
151        imgpoints.append(corners)
152
153        print(f"\n사용된 이미지 수: {len(objpoints)}")
154
155        # 캘리브레이션 (최소 3-5개 이미지 필요)
156        # 여기서는 시뮬레이션이므로 실제 결과와 다를 수 있음
157        h, w = gray.shape
158
159        # 초기 카메라 행렬 추정
160        fx = fy = w  # 대략적 초점 거리
161        cx, cy = w/2, h/2
162
163        camera_matrix = np.array([
164            [fx, 0, cx],
165            [0, fy, cy],
166            [0, 0, 1]
167        ], dtype=np.float64)
168
169        dist_coeffs = np.zeros(5)
170
171        print("\n추정된 카메라 행렬:")
172        print(camera_matrix)
173
174        print("\n캘리브레이션 프로세스:")
175        print("  1. 여러 각도에서 체스보드 촬영 (10-20장)")
176        print("  2. 각 이미지에서 코너 검출")
177        print("  3. cv2.calibrateCamera() 호출")
178        print("  4. 카메라 행렬, 왜곡 계수 획득")
179
180
181def calibration_workflow():
182    """캘리브레이션 워크플로우"""
183    print("\n" + "=" * 50)
184    print("실제 캘리브레이션 워크플로우")
185    print("=" * 50)
186
187    code = '''
188import cv2
189import numpy as np
190import glob
191
192# 체스보드 설정
193pattern_size = (9, 6)  # 내부 코너 수
194square_size = 25.0     # mm 단위
195
196# 객체 점 생성
197objp = np.zeros((pattern_size[0] * pattern_size[1], 3), np.float32)
198objp[:, :2] = np.mgrid[0:pattern_size[0], 0:pattern_size[1]].T.reshape(-1, 2)
199objp *= square_size
200
201objpoints = []  # 3D
202imgpoints = []  # 2D
203
204# 이미지 로드 및 코너 검출
205images = glob.glob('calibration_images/*.jpg')
206
207for fname in images:
208    img = cv2.imread(fname)
209    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
210
211    found, corners = cv2.findChessboardCorners(gray, pattern_size)
212
213    if found:
214        objpoints.append(objp)
215        corners2 = cv2.cornerSubPix(gray, corners, (11, 11), (-1, -1),
216                                    (cv2.TERM_CRITERIA_EPS + cv2.TERM_CRITERIA_MAX_ITER, 30, 0.001))
217        imgpoints.append(corners2)
218
219# 캘리브레이션 수행
220ret, camera_matrix, dist_coeffs, rvecs, tvecs = cv2.calibrateCamera(
221    objpoints, imgpoints, gray.shape[::-1], None, None
222)
223
224print(f"RMS error: {ret}")
225print(f"Camera matrix:\\n{camera_matrix}")
226print(f"Distortion coefficients:\\n{dist_coeffs}")
227
228# 결과 저장
229np.savez('calibration.npz',
230         camera_matrix=camera_matrix,
231         dist_coeffs=dist_coeffs)
232'''
233
234    print(code)
235
236    print("\n캘리브레이션 팁:")
237    print("  1. 최소 10-20장의 이미지 사용")
238    print("  2. 다양한 각도와 위치에서 촬영")
239    print("  3. 체스보드가 이미지 전체에 분포하도록")
240    print("  4. 조명이 균일해야 함")
241    print("  5. 블러 없이 선명한 이미지")
242
243
244def undistort_demo():
245    """왜곡 보정 데모"""
246    print("\n" + "=" * 50)
247    print("왜곡 보정 (Undistortion)")
248    print("=" * 50)
249
250    # 시뮬레이션용 왜곡 이미지 생성
251    img = np.zeros((400, 600, 3), dtype=np.uint8)
252    img[:] = [200, 200, 200]
253
254    # 격자 패턴
255    for i in range(0, 600, 50):
256        cv2.line(img, (i, 0), (i, 400), (0, 0, 0), 1)
257    for j in range(0, 400, 50):
258        cv2.line(img, (0, j), (600, j), (0, 0, 0), 1)
259
260    # 가상의 왜곡 적용 (barrel distortion 시뮬레이션)
261    h, w = img.shape[:2]
262    camera_matrix = np.array([
263        [w, 0, w/2],
264        [0, w, h/2],
265        [0, 0, 1]
266    ], dtype=np.float64)
267
268    # 왜곡 계수 (k1이 음수면 barrel, 양수면 pincushion)
269    dist_coeffs = np.array([-0.3, 0.1, 0, 0, 0])
270
271    # 왜곡 적용 (역으로 undistort 사용)
272    distorted = cv2.undistort(img, camera_matrix, -dist_coeffs)
273
274    # 왜곡 보정
275    undistorted = cv2.undistort(distorted, camera_matrix, dist_coeffs)
276
277    cv2.imwrite('undistort_original.jpg', img)
278    cv2.imwrite('undistort_distorted.jpg', distorted)
279    cv2.imwrite('undistort_corrected.jpg', undistorted)
280
281    print("왜곡 보정 방법:")
282    print("  1. cv2.undistort()")
283    print("     - 간단하게 사용")
284    print("     - 매번 계산")
285
286    print("\n  2. cv2.initUndistortRectifyMap() + cv2.remap()")
287    print("     - 맵을 미리 계산")
288    print("     - 비디오에서 효율적")
289
290    code = '''
291# 효율적인 방법 (비디오용)
292map1, map2 = cv2.initUndistortRectifyMap(
293    camera_matrix, dist_coeffs, None,
294    camera_matrix, (w, h), cv2.CV_32FC1
295)
296
297# 프레임마다 적용
298undistorted = cv2.remap(distorted, map1, map2, cv2.INTER_LINEAR)
299'''
300    print(code)
301
302
303def stereo_vision_concept():
304    """스테레오 비전 개념"""
305    print("\n" + "=" * 50)
306    print("스테레오 비전 기초")
307    print("=" * 50)
308
309    print("\n1. 스테레오 비전 원리")
310    print("   - 두 카메라로 동일 장면 촬영")
311    print("   - 시차(disparity)로 깊이 계산")
312    print("   - depth = (baseline * focal_length) / disparity")
313
314    print("\n2. 스테레오 캘리브레이션")
315    print("   - 각 카메라 개별 캘리브레이션")
316    print("   - 스테레오 쌍 캘리브레이션")
317    print("   - 에피폴라 기하학 계산")
318
319    code = '''
320# 스테레오 캘리브레이션
321ret, K1, D1, K2, D2, R, T, E, F = cv2.stereoCalibrate(
322    objpoints, imgpoints_left, imgpoints_right,
323    K1, D1, K2, D2, image_size,
324    flags=cv2.CALIB_FIX_INTRINSIC
325)
326'''
327    print(code)
328
329    print("\n3. 스테레오 정합 (Stereo Rectification)")
330    print("   - 두 이미지를 같은 평면으로 정렬")
331    print("   - 수평선상에서만 매칭 탐색")
332
333    print("\n4. 시차 맵 계산")
334    print("   - StereoBM: Block Matching (빠름)")
335    print("   - StereoSGBM: Semi-Global BM (정확)")
336
337
338def stereo_matching_demo():
339    """스테레오 매칭 시뮬레이션"""
340    print("\n" + "=" * 50)
341    print("스테레오 매칭 시뮬레이션")
342    print("=" * 50)
343
344    # 시뮬레이션용 스테레오 이미지 쌍 생성
345    left = np.zeros((300, 400), dtype=np.uint8)
346    left[:] = 150
347    cv2.rectangle(left, (100, 100), (200, 200), 80, -1)  # 가까운 객체
348    cv2.rectangle(left, (250, 120), (350, 180), 100, -1)  # 먼 객체
349
350    # 오른쪽 이미지 (시차 적용)
351    right = np.zeros((300, 400), dtype=np.uint8)
352    right[:] = 150
353    cv2.rectangle(right, (80, 100), (180, 200), 80, -1)   # 시차 20 (가까움)
354    cv2.rectangle(right, (240, 120), (340, 180), 100, -1)  # 시차 10 (멀음)
355
356    # StereoBM
357    stereo_bm = cv2.StereoBM_create(numDisparities=64, blockSize=15)
358    disparity_bm = stereo_bm.compute(left, right)
359
360    # StereoSGBM
361    stereo_sgbm = cv2.StereoSGBM_create(
362        minDisparity=0,
363        numDisparities=64,
364        blockSize=5,
365        P1=8 * 3 * 5 ** 2,
366        P2=32 * 3 * 5 ** 2,
367        disp12MaxDiff=1,
368        uniquenessRatio=10,
369        speckleWindowSize=100,
370        speckleRange=32
371    )
372    disparity_sgbm = stereo_sgbm.compute(left, right)
373
374    # 정규화
375    disparity_bm_norm = cv2.normalize(disparity_bm, None, 0, 255, cv2.NORM_MINMAX).astype(np.uint8)
376    disparity_sgbm_norm = cv2.normalize(disparity_sgbm, None, 0, 255, cv2.NORM_MINMAX).astype(np.uint8)
377
378    cv2.imwrite('stereo_left.jpg', left)
379    cv2.imwrite('stereo_right.jpg', right)
380    cv2.imwrite('stereo_disparity_bm.jpg', disparity_bm_norm)
381    cv2.imwrite('stereo_disparity_sgbm.jpg', disparity_sgbm_norm)
382
383    print("시차 맵 생성 완료")
384    print("\nStereoBM 파라미터:")
385    print("  numDisparities: 시차 범위 (16의 배수)")
386    print("  blockSize: 매칭 블록 크기 (홀수, 5~21)")
387
388    print("\nStereoSGBM 파라미터:")
389    print("  P1, P2: 부드러움 제어")
390    print("  uniquenessRatio: 매칭 고유성")
391    print("  speckleWindowSize: 스페클 필터 크기")
392
393
394def pose_estimation_concept():
395    """포즈 추정 개념"""
396    print("\n" + "=" * 50)
397    print("포즈 추정 (Pose Estimation)")
398    print("=" * 50)
399
400    print("\n카메라 포즈 추정:")
401    print("  - 3D-2D 대응점으로 카메라 위치/방향 추정")
402    print("  - cv2.solvePnP()")
403
404    code = '''
405# 3D 객체 점 (알려진 월드 좌표)
406object_points = np.array([
407    [0, 0, 0],
408    [1, 0, 0],
409    [0, 1, 0],
410    [1, 1, 0]
411], dtype=np.float32)
412
413# 2D 이미지 점 (검출된 좌표)
414image_points = np.array([...], dtype=np.float32)
415
416# 포즈 추정
417success, rvec, tvec = cv2.solvePnP(
418    object_points, image_points,
419    camera_matrix, dist_coeffs
420)
421
422# 회전 벡터 → 회전 행렬
423rotation_matrix, _ = cv2.Rodrigues(rvec)
424
425# 3D 축 그리기
426axis_points = np.float32([
427    [3, 0, 0], [0, 3, 0], [0, 0, -3]
428]).reshape(-1, 3)
429imgpts, _ = cv2.projectPoints(
430    axis_points, rvec, tvec, camera_matrix, dist_coeffs
431)
432'''
433    print(code)
434
435    print("\n활용:")
436    print("  - AR (Augmented Reality)")
437    print("  - 로봇 비전")
438    print("  - 3D 재구성")
439
440
441def main():
442    """메인 함수"""
443    # 카메라 모델 개념
444    camera_model_concept()
445
446    # 체스보드 검출
447    chessboard_detection_demo()
448
449    # 캘리브레이션 시뮬레이션
450    camera_calibration_simulation()
451
452    # 캘리브레이션 워크플로우
453    calibration_workflow()
454
455    # 왜곡 보정
456    undistort_demo()
457
458    # 스테레오 비전
459    stereo_vision_concept()
460
461    # 스테레오 매칭
462    stereo_matching_demo()
463
464    # 포즈 추정
465    pose_estimation_concept()
466
467    print("\n카메라 캘리브레이션 데모 완료!")
468
469
470if __name__ == '__main__':
471    main()