implementation_logic_without_Ui/hough_transformation/hough_circle.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import cv2 as cv \n",
    "import matplotlib.pyplot as plt \n",
    "import numpy as np \n",
    "from collections import defaultdict"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Edge Detection Step"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "image_path = '../test_images/hough_circle/coins02.jpeg'\n",
    "\n",
    "# Load the image\n",
    "image = cv.imread(image_path, cv.IMREAD_GRAYSCALE)\n",
    "\n",
    "# Apply Gaussian blur to reduce noise\n",
    "blurred = cv.GaussianBlur(image, (5, 5), 0)\n",
    "\n",
    "# Canny edge detection\n",
    "edges = cv.Canny(blurred, 50, 180)\n",
    "\n",
    "# Display the original image and the edges\n",
    "cv.imshow('Original Image', image)\n",
    "cv.imshow('Canny Edges', edges)\n",
    "cv.waitKey(0)\n",
    "cv.destroyAllWindows()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Hough Circle Detection Step"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "86 150 22 70\n",
      "171 124 18 67\n",
      "106 23 21 65\n",
      "40 34 18 65\n",
      "126 86 22 65\n",
      "68 104 22 64\n",
      "107 23 21 63\n",
      "126 85 22 62\n",
      "69 104 22 62\n",
      "39 34 18 59\n",
      "87 150 22 59\n",
      "107 24 22 58\n",
      "79 60 19 58\n",
      "26 76 22 58\n",
      "170 124 18 58\n",
      "78 59 19 56\n",
      "127 85 21 55\n",
      "157 49 21 54\n",
      "80 59 18 54\n",
      "192 73 18 54\n",
      "86 149 23 54\n",
      "170 123 19 53\n",
      "27 75 21 52\n",
      "24 76 21 52\n"
     ]
    }
   ],
   "source": [
    "#dp to control accumulator size, min_dist to control accepted circles according to the distance bet. their centers\n",
    "def hough_circle_transform(edge_image, min_radius, max_radius, accumulator_threshold, min_dist):\n",
    "    # Define Hough space dimensions based on edge_image size and radius range\n",
    "    height, width = edge_image.shape[:2]\n",
    "\n",
    "    # Define radius range for iteration\n",
    "    radii = np.arange(min_radius, max_radius + 1)\n",
    "\n",
    "    circle_candidates = []\n",
    "    for radius in radii:\n",
    "        for theta in np.linspace(0, 2*np.pi, 100):\n",
    "            circle_candidates.append((radius,int(radius * np.cos(theta)),int(radius * np.sin(theta))))\n",
    "\n",
    "    # Hough Accumulator, we are using defaultdic instead of standard dict as this will initialize for key which is not \n",
    "    # aready present in the dictionary instead of throwing exception.\n",
    "    accumulator = defaultdict(int)\n",
    "    \n",
    "    # Find edge pixels in the image to get (x,y) in image space\n",
    "    edge_pixels = np.argwhere(image > 0)\n",
    "    for y in range(height):\n",
    "        for x in range(width):\n",
    "            if edge_image[y][x] != 0: #white pixel (edge)\n",
    "                for r, r_cos, r_sin in circle_candidates:\n",
    "                    a = x - r_cos\n",
    "                    b = y - r_sin\n",
    "                    accumulator[(a, b, r)] += 1 #vote for current candidate\n",
    "\n",
    "    # Output image with detected lines drawn\n",
    "    output_img = image.copy()\n",
    "    # Output list of detected circles. A single circle would be a tuple of (x,y,r,threshold) \n",
    "    out_circles = []\n",
    "\n",
    "    # Sort the accumulator based on the votes for the candidate circles \n",
    "    for candidate_circle, votes in sorted(accumulator.items(), key=lambda i: -i[1]):\n",
    "        x, y, r = candidate_circle\n",
    "        current_vote = votes\n",
    "        if current_vote >= accumulator_threshold: \n",
    "            # Shortlist the circle for final result\n",
    "            out_circles.append((x, y, r, current_vote))\n",
    "            print(x, y, r, current_vote)\n",
    "\n",
    "    filtered_circles = []\n",
    "    for x, y, r, v in out_circles:\n",
    "    # Exclude circles that are too close of each other\n",
    "    # all((x - xc) ** 2 + (y - yc) ** 2 > rc ** 2 for xc, yc, rc, v in filtered_circles)\n",
    "    # Remove nearby duplicate circles based on min_dist\n",
    "        if all(abs(x - xc) > min_dist or abs(y - yc) > min_dist or abs(r - rc) > min_dist for xc, yc, rc, v in filtered_circles):\n",
    "            filtered_circles.append((x, y, r, v))\n",
    "    out_circles = filtered_circles\n",
    "\n",
    "    # Draw shortlisted circles on the output image\n",
    "    for x, y, r, v in out_circles:\n",
    "        output_img = cv.circle(output_img, (x,y), r, (0,255,0), 3)\n",
    "    \n",
    "    return output_img\n",
    "\n",
    "min_radius = 10\n",
    "max_radius = 80\n",
    "accumulator_threshold = 52\n",
    "min_dist = 30  # Adjust this value as needed\n",
    "\n",
    "circle_img = hough_circle_transform(edges, min_radius, max_radius, accumulator_threshold, min_dist)\n",
    "\n",
    "# Draw detected circles on the grayscale version of the original image\n",
    "cv.imshow('Detected Circles', circle_img)\n",
    "cv.waitKey(0)\n",
    "cv.destroyAllWindows()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load the image\n",
    "image = cv.imread('../test_images/hough_circle/coins01.jpeg', cv.IMREAD_GRAYSCALE)\n",
    "\n",
    "# Apply Gaussian blur to reduce noise\n",
    "blurred_image = cv.GaussianBlur(image, (5, 5), 0)\n",
    "\n",
    "# Detect circles using Hough Circle Transform\n",
    "circles = cv.HoughCircles(edges, cv.HOUGH_GRADIENT, dp=1, minDist=20,\n",
    "                           param1=50, param2=30, minRadius=10, maxRadius=50)\n",
    "\n",
    "# If circles are detected, draw them\n",
    "if circles is not None:\n",
    "    circles = np.round(circles[0, :]).astype(\"int\")\n",
    "    for (x, y, r) in circles:\n",
    "        cv.circle(image, (x, y), r, (0, 255, 0), 3)\n",
    "\n",
    "# Display the image with detected circles\n",
    "cv.imshow(\"Detected Circles (OpenCV)\", image)\n",
    "cv.waitKey(0)\n",
    "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.11.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}