OPENCV 왜곡보정

기존에 사용하던 Opencv 보정함수는 

단순히 cv2.Undistortion 함수였는데 UndistortImageOptimal 함수에 대해서도 알아보게 되었음.

 

또한 배경의 장애물들로 인한 cv2.FindChessboardCorners 인식이 저하되어

해당 이미지들의 ChessboardCorner를 강제로 찾아내는 과정에 대해서도 알게되었음.

 

기존에는 FOV 800mm의 크지않은 ChessBoard를 사용하였기 때문에 

큰 무리없이 이미지 촬영을 진행하였는데

이번 프로젝트에서는 FOV 3000mm의 넓은 CheckerBoard를 제작하여

사용하였기 때문에 이미지 촬영이 쉽지 않았음.

 

1000*1000 (mm) CheckerBoard

3000 * 3000 (mm) Checkerboard

 

위 이미지를 보면 알 수 있듯이 센터에서 촬영하는건 줄을 매달고 올라가지 않는 이상 불가능 하였음.

 

따라서 위 이미지를 사용하여 cv2. FindChessboardCorners 하게되면 34장의 이미지 중 

15장의 이미지만 인식이 되는 결과가 발생함.

 

위 문제를 CheckerBoard의 영역만 ROI를 지정해 준 뒤 

픽셀값 0의 Mask 이미지를 하나 생성하고 해당 ROI에 해당하는 부분을 255로 변환

및 해당 Mask 이미지위에 이미지를 and연산하여 

ROI의 영역만 보이는 새로운 이미지에서 FindChessboardCorners 를 실행

Mask Image

위 이미지 처리 방법을 사용하여 기존 15/34 => 44%의 인식률을 24/34 => 70%의 인식률까지 개선 하였음.

import cv2

import numpy as np

import glob

import os

def resize_with_aspect_ratio(image, max_size=720):

    """가로 세로 비율을 유지하면서 이미지 리사이즈"""

    height, width = image.shape[:2]

    ratio = min(max_size / width, max_size / height)

    new_width = int(width * ratio)

    new_height = int(height * ratio)

    return cv2.resize(image, (new_width, new_height)), ratio

def show_image(window_name, image, max_size=1024):

    """이미지를 리사이즈하여 화면에 표시"""

    display_img, _ = resize_with_aspect_ratio(image, max_size)

    cv2.imshow(window_name, display_img)

    cv2.waitKey(1000)  # 1초 동안 표시

    cv2.destroyWindow(window_name)

def calibrate_camera_with_roi():

    # 입력/출력 경로 설정

    input_path =

    output_path =

    calib_data_path =

   

    # 출력 디렉토리가 없으면 생성

    os.makedirs(output_path, exist_ok=True)

    os.makedirs(calib_data_path, exist_ok=True)

    # 체커보드 패턴 크기 설정

    pattern_size = (17, 13)  # 체커보드의 내부 코너 수

    square_size = 150.0  # 실제 체커보드 한 칸의 크기 (mm)

    # 3D 점 좌표 준비

    objp = np.zeros((pattern_size[0] * pattern_size[1], 3), np.float32)

    objp[:, :2] = np.mgrid[0:pattern_size[0], 0:pattern_size[1]].T.reshape(-1, 2) * square_size

    # 저장할 점들의 배열 초기화

    objpoints = []  # 3D 점 좌표

    imgpoints = []  # 2D 점 좌표

    # 이미지 파일 로드

    images = glob.glob(os.path.join(input_path, '*.*'))

    print(f"Found {len(images)} images in {input_path}")

    for fname in images:

        base_name = os.path.basename(fname)

        print(f"\nProcessing {base_name}...")

       

        try:

            # 원본 이미지 로드

            original_img = cv2.imread(fname)

            if original_img is None:

                print(f"Failed to load {base_name}")

                continue

               

            # ROI 선택을 위해 이미지 리사이즈

            display_img, resize_ratio = resize_with_aspect_ratio(original_img, max_size=1024)

           

            # ROI 선택 창 생성 및 위치 지정

            window_name = "Select Chessboard ROI"

            cv2.namedWindow(window_name, cv2.WINDOW_NORMAL)

            cv2.moveWindow(window_name, 0, 0)

           

            # 리사이즈된 이미지에서 ROI 선택

            roi = cv2.selectROI(window_name, display_img)

            cv2.destroyWindow(window_name)

            # ROI 좌표를 원본 이미지 크기로 변환

            original_roi = tuple(int(x / resize_ratio) for x in roi)

           

            # 그레이스케일 변환

            gray = cv2.cvtColor(original_img, cv2.COLOR_BGR2GRAY)

           

            # 그레이스케일 이미지 표시

            show_image("Grayscale Image", gray)

            # ROI 마스크 생성

            mask = np.zeros(gray.shape, np.uint8)

            mask[int(original_roi[1]):int(original_roi[1]+original_roi[3]),

                 int(original_roi[0]):int(original_roi[0]+original_roi[2])] = 255

           

            # 마스크 이미지 표시

            show_image("ROI Mask", mask)

            # ROI 영역에서만 체커보드 코너 검출

            masked_gray = cv2.bitwise_and(gray, gray, mask=mask)

           

            # 마스크 적용된 그레이스케일 이미지 표시

            show_image("Masked Grayscale", masked_gray)

            print("Detecting chessboard corners...")

            # 체커보드 코너 검출

            ret, corners = cv2.findChessboardCorners(masked_gray, pattern_size,

                                                   cv2.CALIB_CB_EXHAUSTIVE + cv2.CALIB_CB_ACCURACY)

            if ret:

                print("Corners found! Refining corner positions...")

                # 코너 위치 개선

                criteria = (cv2.TERM_CRITERIA_EPS + cv2.TERM_CRITERIA_MAX_ITER, 30, 0.001)

                corners2 = cv2.cornerSubPix(gray, corners, (11, 11), (-1, -1), criteria)

                # 점들 저장

                objpoints.append(objp)

                imgpoints.append(corners2)

                # 코너 그리기

                img_with_corners = original_img.copy()

                cv2.drawChessboardCorners(img_with_corners, pattern_size, corners2, ret)

               

                # 결과 이미지 저장

                output_file = os.path.join(output_path, f"detected_{base_name}")

                cv2.imwrite(output_file, img_with_corners)

               

                print(f"Corners found and saved: {output_file}")

               

                # 결과 이미지 표시

                show_image("Detected Corners", img_with_corners)

               

                # ROI가 표시된 원본 이미지 생성 및 표시

                roi_visualization = original_img.copy()

                cv2.rectangle(roi_visualization,

                            (original_roi[0], original_roi[1]),

                            (original_roi[0] + original_roi[2], original_roi[1] + original_roi[3]),

                            (0, 255, 0), 2)

                show_image("ROI Visualization", roi_visualization)

               

            else:

                print(f"No corners found in {base_name}")

        except Exception as e:

            print(f"Error processing {base_name}: {str(e)}")

            continue

    # 카메라 캘리브레이션 수행

    if len(objpoints) > 0:

        print("\nPerforming camera calibration...")

        ret, camera_matrix, dist_coeffs, rvecs, tvecs = cv2.calibrateCamera(

            objpoints, imgpoints, gray.shape[::-1], None, None

        )

        # 캘리브레이션 결과를 텍스트 파일로 저장

        camera_matrix_file = os.path.join(calib_data_path, 'cameraMatrix.txt')

        dist_coeffs_file = os.path.join(calib_data_path, 'distCoeffs.txt')

        # 카메라 매트릭스 저장 (3x3 행렬)

        np.savetxt(camera_matrix_file, camera_matrix, fmt='%.18e')

       

        # 왜곡 계수 저장 (1x5 벡터)

        np.savetxt(dist_coeffs_file, dist_coeffs, fmt='%.18e')

       

        print(f"\nCalibration completed successfully!")

        print(f"Number of images used: {len(objpoints)}")

        print(f"Camera Matrix:\n{camera_matrix}")

        print(f"\nDistortion Coefficients:\n{dist_coeffs}")

        print(f"\nCalibration error: {ret}")

        print(f"\nCalibration data saved to:")

        print(f"Camera Matrix: {camera_matrix_file}")

        print(f"Distortion Coefficients: {dist_coeffs_file}")

       

        return camera_matrix, dist_coeffs

    else:

        print("Calibration failed: No valid chessboard patterns found")

        return None, None

if __name__ == "__main__":

    try:

        camera_matrix, dist_coeffs = calibrate_camera_with_roi()

        if camera_matrix is not None:

            print("\nProgram completed successfully!")

    except Exception as e:

        print(f"An error occurred: {str(e)}")

 

위 왜곡보정 데이터를 사용하여 실제 렌즈의 왜곡률을 개선하고 

개선된 이미지를 사용하여 Motor와의 위치값을 통일시키는 Calibration 을 진행하는데

 

실제 사용해야하는 이미지를 

cv2.Undistortion 과 getOptimalNewCameraMatrix 이후의 cv2.Undistortion 중 선택하여 사용해야 함.

 

위 매서드의 차이점을 CluadeAI를 통해 알아 보았음.

 

 

• • 1. 일반적인 cv2.undistort 사용

    python

    Copy

    dst = cv2.undistort(img, camera_matrix, dist_coeffs)
    이 방법은 가장 기본적인 렌즈 왜곡 보정 방법으로:
    • 원본 이미지의 모든 픽셀을 왜곡 계수를 사용하여 보정합니다
    • 보정 후 이미지 가장자리에 검은색 영역이 생길 수 있습니다
    • 출력 이미지의 크기가 입력 이미지와 동일합니다
    • 간단하지만 이미지 가장자리의 정보 손실이 발생할 수 있습니다

    2. cv2.getOptimalNewCameraMatrix 적용 후 cv2.undistort 사용

    python

    Copy

    new_camera_matrix, roi = cv2.getOptimalNewCameraMatrix( camera_matrix, dist_coeffs, imageSize, alpha) dst = cv2.undistort(img, camera_matrix, dist_coeffs, None, new_camera_matrix)
    이 방법의 특징:
    • 왜곡 보정 후 최적의 새로운 카메라 행렬을 계산합니다
    • alpha 매개변수를 통해 출력 이미지의 특성을 조절할 수 있습니다:
      • alpha=0: 불필요한 픽셀을 모두 제거 (검은 영역 최소화)
      • alpha=1: 모든 픽셀을 유지 (원본 이미지의 모든 정보 보존)
      • 0<alpha<1: 두 경우의 절충안
    • ROI(Region of Interest) 정보를 얻을 수 있어 불필요한 영역을 크롭할 수 있습니다

    주요 차이점 정리

    1. 이미지 품질:
    • 일반 undistort: 단순 보정으로 가장자리 왜곡이나 정보 손실이 발생할 수 있음
    • getOptimalNewCameraMatrix 사용: 최적화된 보정으로 더 나은 이미지 품질 제공
    1. 유연성:
    • 일반 undistort: 매개변수 조정 불가
    • getOptimalNewCameraMatrix 사용: alpha 값 조정으로 결과 이미지 특성 제어 가능
    1. 활용성:
    • 일반 undistort: 간단한 보정이 필요한 경우 적합
    • getOptimalNewCameraMatrix 사용: 전문적인 컴퓨터 비전 응용에 더 적합
    1. 출력 이미지:
    • 일반 undistort: 항상 원본과 같은 크기
    • getOptimalNewCameraMatrix 사용: ROI를 통해 필요한 영역만 선택 가능

    사용 권장 사항

    1. 일반 cv2.undistort 사용 시나리오:
    • 간단한 왜곡 보정이 필요한 경우
    • 실시간 처리가 필요한 경우
    • 이미지 크기 유지가 중요한 경우
    1. getOptimalNewCameraMatrix 사용 시나리오:
    • 고품질의 왜곡 보정이 필요한 경우
    • 이미지 가장자리의 품질이 중요한 경우
    • 유연한 출력 이미지 조정이 필요한 경우
    • 정밀한 컴퓨터 비전 작업이 필요한 경우

 

좀 더 이해한 내용을 바탕으로 정리하면

 

일반 cv2.Undistortion 의 경우 기존의 카메라가 갖고 있는 Matrix 를 사용한 이미지에 단순 왜곡 계수를 사용하여
( * 여기서 Opencv의 Mat과 헷갈렸는데 카메라 내부 파라메타를 가지고 있는 3x3 행렬의 카메라 매트릭스를 의미 )

이미지를 보정하지만

 

getOptimalNewCameraMatrix 는 왜곡 계수를 사용하여 새로운 카메라 특성의 Matrix를 생성하고

해당 Matrix를 사용하여 원본 이미지를 왜곡 보정하는 것임.

 

개인적인 생각으로 getOptimalNewCameraMatrix를 사용하면 가장자리에 있는 이미지 보정이 좀 더 미세하게 가능하지만
만약 이미지의 가장자리 보정이 중요하지 않다면 단순 Undistortion을 사용하여도 무방할 것 같음.

결과 이미지를 첨부하고 글을 마침.

원본 이미지

 

GetOptimalNewCameraMatrix 0 적용 결과 이미지

GetOptimalNewCameraMatrix 1 적용 결과 이미지

 

Undistrion 결과 이미지