StereoCalibration.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 209,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Current version of openCV= 4.1.1\n"
     ]
    }
   ],
   "source": [
    "import cv2 as cv\n",
    "print(\"Current version of openCV=\", cv.__version__)\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import os\n",
    "import glob\n",
    "from PIL import Image, ImageDraw"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "left_calibration_path = './calibration/fisheye_calibrated/{}.png'\n",
    "right_calibration_path ='./calibration/pinhole_calibrated/{}.png'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "# termination criteria\n",
    "criteria = (cv.TERM_CRITERIA_EPS + cv.TERM_CRITERIA_MAX_ITER, 30, 0.001)\n",
    "# prepare object points, like (0,0,0), (1,0,0), (2,0,0) ....,(6,5,0)\n",
    "points_per_row = 6\n",
    "points_per_column = 10\n",
    "objp = np.zeros((points_per_column*points_per_row,3), np.float32)\n",
    "objp[:,:2] = np.mgrid[0:points_per_row,0:points_per_column].T.reshape(-1,2)\n",
    "# Arrays to store object points and image points from all the images.\n",
    "objpoints = [] # 3d point in real world space\n",
    "imgpointsL = [] # 2d points in Right image plane.\n",
    "imgpointsR = [] # 2d points in Left image plane.\n",
    "imagesL = glob.glob(left_calibration_path.format('*'))\n",
    "imagesR = glob.glob(right_calibration_path.format('*'))\n",
    "for img_id in range(len(imagesR)):\n",
    "    fnameL = left_calibration_path.format(img_id)\n",
    "    fnameR = right_calibration_path.format(img_id)\n",
    "    imgL = cv.imread(fnameL)\n",
    "    imgR = cv.imread(fnameR)\n",
    "    grayL = cv.cvtColor(imgL, cv.COLOR_BGR2GRAY)\n",
    "    grayR = cv.cvtColor(imgR, cv.COLOR_BGR2GRAY)\n",
    "    # Find the chess board corners\n",
    "    retL, cornersL = cv.findChessboardCorners(grayL, (points_per_row,points_per_column), None)\n",
    "    retR, cornersR = cv.findChessboardCorners(grayR, (points_per_row,points_per_column), None)\n",
    "    # If found on both, add object points, image points (after refining them)\n",
    "    if retL == True and retR == True:\n",
    "        objpoints.append(objp)\n",
    "        corners2L = cv.cornerSubPix(grayL,cornersL, (11,11), (-1,-1), criteria)\n",
    "        corners2R = cv.cornerSubPix(grayR,cornersR, (11,11), (-1,-1), criteria)\n",
    "        imgpointsL.append(cornersL)\n",
    "        imgpointsR.append(cornersR)\n",
    "        # Draw and display the corners\n",
    "        cv.drawChessboardCorners(imgL, (points_per_row,points_per_column), corners2L, retL)\n",
    "        cv.drawChessboardCorners(imgR, (points_per_row,points_per_column), corners2R, retR)\n",
    "        cv.imshow('img', imgL)\n",
    "        cv.waitKey(500)\n",
    "        cv.imshow('img', imgR)\n",
    "        cv.waitKey(500)\n",
    "cv.destroyAllWindows()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 283,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "720 1280\n"
     ]
    }
   ],
   "source": [
    "img = cv.imread(left_calibration_path.format(img_id))\n",
    "width, height = img.shape[:-1]\n",
    "R = None\n",
    "T = None\n",
    "E = None\n",
    "F = None\n",
    "# Try loading previous calibration matrices. else recompute\n",
    "cameraMatrix1 = None\n",
    "distCoeffs1 = None\n",
    "cameraMatrix2 = None\n",
    "distCoeffs2 = None\n",
    "\n",
    "stereocalib_criteria = (cv.TERM_CRITERIA_MAX_ITER | cv.TERM_CRITERIA_EPS, 100, 1e-5)\n",
    "#This flag decreases the accuracy but now the results match better... it is probably better for the 3d reconstruct to be on\n",
    "stereocalib_flags = cv.CALIB_RATIONAL_MODEL | \\\n",
    "cv.CALIB_SAME_FOCAL_LENGTH\n",
    "#cv.CALIB_ZERO_DISPARITY\n",
    "#cv.CALIB_FIX_K3 | \\\n",
    "#cv.CALIB_FIX_K4\n",
    "#cv.CALIB_ZERO_TANGENT_DIST #\n",
    "#cv.CALIB_FIX_ASPECT_RATIO \n",
    "#cv.CALIB_FIX_K3 | \\\n",
    "#cv.CALIB_FIX_K4 | \\\n",
    "#cv.CALIB_FIX_K5 \n",
    "print(width, height)\n",
    "retval, KL, DL, KR, DR, R, T, E, F = \\\n",
    " cv.stereoCalibrate(objpoints, imgpointsL, imgpointsR,\n",
    "                                #imageSize = (width, height),\n",
    "                                imageSize = (height, width),\n",
    "                                cameraMatrix1 = cameraMatrix1,\n",
    "                                distCoeffs1 = distCoeffs1,\n",
    "                                cameraMatrix2 = cameraMatrix2,\n",
    "                                distCoeffs2 = distCoeffs2,\n",
    "                                R=R,\n",
    "                                T=T,\n",
    "                                E=E,\n",
    "                                F=F,\n",
    "                                #flags=cv.CALIB_FIX_INTRINSIC\n",
    "                                flags=stereocalib_flags,\n",
    "                                criteria=stereocalib_criteria\n",
    "                   )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 284,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.1961377234854718\n",
      "cameraM1: \n",
      " [[802.11721732   0.         623.22087234]\n",
      " [  0.         811.59053067 333.30576496]\n",
      " [  0.           0.           1.        ]]\n",
      "distCoeffs1: \n",
      " [[-7.03114181e+00  1.49422684e+01  7.93620777e-03  7.08637333e-03\n",
      "  -8.28869175e+00 -7.03898126e+00  1.49989650e+01 -8.38848878e+00\n",
      "   0.00000000e+00  0.00000000e+00  0.00000000e+00  0.00000000e+00\n",
      "   0.00000000e+00  0.00000000e+00]]\n",
      "cameraM2: \n",
      " [[802.11721732   0.         637.98681702]\n",
      " [  0.         811.59053067 349.28613959]\n",
      " [  0.           0.           1.        ]]\n",
      "distCoeffs2: \n",
      " [[ 1.09285318e+02  4.84849538e+02  3.46575944e-03 -6.17171589e-03\n",
      "   4.11781408e+02  7.53613839e+01  4.39702201e+02  1.80059334e+02\n",
      "   0.00000000e+00  0.00000000e+00  0.00000000e+00  0.00000000e+00\n",
      "   0.00000000e+00  0.00000000e+00]]\n",
      "R:  [[ 0.99968986 -0.00218367  0.02480762]\n",
      " [ 0.00190046  0.99993282  0.01143429]\n",
      " [-0.02483092 -0.0113836   0.99962685]]\n",
      "T:  [[ 3.67232582]\n",
      " [-0.25571715]\n",
      " [-1.08089799]]\n",
      "E:  [[ 0.00840389  1.08373636 -0.24326243]\n",
      " [-0.98937554  0.0441646  -3.69776999]\n",
      " [ 0.26261694  3.67152071  0.04833417]]\n",
      "F:  [[ 8.29164895e-08  1.05678108e-05 -5.49917671e-03]\n",
      " [-9.64767259e-06  4.25634286e-07 -2.30519546e-02]\n",
      " [ 5.39526021e-03  2.18266139e-02  1.00000000e+00]]\n"
     ]
    }
   ],
   "source": [
    "print(retval)\n",
    "print(\"cameraM1: \\n\", KL)\n",
    "print(\"distCoeffs1: \\n\", DL)\n",
    "print(\"cameraM2: \\n\", KR)\n",
    "print(\"distCoeffs2: \\n\", DR)\n",
    "print(\"R: \", R)\n",
    "print(\"T: \", T)\n",
    "print(\"E: \", E)\n",
    "print(\"F: \", F)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 285,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "720 1280\n"
     ]
    }
   ],
   "source": [
    "img_size = imgL.shape[:2]\n",
    "alpha = 0 ### =0 crop, =1 keep dimensions\n",
    "print(width, height)\n",
    "\n",
    "RL = np.zeros(shape=(3,3))\n",
    "RR = np.zeros(shape=(3,3))\n",
    "PL = np.zeros(shape=(3,4))\n",
    "PR = np.zeros(shape=(3,4))\n",
    "\n",
    "\"\"\"out = cv.stereoRectify(KL, DL, KR, DR, (width, height), R=R, T=T, \n",
    "                       R1=RL, R2=RR, P1=PL, P2=PR,\n",
    "                      Q=None, flags=cv.CALIB_ZERO_DISPARITY, alpha=alpha, newImageSize=(0,0))\n",
    "\"\"\"\n",
    "RL, RR, PL, PR, Q, roiL, roiR = cv.stereoRectify(KL, \n",
    "                                                 DL, \n",
    "                                                 KR, \n",
    "                                                 DR, \n",
    "                                                 (height, width), \n",
    "                                                 R=R, \n",
    "                                                 T=T, \n",
    "                                                 alpha=alpha)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 286,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RL: \n",
      " [[ 0.96374767 -0.06553011 -0.25864304]\n",
      " [ 0.06714765  0.9977397  -0.00258506]\n",
      " [ 0.25822783 -0.01487593  0.96596951]]\n",
      "RR: \n",
      " [[ 0.95717556 -0.06665155 -0.2817313 ]\n",
      " [ 0.06488396  0.99777073 -0.0156093 ]\n",
      " [ 0.28214363 -0.00333901  0.95936637]]\n",
      "PL: \n",
      " [[1.34862688e+03 0.00000000e+00 9.83503563e+02 0.00000000e+00]\n",
      " [0.00000000e+00 1.34862688e+03 3.60555145e+02 0.00000000e+00]\n",
      " [0.00000000e+00 0.00000000e+00 1.00000000e+00 0.00000000e+00]]\n",
      "RR: \n",
      " [[1.34862688e+03 0.00000000e+00 9.83503563e+02 5.17417865e+03]\n",
      " [0.00000000e+00 1.34862688e+03 3.60555145e+02 0.00000000e+00]\n",
      " [0.00000000e+00 0.00000000e+00 1.00000000e+00 0.00000000e+00]]\n",
      "Q:  [[ 1.00000000e+00  0.00000000e+00  0.00000000e+00 -9.83503563e+02]\n",
      " [ 0.00000000e+00  1.00000000e+00  0.00000000e+00 -3.60555145e+02]\n",
      " [ 0.00000000e+00  0.00000000e+00  0.00000000e+00  1.34862688e+03]\n",
      " [ 0.00000000e+00  0.00000000e+00 -2.60645597e-01  0.00000000e+00]]\n",
      "roiL: \n",
      " (0, 0, 1280, 720)\n",
      "roiR: \n",
      " (0, 0, 1280, 720)\n"
     ]
    }
   ],
   "source": [
    "print(\"RL: \\n\", RL)\n",
    "print(\"RR: \\n\", RR)\n",
    "print(\"PL: \\n\", PL)\n",
    "print(\"RR: \\n\", PR)\n",
    "print(\"Q: \", Q)\n",
    "print(\"roiL: \\n\", roiL)\n",
    "print(\"roiR: \\n\", roiR)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 287,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cameraMatrix1: \n",
      " [[770.27392578   0.         604.03858401]\n",
      " [  0.         773.95489502 321.97347741]\n",
      " [  0.           0.           1.        ]]\n",
      "distCoeffs1: \n",
      " [[-7.63157450e-01 -2.28545804e+01 -2.01766132e-02 -4.91723979e-03\n",
      "   4.95143851e+01 -6.73908321e-01 -2.34229292e+01  5.04215253e+01\n",
      "   0.00000000e+00  0.00000000e+00  0.00000000e+00  0.00000000e+00\n",
      "   0.00000000e+00  0.00000000e+00]]\n",
      "cameraMatrix2: \n",
      " [[1.09387634e+03 0.00000000e+00 6.47218680e+02]\n",
      " [0.00000000e+00 1.09678967e+03 3.55147063e+02]\n",
      " [0.00000000e+00 0.00000000e+00 1.00000000e+00]]\n",
      "distCoeffs2: \n",
      " [[ 0.02451276  0.04372337 -0.00407773  0.0011938  -0.12879966]]\n"
     ]
    }
   ],
   "source": [
    "# load camera and distortion matrices\n",
    "path_to_matrices = \"./calibration_matrices/\"\n",
    "cameraMatrix1 = np.load(path_to_matrices+\"fisheye_new_matrix.npy\")\n",
    "distCoeffs1 = np.load(path_to_matrices+\"fisheye_distortions.npy\")\n",
    "cameraMatrix2 = np.load(path_to_matrices+\"pinhole_new_matrix.npy\")\n",
    "distCoeffs2 = np.load(path_to_matrices+\"pinhole_distortions.npy\")\n",
    "print(\"cameraMatrix1: \\n\", cameraMatrix1)\n",
    "print(\"distCoeffs1: \\n\", distCoeffs1)\n",
    "print(\"cameraMatrix2: \\n\", cameraMatrix2)\n",
    "print(\"distCoeffs2: \\n\", distCoeffs2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 288,
   "metadata": {},
   "outputs": [],
   "source": [
    "def undistort_and_crop(img, camera_matrix, distortion_coeffs):\n",
    "    h,  w = img.shape[:2]\n",
    "    alpha = 0 #crop image\n",
    "    newcameramtx, roi = cv.getOptimalNewCameraMatrix(camera_matrix, distortion_coeffs, (w,h), alpha, (w,h))\n",
    "    # undistort\n",
    "    dst = cv.undistort(img, camera_matrix, distortion_coeffs, None, newcameramtx)\n",
    "    # crop the image\n",
    "    x, y, w, h = roi\n",
    "    dst = dst[y:y+h, x:x+w]\n",
    "    return dst"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 290,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Applying Undistort\n",
      "\n",
      "Undistort complete\n",
      "\n",
      "fname:  ./validation_images/fisheye/1.png ./validation_images/pinhole/1.png\n"
     ]
    }
   ],
   "source": [
    "print(\"Applying Undistort\\n\")\n",
    "#map1x, map1y = cv.initUndistortRectifyMap(KL, DL, RL, PL, (width, height), cv.CV_32FC1)\n",
    "#map2x, map2y = cv.initUndistortRectifyMap(KR, DR, RR, PR, (width, height), cv.CV_32FC1)\n",
    "\n",
    "map1x, map1y = cv.initUndistortRectifyMap(KL, DL, RL, PL, (height, width), cv.CV_32FC1)\n",
    "map2x, map2y = cv.initUndistortRectifyMap(KR, DR, RR, PR, (height, width), cv.CV_32FC1)\n",
    "print(\"Undistort complete\\n\")\n",
    "\n",
    "#print(\"Maps1: \\n\", map1x, map1y)\n",
    "#print(\"Maps2: \\n\", map2x, map2y)\n",
    "\n",
    "#image remap example\n",
    "img_id = 1\n",
    "validation_path = './validation_images/'\n",
    "pinhole_path = 'pinhole/{}.png'\n",
    "fisheye_path = 'fisheye/{}.png'\n",
    "fnameL = validation_path+fisheye_path.format(img_id)\n",
    "fnameR = validation_path+pinhole_path.format(img_id)\n",
    "print(\"fname: \", fnameL, fnameR)\n",
    "imgL = cv.imread(fnameL)\n",
    "imgR = cv.imread(fnameR)\n",
    "cv.imshow(\"imgL original: \", imgL)\n",
    "cv.imshow(\"imgR original: \", imgR)\n",
    "imgL = undistort_and_crop(imgL, cameraMatrix1, distCoeffs1)\n",
    "imgR = undistort_and_crop(imgR, cameraMatrix2, distCoeffs2)\n",
    "cv.imshow('imgL', imgL)\n",
    "cv.imshow('imgr', imgR)\n",
    "if cv.waitKey(500) & 0xff == 27:\n",
    "    cv.destroyAllWindows()\n",
    "\n",
    "left_img_remap = cv.remap(imgL, map1x, map1y, cv.INTER_LANCZOS4)\n",
    "right_img_remap = cv.remap(imgR, map2x, map2y, cv.INTER_LANCZOS4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 294,
   "metadata": {},
   "outputs": [],
   "source": [
    "cv.imshow(\"imgL remap\", left_img_remap)\n",
    "cv.imshow(\"imgR remap\", right_img_remap)\n",
    "left_gray_remap = cv.cvtColor(left_img_remap, cv.COLOR_BGR2GRAY)\n",
    "right_gray_remap = cv.cvtColor(right_img_remap, cv.COLOR_BGR2GRAY)\n",
    "if cv.waitKey(500) & 0xff == 27:\n",
    "    cv.destroyAllWindows()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Stereo reconstruction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 264,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "stereo = cv.StereoBM_create(numDisparities=16, blockSize=5)\n",
    "disparity = stereo.compute(left_gray_remap, right_gray_remap)\n",
    "plt.imshow(disparity,'gray')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Finding corners with Harris algorithm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "metadata": {},
   "outputs": [],
   "source": [
    "left_gray_remap = cv.cvtColor(left_img_remap, cv.COLOR_BGR2GRAY)\n",
    "right_gray_remap = cv.cvtColor(right_img_remap, cv.COLOR_BGR2GRAY)\n",
    "left_kpts = cv.cornerHarris(left_gray_remap, 2, 3, 0.04)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 277,
   "metadata": {},
   "outputs": [],
   "source": [
    "#left_kpts = cv.dilate(left_kpts, None)\n",
    "left_img_copy = left_img_remap\n",
    "left_img_copy[left_kpts > 0.01*left_kpts.max()] = [0,0,255]\n",
    "cv.imshow('with corners',left_img_copy)\n",
    "if cv.waitKey(0) & 0xff == 27:\n",
    "    cv.destroyAllWindows()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Use SURF for feature extraction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 295,
   "metadata": {},
   "outputs": [],
   "source": [
    "#-- Step 1: Detect the keypoints using SURF Detector, compute the descriptors\n",
    "minHessian = 400\n",
    "detector = cv.xfeatures2d_SURF.create(hessianThreshold=minHessian)\n",
    "keypoints1, descriptors1 = detector.detectAndCompute(left_gray_remap, None)\n",
    "keypoints2, descriptors2 = detector.detectAndCompute(right_gray_remap, None)\n",
    "#-- Step 2: Matching descriptor vectors with a FLANN based matcher\n",
    "# Since SURF is a floating-point descriptor NORM_L2 is used\n",
    "matcher = cv.DescriptorMatcher_create(cv.DescriptorMatcher_FLANNBASED)\n",
    "knn_matches = matcher.knnMatch(descriptors1, descriptors2, 2)\n",
    "#-- Filter matches using the Lowe's ratio test\n",
    "ratio_thresh = 0.5 #maybe decrease it? originally set to 0.7\n",
    "good_matches = []\n",
    "for m,n in knn_matches:\n",
    "    if m.distance < ratio_thresh * n.distance:\n",
    "        good_matches.append(m)\n",
    "#-- Draw matches\n",
    "img_matches = np.empty((max(left_gray_remap.shape[0], right_gray_remap.shape[0]), \n",
    "                        left_gray_remap.shape[1]+right_gray_remap.shape[1], 3), dtype=np.uint8)\n",
    "cv.drawMatches(left_gray_remap, keypoints1, right_gray_remap, \n",
    "               keypoints2, good_matches, img_matches, flags=cv.DrawMatchesFlags_NOT_DRAW_SINGLE_POINTS)\n",
    "#-- Show detected matches\n",
    "cv.imshow('Good Matches', img_matches)\n",
    "if cv.waitKey(500) & 0xff == 27:\n",
    "    cv.destroyAllWindows()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 296,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "m.queryIdx:  3\n",
      "distance:  2.732152907252788\n",
      "m.queryIdx:  9\n",
      "distance:  11.412368216744909\n",
      "m.queryIdx:  56\n",
      "distance:  3.0524255264094187\n",
      "m.queryIdx:  62\n",
      "distance:  3.8792980979190235\n",
      "m.queryIdx:  66\n",
      "distance:  3.8564325200806824\n",
      "m.queryIdx:  68\n",
      "distance:  3.046698124171916\n",
      "m.queryIdx:  71\n",
      "distance:  3.038340879939421\n",
      "m.queryIdx:  81\n",
      "distance:  3.892482627087884\n",
      "m.queryIdx:  82\n",
      "distance:  3.4750465809920095\n",
      "m.queryIdx:  87\n",
      "distance:  3.8112296821842926\n",
      "m.queryIdx:  95\n",
      "distance:  3.3794411372061446\n",
      "m.queryIdx:  96\n",
      "distance:  3.0628234936732524\n",
      "m.queryIdx:  102\n",
      "distance:  2.570484430309825\n",
      "m.queryIdx:  104\n",
      "distance:  0.6759176601228245\n",
      "m.queryIdx:  111\n",
      "distance:  2.9693225281509066\n",
      "m.queryIdx:  114\n",
      "distance:  0.6759875730162656\n",
      "m.queryIdx:  116\n",
      "distance:  3.029932075878782\n",
      "m.queryIdx:  118\n",
      "distance:  2.545903056319015\n",
      "m.queryIdx:  119\n",
      "distance:  2.5550484845990735\n",
      "m.queryIdx:  120\n",
      "distance:  2.59777427634252\n",
      "m.queryIdx:  130\n",
      "distance:  4.032012796915615\n",
      "m.queryIdx:  134\n",
      "distance:  2.962424991241915\n",
      "m.queryIdx:  138\n",
      "distance:  3.9148563349993033\n",
      "m.queryIdx:  141\n",
      "distance:  3.450887698594953\n",
      "m.queryIdx:  143\n",
      "distance:  2.9778262450018174\n",
      "m.queryIdx:  148\n",
      "distance:  3.0238390632529812\n",
      "m.queryIdx:  152\n",
      "distance:  3.252321761630175\n",
      "m.queryIdx:  153\n",
      "distance:  3.583818786940678\n",
      "m.queryIdx:  203\n",
      "distance:  3.477510302987424\n",
      "m.queryIdx:  240\n",
      "distance:  2.562942266621186\n",
      "m.queryIdx:  274\n",
      "distance:  4.091957770882583\n",
      "m.queryIdx:  293\n",
      "distance:  3.2665104919503563\n",
      "m.queryIdx:  298\n",
      "distance:  4.313991376756739\n",
      "m.queryIdx:  316\n",
      "distance:  3.3674691056701693\n",
      "m.queryIdx:  317\n",
      "distance:  0.679592180629588\n",
      "m.queryIdx:  329\n",
      "distance:  3.0642117950209884\n",
      "m.queryIdx:  330\n",
      "distance:  0.6805866041647886\n",
      "m.queryIdx:  363\n",
      "distance:  2.678789915661064\n",
      "m.queryIdx:  371\n",
      "distance:  0.7513729386811381\n",
      "m.queryIdx:  381\n",
      "distance:  11.709246116432578\n",
      "m.queryIdx:  405\n",
      "distance:  0.6812106183917651\n",
      "m.queryIdx:  410\n",
      "distance:  0.6930957929751407\n",
      "m.queryIdx:  413\n",
      "distance:  2.403251469374866\n",
      "m.queryIdx:  416\n",
      "distance:  2.992575943418364\n",
      "m.queryIdx:  441\n",
      "distance:  0.6926967390672463\n",
      "m.queryIdx:  445\n",
      "distance:  2.655020104274395\n",
      "m.queryIdx:  476\n",
      "distance:  0.6742819433859997\n",
      "m.queryIdx:  488\n",
      "distance:  2.4770422010257596\n",
      "m.queryIdx:  510\n",
      "distance:  0.6850110853929479\n",
      "m.queryIdx:  530\n",
      "distance:  3.2717242832993816\n",
      "m.queryIdx:  533\n",
      "distance:  17.413995508653315\n",
      "m.queryIdx:  541\n",
      "distance:  2.4847981868198996\n",
      "m.queryIdx:  547\n",
      "distance:  0.6861379569177455\n",
      "m.queryIdx:  552\n",
      "distance:  3.4849070315684987\n",
      "m.queryIdx:  555\n",
      "distance:  3.772712590228317\n",
      "m.queryIdx:  594\n",
      "distance:  3.372258329176309\n",
      "m.queryIdx:  601\n",
      "distance:  2.56905692921334\n",
      "m.queryIdx:  606\n",
      "distance:  0.6808573512979398\n",
      "m.queryIdx:  628\n",
      "distance:  3.4107476392318326\n",
      "m.queryIdx:  635\n",
      "distance:  2.2982230214285577\n",
      "m.queryIdx:  638\n",
      "distance:  2.8592571227047916\n",
      "m.queryIdx:  645\n",
      "distance:  2.57090738702612\n",
      "m.queryIdx:  647\n",
      "distance:  3.688895768543405\n",
      "m.queryIdx:  652\n",
      "distance:  1.0663132922619953\n",
      "m.queryIdx:  657\n",
      "distance:  4.616069105174083\n",
      "m.queryIdx:  659\n",
      "distance:  2.515442066263294\n",
      "m.queryIdx:  705\n",
      "distance:  3.5121166966129223\n",
      "m.queryIdx:  713\n",
      "distance:  1.1930266002957162\n",
      "m.queryIdx:  724\n",
      "distance:  3.2987319861355986\n",
      "m.queryIdx:  739\n",
      "distance:  3.9366806215804484\n",
      "m.queryIdx:  744\n",
      "distance:  0.6836702138295014\n",
      "m.queryIdx:  763\n",
      "distance:  0.6830769872180164\n"
     ]
    }
   ],
   "source": [
    "#cv.destroyAllWindows()\n",
    "triangulation_constant = 800 * 0.18\n",
    "depths = np.zeros(len(good_matches))\n",
    "for idx in range(len(good_matches)):\n",
    "    m = good_matches[idx]\n",
    "    left_pt = keypoints1[m.queryIdx].pt\n",
    "    right_pt = keypoints2[m.trainIdx].pt\n",
    "    dispartity = abs(left_pt[0] - right_pt[0])\n",
    "    z = triangulation_constant / dispartity\n",
    "    depths[idx] = z\n",
    "    print(\"m.queryIdx: \", m.queryIdx)\n",
    "    print(\"distance: \", z)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 298,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dmatch:  <DMatch 0x7fa3b404e930>\n",
      "depth:  2.732152907252788\n",
      "dmatch:  <DMatch 0x7fa3b404e190>\n",
      "depth:  11.412368216744909\n",
      "dmatch:  <DMatch 0x7fa3b411dbf0>\n",
      "depth:  3.0524255264094187\n",
      "dmatch:  <DMatch 0x7fa3b411dc30>\n",
      "depth:  3.8792980979190235\n",
      "dmatch:  <DMatch 0x7fa3a6f532f0>\n",
      "depth:  3.8564325200806824\n",
      "dmatch:  <DMatch 0x7fa3a6f53a10>\n",
      "depth:  3.046698124171916\n",
      "dmatch:  <DMatch 0x7fa3a6f53950>\n",
      "depth:  3.038340879939421\n",
      "dmatch:  <DMatch 0x7fa3a6f53990>\n",
      "depth:  3.892482627087884\n",
      "dmatch:  <DMatch 0x7fa3a6f53d90>\n",
      "depth:  3.4750465809920095\n",
      "dmatch:  <DMatch 0x7fa3a6f53b10>\n",
      "depth:  3.8112296821842926\n",
      "dmatch:  <DMatch 0x7fa3a6f53510>\n",
      "depth:  3.3794411372061446\n",
      "dmatch:  <DMatch 0x7fa3a6f533b0>\n",
      "depth:  3.0628234936732524\n",
      "dmatch:  <DMatch 0x7fa3a6f53490>\n",
      "depth:  2.570484430309825\n",
      "dmatch:  <DMatch 0x7fa3a6f53e90>\n",
      "depth:  0.6759176601228245\n",
      "dmatch:  <DMatch 0x7fa3a6f53870>\n",
      "depth:  2.9693225281509066\n",
      "dmatch:  <DMatch 0x7fa3b40582b0>\n",
      "depth:  0.6759875730162656\n",
      "dmatch:  <DMatch 0x7fa3b40589f0>\n",
      "depth:  3.029932075878782\n",
      "dmatch:  <DMatch 0x7fa3b4058450>\n",
      "depth:  2.545903056319015\n",
      "dmatch:  <DMatch 0x7fa3b4058e10>\n",
      "depth:  2.5550484845990735\n",
      "dmatch:  <DMatch 0x7fa3b4058810>\n",
      "depth:  2.59777427634252\n",
      "dmatch:  <DMatch 0x7fa3b4058a90>\n",
      "depth:  4.032012796915615\n",
      "dmatch:  <DMatch 0x7fa3b4058570>\n",
      "depth:  2.962424991241915\n",
      "dmatch:  <DMatch 0x7fa3b4058110>\n",
      "depth:  3.9148563349993033\n",
      "dmatch:  <DMatch 0x7fa3b4058150>\n",
      "depth:  3.450887698594953\n",
      "dmatch:  <DMatch 0x7fa3b4058510>\n",
      "depth:  2.9778262450018174\n",
      "dmatch:  <DMatch 0x7fa3b40586d0>\n",
      "depth:  3.0238390632529812\n",
      "dmatch:  <DMatch 0x7fa3b846c9d0>\n",
      "depth:  3.252321761630175\n",
      "dmatch:  <DMatch 0x7fa3b846ccb0>\n",
      "depth:  3.583818786940678\n",
      "dmatch:  <DMatch 0x7fa3b40b16d0>\n",
      "depth:  3.477510302987424\n",
      "dmatch:  <DMatch 0x7fa3b75f8430>\n",
      "depth:  2.562942266621186\n",
      "dmatch:  <DMatch 0x7fa3b75f8310>\n",
      "depth:  4.091957770882583\n",
      "dmatch:  <DMatch 0x7fa3b78c0150>\n",
      "depth:  3.2665104919503563\n",
      "dmatch:  <DMatch 0x7fa3b78c0870>\n",
      "depth:  4.313991376756739\n",
      "dmatch:  <DMatch 0x7fa3b78c0850>\n",
      "depth:  3.3674691056701693\n",
      "dmatch:  <DMatch 0x7fa3b78c0c90>\n",
      "depth:  0.679592180629588\n",
      "dmatch:  <DMatch 0x7fa3b404e390>\n",
      "depth:  3.0642117950209884\n",
      "dmatch:  <DMatch 0x7fa3a6fb6bf0>\n",
      "depth:  0.6805866041647886\n",
      "dmatch:  <DMatch 0x7fa3b409a8b0>\n",
      "depth:  2.678789915661064\n",
      "dmatch:  <DMatch 0x7fa3b409ad10>\n",
      "depth:  0.7513729386811381\n",
      "dmatch:  <DMatch 0x7fa3b409a110>\n",
      "depth:  11.709246116432578\n",
      "dmatch:  <DMatch 0x7fa3b406f430>\n",
      "depth:  0.6812106183917651\n",
      "dmatch:  <DMatch 0x7fa3b406f690>\n",
      "depth:  0.6930957929751407\n",
      "dmatch:  <DMatch 0x7fa3b410f730>\n",
      "depth:  2.403251469374866\n",
      "dmatch:  <DMatch 0x7fa3b410fbd0>\n",
      "depth:  2.992575943418364\n",
      "dmatch:  <DMatch 0x7fa3b408aad0>\n",
      "depth:  0.6926967390672463\n",
      "dmatch:  <DMatch 0x7fa3b408a2b0>\n",
      "depth:  2.655020104274395\n",
      "dmatch:  <DMatch 0x7fa3b408adf0>\n",
      "depth:  0.6742819433859997\n",
      "dmatch:  <DMatch 0x7fa3b78b7070>\n",
      "depth:  2.4770422010257596\n",
      "dmatch:  <DMatch 0x7fa3a7012650>\n",
      "depth:  0.6850110853929479\n",
      "dmatch:  <DMatch 0x7fa3a70127f0>\n",
      "depth:  3.2717242832993816\n",
      "dmatch:  <DMatch 0x7fa3a7012990>\n",
      "depth:  17.413995508653315\n",
      "dmatch:  <DMatch 0x7fa3a7012d70>\n",
      "depth:  2.4847981868198996\n",
      "dmatch:  <DMatch 0x7fa3a7012f10>\n",
      "depth:  0.6861379569177455\n",
      "dmatch:  <DMatch 0x7fa3a7019b10>\n",
      "depth:  3.4849070315684987\n",
      "dmatch:  <DMatch 0x7fa3a70190b0>\n",
      "depth:  3.772712590228317\n",
      "dmatch:  <DMatch 0x7fa3a7019930>\n",
      "depth:  3.372258329176309\n",
      "dmatch:  <DMatch 0x7fa3a7019d50>\n",
      "depth:  2.56905692921334\n",
      "dmatch:  <DMatch 0x7fa3a7019eb0>\n",
      "depth:  0.6808573512979398\n",
      "dmatch:  <DMatch 0x7fa3a7006290>\n",
      "depth:  3.4107476392318326\n",
      "dmatch:  <DMatch 0x7fa3a70065d0>\n",
      "depth:  2.2982230214285577\n",
      "dmatch:  <DMatch 0x7fa3a7006690>\n",
      "depth:  2.8592571227047916\n",
      "dmatch:  <DMatch 0x7fa3a7006890>\n",
      "depth:  2.57090738702612\n",
      "dmatch:  <DMatch 0x7fa3a7006930>\n",
      "depth:  3.688895768543405\n",
      "dmatch:  <DMatch 0x7fa3a7006a70>\n",
      "depth:  1.0663132922619953\n",
      "dmatch:  <DMatch 0x7fa3a7006bb0>\n",
      "depth:  4.616069105174083\n",
      "dmatch:  <DMatch 0x7fa3a7006c30>\n",
      "depth:  2.515442066263294\n",
      "dmatch:  <DMatch 0x7fa3a7004870>\n",
      "depth:  3.5121166966129223\n",
      "dmatch:  <DMatch 0x7fa3a7004a70>\n",
      "depth:  1.1930266002957162\n",
      "dmatch:  <DMatch 0x7fa3a7004d30>\n",
      "depth:  3.2987319861355986\n",
      "dmatch:  <DMatch 0x7fa3a70c02b0>\n",
      "depth:  3.9366806215804484\n",
      "dmatch:  <DMatch 0x7fa3a70c0390>\n",
      "depth:  0.6836702138295014\n",
      "dmatch:  <DMatch 0x7fa3a70c0850>\n",
      "depth:  0.6830769872180164\n"
     ]
    }
   ],
   "source": [
    "#Convert openCV BGR image top PIL RGB format\n",
    "\n",
    "pil_img = cv.cvtColor(left_img_remap, cv.COLOR_BGR2RGB)\n",
    "pil_img = Image.fromarray(pil_img)\n",
    "draw_depths = ImageDraw.Draw(pil_img)\n",
    "for d_match, depth in zip(good_matches, depths):\n",
    "    print('dmatch: ', d_match)\n",
    "    print(\"depth: \", depth)\n",
    "    draw_depths.text(keypoints1[d_match.queryIdx].pt, str(depth), fill=(255,255,255))#white text\n",
    "\n",
    "pil_img.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 299,
   "metadata": {},
   "outputs": [],
   "source": [
    "cv.destroyAllWindows()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.7.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}