implementation_logic_without_Ui/hough_transformation/hough_line---from-another-contributor.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "a413ecb7",
   "metadata": {},
   "source": [
    "# Lab 02 - Road Lines and Street Signs Detection with the Hough Transform\n",
    "\n",
    "Computer Vision 2023-24 (M. Caligiuri, F. Lincetto, P. Zanuttigh)\n",
    "\n",
    "In this lab you will explore the topic of line and circle detection using the Hough transform. In particular you will use this technique to segment the street lanes and the round street signs from the provided images.\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3f300f03",
   "metadata": {},
   "source": [
    "## Import the necessary libraries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "84e064f4-1110-48b6-80bb-5ce18761162a",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-12-11T09:45:49.932308023Z",
     "start_time": "2023-12-11T09:45:49.035207217Z"
    }
   },
   "outputs": [],
   "source": [
    "# Import the necessary packages\n",
    "%matplotlib inline\n",
    "\n",
    "import typing as tp\n",
    "import numpy as np\n",
    "import cv2 as cv\n",
    "from matplotlib import pyplot as plt\n",
    "from pathlib import Path"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "240c486d",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a7d4904f",
   "metadata": {},
   "source": [
    "## Define some auxiliary functions\n",
    "\n",
    "Write here all the auxiliary functions you will need.\n",
    "More precisely the following functions are provided:\n",
    "- `show_img` -> given in input an image and optionally a title it will plot the image as a matplotlib plot performing also the necessary conversion from BGR to RGB,\n",
    "- `polar2cartesian` -> given an array of angles and one of radius it will return the corresponding cartesian coordinates as numpy arrays,\n",
    "- `draw_lines` -> given in input an image and a set of lines it will draw the lines on the image and return the resulting image,\n",
    "- `fill_lines` -> given in input an image and the mask of the lines it will fill the lines with a given color and return the resulting image,\n",
    "- `check_param` -> given a list of value in imput check that none of them is less or equal to 0, returns a list containing the same values apart from the negative ones that will be set to 1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "bfe52fc7",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-12-11T09:45:49.988482871Z",
     "start_time": "2023-12-11T09:45:49.974217520Z"
    }
   },
   "outputs": [],
   "source": [
    "# Function to plot images inline in the notebook\n",
    "def show_img(img, title=None):\n",
    "    #Check if the image is in BGR format and convert it to RGB\n",
    "    if len(img.shape) == 3 and img.shape[2] == 3:\n",
    "        img = cv.cvtColor(img, cv.COLOR_BGR2RGB)\n",
    "\n",
    "    #Plot the image\n",
    "    plt.figure(figsize=(10,5)) \n",
    "    plt.imshow(img)\n",
    "    if title:\n",
    "        plt.title(title)\n",
    "    plt.axis('off')\n",
    "    plt.tight_layout()\n",
    "    plt.show()\n",
    "    plt.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "e22a27a9",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-12-11T09:45:49.988916486Z",
     "start_time": "2023-12-11T09:45:49.974765799Z"
    }
   },
   "outputs": [],
   "source": [
    "# Function to perform the conversion between polar and cartesian coordinates\n",
    "def polar2cartesian(radius: np.ndarray, angle: np.ndarray, cv2_setup: bool = True) -> np.ndarray:\n",
    "    if cv2_setup:\n",
    "        return radius * np.array([np.cos(angle), np.sin(angle)])\n",
    "    else:\n",
    "        return radius * np.array([np.sin(angle), np.cos(angle)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "a4c82e7b",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-12-11T09:45:49.989189942Z",
     "start_time": "2023-12-11T09:45:49.975260467Z"
    }
   },
   "outputs": [],
   "source": [
    "#Funtion to add lines to an image\n",
    "def draw_lines(img: np.ndarray, lines: np.ndarray, color: tp.List[int] = [0, 0, 255], thickness: int = 1, cv2_setup: bool = True) -> tp.Tuple[np.ndarray]:\n",
    "    new_image = np.copy(img)\n",
    "    empty_image = np.zeros(img.shape[:2])\n",
    "\n",
    "    if len(lines.shape) == 1:\n",
    "        lines = lines[None, ...]\n",
    "\n",
    "    # Draw found lines\n",
    "    for rho, theta in lines:\n",
    "        x0 = polar2cartesian(rho, theta, cv2_setup)\n",
    "        direction = np.array([x0[1], -x0[0]])\n",
    "        pt1 = np.round(x0 + 1000*direction).astype(int)\n",
    "        pt2 = np.round(x0 - 1000*direction).astype(int)\n",
    "        empty_image = cv.line(img=empty_image,pt1=pt1, pt2=pt2, color=255, thickness=thickness)\n",
    "\n",
    "    # Keep lower part of each line until intersection\n",
    "    mask_lines = empty_image != 0\n",
    "    min_diff = np.inf\n",
    "    max_line = 0\n",
    "    for i in range(mask_lines.shape[0]):\n",
    "        line = mask_lines[i]\n",
    "        indices = np.argwhere(line)\n",
    "        if indices[-1] - indices[0] < min_diff:\n",
    "            min_diff = indices[-1] - indices[0]\n",
    "            max_line = i\n",
    "\n",
    "    mask_boundaries = np.zeros_like(empty_image)\n",
    "    mask_boundaries[max_line:] = 1\n",
    "    mask = (mask_lines * mask_boundaries).astype(bool)\n",
    "\n",
    "    new_image[mask] = np.array(color)\n",
    "    \n",
    "    return new_image, mask"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "19dcc3d4",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-12-11T09:45:49.989426265Z",
     "start_time": "2023-12-11T09:45:49.975865081Z"
    }
   },
   "outputs": [],
   "source": [
    "# Function that given the image and the mask of the lines, fill the area between the lines\n",
    "def fill_lines(img: np.ndarray, mask: np.ndarray, color: tp.List[int] = [0, 0, 255]) -> np.ndarray:\n",
    "    border = np.where(mask)\n",
    "\n",
    "    possible_vertex = np.where(border[0] == np.min(border[0]))\n",
    "    vertex = np.array([border[0][int(len(possible_vertex[0]) / 2)], border[1][int(len(possible_vertex[0]) / 2)]])[::-1]\n",
    "\n",
    "    possible_bottom = np.where(border[0] == np.max(border[0]))\n",
    "    bottom_pos = [np.min(possible_bottom[0]), np.max(possible_bottom[0])]\n",
    "    bottom_left = np.array([border[0][bottom_pos[0]], border[1][bottom_pos[0]]])[::-1]\n",
    "    bottom_right = np.array([border[0][bottom_pos[1]], border[1][bottom_pos[1]]])[::-1]\n",
    "    points = np.array([vertex, bottom_left, bottom_right])\n",
    "\n",
    "    return cv.fillConvexPoly(np.copy(img), points=points, color=color)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "21a38d4f",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-12-11T09:45:49.989659355Z",
     "start_time": "2023-12-11T09:45:49.976326268Z"
    }
   },
   "outputs": [],
   "source": [
    "check_params = lambda x: [i if i > 0 else 1 for i in x]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1c9310fc",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a4f2a721-2a29-4db6-a70e-c192aec7b6b8",
   "metadata": {},
   "source": [
    "## Road lines Detection\n",
    "\n",
    "In this section you have to implement the road detection using the Hough transform together with the Canny algorithm."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6bffd112-6500-41f8-adfa-45738a154558",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-12-11T09:45:50.547286446Z",
     "start_time": "2023-12-11T09:45:49.976748541Z"
    }
   },
   "outputs": [],
   "source": [
    "# Load image (img path './data/road2.png')\n",
    "image_folder = Path('./data')\n",
    "image_name = 'road2.png'\n",
    "image_path = image_folder / image_name\n",
    "# Open the image\n",
    "image = cv.imread(str(image_path))\n",
    "\n",
    "grey_image = cv.cvtColor(image, cv.COLOR_BGR2GRAY);\n",
    "# Show the image\n",
    "# Suggestion: to show the image inline use the function show_img()\n",
    "show_img(image)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "38239977",
   "metadata": {},
   "source": [
    "### Edge extraction using the Canny algorithm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "1a5e3de0",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-12-11T09:45:51.598610458Z",
     "start_time": "2023-12-11T09:45:50.545316778Z"
    }
   },
   "outputs": [],
   "source": [
    "#Create a cv window with two trackbars to change the thresholds values of the Canny algorithm\n",
    "# Using the trackbars choose the best thresholds values to extract the edges of the road\n",
    "# Print also the best parameters\n",
    "win_name = 'CannyParameters'\n",
    "\n",
    "cv.namedWindow(win_name)\n",
    "max_th = 1000\n",
    "\n",
    "class CannyFilter:\n",
    "    def __init__(self, tl, th):\n",
    "        self.th = th\n",
    "        self.tl = tl\n",
    "        \n",
    "    def set_th(self, val):\n",
    "        #if self.th >= self.tl:\n",
    "        self.th = val\n",
    "        \n",
    "    def set_tl(self, val):\n",
    "        #if self.tl <= self.th:\n",
    "        self.tl = val\n",
    "    \n",
    "    def get_th(self):\n",
    "        return self.th\n",
    "    \n",
    "    def get_tl(self):\n",
    "        return self.tl\n",
    "    \n",
    "    def __call__(self, image, tl: float, th: float):\n",
    "        self.set_th(th)\n",
    "        self.set_tl(tl)\n",
    "        return cv.Canny(image, self.get_tl(), self.get_th(), 4)\n",
    "        \n",
    "filter = CannyFilter(600, 900)\n",
    "canny_edges = filter(grey_image, filter.get_tl(), filter.get_th())\n",
    "\n",
    "cv.createTrackbar('threshold_1', win_name, filter.get_tl(), max_th, lambda x: cv.imshow(win_name,filter(grey_image, x, filter.get_th())))\n",
    "cv.createTrackbar('threshold_2', win_name, filter.get_th(), max_th, lambda x: cv.imshow(win_name, filter(grey_image, filter.get_tl(), x)))\n",
    "\n",
    "cv.imshow(win_name, canny_edges)\n",
    "cv.waitKey(0)\n",
    "cv.destroyAllWindows()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "baec9ad4f1e247df",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-12-11T09:45:51.605390558Z",
     "start_time": "2023-12-11T09:45:51.542244784Z"
    },
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "best_tl = 634\n",
    "best_th = 854\n",
    "print(f'tl={best_tl}, th={best_th}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e58bef97",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-12-11T09:45:51.885617179Z",
     "start_time": "2023-12-11T09:45:51.552532453Z"
    }
   },
   "outputs": [],
   "source": [
    "#Visualize the result of the Canny algorithm with the best thresholds values\n",
    "# Suggestions: use the function show_img() and check that the edges are suitable for the next step (see the example on the slides)\n",
    "\n",
    "best_canny_res = cv.Canny(grey_image, best_tl, best_th, 7)\n",
    "show_img(best_canny_res, 'Result of Canny edge detector')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "28572b6d",
   "metadata": {},
   "source": [
    "### Hough transform to detect lines"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b7d4621f",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-12-11T09:45:52.564104415Z",
     "start_time": "2023-12-11T09:45:51.892941373Z"
    }
   },
   "outputs": [],
   "source": [
    "# Create a window with a set of trackbars to change the parameters of the Hough transform\n",
    "# Using the trackbars choose the best parameters to find the lines of the road\n",
    "win_name = 'Hough_transform'\n",
    "\n",
    "theta = np.pi/180\n",
    "rho = 1\n",
    "threshold = 100\n",
    "min_theta = 0\n",
    "max_theta = np.pi\n",
    "\n",
    "hough_params = [rho, theta, threshold, min_theta, max_theta]\n",
    "\n",
    "cv.namedWindow(win_name)\n",
    "\n",
    "def updateParam(val, index):\n",
    "    if index != 2 and index != 0:\n",
    "        hough_params[index] = val / 1000.\n",
    "    else:\n",
    "        hough_params[index] = val\n",
    "       \n",
    "    lines = cv.HoughLines(best_canny_res, hough_params[0], hough_params[1], hough_params[2], None, 0, 0, hough_params[3], hough_params[4])\n",
    "\n",
    "    if lines is not None:\n",
    "        lines = np.squeeze(lines, axis=1)\n",
    "        result, _ = draw_lines(image, lines)\n",
    "        cv.imshow(win_name, result)\n",
    "        \n",
    "\n",
    "cv.createTrackbar('rho', win_name, int(hough_params[0] * 10), 20, lambda x: updateParam(x, 0))\n",
    "cv.createTrackbar('theta * 100', win_name, int(hough_params[1] * 1000), int(np.pi * 1000), lambda x: updateParam(x, 1))\n",
    "cv.createTrackbar('threshold', win_name, hough_params[2], 200, lambda x: updateParam(x, 2))\n",
    "cv.createTrackbar('min_theta * 100', win_name, int(hough_params[3] * 1000), int(np.pi * 1000), lambda x: updateParam(x, 3))\n",
    "cv.createTrackbar('max_theta * 100', win_name, int(hough_params[4] * 1000), int(np.pi * 1000), lambda x: updateParam(x, 4))\n",
    "\n",
    "cv.imshow(win_name, image)\n",
    "cv.waitKey(0)\n",
    "cv.destroyAllWindows()\n",
    "\n",
    "print(hough_params)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "96f1032d",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-12-11T09:45:53.525705485Z",
     "start_time": "2023-12-11T09:45:52.504929675Z"
    }
   },
   "outputs": [],
   "source": [
    "# Visualize the result of the Hough transform with the best parameters\n",
    "rho = 9\n",
    "theta = 0.261\n",
    "threshold = 101\n",
    "min_theta = 0\n",
    "max_theta = np.pi\n",
    "\n",
    "lines = cv.HoughLines(best_canny_res, rho, theta, threshold, None, 0, 0)\n",
    "print(lines)\n",
    "lines = np.squeeze(lines, axis=1)\n",
    "\n",
    "result, mask = draw_lines(image, lines)\n",
    "\n",
    "show_img(result, 'Hough Result Lines')\n",
    "\n",
    "# Color all the pixel inside the lines in red (you can use the provided fill_lines function)\n",
    "filled_image = fill_lines(result, mask)\n",
    "\n",
    "show_img(filled_image, 'Hough Result Filled')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2d0dc3e4-ec2d-444b-a630-df450666ae0b",
   "metadata": {},
   "source": [
    "### Custom implementation of the Hough Transform\n",
    "\n",
    "Now try to implement the Hough transform by yourself. You can use the following steps as a guide:\n",
    "1. Define the discretization of the parameter space (i.e. the accumulator) and initialize the accumulator matrix to zero,\n",
    "2. For each edge point in the image:\n",
    "    - For each angle in the discretization:\n",
    "        1. Compute the corresponding radius,\n",
    "        2. Increment the accumulator at the corresponding position,\n",
    "3. Find the largest values in the accumulator,\n",
    "4. Get the corresponding angle and radius,\n",
    "5. Return the line corresponding to the angle and radius."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "7f6da642-953a-4fd5-abc7-c9685d157d6e",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-12-11T09:45:53.526136052Z",
     "start_time": "2023-12-11T09:45:53.498063101Z"
    }
   },
   "outputs": [],
   "source": [
    "rho = 9\n",
    "theta = 0.261\n",
    "threshold = 101\n",
    "\n",
    "# Define a function to perform the Hough transform and return the lines found\n",
    "def hough_lines(edges: np.ndarray, threshold: float, min_theta: float, max_theta: float) -> np.ndarray:\n",
    "    # Initialize the counter matrix in polar coordinates\n",
    "    diagonal = np.sqrt(image.shape[0]**2 + image.shape[1]**2)\n",
    "    \n",
    "    # Compute the values for the thetas and the rhos\n",
    "    theta_angles = np.arange(min_theta, max_theta, theta)\n",
    "    rho_values = np.arange(-diagonal, diagonal, rho)\n",
    "    # Compute the dimension of the accumulator matrix\n",
    "    num_thetas = len(theta_angles)\n",
    "    num_rhos = len(rho_values)\n",
    "    accumulator = np.zeros([num_rhos, num_thetas])\n",
    "    print('Accumulator shape (rhos x thetas):' + str(accumulator.shape))\n",
    "\n",
    "    # Pre-compute sin and cos\n",
    "    sins = np.sin(theta_angles)\n",
    "    coss = np.cos(theta_angles)\n",
    "    \n",
    "    # Consider edges only\n",
    "    xs, ys = np.where(edges > 0)\n",
    "    \n",
    "    for x,y in zip(xs,ys):\n",
    "        for t in range(num_thetas):\n",
    "            # compute the rhos for the given point for each theta\n",
    "            current_rho = x * coss[t] + y * sins[t]\n",
    "            # for each rho, compute the closest rho among the rho_values below it\n",
    "            # the index corresponding to that rho is the one we will increase\n",
    "            rho_pos = np.where(current_rho > rho_values)[0][-1]\n",
    "            #rho_pos = np.argmin(np.abs(current_rho - rho_values))\n",
    "            accumulator[rho_pos, t] += 1\n",
    "    \n",
    "    print(f'Accumulator matrix at the end', accumulator)\n",
    "    # Take the polar coordinates most matched\n",
    "    final_rho_index, final_theta_index = np.where(accumulator > threshold)\n",
    "    final_rho = rho_values[final_rho_index]    \n",
    "    final_theta = theta_angles[final_theta_index]\n",
    "    \n",
    "    polar_coordinates = np.vstack([final_rho, final_theta]).T\n",
    "    \n",
    "    #neg_coord = np.where(polar_coordinates[:,1] < 0)[0]\n",
    "    #polar_coordinates[neg_coord, 1] = polar_coordinates[neg_coord, 1] + np.pi\n",
    "    #polar_coordinates[neg_coord, 0] = -polar_coordinates[neg_coord, 0]\n",
    "    print('Final polar coordinates shape', polar_coordinates.shape)\n",
    "    print('Final polar coordinates\\n', polar_coordinates)\n",
    "    \n",
    "    return polar_coordinates\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4d306618-30ec-4a56-adf0-18e2cbed6910",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-12-11T09:45:54.314965838Z",
     "start_time": "2023-12-11T09:45:53.499994453Z"
    }
   },
   "outputs": [],
   "source": [
    "# Use the function to find the lines in the image\n",
    "lines = hough_lines(best_canny_res, threshold, -np.pi/2, np.pi/2)\n",
    "\n",
    "# Show the image with the lines found\n",
    "# Suggestions: use the function fill_lines() and show_img()\n",
    "lines_img, mask = draw_lines(image, lines, cv2_setup=False)\n",
    "show_img(lines_img)\n",
    "\n",
    "masked_img = fill_lines(lines_img, mask)\n",
    "show_img(masked_img)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "03fd225b",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "44931abd",
   "metadata": {},
   "source": [
    "835## Road signs detection using the Hough transform\n",
    "\n",
    "In this section you will implement the road signs detection using again the Hough transform.\n",
    "\n",
    "**N.B.** You can use the `cv.HoughCircles()` function (keep in mind that this function includes the edge extraction). Here no need to implement the Hough transform manually, just use openCV in this point.\n",
    "\n",
    "**N.B.** You can use the `cv.circle()` function to draw the circles on the image (set thickness = -1 to fill the circles)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "142a38e6",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-12-11T09:45:55.074561700Z",
     "start_time": "2023-12-11T09:45:54.313941335Z"
    }
   },
   "outputs": [],
   "source": [
    "# Convert the image to uint8 for the Hough transform algorithm\n",
    "#image = image.astype(np.uint8)\n",
    "#grey_image = cv.cvtColor(image, cv.COLOR_BGR2GRAY)\n",
    "\n",
    "hough_circle_params = [1.3, 30, 20, 4, 15]\n",
    "\n",
    "win_name = 'hough_circles'\n",
    "\n",
    "def update_circle_param(val, index):\n",
    "    scratch_img = image.astype(np.uint8)\n",
    "    if index != 0:\n",
    "        hough_circle_params[index] = val\n",
    "    else:\n",
    "        hough_circle_params[index] = val / 10.\n",
    "    \n",
    "    circles = cv.HoughCircles(grey_image, cv.HOUGH_GRADIENT, hough_circle_params[0], hough_circle_params[1], param1=best_th, param2=hough_circle_params[2], minRadius=hough_circle_params[3], maxRadius=hough_circle_params[4])\n",
    "    \n",
    "    if circles is not None:\n",
    "        # Convert circle coordinates to integers\n",
    "        circles = circles.astype(np.int32)\n",
    "        # Plot the circles over the scratch image we just created\n",
    "        for c in circles[0, :]:\n",
    "            cv.circle(scratch_img, (c[0], c[1]), c[2], (0,255,0), -1)\n",
    "        cv.imshow(win_name, scratch_img)\n",
    "\n",
    "# Create a window with a set of trackbars to change the parameters of the Hough transform\n",
    "# Using the trackbars choose the best parameters to find all the circle sign in the image\n",
    "cv.namedWindow(win_name)\n",
    "cv.createTrackbar('dp', win_name, int(hough_circle_params[0] * 10), 30, lambda x: update_circle_param(x, 0))\n",
    "cv.createTrackbar('minDist', win_name, hough_circle_params[1], 50, lambda x: update_circle_param(x, 1))\n",
    "cv.createTrackbar('threshold', win_name, hough_circle_params[2], 80, lambda x: update_circle_param(x, 2))\n",
    "cv.createTrackbar('minRadius', win_name, hough_circle_params[3], 50, lambda x: update_circle_param(x, 3))\n",
    "cv.createTrackbar('maxRadius', win_name, hough_circle_params[4], 50, lambda x: update_circle_param(x, 4))\n",
    "\n",
    "cv.imshow(win_name, image)\n",
    "cv.waitKey(0)\n",
    "cv.destroyAllWindows()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ace3e600",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-12-11T09:45:55.540319607Z",
     "start_time": "2023-12-11T09:45:55.066426756Z"
    }
   },
   "outputs": [],
   "source": [
    "# Visualize the result of the Hough transform with the best parameters\n",
    "best_circle_params = [1.3, 30, 20, 4, 15]\n",
    "\n",
    "scratch_img = filled_image.astype(np.uint8)\n",
    "\n",
    "circles = cv.HoughCircles(grey_image, cv.HOUGH_GRADIENT, hough_circle_params[0], hough_circle_params[1], param1=best_th, param2=hough_circle_params[2], minRadius=hough_circle_params[3], maxRadius=hough_circle_params[4])\n",
    "\n",
    "if circles is not None:\n",
    "    circles = circles.astype(np.int32)\n",
    "    for c in circles[0, :]:\n",
    "        cv.circle(scratch_img, (c[0], c[1]), c[2], (0,255,0), -1)\n",
    "        \n",
    "show_img(scratch_img, 'Lines and Circle Detection with Hough Transform')"
   ]
  }
 ],
 "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.11.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}