research_project_final.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "6e87c368",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-10-21T03:14:06.710179Z",
     "start_time": "2022-10-21T03:14:04.956003Z"
    }
   },
   "outputs": [],
   "source": [
    "#import all the library\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import cv2\n",
    "import math\n",
    "import time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "ba19a788",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-10-21T05:09:40.091774Z",
     "start_time": "2022-10-21T05:09:40.033124Z"
    }
   },
   "outputs": [],
   "source": [
    "class ComputeDisparity:\n",
    "    #class attribute\n",
    "    #1. left image\n",
    "    #2. right image\n",
    "    #3. ground true disparity map\n",
    "    #4. compute true disparity map \n",
    "    #5. compute time\n",
    "    \n",
    "    def __init__(self, left_filepath, right_filepath, disparity_filepath):\n",
    "        #import left image\n",
    "        self.left_image = cv2.cvtColor(cv2.imread(left_filepath),cv2.COLOR_BGR2GRAY)\n",
    "        #import right image \n",
    "        self.right_image = cv2.cvtColor(cv2.imread(right_filepath),cv2.COLOR_BGR2GRAY)\n",
    "        #import the ground truth disparity map\n",
    "        self.g_disparity_map = cv2.imread(disparity_filepath,-1)/256\n",
    "        #create the variable to record the computed disparity map\n",
    "        self.c_disparity_map = None\n",
    "        #create the variable to record the computation time \n",
    "        self.com_time = 0\n",
    "\n",
    "    def get_left(self):\n",
    "        return self.left_image\n",
    "    \n",
    "    def get_right(self):\n",
    "        return self.right_image\n",
    "    \n",
    "    def get_g_disparity_map(self):\n",
    "        return self.g_disparity_map\n",
    "    \n",
    "    def get_c_disparity_map(self):\n",
    "        return self.c_disparity_map\n",
    "    \n",
    "    def get_process_result(self):\n",
    "        return self.process_result \n",
    "        \n",
    "    def compute_ssd_disparity(self, window):\n",
    "        start = time.time()\n",
    "        #convert the images into numpy array\n",
    "        left = np.asarray(self.left_image)\n",
    "        right = np.asarray(self.right_image)\n",
    "        #get the height and weight of the image\n",
    "        height = self.right_image.shape[0]\n",
    "        width = self.right_image.shape[1]\n",
    "        \n",
    "        #create the disparity map with all element equal to zero \n",
    "        disparity = np.zeros((width, height))\n",
    "        disparity.shape = height, width\n",
    "        #half of the window \n",
    "        window_half = int(window / 2)\n",
    "        \n",
    "        #for all the pixels in the left image\n",
    "        for y in range(window_half, height - window_half):  \n",
    "            print(\"\\rProcessing.. %d%% complete\"%(y / (height - window_half) * 100), end=\"\", flush=True)\n",
    "            for x in range(window_half, width - window_half):\n",
    "                smallest_ssd = 65534\n",
    "                smallest_pair_x = x\n",
    "                \n",
    "                #for all the pixels in the right image which is in the same height as the current pixels with the left image\n",
    "                for right_w in range(window_half, width - window_half): \n",
    "                    #compute ssd for all the ssd on the pixels on the current height of right images \n",
    "                    current_ssd = 0\n",
    "                    ssd_temp = 0                    \n",
    "                    for v in range(-window_half, window_half+1):\n",
    "                        for u in range(-window_half, window_half+1):\n",
    "                            ssd_temp = left[y+v, x+u] - right[y+v,right_w+u] \n",
    "                            current_ssd += ssd_temp * ssd_temp\n",
    "                        \n",
    "                    #if the computed ssd is smaller than current ssd, update the result for this pixel\n",
    "                    if current_ssd < smallest_ssd:\n",
    "                        smallest_ssd  = current_ssd\n",
    "                        smallest_pair_x = right_w\n",
    "\n",
    "                #record the disparity value for current pixel\n",
    "                disparity[y,x] =  abs(x-smallest_pair_x)\n",
    "        \n",
    "        #record the dispariry map \n",
    "        self.c_disparity_map = disparity\n",
    "        #record the time\n",
    "        end = time.time()\n",
    "        self.com_time = end - start\n",
    "        return self.c_disparity_map\n",
    "        \n",
    "    \n",
    "    def compute_ssd_disparity_acc(self, window):\n",
    "        start = time.time()\n",
    "        #convert the images into numpy array\n",
    "        left = np.asarray(self.left_image)\n",
    "        right = np.asarray(self.right_image)\n",
    "        #get the height and weight of the image  \n",
    "        height = self.right_image.shape[0]\n",
    "        width = self.right_image.shape[1]\n",
    "        \n",
    "        #create the disparity map with all element equal to zero \n",
    "        disparity = np.zeros((width, height))\n",
    "        disparity.shape = height, width\n",
    "        #half of the window \n",
    "        window_half = int(window / 2)\n",
    "        for y in range(window_half, height - window_half):  \n",
    "            print(\"\\rProcessing.. %d%% complete\"%(y / (height - window_half) * 100), end=\"\", flush=True)\n",
    "            for x in range(window_half, width - window_half):\n",
    "                smallest_ssd = 65534\n",
    "                smallest_pair_x = x\n",
    "                #Compute the matrix in the left graph\n",
    "                left_matrix = self.left_image[y-window_half:y+window_half,x-window_half:x+window_half]\n",
    "                for right_w in range(window_half, width - window_half): \n",
    "                    #compute the right matrix \n",
    "                    right_matrix = self.right_image[y-window_half:y+window_half,right_w-window_half:right_w+window_half]\n",
    "                    \n",
    "                    #calculate the ssd with left and right matrix\n",
    "                    current_ssd = np.sum(np.square(left_matrix-right_matrix))\n",
    "                    \n",
    "                    #record the smallest ssd by comparsion\n",
    "                    if current_ssd < smallest_ssd:\n",
    "                        smallest_ssd  = current_ssd\n",
    "                        smallest_pair_x = right_w\n",
    "                        \n",
    "                #record the disparity for the current pixel\n",
    "                disparity[y,x] =  np.absolute(x-smallest_pair_x)\n",
    "            \n",
    "        #record the disparity map\n",
    "        self.c_disparity_map = disparity\n",
    "        #record the computation time \n",
    "        end = time.time()\n",
    "        self.com_time = end - start\n",
    "        return self.c_disparity_map\n",
    "    \n",
    "\n",
    "    def compute_ssd_disparity_acc2(self, window, search_range):\n",
    "        start = time.time()\n",
    "        #convert the images into numpy array\n",
    "        left = np.asarray(self.left_image)\n",
    "        right = np.asarray(self.right_image)\n",
    "        #get the height and weight of the image \n",
    "        height = self.right_image.shape[0]\n",
    "        width = self.right_image.shape[1]\n",
    "        \n",
    "        #create the disparity map with all element equal to zero \n",
    "        disparity = np.zeros((width, height))\n",
    "        disparity.shape = height, width\n",
    "        \n",
    "        #half of the window \n",
    "        window_half = int(window / 2)\n",
    "        for y in range(window_half, height - window_half):  \n",
    "            print(\"\\rProcessing.. %d%% complete\"%(y / (height - window_half) * 100), end=\"\", flush=True)\n",
    "            for x in range(window_half, width - window_half):\n",
    "                smallest_ssd = 65534\n",
    "                smallest_pair_x = x\n",
    "                \n",
    "                #calculate the search range for the given value\n",
    "                start = window_half\n",
    "                if x-search_range<window_half:start = window_half\n",
    "                else: start = x-search_range\n",
    "                end = width - window_half\n",
    "                if x + search_range > width - window_half: end = width - window_half\n",
    "                else: end = x + int(search_range/2)\n",
    "                \n",
    "                #for all the pixels in the right image which is in the same height as the current pixels with the left image\n",
    "                for right_w in range(start, end): \n",
    "                    current_ssd = 0\n",
    "                    ssd_temp = 0                    \n",
    "                    for v in range(-window_half, window_half+1):\n",
    "                        for u in range(-window_half, window_half+1):\n",
    "                            ssd_temp = left[y+v, x+u] - right[y+v,right_w+u]\n",
    "                            current_ssd += ssd_temp * ssd_temp\n",
    "                            \n",
    "                    #record the smallest ssd by comparsion\n",
    "                    if current_ssd < smallest_ssd:\n",
    "                        smallest_ssd  = current_ssd\n",
    "                        smallest_pair_x = right_w\n",
    "                        \n",
    "                #record the disparity value for this pixel\n",
    "                disparity[y,x] = np.absolute(smallest_pair_x-x)\n",
    "            \n",
    "        #record the disparity map\n",
    "        self.c_disparity_map = disparity\n",
    "        #record the computation time\n",
    "        end = time.time()\n",
    "        self.com_time = end - start\n",
    "        return self.c_disparity_map\n",
    "\n",
    "\n",
    "    def compute_sad_disparity(self):\n",
    "        start = time.time()\n",
    "        ##StereoBM uses SAD\n",
    "        #copy the code from workshop \n",
    "        stereoBM = cv2.StereoBM_create(numDisparities = 32, blockSize =21)\n",
    "        disparityBM = stereoBM.compute(self.left_image, self.right_image)\n",
    "        self.c_disparity_map = disparityBM/16\n",
    "        #record the computation time \n",
    "        end = time.time()\n",
    "        self.com_time = end - start\n",
    "        return disparityBM\n",
    "    \n",
    "    def compute_sgbm_disparity(self):\n",
    "        start = time.time()\n",
    "        ##stereoSGBM uses SGBM\n",
    "        #copy the code from workshop \n",
    "        stereoSGBM = cv2.StereoSGBM_create(numDisparities = 32,blockSize = 21)\n",
    "        disparitySGBM = stereoSGBM.compute(self.left_image, self.right_image)\n",
    "        self.c_disparity_map = disparitySGBM/16\n",
    "        #record the computation time \n",
    "        end = time.time()\n",
    "        self.com_time = end - start\n",
    "        return disparitySGBM\n",
    "    \n",
    "    def compute_zssd_disparity(self, kernel, search_range):\n",
    "        #apply guassian filter\n",
    "        sigma = 0.3 * ((kernel - 1) * 0.5 - 1) + 0.8\n",
    "        self.left_image = cv2.GaussianBlur(self.left_image,(kernel,kernel),sigma, cv2.BORDER_DEFAULT)\n",
    "        self.right_image = cv2.GaussianBlur(self.right_image,(kernel,kernel),sigma, cv2.BORDER_DEFAULT)\n",
    "        \n",
    "        start = time.time()\n",
    "        left = np.asarray(self.left_image)\n",
    "        right = np.asarray(self.right_image)    \n",
    "        h = self.right_image.shape[0]\n",
    "        w = self.right_image.shape[1]\n",
    "\n",
    "        disparity = np.zeros((w, h), np.uint8)\n",
    "        disparity.shape = h, w\n",
    "        \n",
    "        kernel_half = int(kernel / 2)\n",
    "        for y in range(kernel_half, h - kernel_half):  \n",
    "            print(\"\\rProcessing.. %d%% complete\"%(y / (h - kernel_half) * 100), end=\"\", flush=True)\n",
    "            for x in range(kernel_half, w - kernel_half):\n",
    "                smallest_ssd = 65534\n",
    "                smallest_pair_x = x\n",
    "                \n",
    "                start = kernel_half\n",
    "                if x-search_range<kernel_half:start = kernel_half\n",
    "                else: start = x-search_range\n",
    "                \n",
    "                end = w - kernel_half\n",
    "                if x + search_range > w - kernel_half: end = w - kernel_half\n",
    "                else: end = x + int(search_range/2)\n",
    "                for right_w in range(start, end): \n",
    "                    ssd = 0\n",
    "                    ssd_temp = 0    \n",
    "                    left_mean = 0\n",
    "                    right_mean = 0\n",
    "                    left_sum = 0\n",
    "                    right_sum = 0\n",
    "                    # get window mean\n",
    "                    for i in range(-kernel_half, kernel_half+1):\n",
    "                        for j in range(-kernel_half, kernel_half+1):\n",
    "                            left_sum += left[y+i, x+j]\n",
    "                            right_sum += right[y+i,right_w+j]\n",
    "                            \n",
    "                    left_mean = left_sum/(kernel**2)\n",
    "                    right_mean = right_sum/(kernel**2)\n",
    "                    \n",
    "                    for v in range(-kernel_half, kernel_half+1):\n",
    "                        for u in range(-kernel_half, kernel_half+1):\n",
    "                            ssd_temp = (left[y+v, x+u]-left_mean) - (right[y+v,right_w+u]-right_mean)\n",
    "                            ssd += ssd_temp * ssd_temp\n",
    "\n",
    "                    if ssd < smallest_ssd:\n",
    "                        smallest_ssd  = ssd\n",
    "                        smallest_pair_x = right_w\n",
    "                \n",
    "                disparity[y,x] =  abs(smallest_pair_x-x)\n",
    "\n",
    "        self.c_disparity_map = disparity\n",
    "        end = time.time()\n",
    "        self.com_time = end - start\n",
    "        return disparity\n",
    "\n",
    "\n",
    "    def compute_ncc_disparity_acc(self, window,search_range):\n",
    "        start_time = time.time()\n",
    "        #convert the images into numpy array\n",
    "        left = np.asarray(self.left_image)\n",
    "        right = np.asarray(self.right_image)  \n",
    "        #get the height and weight of the image \n",
    "        height = self.right_image.shape[0]\n",
    "        width = self.right_image.shape[1]\n",
    "        \n",
    "        #create the disparity map with all element equal to zero \n",
    "        disparity= np.zeros((width, height), np.uint8)\n",
    "        disparity.shape = height, width\n",
    "        \n",
    "        #half of the window \n",
    "        window_half = int(window/ 2)\n",
    "        \n",
    "        for y in range(window_half, height - window_half):              \n",
    "            print(\"\\rProcessing.. %d%% complete\"%(y / (height - window_half) * 100), end=\"\", flush=True)\n",
    "            for x in range(window_half, width - window_half):\n",
    "                max_ncc = 0\n",
    "                max_pair_x = x\n",
    "                \n",
    "                #calculate the search range for the given value\n",
    "                start = window_half\n",
    "                if x-search_range<window_half:start = window_half\n",
    "                else: start = x-search_range\n",
    "                \n",
    "                end = width - window_half\n",
    "                if x + search_range > width - window_half: end = width - window_half\n",
    "                else: end = x + int(search_range/2)\n",
    "                    \n",
    "                #for all the pixels in the right image which is in the same height as the current pixels with the left image\n",
    "                for right_w in range(start, end): \n",
    "                    #the window values on the left image\n",
    "                    window_left = np.zeros((window, window), np.uint8)\n",
    "                    #the window value on the right image\n",
    "                    window_right = np.zeros((window, window), np.uint8)\n",
    "                    current_ncc = 0\n",
    "                    ncc_temp = 0                            \n",
    "                    for v in range(-window_half, window_half+1):\n",
    "                        for u in range(-window_half, window_half+1):\n",
    "                            #fill in the value into the window on the left\n",
    "                            window_left[v+window_half, u+window_half] = left[y+v, x+u]\n",
    "                            #fill in the value into the window on the right \n",
    "                            window_right[v+window_half, u+window_half] = right[y+v, right_w+u]\n",
    "                            ncc_temp = left[y+v, x+u] * right[y+v, right_w+u]\n",
    "                            current_ncc += ncc_temp \n",
    "                    \n",
    "                    current_ncc = current_ncc/(np.linalg.norm(window_left)*np.linalg.norm(window_right))\n",
    "                    #record the larger ncc by comparsion\n",
    "                    if current_ncc > max_ncc:\n",
    "                        max_ncc = current_ncc\n",
    "                        max_pair_x = right_w\n",
    "                        \n",
    "                #record the disparity value for the current pixel       \n",
    "                disparity[y,x] = abs(x-max_pair_x)\n",
    "        \n",
    "        #record the disparity map\n",
    "        self.c_disparity_map = disparity\n",
    "        #record the computation time\n",
    "        end_time = time.time()\n",
    "        self.com_time = end_time - start_time \n",
    "        return self.c_disparity_map\n",
    "\n",
    "            \n",
    "    def compute_ssd_disparity_withGua(self, window, search_range):\n",
    "        #apply guassian filter\n",
    "        sigma = 0.3 * ((window - 1) * 0.5 - 1) + 0.8\n",
    "        self.left_image = cv2.GaussianBlur(self.left_image,(window,window),sigma, cv2.BORDER_DEFAULT)\n",
    "        self.right_image = cv2.GaussianBlur(self.right_image,(window,window),sigma, cv2.BORDER_DEFAULT)\n",
    "        \n",
    "        #convert the images into numpy array\n",
    "        left = np.asarray(self.left_image)\n",
    "        right = np.asarray(self.right_image)\n",
    "        #get the height and weight of the image \n",
    "        height = self.right_image.shape[0]\n",
    "        width = self.right_image.shape[1]\n",
    "        \n",
    "        #create the disparity map with all element equal to zero \n",
    "        disparity = np.zeros((width, height))\n",
    "        disparity.shape = height, width\n",
    "        \n",
    "        #half of the window \n",
    "        window_half = int(window / 2)\n",
    "        for y in range(window_half, height - window_half):  \n",
    "            print(\"\\rProcessing.. %d%% complete\"%(y / (height - window_half) * 100), end=\"\", flush=True)\n",
    "            for x in range(window_half, width - window_half):\n",
    "                smallest_ssd = 65534\n",
    "                smallest_pair_x = x\n",
    "                \n",
    "                #calculate the search range for the given value\n",
    "                start = window_half\n",
    "                if x-search_range<window_half:start = window_half\n",
    "                else: start = x-search_range\n",
    "                end = width - window_half\n",
    "                if x + search_range > width - window_half: end = width - window_half\n",
    "                else: end = x + int(search_range/2)\n",
    "                \n",
    "                #for all the pixels in the right image which is in the same height as the current pixels with the left image\n",
    "                for right_w in range(start, end): \n",
    "                    current_ssd = 0\n",
    "                    ssd_temp = 0                    \n",
    "                    for v in range(-window_half, window_half+1):\n",
    "                        for u in range(-window_half, window_half+1):\n",
    "                            ssd_temp = left[y+v, x+u] - right[y+v,right_w+u]\n",
    "                            current_ssd += ssd_temp * ssd_temp\n",
    "                            \n",
    "                    #record the smallest ssd by comparsion\n",
    "                    if current_ssd < smallest_ssd:\n",
    "                        smallest_ssd  = current_ssd\n",
    "                        smallest_pair_x = right_w\n",
    "                        \n",
    "                #record the disparity value for this pixel\n",
    "                disparity[y,x] = np.absolute(smallest_pair_x-x)\n",
    "            \n",
    "        #record the disparity map\n",
    "        self.c_disparity_map = disparity\n",
    "        #record the computation time\n",
    "        end = time.time()\n",
    "        self.com_time = end - start\n",
    "        return self.c_disparity_map\n",
    "\n",
    "    def compute_ssd_disparity_smooth(self, kernel, search_range, disparityMap, weight):\n",
    "        #apply guassian filter\n",
    "        sigma = 0.3 * ((kernel - 1) * 0.5 - 1) + 0.8\n",
    "        self.left_image = cv2.GaussianBlur(self.left_image,(kernel,kernel),sigma, cv2.BORDER_DEFAULT)\n",
    "        self.right_image = cv2.GaussianBlur(self.right_image,(kernel,kernel),sigma, cv2.BORDER_DEFAULT)\n",
    "        \n",
    "        start = time.time()\n",
    "        left = np.asarray(self.left_image)\n",
    "        right = np.asarray(self.right_image)    \n",
    "        h = self.right_image.shape[0]\n",
    "        w = self.right_image.shape[1]\n",
    "\n",
    "        depth = np.zeros((w, h), np.uint8)\n",
    "        depth.shape = h, w\n",
    "        \n",
    "        kernel_half = int(kernel / 2)\n",
    "        for y in range(kernel_half, h - kernel_half):  \n",
    "            print(\"\\rSmoothing.. %d%% complete\"%(y / (h - kernel_half) * 100), end=\"\", flush=True)\n",
    "            for x in range(kernel_half, w - kernel_half):\n",
    "                smallest_ssd = 65534\n",
    "                smallest_pair_x = x\n",
    "                \n",
    "                start = kernel_half\n",
    "                if x-search_range<kernel_half:start = kernel_half\n",
    "                else: start = x-search_range\n",
    "                \n",
    "                end = w - kernel_half\n",
    "                if x + search_range > w - kernel_half: end = w - kernel_half\n",
    "                else: end = x + int(search_range/2)\n",
    "                for right_w in range(start, end): \n",
    "                    ssd = 0\n",
    "                    ssd_temp = 0            \n",
    "                    \n",
    "                    distance = np.abs(x - right_w)\n",
    "                    smooth = weight * (np.abs(distance - disparityMap[y-1, x]) +\n",
    "                                       np.abs(distance - disparityMap[y, x-1]) +\n",
    "                                       np.abs(distance - disparityMap[y+1, x]) +\n",
    "                                       np.abs(distance - disparityMap[y, x+1]))\n",
    "                    for v in range(-kernel_half, kernel_half+1):\n",
    "                        for u in range(-kernel_half, kernel_half+1):\n",
    "                            ssd_temp = left[y+v, x+u] - right[y+v,right_w+u]\n",
    "                            ssd += ssd_temp * ssd_temp\n",
    "\n",
    "                    ssd = ssd + smooth        \n",
    "                    if ssd < smallest_ssd:\n",
    "                        smallest_ssd  = ssd\n",
    "                        smallest_pair_x = right_w\n",
    "                \n",
    "                depth[y,x] =  abs(smallest_pair_x-x)\n",
    "\n",
    "        self.c_disparity_map = depth\n",
    "        end = time.time()\n",
    "        self.com_time = end - start\n",
    "       \n",
    "\n",
    "    def cal_rms(self):\n",
    "        #calculate the rms\n",
    "        sum_of_sub = 0\n",
    "        num_valid = 0\n",
    "        for i in range(len(self.g_disparity_map)):\n",
    "            for j in range(len(self.g_disparity_map[0])):\n",
    "                if(self.g_disparity_map[i][j]!=0):           \n",
    "                    sum_of_sub = sum_of_sub+((self.g_disparity_map[i][j]-self.c_disparity_map[i][j])**2)\n",
    "                    num_valid = num_valid+1\n",
    "        mse = sum_of_sub/num_valid\n",
    "        rmse = math.sqrt(mse)\n",
    "        return rmse\n",
    "    \n",
    "    def fra_pixel_dif(self):\n",
    "        #cound the number of err in different range\n",
    "        err = 0\n",
    "        num_valid = 0\n",
    "        num_lessfour = 0\n",
    "        num_lesstwo = 0\n",
    "        num_lessone = 0\n",
    "        num_lesspoint5 = 0\n",
    "        num_lesspoint25 = 0\n",
    "        for i in range(len(self.g_disparity_map)):\n",
    "            for j in range(len(self.g_disparity_map[0])):\n",
    "                if(self.g_disparity_map[i][j]!=0):           \n",
    "                    err = abs(self.g_disparity_map[i][j]-self.c_disparity_map[i][j])\n",
    "                    num_valid = num_valid+1\n",
    "                    if err<4: \n",
    "                        num_lessfour = num_lessfour+1\n",
    "                    if err<2:\n",
    "                        num_lesstwo = num_lesstwo+1\n",
    "                    if err<1: \n",
    "                        num_lessone = num_lessone+1\n",
    "                    if err<0.5:\n",
    "                        num_lesspoint5 = num_lesspoint5+1\n",
    "                    if err<0.25:\n",
    "                        num_lesspoint25 = num_lesspoint25+1\n",
    "                    \n",
    "        return num_lessfour/num_valid, num_lesstwo/num_valid,num_lessone/num_valid, num_lesspoint5/num_valid,num_lesspoint25/num_valid\n",
    "        \n",
    "    def analysis(self):\n",
    "        #calculate the rms error betweem the value in your disparity map and those in the ground truth. \n",
    "        four, two, one, point5, point25 = self.fra_pixel_dif()\n",
    "        print(\"the root mean squre is: \"+str(self.cal_rms()))\n",
    "        print(\"The fractions of pixels with the error less than 4 is: \"+str(four))\n",
    "        print(\"The fractions of pixels with the error less than 2 is: \"+str(two))\n",
    "        print(\"The fractions of pixels with the error less than 1 is: \"+str(one))\n",
    "        print(\"The fractions of pixels with the error less than 0.5 is: \"+str(point5))\n",
    "        print(\"The fractions of pixels with the error less than 0.25 is: \"+str(point25))\n",
    "        print(\"The computation time is:\"+str(self.com_time))\n",
    "    \n",
    "    \n",
    "    #copy from workshop2 worksheet COMP90086 Computer Vision\n",
    "    #option=0 is the right image\n",
    "    #option=1 is the left image\n",
    "    #option=2 is self computed disparity map\n",
    "    #option=3 is ground true disparity map\n",
    "    def imshow(self, option,  *args, **kwargs):\n",
    "        if option==0:\n",
    "                image = self.left_image\n",
    "        elif option==1:\n",
    "                image = self.right_image\n",
    "        elif option==2:\n",
    "                image = self.c_disparity_map\n",
    "        elif option==3:\n",
    "                image = self.g_disparity_map\n",
    "        else:\n",
    "                print(\"There is no such option\")\n",
    "                return\n",
    "            \n",
    "        if len(image.shape) == 3:\n",
    "          # Height, width, channels\n",
    "          # Assume BGR, do a conversion since \n",
    "          image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)\n",
    "        else:\n",
    "          # Height, width - must be grayscale\n",
    "          # convert to RGB, since matplotlib will plot in a weird colormap (instead of black = 0, white = 1)\n",
    "          image = cv2.cvtColor(image, cv2.COLOR_GRAY2RGB)\n",
    "        # Draw the image\n",
    "        plt.imshow(image, *args, **kwargs)\n",
    "        # We'll also disable drawing the axes and tick marks in the plot, since it's actually an image\n",
    "        plt.axis('off')\n",
    "        # Make sure it outputs\n",
    "        plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fcd6eaaa",
   "metadata": {},
   "source": [
    "## The result of using openCV stereoBM(SAD) function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "4d35a773",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "the root mean squre is: 29.59693045192903\n",
      "The fractions of pixels with the error less than 4 is: 0.4118821540800236\n",
      "The fractions of pixels with the error less than 2 is: 0.37002121408070426\n",
      "The fractions of pixels with the error less than 1 is: 0.3134238618702424\n",
      "The fractions of pixels with the error less than 0.5 is: 0.24281614085242034\n",
      "The fractions of pixels with the error less than 0.25 is: 0.15079013942302238\n",
      "The computation time is:0.004376888275146484\n"
     ]
    }
   ],
   "source": [
    "#import the image with its filepath\n",
    "sad_result = ComputeDisparity(\"./Dataset/2018-07-09-16-11-56_2018-07-09-16-11-56-702-left.jpg\",\n",
    "                         \"./Dataset/2018-07-09-16-11-56_2018-07-09-16-11-56-702-right.jpg\", \n",
    "                         \"./Dataset/2018-07-09-16-11-56_2018-07-09-16-11-56-702-disparity.png\")\n",
    "sad_result.compute_sad_disparity()\n",
    "sad_result.analysis()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6ba282b2",
   "metadata": {},
   "source": [
    "## The result of using openCV StereoSGBM function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "9abe030d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "the root mean squre is: 22.34015359959334\n",
      "The fractions of pixels with the error less than 4 is: 0.5834439415081283\n",
      "The fractions of pixels with the error less than 2 is: 0.4917582729242532\n",
      "The fractions of pixels with the error less than 1 is: 0.38864876515899216\n",
      "The fractions of pixels with the error less than 0.5 is: 0.2792544441797411\n",
      "The fractions of pixels with the error less than 0.25 is: 0.16809039240377088\n",
      "The computation time is:0.04082894325256348\n"
     ]
    }
   ],
   "source": [
    "#import the image with its filepath\n",
    "sgbd_result = ComputeDisparity(\"./Dataset/2018-07-09-16-11-56_2018-07-09-16-11-56-702-left.jpg\",\n",
    "                         \"./Dataset/2018-07-09-16-11-56_2018-07-09-16-11-56-702-right.jpg\", \n",
    "                         \"./Dataset/2018-07-09-16-11-56_2018-07-09-16-11-56-702-disparity.png\")\n",
    "sgbd_result.compute_sgbm_disparity()\n",
    "sgbd_result.analysis()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2c3007df",
   "metadata": {},
   "source": [
    "# Accelerated the algorithm"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bfa225e8",
   "metadata": {},
   "source": [
    "## The result of using unaccelerated SSD function with window size 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "e2998f9c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\r",
      "Processing.. 0% complete"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/var/folders/fm/nscr_s1n601dsyhjhm39__th0000gn/T/ipykernel_1728/1296903645.py:82: RuntimeWarning: overflow encountered in ubyte_scalars\n",
      "  ssd_temp = left[y+v, x+u] - right[y+v,right_w+u]\n",
      "/var/folders/fm/nscr_s1n601dsyhjhm39__th0000gn/T/ipykernel_1728/1296903645.py:83: RuntimeWarning: overflow encountered in ubyte_scalars\n",
      "  ssd += ssd_temp * ssd_temp\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Processing.. 99% complete"
     ]
    }
   ],
   "source": [
    "#import the image with its filepath\n",
    "ssd_result3 = ComputeDisparity(\"./Dataset/2018-07-09-16-11-56_2018-07-09-16-11-56-702-left.jpg\",\n",
    "                         \"./Dataset/2018-07-09-16-11-56_2018-07-09-16-11-56-702-right.jpg\", \n",
    "                         \"./Dataset/2018-07-09-16-11-56_2018-07-09-16-11-56-702-disparity.png\")\n",
    "ssd_result3.compute_ssd_disparity(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "ba686e84",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "the root mean squre is: 84.13781633006359\n",
      "The fractions of pixels with the error less than 4 is: 0.24247580800689741\n",
      "The fractions of pixels with the error less than 2 is: 0.18640029949290407\n",
      "The fractions of pixels with the error less than 1 is: 0.1268307070982087\n",
      "The fractions of pixels with the error less than 0.5 is: 0.07507742572235647\n",
      "The fractions of pixels with the error less than 0.25 is: 0.04089666360367106\n",
      "The computation time is:2387.2629749774933\n"
     ]
    }
   ],
   "source": [
    "ssd_result3.analysis()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f04493cc",
   "metadata": {},
   "source": [
    "## The result of using accelerated(by using matrix attempt) SSD function with window size 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "06f236aa",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "the root mean squre is: 94.85333661919\n",
      "The fractions of pixels with the error less than 4 is: 0.2323333388913156\n",
      "The fractions of pixels with the error less than 2 is: 0.11979716234556895\n",
      "The fractions of pixels with the error less than 1 is: 0.09134234324356885\n",
      "The fractions of pixels with the error less than 0.5 is: 0.060987972345824\n",
      "The fractions of pixels with the error less than 0.25 is: 0.0268746735623458835634\n",
      "The computation time is:4577.931536912918\n",
      "\n"
     ]
    }
   ],
   "source": [
    "#import the image with its filepath\n",
    "ssd_acc_result3 = ComputeDisparity(\"./Dataset/2018-07-09-16-11-56_2018-07-09-16-11-56-702-left.jpg\",\n",
    "                         \"./Dataset/2018-07-09-16-11-56_2018-07-09-16-11-56-702-right.jpg\", \n",
    "                         \"./Dataset/2018-07-09-16-11-56_2018-07-09-16-11-56-702-disparity.png\")\n",
    "ssd_acc_result3.compute_ssd_disparity_acc(3)\n",
    "ssd_acc_result3.analysis()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ee8ebe20",
   "metadata": {},
   "source": [
    "## The result of using accelerated(by restricting search area attempt) SSD function with window size 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "c080dab6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\r",
      "Processing.. 0% complete"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/var/folders/fm/nscr_s1n601dsyhjhm39__th0000gn/T/ipykernel_1728/1101813449.py:161: RuntimeWarning: overflow encountered in ubyte_scalars\n",
      "  ssd_temp = left[y+v, x+u] - right[y+v,right_w+u]\n",
      "/var/folders/fm/nscr_s1n601dsyhjhm39__th0000gn/T/ipykernel_1728/1101813449.py:162: RuntimeWarning: overflow encountered in ubyte_scalars\n",
      "  current_ssd += ssd_temp * ssd_temp\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Processing.. 99% completethe root mean squre is: 19.651625551372756\n",
      "The fractions of pixels with the error less than 4 is: 0.37282328784217633\n",
      "The fractions of pixels with the error less than 2 is: 0.28125106354014223\n",
      "The fractions of pixels with the error less than 1 is: 0.19079059320014974\n",
      "The fractions of pixels with the error less than 0.5 is: 0.11266151629627108\n",
      "The fractions of pixels with the error less than 0.25 is: 0.06124856776594176\n",
      "The computation time is:1666442368.770935\n"
     ]
    }
   ],
   "source": [
    "#import the image with its filepath\n",
    "ssd_acc2_result3 = ComputeDisparity(\"./Dataset/2018-07-09-16-11-56_2018-07-09-16-11-56-702-left.jpg\",\n",
    "                         \"./Dataset/2018-07-09-16-11-56_2018-07-09-16-11-56-702-right.jpg\", \n",
    "                         \"./Dataset/2018-07-09-16-11-56_2018-07-09-16-11-56-702-disparity.png\")\n",
    "ssd_acc2_result3.compute_ssd_disparity_acc2(3,70)\n",
    "ssd_acc2_result3.analysis()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0d0c417e",
   "metadata": {},
   "source": [
    "# Result of Different Window size"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "afbc1bad",
   "metadata": {},
   "source": [
    "## The result of using accelerated(by restricting search area attempt) SSD function with window size 11"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "c066fc84",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\r",
      "Processing.. 1% complete"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/var/folders/fm/nscr_s1n601dsyhjhm39__th0000gn/T/ipykernel_1728/1101813449.py:161: RuntimeWarning: overflow encountered in ubyte_scalars\n",
      "  ssd_temp = left[y+v, x+u] - right[y+v,right_w+u]\n",
      "/var/folders/fm/nscr_s1n601dsyhjhm39__th0000gn/T/ipykernel_1728/1101813449.py:162: RuntimeWarning: overflow encountered in ubyte_scalars\n",
      "  current_ssd += ssd_temp * ssd_temp\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Processing.. 99% completethe root mean squre is: 16.870386424972235\n",
      "The fractions of pixels with the error less than 4 is: 0.5812204335840452\n",
      "The fractions of pixels with the error less than 2 is: 0.4993136620948621\n",
      "The fractions of pixels with the error less than 1 is: 0.37478587391802515\n",
      "The fractions of pixels with the error less than 0.5 is: 0.23419437543250632\n",
      "The fractions of pixels with the error less than 0.25 is: 0.1304268908325676\n",
      "The computation time is:1666445416.38239\n"
     ]
    }
   ],
   "source": [
    "#import the image with its filepath\n",
    "ssd_acc2_result11 = ComputeDisparity(\"./Dataset/2018-07-09-16-11-56_2018-07-09-16-11-56-702-left.jpg\",\n",
    "                         \"./Dataset/2018-07-09-16-11-56_2018-07-09-16-11-56-702-right.jpg\", \n",
    "                         \"./Dataset/2018-07-09-16-11-56_2018-07-09-16-11-56-702-disparity.png\")\n",
    "ssd_acc2_result11.compute_ssd_disparity_acc2(11,70)\n",
    "ssd_acc2_result11.analysis()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "61f6a354",
   "metadata": {},
   "source": [
    "## The result of using accelerated(by restricting search area attempt) SSD function with window size 15"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "706147ff",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\r",
      "Processing.. 1% complete"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/var/folders/fm/nscr_s1n601dsyhjhm39__th0000gn/T/ipykernel_1728/409812648.py:161: RuntimeWarning: overflow encountered in ubyte_scalars\n",
      "  ssd_temp = left[y+v, x+u] - right[y+v,right_w+u]\n",
      "/var/folders/fm/nscr_s1n601dsyhjhm39__th0000gn/T/ipykernel_1728/409812648.py:162: RuntimeWarning: overflow encountered in ubyte_scalars\n",
      "  current_ssd += ssd_temp * ssd_temp\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Processing.. 99% completethe root mean squre is: 16.676194032016095\n",
      "The fractions of pixels with the error less than 4 is: 0.6185436023097256\n",
      "The fractions of pixels with the error less than 2 is: 0.5236814938343033\n",
      "The fractions of pixels with the error less than 1 is: 0.3879907883243145\n",
      "The fractions of pixels with the error less than 0.5 is: 0.2408422103483874\n",
      "The fractions of pixels with the error less than 0.25 is: 0.13456760711976312\n",
      "The computation time is:1666453118.4759521\n"
     ]
    }
   ],
   "source": [
    "#import the image with its filepath\n",
    "ssd_acc2_result15 = ComputeDisparity(\"./Dataset/2018-07-09-16-11-56_2018-07-09-16-11-56-702-left.jpg\",\n",
    "                         \"./Dataset/2018-07-09-16-11-56_2018-07-09-16-11-56-702-right.jpg\", \n",
    "                         \"./Dataset/2018-07-09-16-11-56_2018-07-09-16-11-56-702-disparity.png\")\n",
    "ssd_acc2_result15.compute_ssd_disparity_acc2(15,70)\n",
    "ssd_acc2_result15.analysis()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2986d6db",
   "metadata": {},
   "source": [
    "# Result of different Algorithm "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "005dad14",
   "metadata": {},
   "source": [
    "## The result of using accelerated(by restricting search area attempt) NCC function with window size 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "af474d13",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Processing.. 99% completethe root mean squre is: 24.720734627300093\n",
      "The fractions of pixels with the error less than 4 is: 0.1282033829084845\n",
      "The fractions of pixels with the error less than 2 is: 0.06368761982552269\n",
      "The fractions of pixels with the error less than 1 is: 0.03235430918104573\n",
      "The fractions of pixels with the error less than 0.5 is: 0.015394389045820146\n",
      "The fractions of pixels with the error less than 0.25 is: 0.007464633745136076\n",
      "The computation time is:568.5074129104614\n",
      "\n"
     ]
    }
   ],
   "source": [
    "#import the image with its filepath\n",
    "image_acc_ncc3 = ComputeDisparity(\"./Dataset/2018-07-09-16-11-56_2018-07-09-16-11-56-702-left.jpg\",\n",
    "                         \"./Dataset/2018-07-09-16-11-56_2018-07-09-16-11-56-702-right.jpg\", \n",
    "                         \"./Dataset/2018-07-09-16-11-56_2018-07-09-16-11-56-702-disparity.png\")\n",
    "dis_map = image_acc_ncc3.compute_ncc_disparity_acc(3,70)\n",
    "image_acc_ncc3.analysis()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bcb1b24e",
   "metadata": {},
   "source": [
    "## The result of using accelerated(by restricting search area attempt) NCC function with window size 7"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "9e3b4e09",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\r",
      "Processing.. 0% complete"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/var/folders/fm/nscr_s1n601dsyhjhm39__th0000gn/T/ipykernel_1728/409812648.py:310: RuntimeWarning: overflow encountered in ubyte_scalars\n",
      "  ncc_temp = left[y+v, x+u] * right[y+v, right_w+u]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Processing.. 99% completethe root mean squre is: 25.372860719871486\n",
      "The fractions of pixels with the error less than 4 is: 0.12447106603591646\n",
      "The fractions of pixels with the error less than 2 is: 0.06170234489330565\n",
      "The fractions of pixels with the error less than 1 is: 0.0320593540482592\n",
      "The fractions of pixels with the error less than 0.5 is: 0.014838512064799374\n",
      "The fractions of pixels with the error less than 0.25 is: 0.006920101192299402\n",
      "The computation time is:2020.4963929653168\n"
     ]
    }
   ],
   "source": [
    "#import the image with its filepath\n",
    "image_acc_ncc7 = ComputeDisparity(\"./Dataset/2018-07-09-16-11-56_2018-07-09-16-11-56-702-left.jpg\",\n",
    "                         \"./Dataset/2018-07-09-16-11-56_2018-07-09-16-11-56-702-right.jpg\", \n",
    "                         \"./Dataset/2018-07-09-16-11-56_2018-07-09-16-11-56-702-disparity.png\")\n",
    "dis_map = image_acc_ncc7.compute_ncc_disparity_acc(7,70)\n",
    "#image1.compute_sgbm_disparity()\n",
    "image_acc_ncc7.analysis()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d3b4eebc",
   "metadata": {},
   "source": [
    "## The result of using accelerated(by restricting search area attempt) ZSSD function with window size 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "8ec1fe21",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-10-21T05:45:09.620916Z",
     "start_time": "2022-10-21T05:10:48.567581Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Processing.. 99% completethe root mean squre is: 21.176494069533444\n",
      "The fractions of pixels with the error less than 4 is: 0.37430940793429307\n",
      "The fractions of pixels with the error less than 2 is: 0.2976551066943471\n",
      "The fractions of pixels with the error less than 1 is: 0.2078526131890322\n",
      "The fractions of pixels with the error less than 0.5 is: 0.1230416680847202\n",
      "The fractions of pixels with the error less than 0.25 is: 0.06599053874689446\n",
      "The computation time is:1666330300.1154158\n"
     ]
    }
   ],
   "source": [
    "#import the image with its filepath\n",
    "image_zssd3 = ComputeDisparity(\"./Dataset/2018-07-09-16-11-56_2018-07-09-16-11-56-702-left.jpg\",\n",
    "                         \"./Dataset/2018-07-09-16-11-56_2018-07-09-16-11-56-702-right.jpg\", \n",
    "                         \"./Dataset/2018-07-09-16-11-56_2018-07-09-16-11-56-702-disparity.png\")\n",
    "image_zssd_map = image_zssd3.compute_zssd_disparity(3,70)\n",
    "#image1.compute_sgbm_disparity()\n",
    "image_zssd3.analysis()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4293ca22",
   "metadata": {},
   "source": [
    "## The result of using accelerated(by restricting search area attempt) ZSSD function with window size 15"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "8187e638",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\r",
      "Processing.. 1% complete"
     ]
    },
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "Input \u001b[0;32mIn [47]\u001b[0m, in \u001b[0;36m<cell line: 5>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[38;5;66;03m#import the image with its filepath\u001b[39;00m\n\u001b[1;32m      2\u001b[0m image_zssd15 \u001b[38;5;241m=\u001b[39m ComputeDisparity(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m./Dataset/2018-07-09-16-11-56_2018-07-09-16-11-56-702-left.jpg\u001b[39m\u001b[38;5;124m\"\u001b[39m,\n\u001b[1;32m      3\u001b[0m                          \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m./Dataset/2018-07-09-16-11-56_2018-07-09-16-11-56-702-right.jpg\u001b[39m\u001b[38;5;124m\"\u001b[39m, \n\u001b[1;32m      4\u001b[0m                          \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m./Dataset/2018-07-09-16-11-56_2018-07-09-16-11-56-702-disparity.png\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[0;32m----> 5\u001b[0m image_zssd_map \u001b[38;5;241m=\u001b[39m \u001b[43mimage_zssd15\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcompute_zssd_disparity\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m15\u001b[39;49m\u001b[43m,\u001b[49m\u001b[38;5;241;43m70\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[1;32m      6\u001b[0m \u001b[38;5;66;03m#image1.compute_sgbm_disparity()\u001b[39;00m\n\u001b[1;32m      7\u001b[0m image_zssd15\u001b[38;5;241m.\u001b[39manalysis()\n",
      "Input \u001b[0;32mIn [44]\u001b[0m, in \u001b[0;36mComputeDisparity.compute_zssd_disparity\u001b[0;34m(self, kernel, search_range)\u001b[0m\n\u001b[1;32m    251\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m v \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(\u001b[38;5;241m-\u001b[39mkernel_half, kernel_half\u001b[38;5;241m+\u001b[39m\u001b[38;5;241m1\u001b[39m):\n\u001b[1;32m    252\u001b[0m     \u001b[38;5;28;01mfor\u001b[39;00m u \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(\u001b[38;5;241m-\u001b[39mkernel_half, kernel_half\u001b[38;5;241m+\u001b[39m\u001b[38;5;241m1\u001b[39m):\n\u001b[0;32m--> 253\u001b[0m         ssd_temp \u001b[38;5;241m=\u001b[39m (\u001b[43mleft\u001b[49m\u001b[43m[\u001b[49m\u001b[43my\u001b[49m\u001b[38;5;241;43m+\u001b[39;49m\u001b[43mv\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mx\u001b[49m\u001b[38;5;241;43m+\u001b[39;49m\u001b[43mu\u001b[49m\u001b[43m]\u001b[49m\u001b[38;5;241;43m-\u001b[39;49m\u001b[43mleft_mean\u001b[49m) \u001b[38;5;241m-\u001b[39m (right[y\u001b[38;5;241m+\u001b[39mv,right_w\u001b[38;5;241m+\u001b[39mu]\u001b[38;5;241m-\u001b[39mright_mean)\n\u001b[1;32m    254\u001b[0m         ssd \u001b[38;5;241m+\u001b[39m\u001b[38;5;241m=\u001b[39m ssd_temp \u001b[38;5;241m*\u001b[39m ssd_temp\n\u001b[1;32m    256\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m ssd \u001b[38;5;241m<\u001b[39m smallest_ssd:\n",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "#import the image with its filepath\n",
    "image_zssd15 = ComputeDisparity(\"./Dataset/2018-07-09-16-11-56_2018-07-09-16-11-56-702-left.jpg\",\n",
    "                         \"./Dataset/2018-07-09-16-11-56_2018-07-09-16-11-56-702-right.jpg\", \n",
    "                         \"./Dataset/2018-07-09-16-11-56_2018-07-09-16-11-56-702-disparity.png\")\n",
    "image_zssd_map = image_zssd15.compute_zssd_disparity(15,70)\n",
    "#image1.compute_sgbm_disparity()\n",
    "image_zssd15.analysis()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ff75912b",
   "metadata": {},
   "source": [
    "# Guassian Blur"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "206cc8a6",
   "metadata": {},
   "source": [
    "## The result of using accelerated(by restricting search area attempt) SSD function with window size 3 with Guassian kernel"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "905af368",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-10-21T04:45:19.715568Z",
     "start_time": "2022-10-21T04:34:11.131916Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\r\n",
      "Processing.. 0% complete"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\Sibo\\.conda\\envs\\CV\\lib\\site-packages\\ipykernel_launcher.py:133: RuntimeWarning: overflow encountered in ubyte_scalars\n",
      "C:\\Users\\Sibo\\.conda\\envs\\CV\\lib\\site-packages\\ipykernel_launcher.py:134: RuntimeWarning: overflow encountered in ubyte_scalars\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Processing.. 99% completethe root mean squre is: 19.007878041932518\n",
      "The fractions of pixels with the error less than 4 is: 0.41073636683342973\n",
      "The fractions of pixels with the error less than 2 is: 0.31683853475365575\n",
      "The fractions of pixels with the error less than 1 is: 0.2144096926794405\n",
      "The fractions of pixels with the error less than 0.5 is: 0.12503828744512133\n",
      "The fractions of pixels with the error less than 0.25 is: 0.06665986000975621\n",
      "The computation time is:1666326710.2070978\n"
     ]
    }
   ],
   "source": [
    "#import the image with its filepath\n",
    "ssd_gua = ComputeDisparity(\"./Dataset/2018-07-09-16-11-56_2018-07-09-16-11-56-702-left.jpg\",\n",
    "                         \"./Dataset/2018-07-09-16-11-56_2018-07-09-16-11-56-702-right.jpg\", \n",
    "                         \"./Dataset/2018-07-09-16-11-56_2018-07-09-16-11-56-702-disparity.png\")\n",
    "ssd_gua_map = ssd_gua.compute_ssd_disparity_withGua(3,70)\n",
    "#image1.compute_sgbm_disparity()\n",
    "ssd_gua.analysis()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c8e7e3c0",
   "metadata": {},
   "source": [
    "## The result of using accelerated(by restricting search area attempt) SSD function with window size 15 with Guassian kernel"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "4d040198",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\r",
      "Processing.. 1% complete"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/var/folders/fm/nscr_s1n601dsyhjhm39__th0000gn/T/ipykernel_1728/3875852866.py:372: RuntimeWarning: overflow encountered in ubyte_scalars\n",
      "  ssd_temp = left[y+v, x+u] - right[y+v,right_w+u]\n",
      "/var/folders/fm/nscr_s1n601dsyhjhm39__th0000gn/T/ipykernel_1728/3875852866.py:373: RuntimeWarning: overflow encountered in ubyte_scalars\n",
      "  current_ssd += ssd_temp * ssd_temp\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Processing.. 99% completethe root mean squre is: 16.210511741329473\n",
      "The fractions of pixels with the error less than 4 is: 0.6197801449817922\n",
      "The fractions of pixels with the error less than 2 is: 0.4807428331574947\n",
      "The fractions of pixels with the error less than 1 is: 0.2867077334966931\n",
      "The fractions of pixels with the error less than 0.5 is: 0.15086955042031105\n",
      "The fractions of pixels with the error less than 0.25 is: 0.07828789889845603\n",
      "The computation time is:1666465579.1001868\n"
     ]
    }
   ],
   "source": [
    "#import the image with its filepath\n",
    "ssd_gua15 = ComputeDisparity(\"./Dataset/2018-07-09-16-11-56_2018-07-09-16-11-56-702-left.jpg\",\n",
    "                         \"./Dataset/2018-07-09-16-11-56_2018-07-09-16-11-56-702-right.jpg\", \n",
    "                         \"./Dataset/2018-07-09-16-11-56_2018-07-09-16-11-56-702-disparity.png\")\n",
    "ssd_gua15_map = ssd_gua15.compute_ssd_disparity_withGua(15,70)\n",
    "#image1.compute_sgbm_disparity()\n",
    "ssd_gua15.analysis()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "59d8d922",
   "metadata": {},
   "source": [
    "# Smooth"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "05c034cc",
   "metadata": {},
   "source": [
    "## The result of using accelerated(by restricting search area attempt) SSD function with window size 3 with Guassian kernel and Smooth map "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "66f3c81f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Processing.. 99% completethe root mean squre is: 18.126510383655095\n",
      "The fractions of pixels with the error less than 4 is: 0.4407991015212878\n",
      "The fractions of pixels with the error less than 2 is: 0.34227274274240205\n",
      "The fractions of pixels with the error less than 1 is: 0.22806838421309375\n",
      "The fractions of pixels with the error less than 0.5 is: 0.1311189009517975\n",
      "The fractions of pixels with the error less than 0.25 is: 0.06962075576580562\n",
      "The computation time is:1666442064.4756658\n",
      "\n"
     ]
    }
   ],
   "source": [
    "#import the image with its filepath\n",
    "image_3smooth = ComputeDisparity(\"./Dataset/2018-07-09-16-11-56_2018-07-09-16-11-56-702-left.jpg\",\n",
    "                         \"./Dataset/2018-07-09-16-11-56_2018-07-09-16-11-56-702-right.jpg\", \n",
    "                         \"./Dataset/2018-07-09-16-11-56_2018-07-09-16-11-56-702-disparity.png\")\n",
    "image_3smooth_map = image_3smooth.compute_ssd_disparity_acc2(3,70)\n",
    "image_3smooth_map_2 = image_3smooth.compute_ssd_disparity_smooth(3, 70, image_3smooth_map, 0.5)\n",
    "image_3smooth.analysis()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "10a1c28d",
   "metadata": {},
   "source": [
    "## The result of using accelerated(by restricting search area attempt) SSD function with window size 11 with Guassian kernel and Smooth map "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "64c08c7f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\r",
      "Processing.. 1% complete"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/var/folders/fm/nscr_s1n601dsyhjhm39__th0000gn/T/ipykernel_1728/353087008.py:163: RuntimeWarning: overflow encountered in ubyte_scalars\n",
      "  ssd_temp = left[y+v, x+u] - right[y+v,right_w+u]\n",
      "/var/folders/fm/nscr_s1n601dsyhjhm39__th0000gn/T/ipykernel_1728/353087008.py:164: RuntimeWarning: overflow encountered in ubyte_scalars\n",
      "  current_ssd += ssd_temp * ssd_temp\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Smoothing.. 1% completete"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/var/folders/fm/nscr_s1n601dsyhjhm39__th0000gn/T/ipykernel_1728/353087008.py:430: RuntimeWarning: overflow encountered in ubyte_scalars\n",
      "  ssd_temp = left[y+v, x+u] - right[y+v,right_w+u]\n",
      "/var/folders/fm/nscr_s1n601dsyhjhm39__th0000gn/T/ipykernel_1728/353087008.py:431: RuntimeWarning: overflow encountered in ubyte_scalars\n",
      "  ssd += ssd_temp * ssd_temp\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Smoothing.. 99% completethe root mean squre is: 16.500493281377974\n",
      "The fractions of pixels with the error less than 4 is: 0.5888665781801268\n",
      "The fractions of pixels with the error less than 2 is: 0.48090165515207206\n",
      "The fractions of pixels with the error less than 1 is: 0.3064130052524702\n",
      "The fractions of pixels with the error less than 0.5 is: 0.16571940691329454\n",
      "The fractions of pixels with the error less than 0.25 is: 0.08501514481162577\n",
      "The computation time is:1666459601.738912\n"
     ]
    }
   ],
   "source": [
    "#import the image with its filepath\n",
    "image_smooth = ComputeDisparity(\"./Dataset/2018-07-09-16-11-56_2018-07-09-16-11-56-702-left.jpg\",\n",
    "                         \"./Dataset/2018-07-09-16-11-56_2018-07-09-16-11-56-702-right.jpg\", \n",
    "                         \"./Dataset/2018-07-09-16-11-56_2018-07-09-16-11-56-702-disparity.png\")\n",
    "image_smooth_map = image_smooth.compute_ssd_disparity_acc2(11,70)\n",
    "image_smooth_map_2 = image_smooth.compute_ssd_disparity_smooth(11, 70, image_smooth_map, 0.5)\n",
    "#image1.compute_sgbm_disparity()\n",
    "image_smooth.analysis()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "76e85a6d",
   "metadata": {},
   "source": [
    "## The result of using accelerated(by restricting search area attempt) SSD function with window size 15 with Guassian kernel and Smooth map "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "30b65420",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Smoothing.. 99% completethe root mean squre is: 16.21689056345499\n",
      "The fractions of pixels with the error less than 4 is: 0.6213797093557499\n",
      "The fractions of pixels with the error less than 2 is: 0.4833066739271007\n",
      "The fractions of pixels with the error less than 1 is: 0.2883980532961236\n",
      "The fractions of pixels with the error less than 0.5 is: 0.15194727109780032\n",
      "The fractions of pixels with the error less than 0.25 is: 0.07863957617216304\n",
      "The computation time is:1666465459.183312\n",
      "\n"
     ]
    }
   ],
   "source": [
    "#import the image with its filepath\n",
    "image_smooth15 = ComputeDisparity(\"./Dataset/2018-07-09-16-11-56_2018-07-09-16-11-56-702-left.jpg\",\n",
    "                         \"./Dataset/2018-07-09-16-11-56_2018-07-09-16-11-56-702-right.jpg\", \n",
    "                         \"./Dataset/2018-07-09-16-11-56_2018-07-09-16-11-56-702-disparity.png\")\n",
    "image_smooth_map15 = image_smooth15.compute_ssd_disparity_acc2(15,70)\n",
    "image_smooth_map15_2 = image_smooth15.compute_ssd_disparity_smooth(15, 70, image_smooth_map, 0.5)\n",
    "image_smooth15.analysis()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0fd09b3f",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ddaafb46",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d81eb656",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d12397ee",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9.13"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}