calibration.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Importing libraries\n",
    "\n",
    "referred to the official document. \n",
    "[OpenCV](https://docs.opencv.org/4.x/d5/de5/tutorial_py_setup_in_windows.html)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "import cv2 as cv\n",
    "import numpy as np\n",
    "import glob2 as glob\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4.11.0\n"
     ]
    }
   ],
   "source": [
    "print( cv.__version__ )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Understanding the usage of OpenCV with code from official document"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2-0. practicing using functions from np and cv"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0., 0., 0.],\n",
       "       [0., 0., 0.],\n",
       "       [0., 0., 0.],\n",
       "       [0., 0., 0.],\n",
       "       [0., 0., 0.],\n",
       "       [0., 0., 0.],\n",
       "       [0., 0., 0.],\n",
       "       [0., 0., 0.],\n",
       "       [0., 0., 0.],\n",
       "       [0., 0., 0.],\n",
       "       [0., 0., 0.],\n",
       "       [0., 0., 0.],\n",
       "       [0., 0., 0.],\n",
       "       [0., 0., 0.]], dtype=float32)"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.zeros((2*7,3), np.float32)\n",
    "# objp[:,:2] = np.mgrid[0:7,0:6].T.reshape(-1,2)\n",
    "\n",
    "# reason why using 2*7 instead of 14 -> it represents a size of the grid pattern "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "X:\n",
      " [[0 1 2 3 4 5 6]\n",
      " [0 1 2 3 4 5 6]]\n",
      "Y:\n",
      " [[0 0 0 0 0 0 0]\n",
      " [1 1 1 1 1 1 1]]\n"
     ]
    }
   ],
   "source": [
    "# mgrid: multi-dimensional meshgrid\n",
    "# two 1D arrays -> two 2D arrays.\n",
    "\n",
    "x = np.arange(0,7)\n",
    "y = np.arange(0,2)\n",
    "\n",
    "X, Y = np.meshgrid(x, y)\n",
    "\n",
    "print(\"X:\\n\", X)\n",
    "print(\"Y:\\n\", Y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "X:\n",
      " [[0 1 2 3 4 5 6]\n",
      " [0 1 2 3 4 5 6]]\n",
      "Y:\n",
      " [[0 0 0 0 0 0 0]\n",
      " [1 1 1 1 1 1 1]]\n"
     ]
    }
   ],
   "source": [
    "x = np.array([0, 1, 2, 3, 4, 5, 6])\n",
    "y = np.array([0, 1])\n",
    "\n",
    "X, Y = np.meshgrid(x, y)\n",
    "\n",
    "print(\"X:\\n\", X)\n",
    "print(\"Y:\\n\", Y)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "X:\n",
      " [[0 0]\n",
      " [1 1]\n",
      " [2 2]\n",
      " [3 3]\n",
      " [4 4]\n",
      " [5 5]\n",
      " [6 6]]\n",
      "Y:\n",
      " [[0 1]\n",
      " [0 1]\n",
      " [0 1]\n",
      " [0 1]\n",
      " [0 1]\n",
      " [0 1]\n",
      " [0 1]]\n"
     ]
    }
   ],
   "source": [
    "X, Y = np.mgrid[0:7,0:2]\n",
    "\n",
    "print(\"X:\\n\", X)\n",
    "print(\"Y:\\n\", Y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[0, 0],\n",
       "        [1, 0],\n",
       "        [2, 0],\n",
       "        [3, 0],\n",
       "        [4, 0],\n",
       "        [5, 0],\n",
       "        [6, 0]],\n",
       "\n",
       "       [[0, 1],\n",
       "        [1, 1],\n",
       "        [2, 1],\n",
       "        [3, 1],\n",
       "        [4, 1],\n",
       "        [5, 1],\n",
       "        [6, 1]]])"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.mgrid[0:7,0:2].T # transpose; matching x, y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 0],\n",
       "       [1, 0],\n",
       "       [2, 0],\n",
       "       [3, 0],\n",
       "       [4, 0],\n",
       "       [5, 0],\n",
       "       [6, 0],\n",
       "       [0, 1],\n",
       "       [1, 1],\n",
       "       [2, 1],\n",
       "       [3, 1],\n",
       "       [4, 1],\n",
       "       [5, 1],\n",
       "       [6, 1]])"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.mgrid[0:7,0:2].T.reshape(-1,2) # -1 : calculated with remaining col and dimension \n",
    "# 2: col"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 0, 1, 0, 2, 0, 3, 0, 4, 0, 5, 0, 6, 0],\n",
       "       [0, 1, 1, 1, 2, 1, 3, 1, 4, 1, 5, 1, 6, 1]])"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.mgrid[0:7,0:2].T.reshape(-1, 14) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 📍 More about the method 'cornerSubPix'\n",
    "https://docs.opencv.org/4.x/dd/d1a/group__imgproc__feature.html#ga354e0d7c86d0d9da75de9b9701a9a87e\n",
    "\n",
    "```python\n",
    "@_typing.overload\n",
    "def cornerSubPix(image: cv2.typing.MatLike, corners: cv2.typing.MatLike, winSize: cv2.typing.Size, zeroZone: cv2.typing.Size, criteria: cv2.typing.TermCriteria) -> cv2.typing.MatLike: ...\n",
    "@_typing.overload\n",
    "def cornerSubPix(image: UMat, corners: UMat, winSize: cv2.typing.Size, zeroZone: cv2.typing.Size, criteria: cv2.typing.TermCriteria) -> UMat: ...\n",
    "```\n",
    "\n",
    "image: tuple. - should be grayscaled.\n",
    "corners: tuple. - return value of findChessboardCorners\n",
    "```python\n",
    "@_typing.overload\n",
    "def findChessboardCorners(image: cv2.typing.MatLike, patternSize: cv2.typing.Size, corners: cv2.typing.MatLike | None = ..., flags: int = ...) -> tuple[bool, cv2.typing.MatLike]: ...\n",
    "@_typing.overload\n",
    "def findChessboardCorners(image: UMat, patternSize: cv2.typing.Size, corners: UMat | None = ..., flags: int = ...) -> tuple[bool, UMat]: ...\n",
    "\n",
    "```\n",
    "\n",
    "winSize\n",
    "\n",
    "zeroZone\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "https://www.tutorialspoint.com/how-to-find-patterns-in-a-chessboard-using-opencv-python\n",
    "\n",
    "### 2-1.1. Additional code blocks for testing since the errors have occurred while executing 2-1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "file name: output/2025-01-31.jpg\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "import cv2 as cv\n",
    "from datetime import date\n",
    "\n",
    "chessboardsize = (8,6)\n",
    "\n",
    "# read input image\n",
    "filepath = \"images/sample.jpg\"\n",
    "srcimg = cv.imread(filepath)\n",
    "cv.imshow(filepath, srcimg)\n",
    "cv.waitKey(0) \n",
    "\n",
    "# convert the input image to a grayscale\n",
    "grayscaled = cv.cvtColor(srcimg, cv.COLOR_BGR2GRAY)\n",
    "\n",
    "# Find the chess board corners\n",
    "ret, corners = cv.findChessboardCorners(grayscaled, chessboardsize, None)\n",
    "print(ret)\n",
    "\n",
    "# terminating criteria\n",
    "criteria = (cv.TERM_CRITERIA_EPS + cv.TERM_CRITERIA_MAX_ITER, 30, 0.001)\n",
    "if ret == True:\n",
    "   corners2 = cv.cornerSubPix(grayscaled,corners,(11,11),(-1,-1),criteria)\n",
    "\n",
    "# Draw and display the corners\n",
    "   outputimg = cv.drawChessboardCorners(srcimg, chessboardsize, corners, ret)\n",
    "   cv.imshow('Chessboard',outputimg)\n",
    "   cv.waitKey(0)\n",
    "\n",
    "   today = date.today()\n",
    "   outputpath = \"output/\" + date.isoformat(today) + \".jpg\"\n",
    "   print(\"file name: \" + outputpath)\n",
    "   status = cv.imwrite(outputpath, outputimg)\n",
    "   print(status)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2-1. Understanding of the codes; simplified version"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "import cv2 as cv\n",
    "\n",
    "with_sample = False \n",
    "\n",
    "\n",
    "if with_sample :\n",
    "    chessboardsize = (8, 6)\n",
    "    filepath = \"images/sample.jpg\"\n",
    "else :\n",
    "    chessboardsize = (30, 20)\n",
    "    filepath = \"images/camera_calib5.jpg\"\n",
    "\n",
    "# fetching source image file \n",
    "srcimg = cv.imread(filepath)\n",
    "cv.imshow(filepath, srcimg)\n",
    "cv.waitKey(0) # how long to wait for showing the next image. unit: ms. 5000: wait for 5 seconds and then show the next img. \n",
    "# if we doesn't use this key, kernel crashes. \n",
    "\n",
    "# making the image grayscaled. \n",
    "# https://www.geeksforgeeks.org/python-opencv-cv2-cvtcolor-method/\n",
    "grayscaledimg = cv.cvtColor(srcimg, cv.COLOR_BGR2GRAY)\n",
    "cv.imshow(filepath +' grayscaled', grayscaledimg)\n",
    "cv.waitKey(0) \n",
    "\n",
    "ret, corners = cv.findChessboardCorners(grayscaledimg, chessboardsize, None)\n",
    "# print(ret, corners)\n",
    "print(ret)\n",
    "\n",
    "# print(\"Before Criteria\") \n",
    "# termination criteria for corner refinement.\n",
    "criteria = (cv.TERM_CRITERIA_EPS + cv.TERM_CRITERIA_MAX_ITER, 30, 0.001) \n",
    "# TODO: find out how the value of cv.TERM_CRITERIA_EPS + cv.TERM_CRITERIA_MAX_ITER results out as 3\n",
    "    # tried to check the files and searched using grep (grep -r \"TERM_CRITERIA_EPS\" .) but I couldn't find where the value is assigned. \n",
    "    \n",
    "# TERM_CRITERIA_EPS : criteria epsilon. - cease the iteration when the corner posiiton moves by less thean it. \n",
    "# print(criteria) \n",
    "\n",
    "if ret == True:\n",
    "    # print(\"if statement - IN\")\n",
    "    ## refining the corner coordinates. \n",
    "    corners2 = cv.cornerSubPix(grayscaledimg,corners, (11,11), (-1,-1), criteria)\n",
    "    # print(corners2)\n",
    "    # (-1,-1): not to reject anything\n",
    "\n",
    "    img = cv.drawChessboardCorners(grayscaledimg, chessboardsize, corners2, ret)\n",
    "    window_name = 'img'\n",
    "    cv.imshow(window_name, img)\n",
    "    cv.waitKey(0)\n",
    "    # cv.waitKey(500)\n",
    "\n",
    "    today = date.today()\n",
    "    outputpath = \"output/\" + date.isoformat(today) + \".jpg\"\n",
    "    print(\"file name: \" + outputpath)\n",
    "    status = cv.imwrite(outputpath, outputimg)\n",
    "    print(status)\n",
    "    \n",
    " \n",
    "#cv.destroyAllWindows()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.1.2 Using Glob and loop statement to handle multiple images with the base code above. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "0 False\n",
      "1 True\n",
      "2 False\n",
      "3 False\n",
      "4 False\n",
      "5 False\n",
      "6 False\n",
      "7 False\n",
      "8 False\n",
      "9 False\n",
      "10 True\n",
      "11 False\n",
      "12 False\n",
      "13 False\n",
      "14 True\n",
      "15 False\n",
      "16 True\n",
      "17 False\n",
      "18 False\n",
      "19 False\n",
      "20 True\n",
      "21 False\n",
      "22 False\n",
      "23 False\n",
      "24\n",
      "24 False\n"
     ]
    }
   ],
   "source": [
    "\n",
    "import cv2 as cv\n",
    "import numpy as np\n",
    "import glob2 as glob\n",
    "\n",
    "# termination criteria\n",
    "criteria = (cv.TERM_CRITERIA_EPS + cv.TERM_CRITERIA_MAX_ITER, 30, 0.001)\n",
    " \n",
    "# prepare object points, like (0,0,0), (1,0,0), (2,0,0) ....,(6,5,0)\n",
    "objp = np.zeros((6*7,3), np.float32)\n",
    "objp[:,:2] = np.mgrid[0:7,0:6].T.reshape(-1,2)\n",
    "# print(objp)\n",
    " \n",
    "# Arrays to store object points and image points from all the images.\n",
    "objpoints = [] # 3d point in real world space\n",
    "imgpoints = [] # 2d points in image plane.\n",
    " \n",
    "images_regex = 'images/camera_calib*.jpg'\n",
    "images = glob.glob(images_regex) # recursively retrieving files with regex\n",
    " \n",
    "for idx, fname  in enumerate(images):\n",
    "    if idx == 0 or idx == len(images) - 1: print(idx)\n",
    "    img = cv.imread(fname)\n",
    "    grayscaledimg = cv.cvtColor(img, cv.COLOR_BGR2GRAY)\n",
    "    cv.imshow(fname, grayscaledimg)\n",
    "    cv.waitKey(0)\n",
    " \n",
    "    # Find the chess board corners\n",
    "    ret, corners = cv.findChessboardCorners(grayscaledimg, (31,23), None)\n",
    "    # if idx == 0 or idx == len(images) - 1: \n",
    "    print(idx, ret) # 10, 19, 22, 24, 5\n",
    "    # Question: some of the sample files returned True for the function fincChessboardCorners and some are not. \n",
    "    # -> https://stackoverflow.com/questions/66225558/cv2-findchessboardcorners-fails-to-find-corners\n",
    " \n",
    "    # If found, add object points, image points (after refining them)\n",
    "    if ret == True:\n",
    "        objpoints.append(objp)\n",
    " \n",
    "        corners2 = cv.cornerSubPix(grayscaledimg,corners, (11,11), (-1,-1), criteria)\n",
    "        imgpoints.append(corners2)\n",
    " \n",
    "        # Draw and display the corners\n",
    "        cv.drawChessboardCorners(img, (31,23), corners2, ret)\n",
    "        window_name = fname + ' outputimg'\n",
    "        cv.imshow(window_name, img)\n",
    "        # cv.waitKey(500)\n",
    "        cv.waitKey(0)\n",
    " \n",
    "#cv.destroyAllWindows()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. Calibration "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "0.2789343940438358 [[459.49627036   0.         462.98078721]\n",
      " [  0.         425.9391768  332.55095914]\n",
      " [  0.           0.           1.        ]] [[-0.13575777  0.0247265   0.00342986  0.00018729 -0.00074961]] (array([[-0.0740356 ],\n",
      "       [ 0.00389051],\n",
      "       [ 0.07810778]]),) (array([[-12.03832935],\n",
      "       [-13.96143027],\n",
      "       [ 20.05135273]]),)\n"
     ]
    }
   ],
   "source": [
    "import cv2 as cv\n",
    "import numpy as np\n",
    "\n",
    "criteria = (cv.TERM_CRITERIA_EPS + cv.TERM_CRITERIA_MAX_ITER, 30, 0.001)\n",
    "\n",
    "# prepare object points, like (0,0,0), (1,0,0), (2,0,0) ....,(6,5,0)\n",
    "objp = np.zeros((23*31, 3), np.float32)\n",
    "objp[:,:2] = np.mgrid[0:31,0:23].T.reshape(-1,2)\n",
    "\n",
    "# Arrays to store object points and image points from all the images.\n",
    "objpoints = [] # 3d point in real world space\n",
    "imgpoints = [] # 2d points in image plane.\n",
    "\n",
    "# imgpath = 'images/sample.jpg'\n",
    "imgpath = 'images/camera_calib5.jpg'\n",
    "img = cv.imread(imgpath)\n",
    "\n",
    "grayscaledimg = cv.cvtColor(img, cv.COLOR_BGR2GRAY)\n",
    "cv.imshow(imgpath, grayscaledimg)\n",
    "cv.waitKey(0)\n",
    "ret, corners = cv.findChessboardCorners(grayscaledimg, (31,23), None)\n",
    "print(ret)\n",
    "\n",
    "if ret == True:\n",
    "    objpoints.append(objp)\n",
    "\n",
    "    corners2 = cv.cornerSubPix(grayscaledimg,corners, (11, 11), (-1, -1), criteria)\n",
    "    imgpoints.append(corners2)\n",
    "\n",
    "    # Draw and display the corners\n",
    "    cv.drawChessboardCorners(img, (31, 23), corners2, ret)\n",
    "    window_name = fname + ' outputimg'\n",
    "    cv.imshow(window_name, img)\n",
    "    cv.waitKey(0)\n",
    "\n",
    "    ret, mtx, dist, rvecs, tvecs = cv.calibrateCamera(objpoints, imgpoints, grayscaledimg.shape[::-1], None, None)\n",
    "    # TROUBLE SHOOTING\n",
    "    # Number of object and image points must be equal (expected: 'numberOfObjectPoints == numberOfImagePoints')\n",
    "    # -> the value of objpoints and imgpoints' is not identical. \n",
    "    print(ret, mtx, dist, rvecs, tvecs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "mtx: camera matrix\n",
    "dist: distortion coefficient\n",
    "rvecs: rotation\n",
    "tvecs: translation vectors"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4. Correcting distortion"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/Users/kimjimin/Developer/camera-calibration-trial/.venv/bin/python\n"
     ]
    }
   ],
   "source": [
    "import sys\n",
    "print(sys.executable)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "import cv2 as cv"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Are Chessboard corners detected:\n",
      " True \n",
      "\n",
      "0.2789344851009926\n",
      "Camera Matrix:\n",
      " [[459.49635782   0.         462.98078123]\n",
      " [  0.         425.93925902 332.55096499]\n",
      " [  0.           0.           1.        ]] \n",
      "\n",
      "Distortion Coefficient:\n",
      " [[-0.13575781  0.02472651  0.00342986  0.00018729 -0.00074961]] \n",
      "\n",
      "(array([[-0.07403562],\n",
      "       [ 0.00389051],\n",
      "       [ 0.07810778]]),) \n",
      " (array([[-12.0383291 ],\n",
      "       [-13.96143052],\n",
      "       [ 20.05135661]]),)\n"
     ]
    }
   ],
   "source": [
    "import cv2 as cv\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "criteria = (cv.TERM_CRITERIA_EPS + cv.TERM_CRITERIA_MAX_ITER, 30, 0.001)\n",
    "\n",
    "W = 23\n",
    "L = 31\n",
    "\n",
    "# prepare object points, like (0,0,0), (1,0,0), (2,0,0) ....,(6,5,0)\n",
    "objp = np.zeros((W*L, 3), np.float32)\n",
    "objp[:,:2] = np.mgrid[0:L,0:W].T.reshape(-1,2)\n",
    "\n",
    "# Arrays to store object points and image points from all the images.\n",
    "objpoints = [] # 3d point in real world space\n",
    "imgpoints = [] # 2d points in image plane.\n",
    "\n",
    "# imgpath = 'images/sample.jpg'\n",
    "imgname = 'camera_calib5.jpg'\n",
    "imgpath = f'images/{imgname}'\n",
    "img = cv.imread(imgpath)\n",
    "cv.imshow(imgname, img)\n",
    "cv.waitKey(0)\n",
    "cv.destroyAllWindows()\n",
    "\n",
    "grayscaledimg = cv.cvtColor(img, cv.COLOR_BGR2GRAY)\n",
    "grayscaledimgtitle = imgname + \" grayscaled\"\n",
    "cv.imshow(grayscaledimgtitle, grayscaledimg)\n",
    "cv.waitKey(0)\n",
    "cv.destroyAllWindows()\n",
    "# print(grayscaledimg.min(), grayscaledimg.max())\n",
    "# plt.imshow(grayscaledimg)\n",
    "# plt.axis(\"off\")\n",
    "# plt.show()\n",
    "\n",
    "ret, corners = cv.findChessboardCorners(grayscaledimg, (L,W), None)\n",
    "print(\"Are Chessboard corners detected:\\n\", ret, \"\\n\")\n",
    "\n",
    "if ret == True:\n",
    "    objpoints.append(objp)\n",
    "\n",
    "    corners2 = cv.cornerSubPix(grayscaledimg, corners, (11, 11), (-1, -1), criteria)\n",
    "    imgpoints.append(corners2)\n",
    "\n",
    "    # Draw and display the corners\n",
    "    cv.drawChessboardCorners(img, (L, W), corners2, ret)\n",
    "    window_name = imgpath + ' with corner'\n",
    "    cv.imshow(window_name,img)\n",
    "    cv.waitKey(0)\n",
    "    cv.destroyAllWindows()\n",
    "    # plt.imshow(imgwithcorner)\n",
    "    # plt.axis(\"off\")\n",
    "    # plt.show()\n",
    "\n",
    "    ret, mtx, dist, rvecs, tvecs = cv.calibrateCamera(objpoints, imgpoints, grayscaledimg.shape[::-1], None, None)\n",
    "    print(ret)\n",
    "    print(\"Camera Matrix:\\n\", mtx, \"\\n\")\n",
    "    print(\"Distortion Coefficient:\\n\", dist, \"\\n\")\n",
    "    print(rvecs, \"\\n\", tvecs)\n",
    "\n",
    "    h,  w = grayscaledimg.shape[:2]\n",
    "    newcameramtx, roi = cv.getOptimalNewCameraMatrix(mtx, dist, (w,h), 1, (w,h))\n",
    "\n",
    "    # undistort\n",
    "    dst = cv.undistort(grayscaledimg, mtx, dist, None, newcameramtx)\n",
    "    \n",
    "    # crop the image\n",
    "    x, y, w, h = roi\n",
    "    dst = dst[y:y+h, x:x+w]\n",
    "    outputpath = f\"output/{imgname}\"\n",
    "    cv.imwrite(outputpath, dst)\n",
    "    # outputimg = plt.imread(outputpath)\n",
    "    # plt.imshow(outputimg) \n",
    "    # plt.axis(\"off\")\n",
    "    # plt.show()\n",
    "    outputimg = cv.imread(outputpath)\n",
    "    cv.imshow(window_name, outputimg)\n",
    "    cv.waitKey(0)\n",
    "    cv.destroyAllWindows()\n",
    "    cv.waitKey(1000)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Final "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Are Chessboard corners detected:\n",
      " True \n",
      "\n",
      "0.2789344851009926\n",
      "Camera Matrix:\n",
      " [[459.49635782   0.         462.98078123]\n",
      " [  0.         425.93925902 332.55096499]\n",
      " [  0.           0.           1.        ]] \n",
      "\n",
      "Distortion Coefficient:\n",
      " [[-0.13575781  0.02472651  0.00342986  0.00018729 -0.00074961]] \n",
      "\n",
      "(array([[-0.07403562],\n",
      "       [ 0.00389051],\n",
      "       [ 0.07810778]]),) \n",
      " (array([[-12.0383291 ],\n",
      "       [-13.96143052],\n",
      "       [ 20.05135661]]),)\n"
     ]
    }
   ],
   "source": [
    "import cv2 as cv\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "criteria = (cv.TERM_CRITERIA_EPS + cv.TERM_CRITERIA_MAX_ITER, 30, 0.001)\n",
    "\n",
    "W = 23\n",
    "L = 31\n",
    "\n",
    "# prepare object points, like (0,0,0), (1,0,0), (2,0,0) ....,(6,5,0)\n",
    "objp = np.zeros((W*L, 3), np.float32)\n",
    "objp[:,:2] = np.mgrid[0:L,0:W].T.reshape(-1,2)\n",
    "\n",
    "# Arrays to store object points and image points from all the images.\n",
    "objpoints = [] # 3d point in real world space\n",
    "imgpoints = [] # 2d points in image plane.\n",
    "\n",
    "imgname = 'camera_calib5.jpg'\n",
    "imgpath = f'images/{imgname}'\n",
    "img = cv.imread(imgpath)\n",
    "cv.imshow(imgname, img)\n",
    "cv.waitKey(0)\n",
    "cv.destroyAllWindows()\n",
    "\n",
    "grayscaledimg = cv.cvtColor(img, cv.COLOR_BGR2GRAY)\n",
    "grayscaledimgtitle = imgname + \" grayscaled\"\n",
    "cv.imshow(grayscaledimgtitle, grayscaledimg)\n",
    "cv.waitKey(0)\n",
    "cv.destroyAllWindows()\n",
    "\n",
    "ret, corners = cv.findChessboardCorners(grayscaledimg, (L,W), None)\n",
    "print(\"Are Chessboard corners detected:\\n\", ret, \"\\n\")\n",
    "\n",
    "if ret == True:\n",
    "    objpoints.append(objp)\n",
    "\n",
    "    corners2 = cv.cornerSubPix(grayscaledimg, corners, (11, 11), (-1, -1), criteria)\n",
    "    imgpoints.append(corners2)\n",
    "\n",
    "    # Draw and display the corners\n",
    "    cv.drawChessboardCorners(img, (L, W), corners2, ret)\n",
    "    window_name = imgpath + ' with corner'\n",
    "    cv.imshow(window_name,img)\n",
    "    cv.waitKey(0)\n",
    "    cv.destroyAllWindows()\n",
    "\n",
    "    ret, mtx, dist, rvecs, tvecs = cv.calibrateCamera(objpoints, imgpoints, grayscaledimg.shape[::-1], None, None)\n",
    "    print(ret)\n",
    "    print(\"Camera Matrix:\\n\", mtx, \"\\n\")\n",
    "    print(\"Distortion Coefficient:\\n\", dist, \"\\n\")\n",
    "    print(rvecs, \"\\n\", tvecs)\n",
    "\n",
    "    h,  w = grayscaledimg.shape[:2]\n",
    "    newcameramtx, roi = cv.getOptimalNewCameraMatrix(mtx, dist, (w,h), 1, (w,h))\n",
    "\n",
    "    dst = cv.undistort(grayscaledimg, mtx, dist, None, newcameramtx)\n",
    "    \n",
    "    x, y, w, h = roi\n",
    "    dst = dst[y:y+h, x:x+w]\n",
    "    outputpath = f\"output/{imgname}\"\n",
    "    cv.imshow(window_name, dst)\n",
    "    cv.waitKey(0)\n",
    "\n",
    "    cv.destroyAllWindows()\n",
    "    cv.waitKey(1000)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Code tyding up"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Are Chessboard corners detected:\n",
      " True \n",
      "\n",
      "0.2789344851009926\n",
      "Camera Matrix:\n",
      " [[459.49635782   0.         462.98078123]\n",
      " [  0.         425.93925902 332.55096499]\n",
      " [  0.           0.           1.        ]] \n",
      "\n",
      "Distortion Coefficient:\n",
      " [[-0.13575781  0.02472651  0.00342986  0.00018729 -0.00074961]] \n",
      "\n",
      "(array([[-0.07403562],\n",
      "       [ 0.00389051],\n",
      "       [ 0.07810778]]),) \n",
      " (array([[-12.0383291 ],\n",
      "       [-13.96143052],\n",
      "       [ 20.05135661]]),)\n"
     ]
    }
   ],
   "source": [
    "import cv2 as cv\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "def showimg(windowname, img, atthelast = False):\n",
    "    cv.imshow(windowname, img)\n",
    "    cv.waitKey(0)\n",
    "    cv.destroyAllWindows()\n",
    "\n",
    "    if atthelast:\n",
    "        cv.waitKey(1000)\n",
    "\n",
    "\n",
    "criteria = (cv.TERM_CRITERIA_EPS + cv.TERM_CRITERIA_MAX_ITER, 30, 0.001)\n",
    "\n",
    "W = 23\n",
    "L = 31\n",
    "\n",
    "objp = np.zeros((W*L, 3), np.float32)\n",
    "objp[:,:2] = np.mgrid[0:L,0:W].T.reshape(-1,2)\n",
    "\n",
    "objpoints = [] \n",
    "imgpoints = [] \n",
    "\n",
    "imgname = 'camera_calib5.jpg'\n",
    "imgpath = f'images/{imgname}'\n",
    "\n",
    "\n",
    "img = cv.imread(imgpath)\n",
    "showimg(imgname, img)\n",
    "\n",
    "grayscaledimg = cv.cvtColor(img, cv.COLOR_BGR2GRAY)\n",
    "grayscaledimgtitle = imgname + \" grayscaled\"\n",
    "showimg(grayscaledimgtitle, grayscaledimg)\n",
    "\n",
    "ret, corners = cv.findChessboardCorners(grayscaledimg, (L,W), None)\n",
    "print(\"Are Chessboard corners detected:\\n\", ret, \"\\n\")\n",
    "\n",
    "if ret:\n",
    "    objpoints.append(objp)\n",
    "\n",
    "    corners2 = cv.cornerSubPix(grayscaledimg, corners, (11, 11), (-1, -1), criteria)\n",
    "    imgpoints.append(corners2)\n",
    "\n",
    "    cv.drawChessboardCorners(img, (L, W), corners2, ret)\n",
    "    window_name = imgpath + ' with corner'\n",
    "    showimg(window_name, img)\n",
    "\n",
    "    ret, mtx, dist, rvecs, tvecs = cv.calibrateCamera(objpoints, imgpoints, grayscaledimg.shape[::-1], None, None)\n",
    "    print(ret)\n",
    "    print(\"Camera Matrix:\\n\", mtx, \"\\n\")\n",
    "    print(\"Distortion Coefficient:\\n\", dist, \"\\n\")\n",
    "    print(rvecs, \"\\n\", tvecs)\n",
    "\n",
    "    h,  w = grayscaledimg.shape[:2]\n",
    "    newcameramtx, roi = cv.getOptimalNewCameraMatrix(mtx, dist, (w,h), 1, (w,h))\n",
    "\n",
    "    dst = cv.undistort(grayscaledimg, mtx, dist, None, newcameramtx)\n",
    "    \n",
    "    x, y, w, h = roi\n",
    "    dst = dst[y:y+h, x:x+w]\n",
    "    outputpath = f\"output/{imgname}\"\n",
    "    showimg(window_name, dst, True)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": ".venv",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}