Generalized_Hough_Transform.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "gpuType": "T4"
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "code",
      "execution_count": 70,
      "metadata": {
        "id": "NMrcu5V87_nE",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "efdd9829-a423-43e2-b5b4-a82748aee037"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Drive already mounted at /content/drive; to attempt to forcibly remount, call drive.mount(\"/content/drive\", force_remount=True).\n"
          ]
        }
      ],
      "source": [
        "from google.colab import drive\n",
        "drive.mount('/content/drive')"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# 1. Source code"
      ],
      "metadata": {
        "id": "FWV2_FRn-5z8"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 1.1 Sequential "
      ],
      "metadata": {
        "id": "q2rp4Qg-A-eZ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "%%writefile sequence_ght.py\n",
        "import cv2\n",
        "import math\n",
        "import time\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "\n",
        "THRESHOLD = 200\n",
        "N_ROTATION_SLICES = 72\n",
        "MAX_SCALE = 1.4\n",
        "MIN_SCALE = 0.6\n",
        "DELTA_SCALE_RATIO = 0.1\n",
        "N_SCALE_SLICE = int((MAX_SCALE - MIN_SCALE) // DELTA_SCALE_RATIO + 1)\n",
        "BLOCK_SIZE = 10\n",
        "THRESHOLD_RATIO = 0.3\n",
        "DELTA_ROTATION_ANGLE = 360 / N_ROTATION_SLICES\n",
        "IMAGE_DIR = 'drive/MyDrive/images'\n",
        "\n",
        "\n",
        "# numpy array sobel filter\n",
        "sobel_filter_x = np.array([[-1, 0, 1], [-2, 0, 2], [-1, 0, 1]])\n",
        "sobel_filter_y = np.array([[-1, -2, -1], [0, 0, 0], [1, 2, 1]])\n",
        "\n",
        "\n",
        "# Keep Pixel function by numpy\n",
        "def keep_pixel_np(magnitude: np.ndarray, pixel_gradient: np.ndarray):\n",
        "    height, width = magnitude.shape\n",
        "    neighbour_one_i = np.tile(np.arange(width), (height, 1)) - (pixel_gradient == 0) + (pixel_gradient == 45) - (\n",
        "            pixel_gradient == 135)\n",
        "    neighbour_one_j = np.tile(np.arange(height)[:, np.newaxis], width) - (pixel_gradient == 45) - (\n",
        "            pixel_gradient == 90) - (pixel_gradient == 135)\n",
        "    neighbour_two_i = np.tile(np.arange(width), (height, 1)) + (pixel_gradient == 0) - (pixel_gradient == 45) + (\n",
        "            pixel_gradient == 135)\n",
        "    neighbour_two_j = np.tile(np.arange(height)[:, np.newaxis], width) + (pixel_gradient == 45) + (\n",
        "            pixel_gradient == 90) + (pixel_gradient == 135)\n",
        "\n",
        "    valid_neighbour_one = (neighbour_one_i >= 0) & (neighbour_one_i < width) & (neighbour_one_j >= 0) & (\n",
        "            neighbour_one_j < height)\n",
        "    valid_neighbour_two = (neighbour_two_i >= 0) & (neighbour_two_i < width) & (neighbour_two_j >= 0) & (\n",
        "            neighbour_two_j < height)\n",
        "\n",
        "    neighbour_one = np.zeros_like(magnitude).astype(int)\n",
        "    neighbour_one[valid_neighbour_one] = magnitude[\n",
        "        neighbour_one_j[valid_neighbour_one], neighbour_one_i[valid_neighbour_one]]\n",
        "    neighbour_two = np.zeros_like(magnitude).astype(int)\n",
        "    neighbour_two[valid_neighbour_two] = magnitude[\n",
        "        neighbour_two_j[valid_neighbour_two], neighbour_two_i[valid_neighbour_two]]\n",
        "    cur = magnitude\n",
        "\n",
        "    return (neighbour_one <= cur) & (neighbour_two <= cur)\n",
        "\n",
        "\n",
        "class SeqGeneralHoughTransform:\n",
        "    def __init__(self, src: np.array, template: np.array, image_dir=IMAGE_DIR):\n",
        "        self.src = src\n",
        "        self.height_src = src.shape[0]\n",
        "        self.width_src = src.shape[1]\n",
        "        self.template = template\n",
        "        self.height_template = template.shape[0]\n",
        "        self.width_template = template.shape[1]\n",
        "        self.r_table = [[] for _ in range(N_ROTATION_SLICES)]\n",
        "        self.image_dir = image_dir\n",
        "\n",
        "    def process_template(self):\n",
        "        print(\"----------Start processing template----------\\n\")\n",
        "        time_process = 0\n",
        "\n",
        "        # Gray convert\n",
        "        start = time.time()\n",
        "        gray_template = self.convertToGray(self.template)\n",
        "        end = time.time()\n",
        "        print(f'\\t + Time of gray scale process: {round((end - start), 5)}')\n",
        "        time_process += end - start\n",
        "\n",
        "        # Sobel filter\n",
        "        start = time.time()\n",
        "        magnitude_x = self.convolve(sobel_filter_x, gray_template)\n",
        "        magnitude_y = self.convolve(sobel_filter_y, gray_template)\n",
        "        end = time.time()\n",
        "        print(f'\\t + Time of sobel filter process: {round((end - start), 5)}')\n",
        "        time_process += end - start\n",
        "\n",
        "        # Magnitude and orientation\n",
        "        start = time.time()\n",
        "        magnitude = self.magnitude(magnitude_x, magnitude_y)\n",
        "        orientation = self.orientation(magnitude_x, magnitude_y)\n",
        "        end = time.time()\n",
        "        print(f'\\t + Time of magnitude and orientation process: {round((end - start), 5)}')\n",
        "        time_process += end - start\n",
        "\n",
        "        # Edge minmax\n",
        "        start = time.time()\n",
        "        edge_minmax = self.edgemns(magnitude, orientation)\n",
        "        end = time.time()\n",
        "        print(f'\\t + Time of edge minmax process: {round((end - start), 5)}')\n",
        "        time_process += end - start\n",
        "\n",
        "        # Threshold\n",
        "        start = time.time()\n",
        "        mag_threshold = self.threshold(edge_minmax, THRESHOLD, type_input='template')\n",
        "        end = time.time()\n",
        "        print(f'\\t + Time of threshold process: {round((end - start), 5)}')\n",
        "        time_process += end - start\n",
        "\n",
        "        # Create R-table\n",
        "        start = time.time()\n",
        "        self.create_r_table(orientation, mag_threshold)\n",
        "        end = time.time()\n",
        "        print(f'\\t + Time of creating R-table process: {round((end - start), 5)}')\n",
        "        time_process += end - start\n",
        "\n",
        "        print(\"----------End processing template----------\\n\")\n",
        "        print(f\"Time processing template: {time_process}\\n\")\n",
        "\n",
        "    def accumulate_src(self):\n",
        "        print(\"----------Start accumulating src----------\\n\")\n",
        "        time_process = 0\n",
        "\n",
        "        # Gray convert\n",
        "        start = time.time()\n",
        "        gray_src = self.convertToGray(self.src)\n",
        "        end = time.time()\n",
        "        print(f'\\t + Time of gray scale process: {round((end - start), 5)}')\n",
        "        time_process += end - start\n",
        "\n",
        "        # Sobel filter\n",
        "        start = time.time()\n",
        "        magnitude_x = self.convolve(sobel_filter_x, gray_src)\n",
        "        magnitude_y = self.convolve(sobel_filter_y, gray_src)\n",
        "        end = time.time()\n",
        "        print(f'\\t + Time of sobel filter process: {round((end - start), 5)}')\n",
        "        time_process += end - start\n",
        "\n",
        "        # Magnitude and orientation\n",
        "        start = time.time()\n",
        "        magnitude = self.magnitude(magnitude_x, magnitude_y)\n",
        "        orientation = self.orientation(magnitude_x, magnitude_y)\n",
        "        end = time.time()\n",
        "        print(f'\\t + Time of magnitude and orientation process: {round((end - start), 5)}')\n",
        "        time_process += end - start\n",
        "\n",
        "        # Edge minmax\n",
        "        start = time.time()\n",
        "        edge_minmax = self.edgemns(magnitude, orientation)\n",
        "        end = time.time()\n",
        "        print(f'\\t + Time of edge minmax process: {round((end - start), 5)}')\n",
        "        time_process += end - start\n",
        "\n",
        "        # Threshold\n",
        "        start = time.time()\n",
        "        mag_threshold = self.threshold(edge_minmax, THRESHOLD)\n",
        "        end = time.time()\n",
        "        print(f'\\t + Time of threshold process: {round((end - start), 5)}')\n",
        "        time_process += end - start\n",
        "\n",
        "        # Accumulate\n",
        "        start = time.time()\n",
        "        self.accumulate(mag_threshold, orientation)\n",
        "        end = time.time()\n",
        "        print(f'\\t + Time of accumulate process: {round((end - start), 5)}')\n",
        "        time_process += end - start\n",
        "\n",
        "        print(\"----------End accumulating src----------\\n\")\n",
        "        print(f\"Time process: {time_process}s\\n\")\n",
        "\n",
        "    def convertToGray(self, image, type_input=None):\n",
        "        result = np.mean(image.data, axis=2)\n",
        "        if type_input in ['template', 'src']:\n",
        "            plt.imshow(result, cmap='gray')\n",
        "            plt.savefig(f'{self.image_dir}/gray_{type_input}.png')\n",
        "        return result\n",
        "\n",
        "    def convolve(self, sobel_filter: np.array, gray_src: np.array, axis='x', type_input=None):\n",
        "        if sobel_filter.shape != (3, 3):\n",
        "            raise Exception(\"Sobel filter must be 3x3\")\n",
        "\n",
        "        result = np.convolve(gray_src.flatten(), sobel_filter.flatten(), 'same').reshape(gray_src.shape)\n",
        "        if type_input in ['template', 'src']:\n",
        "            plt.imshow(result, cmap='gray')\n",
        "            plt.savefig(f'{self.image_dir}/sobel_{axis}_{type_input}.png')\n",
        "        return result\n",
        "\n",
        "    def magnitude(self, magnitude_x: np.array, magnitude_y: np.array, type_input=None):\n",
        "        result = np.sqrt(np.square(magnitude_x) + np.square(magnitude_y))\n",
        "        if type_input in ['template', 'src']:\n",
        "            plt.imshow(result, cmap='gray')\n",
        "            plt.savefig(f'{self.image_dir}/magnitude_{type_input}.png')\n",
        "        return result\n",
        "\n",
        "    def orientation(self, magnitude_x: np.array, magnitude_y: np.array):\n",
        "        phi = np.arctan2(magnitude_y, magnitude_x)\n",
        "        result = np.mod(phi * 180 / np.pi + 360, 360)\n",
        "        return result\n",
        "\n",
        "    def edgemns(self, magnitude: np.array, orientation: np.array, type_input=None):\n",
        "        pixel_gradient = ((orientation // 45).astype(int) * 45 % 180)\n",
        "        result = np.where(keep_pixel_np(magnitude, pixel_gradient), magnitude, 0)\n",
        "        if type_input in ['template', 'src']:\n",
        "            plt.imshow(result, cmap='gray')\n",
        "            plt.savefig(f'{self.image_dir}/edge_minmax_{type_input}.png')\n",
        "        return result\n",
        "\n",
        "    def threshold(self, magnitude: np.array, threshold: int, type_input=None):\n",
        "        result = np.where(magnitude > threshold, 255, 0)\n",
        "        if type_input in ['template', 'src']:\n",
        "            plt.imshow(result, cmap='gray')\n",
        "            plt.savefig(f'{self.image_dir}/threshold_{type_input}.png')\n",
        "            plt.plot()\n",
        "        return result\n",
        "\n",
        "    def create_r_table(self, orientation: np.array, magnitude_threshold: np.array):\n",
        "        indices_j, indices_i = np.where(magnitude_threshold == 255)\n",
        "\n",
        "        phi = np.fmod(orientation[indices_j, indices_i], 360)\n",
        "        i_slice = (phi / DELTA_ROTATION_ANGLE).astype(int)\n",
        "\n",
        "        center_x = self.width_template // 2\n",
        "        center_y = self.height_template // 2\n",
        "        entry_x = center_x - indices_i\n",
        "        entry_y = center_y - indices_j\n",
        "\n",
        "        r = np.sqrt(entry_x ** 2 + entry_y ** 2)\n",
        "        alpha = np.arctan2(entry_y, entry_x)\n",
        "\n",
        "        for i in range(len(indices_i)):\n",
        "            entry = {'r': r[i], 'alpha': alpha[i]}\n",
        "            self.r_table[i_slice[i]].append(entry)\n",
        "\n",
        "    def accumulate(self, mag_threshold: np.array, orient: np.array):\n",
        "        width = self.width_src\n",
        "        height = self.height_src\n",
        "        wblock = (width + BLOCK_SIZE - 1) // BLOCK_SIZE\n",
        "        hblock = (height + BLOCK_SIZE - 1) // BLOCK_SIZE\n",
        "\n",
        "        accumulator = np.zeros((hblock, wblock), dtype=np.int32)\n",
        "        block_maxima = np.zeros((hblock, wblock), dtype=[('x', int), ('y', int), ('hits', int)])\n",
        "\n",
        "        _max = 0\n",
        "        for j in range(height):\n",
        "            for i in range(width):\n",
        "                if mag_threshold[j][i] == 255:\n",
        "                    phi = orient[j][i]\n",
        "                    i_slice = int(phi // DELTA_ROTATION_ANGLE)\n",
        "                    entries = self.r_table[i_slice]\n",
        "                    for entry in entries:\n",
        "                        r = entry['r']\n",
        "                        alpha = entry['alpha']\n",
        "                        xc = int(i + r * math.cos(alpha))\n",
        "                        yc = int(j + r * math.sin(alpha))\n",
        "\n",
        "                        if xc < 0 or xc >= width or yc < 0 or yc >= height:\n",
        "                            continue\n",
        "                        accumulator[yc // BLOCK_SIZE][xc // BLOCK_SIZE] += 1\n",
        "                        block_maxima[yc // BLOCK_SIZE][xc // BLOCK_SIZE]['hits'] = accumulator[yc // BLOCK_SIZE][\n",
        "                            xc // BLOCK_SIZE]\n",
        "                        block_maxima[yc // BLOCK_SIZE][xc // BLOCK_SIZE]['x'] = xc\n",
        "                        block_maxima[yc // BLOCK_SIZE][xc // BLOCK_SIZE]['y'] = yc\n",
        "                        if accumulator[yc // BLOCK_SIZE][xc // BLOCK_SIZE] > _max:\n",
        "                            _max = accumulator[yc // BLOCK_SIZE][xc // BLOCK_SIZE]\n",
        "\n",
        "        maxima_threshold = round(_max * THRESHOLD_RATIO)\n",
        "        plt.imshow(self.src)\n",
        "        for j in range(hblock):\n",
        "            for i in range(wblock):\n",
        "                if block_maxima[j][i]['hits'] > maxima_threshold:\n",
        "                    plt.plot([block_maxima[j][i]['x']], [block_maxima[j][i]['y']], marker='o', color=\"yellow\")\n",
        "\n",
        "        plt.savefig(f'seq_output.png')\n",
        "        plt.show()\n",
        "\n",
        "if __name__ == '__main__':\n",
        "    src = cv2.imread(f'{IMAGE_DIR}/leaves.png')\n",
        "    template = cv2.imread(f'{IMAGE_DIR}/leaf.png')\n",
        "    ght = SeqGeneralHoughTransform(src, template, image_dir=IMAGE_DIR)\n",
        "    ght.process_template()\n",
        "    ght.accumulate_src()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "bIC7gZ599j5l",
        "outputId": "010b8c82-9cb7-4571-e872-91b2592dc3f5"
      },
      "execution_count": 45,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Writing sequence_ght.py\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 1.2 Sequential with numba"
      ],
      "metadata": {
        "id": "4Et3mmGHBEnW"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "%%writefile sequence_ght_numba.py\n",
        "import cv2\n",
        "import math\n",
        "import time\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "from numba import jit\n",
        "import warnings\n",
        "warnings.filterwarnings('ignore')\n",
        "\n",
        "THRESHOLD = 200\n",
        "N_ROTATION_SLICES = 72\n",
        "MAX_SCALE = 1.4\n",
        "MIN_SCALE = 0.6\n",
        "DELTA_SCALE_RATIO = 0.1\n",
        "N_SCALE_SLICE = int((MAX_SCALE - MIN_SCALE) // DELTA_SCALE_RATIO + 1)\n",
        "BLOCK_SIZE = 10\n",
        "THRESHOLD_RATIO = 0.3\n",
        "DELTA_ROTATION_ANGLE = 360 / N_ROTATION_SLICES\n",
        "IMAGE_DIR = 'drive/MyDrive/images'\n",
        "\n",
        "# numpy array sobel filter\n",
        "sobel_filter_x = np.array([[-1, 0, 1], [-2, 0, 2], [-1, 0, 1]])\n",
        "sobel_filter_y = np.array([[-1, -2, -1], [0, 0, 0], [1, 2, 1]])\n",
        "\n",
        "statictics_time = {\n",
        "  'time_process_tpl': 0,\n",
        "  'time_process_src': 0\n",
        "}\n",
        "\n",
        "\n",
        "class SeqGeneralHoughTransformNumba:\n",
        "    def __init__(self, src: np.array, template: np.array, image_dir=IMAGE_DIR):\n",
        "        self.src = src\n",
        "        self.height_src = src.shape[0]\n",
        "        self.width_src = src.shape[1]\n",
        "        self.template = template\n",
        "        self.height_template = template.shape[0]\n",
        "        self.width_template = template.shape[1]\n",
        "        self.r_table = [[] for _ in range(N_ROTATION_SLICES)]\n",
        "        self.image_dir = image_dir\n",
        "\n",
        "    def process_template(self):\n",
        "        print(\"----------Start processing template----------\\n\")\n",
        "        time_process = 0\n",
        "\n",
        "        # Gray convert\n",
        "        start = time.time()\n",
        "        gray_template = self.convertToGray(self.template)\n",
        "        end = time.time()\n",
        "        print(f'\\t + Time of gray scale process: {round((end - start), 5)}')\n",
        "        time_process += end - start\n",
        "\n",
        "        # Sobel filter\n",
        "        start = time.time()\n",
        "        magnitude_x = self.convolve(sobel_filter_x, gray_template)\n",
        "        magnitude_y = self.convolve(sobel_filter_y, gray_template)\n",
        "        end = time.time()\n",
        "        print(f'\\t + Time of sobel filter process: {round((end - start), 5)}')\n",
        "        time_process += end - start\n",
        "\n",
        "        # Magnitude and orientation\n",
        "        start = time.time()\n",
        "        magnitude = self.magnitude(magnitude_x, magnitude_y)\n",
        "        orientation = self.orientation(magnitude_x, magnitude_y)\n",
        "        end = time.time()\n",
        "        print(f'\\t + Time of magnitude and orientation process: {round((end - start), 5)}')\n",
        "        time_process += end - start\n",
        "\n",
        "        # Edge minmax\n",
        "        start = time.time()\n",
        "        edge_minmax = self.edgemns(magnitude, orientation)\n",
        "        end = time.time()\n",
        "        print(f'\\t + Time of edge minmax process: {round((end - start), 5)}')\n",
        "        time_process += end - start\n",
        "\n",
        "        # Threshold\n",
        "        start = time.time()\n",
        "        mag_threshold = self.threshold(edge_minmax, THRESHOLD, type_input='template')\n",
        "        end = time.time()\n",
        "        print(f'\\t + Time of threshold process: {round((end - start), 5)}')\n",
        "        time_process += end - start\n",
        "\n",
        "        # Create R-table\n",
        "        start = time.time()\n",
        "        self.create_r_table(orientation, mag_threshold)\n",
        "        end = time.time()\n",
        "        print(f'\\t + Time of creating R-table process: {round((end - start), 5)}')\n",
        "        time_process += end - start\n",
        "\n",
        "        print(\"----------End processing template----------\\n\")\n",
        "        statictics_time['time_process_tpl'] = time_process\n",
        "\n",
        "    def accumulate_src(self):\n",
        "        print(\"----------Start accumulating src----------\\n\")\n",
        "        time_process = 0\n",
        "\n",
        "        # Gray convert\n",
        "        start = time.time()\n",
        "        gray_src = self.convertToGray(self.src)\n",
        "        end = time.time()\n",
        "        print(f'\\t + Time of gray scale process: {round((end - start), 5)}')\n",
        "        time_process += end - start\n",
        "\n",
        "        # Sobel filter\n",
        "        start = time.time()\n",
        "        magnitude_x = self.convolve(sobel_filter_x, gray_src)\n",
        "        magnitude_y = self.convolve(sobel_filter_y, gray_src)\n",
        "        end = time.time()\n",
        "        print(f'\\t + Time of sobel filter process: {round((end - start), 5)}')\n",
        "        time_process += end - start\n",
        "\n",
        "        # Magnitude and orientation\n",
        "        start = time.time()\n",
        "        magnitude = self.magnitude(magnitude_x, magnitude_y)\n",
        "        orientation = self.orientation(magnitude_x, magnitude_y)\n",
        "        end = time.time()\n",
        "        print(f'\\t + Time of magnitude and orientation process: {round((end - start), 5)}')\n",
        "        time_process += end - start\n",
        "\n",
        "        # Edge minmax\n",
        "        start = time.time()\n",
        "        edge_minmax = self.edgemns(magnitude, orientation)\n",
        "        end = time.time()\n",
        "        print(f'\\t + Time of edge minmax process: {round((end - start), 5)}')\n",
        "        time_process += end - start\n",
        "\n",
        "        # Threshold\n",
        "        start = time.time()\n",
        "        mag_threshold = self.threshold(edge_minmax, THRESHOLD)\n",
        "        end = time.time()\n",
        "        print(f'\\t + Time of threshold process: {round((end - start), 5)}')\n",
        "        time_process += end - start\n",
        "\n",
        "        # Accumulate\n",
        "        start = time.time()\n",
        "        block_maxima, maxima_threshold = self.accumulate(mag_threshold, orientation)\n",
        "        end = time.time()\n",
        "        print(f'\\t + Time of accumulate process: {round((end - start), 5)}')\n",
        "        time_process += end - start\n",
        "\n",
        "        # Draw\n",
        "        wblock = (self.width_src + BLOCK_SIZE - 1) // BLOCK_SIZE\n",
        "        hblock = (self.height_src + BLOCK_SIZE - 1) // BLOCK_SIZE\n",
        "        plt.imshow(self.src)\n",
        "        for j in range(hblock):\n",
        "            for i in range(wblock):\n",
        "                if block_maxima[j][i]['hits'] > maxima_threshold:\n",
        "                    plt.plot([block_maxima[j][i]['x']], [block_maxima[j][i]['y']], marker='o', color=\"yellow\")\n",
        "\n",
        "        plt.savefig(f'seq_output_numba.png')\n",
        "        plt.show()\n",
        "\n",
        "        print(\"----------End accumulating src----------\\n\")\n",
        "        statictics_time['time_process_src'] = time_process\n",
        "\n",
        "    @jit(cache=True)\n",
        "    def convertToGray(self, image, type_input=None):\n",
        "        result = np.zeros(image.shape[:2], dtype=np.float64)\n",
        "        for i in range(image.shape[0]):\n",
        "            for j in range(image.shape[1]):\n",
        "                result[i][j] = 0.299 * image[i][j][0] + 0.587 * image[i][j][1] + 0.114 * image[i][j][2]\n",
        "\n",
        "        return result\n",
        "\n",
        "    @jit(cache=True,)\n",
        "    def convolve(self, sobel_filter: np.array, gray_src: np.array, axis='x', type_input=None):\n",
        "        result = np.zeros_like(gray_src)\n",
        "        for i in range(gray_src.shape[0]):\n",
        "            for j in range(gray_src.shape[1]):\n",
        "                temp = 0\n",
        "                for jj in range(-1, 2):\n",
        "                    for ii in range(-1, 2):\n",
        "                        jj_pad = max(0, min(gray_src.shape[1] - 1, j + jj))\n",
        "                        ii_pad = max(0, min(gray_src.shape[0] - 1, i + ii))\n",
        "                        temp += gray_src[ii_pad][jj_pad] * sobel_filter[ii + 1][jj + 1]\n",
        "                result[i][j] = temp\n",
        "\n",
        "        return result\n",
        "\n",
        "    @jit(cache=True)\n",
        "    def magnitude(self, magnitude_x: np.array, magnitude_y: np.array, type_input=None):\n",
        "        result = np.zeros_like(magnitude_x)\n",
        "        for i in range(magnitude_x.shape[0]):\n",
        "            for j in range(magnitude_x.shape[1]):\n",
        "                result[i][j] = math.sqrt(magnitude_x[i][j] ** 2 + magnitude_y[i][j] ** 2)\n",
        "\n",
        "        return result\n",
        "\n",
        "    @jit(cache=True)\n",
        "    def orientation(self, magnitude_x: np.array, magnitude_y: np.array):\n",
        "        result = np.zeros_like(magnitude_x)\n",
        "        for i in range(magnitude_x.shape[0]):\n",
        "            for j in range(magnitude_x.shape[1]):\n",
        "                result[i][j] = (math.atan2(magnitude_y[i][j], magnitude_x[i][j]) * 180 / math.pi + 360) % 360\n",
        "        return result\n",
        "\n",
        "    @jit(cache=True)\n",
        "    def edgemns(self, magnitude: np.array, orientation: np.array, type_input=None):\n",
        "        result = np.zeros_like(magnitude)\n",
        "        for i in range(magnitude.shape[0]):\n",
        "            for j in range(magnitude.shape[1]):\n",
        "                pixel_gradient = int(orientation[i][j] // 45) * 45 % 180\n",
        "                neighbour_one_i = i\n",
        "                neighbour_one_j = j\n",
        "                neighbour_two_i = i\n",
        "                neighbour_two_j = j\n",
        "\n",
        "                if pixel_gradient == 0:\n",
        "                    neighbour_one_i = i - 1\n",
        "                    neighbour_two_i = i + 1\n",
        "                elif pixel_gradient == 45:\n",
        "                    neighbour_one_i = i + 1\n",
        "                    neighbour_one_j = j - 1\n",
        "                    neighbour_two_i = i - 1\n",
        "                    neighbour_two_j = j + 1\n",
        "                elif pixel_gradient == 90:\n",
        "                    neighbour_one_j = j - 1\n",
        "                    neighbour_two_j = j + 1\n",
        "                elif pixel_gradient == 135:\n",
        "                    neighbour_one_i = i - 1\n",
        "                    neighbour_one_j = j - 1\n",
        "                    neighbour_two_i = i + 1\n",
        "                    neighbour_two_j = j + 1\n",
        "\n",
        "                neighbour_one_i = max(0, min(magnitude.shape[0] - 1, neighbour_one_i))\n",
        "                neighbour_one_j = max(0, min(magnitude.shape[1] - 1, neighbour_one_j))\n",
        "                neighbour_two_i = max(0, min(magnitude.shape[0] - 1, neighbour_two_i))\n",
        "                neighbour_two_j = max(0, min(magnitude.shape[1] - 1, neighbour_two_j))\n",
        "\n",
        "                neighbour_one = magnitude[neighbour_one_i][neighbour_one_j]\n",
        "                neighbour_two = magnitude[neighbour_two_i][neighbour_two_j]\n",
        "\n",
        "                if (neighbour_one <= magnitude[i][j]) & (neighbour_two <= magnitude[i][j]):\n",
        "                    result[i][j] = magnitude[i][j]\n",
        "                else:\n",
        "                    result[i][j] = 0\n",
        "        return result\n",
        "\n",
        "    @jit(cache=True)\n",
        "    def threshold(self, magnitude: np.array, threshold: int, type_input=None):\n",
        "        result = np.zeros_like(magnitude)\n",
        "        for i in range(magnitude.shape[0]):\n",
        "            for j in range(magnitude.shape[1]):\n",
        "                if magnitude[i][j] > threshold:\n",
        "                    result[i][j] = 255\n",
        "                else:\n",
        "                    result[i][j] = 0\n",
        "        return result\n",
        "\n",
        "    @jit(cache=True)\n",
        "    def create_r_table(self, orientation: np.array, magnitude_threshold: np.array):\n",
        "        for i in range(orientation.shape[0]):\n",
        "            for j in range(orientation.shape[1]):\n",
        "                if magnitude_threshold[i][j] == 255:\n",
        "                    phi = orientation[i][j] % 360\n",
        "                    i_slice = int(phi // DELTA_ROTATION_ANGLE)\n",
        "\n",
        "                    center_x = self.width_template // 2\n",
        "                    center_y = self.height_template // 2\n",
        "                    entry_x = center_x - j\n",
        "                    entry_y = center_y - i\n",
        "\n",
        "                    r = math.sqrt(entry_x ** 2 + entry_y ** 2)\n",
        "                    alpha = math.atan2(entry_y, entry_x)\n",
        "\n",
        "                    entry = {'r': r, 'alpha': alpha}\n",
        "                    self.r_table[i_slice].append(entry)\n",
        "\n",
        "    @jit(cache=True)\n",
        "    def accumulate4D(self, mag_threshold: np.array, orient: np.array):\n",
        "        width = self.width_src\n",
        "        height = self.height_src\n",
        "        wblock = (width + BLOCK_SIZE - 1) // BLOCK_SIZE\n",
        "        hblock = (height + BLOCK_SIZE - 1) // BLOCK_SIZE\n",
        "\n",
        "        accumulator = np.zeros((N_SCALE_SLICE, N_ROTATION_SLICES, hblock, wblock), dtype=np.int32)\n",
        "        block_maxima = np.zeros((hblock, wblock), dtype=[('x', int), ('y', int), ('hits', int)])\n",
        "\n",
        "        _max = 0\n",
        "        for j in range(height):\n",
        "            for i in range(width):\n",
        "                if mag_threshold[j][i] == 255:\n",
        "                    phi = orient[j][i]\n",
        "                    for i_theta in range(N_ROTATION_SLICES):\n",
        "                        theta = i_theta * DELTA_ROTATION_ANGLE\n",
        "                        theta_r = math.radians(theta)\n",
        "                        i_slice = int(((phi - theta + 360) % 360) // DELTA_ROTATION_ANGLE)\n",
        "                        entries = self.r_table[i_slice]\n",
        "                        for entry in entries:\n",
        "                            r = entry['r']\n",
        "                            alpha = entry['alpha']\n",
        "                            for scale in range(N_SCALE_SLICE):\n",
        "                                s = scale * DELTA_SCALE_RATIO + MIN_SCALE\n",
        "                                xc = int(i + r * s * math.cos(alpha + theta_r))\n",
        "                                yc = int(j + r * s * math.sin(alpha + theta_r))\n",
        "\n",
        "                                if xc < 0 or xc >= width or yc < 0 or yc >= height:\n",
        "                                    continue\n",
        "                                accumulator[scale][i_theta][yc // BLOCK_SIZE][xc // BLOCK_SIZE] += 1\n",
        "                                if accumulator[scale][i_theta][yc // BLOCK_SIZE][xc // BLOCK_SIZE] > \\\n",
        "                                        block_maxima[yc // BLOCK_SIZE][xc // BLOCK_SIZE]['hits']:\n",
        "                                    block_maxima[yc // BLOCK_SIZE][xc // BLOCK_SIZE]['hits'] = \\\n",
        "                                        accumulator[scale][i_theta][yc // BLOCK_SIZE][xc // BLOCK_SIZE]\n",
        "                                    block_maxima[yc // BLOCK_SIZE][xc // BLOCK_SIZE]['x'] = xc\n",
        "                                    block_maxima[yc // BLOCK_SIZE][xc // BLOCK_SIZE]['y'] = yc\n",
        "                                    if accumulator[scale][i_theta][yc // BLOCK_SIZE][xc // BLOCK_SIZE] > _max:\n",
        "                                        _max = accumulator[scale][i_theta][yc // BLOCK_SIZE][xc // BLOCK_SIZE]\n",
        "\n",
        "        maxima_threshold = round(_max * THRESHOLD_RATIO)\n",
        "\n",
        "        return block_maxima, maxima_threshold\n",
        "\n",
        "    @jit(cache=True)\n",
        "    def accumulate(self, mag_threshold: np.array, orient: np.array):\n",
        "        width = self.width_src\n",
        "        height = self.height_src\n",
        "        wblock = (width + BLOCK_SIZE - 1) // BLOCK_SIZE\n",
        "        hblock = (height + BLOCK_SIZE - 1) // BLOCK_SIZE\n",
        "\n",
        "        accumulator = np.zeros((hblock, wblock), dtype=np.int32)\n",
        "        block_maxima = np.zeros((hblock, wblock), dtype=[('x', int), ('y', int), ('hits', int)])\n",
        "\n",
        "        _max = 0\n",
        "        for j in range(self.height_src):\n",
        "            for i in range(self.width_src):\n",
        "                if mag_threshold[j][i] == 255:\n",
        "                    phi = orient[j][i]\n",
        "                    i_slice = int(phi // DELTA_ROTATION_ANGLE)\n",
        "                    entries = self.r_table[i_slice]\n",
        "                    for entry in entries:\n",
        "                        r = entry['r']\n",
        "                        alpha = entry['alpha']\n",
        "                        xc = int(i + r * math.cos(alpha))\n",
        "                        yc = int(j + r * math.sin(alpha))\n",
        "\n",
        "                        if xc < 0 or xc >= self.width_src or yc < 0 or yc >= self.height_src:\n",
        "                            continue\n",
        "                        accumulator[yc // BLOCK_SIZE][xc // BLOCK_SIZE] += 1\n",
        "                        block_maxima[yc // BLOCK_SIZE][xc // BLOCK_SIZE]['hits'] = accumulator[yc // BLOCK_SIZE][\n",
        "                            xc // BLOCK_SIZE]\n",
        "                        block_maxima[yc // BLOCK_SIZE][xc // BLOCK_SIZE]['x'] = xc\n",
        "                        block_maxima[yc // BLOCK_SIZE][xc // BLOCK_SIZE]['y'] = yc\n",
        "                        if accumulator[yc // BLOCK_SIZE][xc // BLOCK_SIZE] > _max:\n",
        "                            _max = accumulator[yc // BLOCK_SIZE][xc // BLOCK_SIZE]\n",
        "        maxima_threshold = round(_max * THRESHOLD_RATIO)\n",
        "        return block_maxima, maxima_threshold\n",
        "\n",
        "if __name__ == '__main__':\n",
        "    src = cv2.imread(f'{IMAGE_DIR}/leaves.png')\n",
        "    template = cv2.imread(f'{IMAGE_DIR}/leaf.png')\n",
        "    ght = SeqGeneralHoughTransformNumba(src, template, image_dir=IMAGE_DIR)\n",
        "    ght.process_template()\n",
        "    ght.accumulate_src()\n",
        "    print(f\"Time process template: {statictics_time['time_process_tpl']}s\\n\")\n",
        "    print(f\"Time process source: {statictics_time['time_process_src']}s\\n\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "i7rihN5a-Tnw",
        "outputId": "f5b1ed4f-e27c-4a2d-e331-d412c87a46f2"
      },
      "execution_count": 53,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Overwriting sequence_ght_numba.py\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 1.3 Parallel on GPU with numba"
      ],
      "metadata": {
        "id": "TyTeeqnxBK3f"
      }
    },
    {
      "cell_type": "code",
      "source": [
        " %%writefile parallel_ght_gpu.py\n",
        "import math\n",
        "import cv2\n",
        "import time\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "from numba import jit, cuda\n",
        "import warnings\n",
        "warnings.filterwarnings('ignore')\n",
        "\n",
        "\n",
        "THRESHOLD = 200\n",
        "N_ROTATION_SLICES = 72\n",
        "MAX_SCALE = 1.4\n",
        "MIN_SCALE = 0.6\n",
        "DELTA_SCALE_RATIO = 0.1\n",
        "N_SCALE_SLICE = int((MAX_SCALE - MIN_SCALE) // DELTA_SCALE_RATIO + 1)\n",
        "BLOCK_SIZE = 10\n",
        "THRESHOLD_RATIO = 0.3\n",
        "DELTA_ROTATION_ANGLE = 360 / N_ROTATION_SLICES\n",
        "PHI_R_TABLE_INDEX = 0\n",
        "R_R_TABLE_INDEX = 1\n",
        "ALPHA_R_TABLE_INDEX = 2\n",
        "IMAGE_DIR = 'drive/MyDrive/images'\n",
        "\n",
        "# numpy array sobel filter\n",
        "sobel_filter_x = np.array([[-1, 0, 1], [-2, 0, 2], [-1, 0, 1]])\n",
        "sobel_filter_y = np.array([[-1, -2, -1], [0, 0, 0], [1, 2, 1]])\n",
        "\n",
        "\n",
        "@cuda.jit\n",
        "def convert_to_gray(image: np.array, result: np.array):\n",
        "    r, c = cuda.grid(2)\n",
        "    if r < image.shape[0] and c < image.shape[1]:\n",
        "        result[r][c] = 0.299 * image[r][c][0] + 0.587 * image[r][c][1] + 0.114 * image[r][c][2]\n",
        "\n",
        "\n",
        "@cuda.jit\n",
        "def convolve(sobel_filter: np.array, gray_src: np.array, result: np.array):\n",
        "    r, c = cuda.grid(2)\n",
        "    if r < gray_src.shape[0] and c < gray_src.shape[1]:\n",
        "        temp = 0\n",
        "        for jj in range(-1, 2):\n",
        "            for ii in range(-1, 2):\n",
        "                jj_pad = max(0, min(gray_src.shape[1] - 1, c + jj))\n",
        "                ii_pad = max(0, min(gray_src.shape[0] - 1, r + ii))\n",
        "                temp += gray_src[ii_pad][jj_pad] * sobel_filter[ii + 1][jj + 1]\n",
        "        result[r][c] = temp\n",
        "\n",
        "\n",
        "@cuda.jit\n",
        "def magnitude(magnitude_x: np.array, magnitude_y: np.array, result: np.array):\n",
        "    r, c = cuda.grid(2)\n",
        "    if r < magnitude_x.shape[0] and c < magnitude_x.shape[1]:\n",
        "        result[r][c] = math.sqrt(magnitude_x[r][c] ** 2 + magnitude_y[r][c] ** 2)\n",
        "\n",
        "\n",
        "@cuda.jit\n",
        "def orientation(magnitude_x: np.array, magnitude_y: np.array, result: np.array):\n",
        "    r, c = cuda.grid(2)\n",
        "    if r < magnitude_x.shape[0] and c < magnitude_x.shape[1]:\n",
        "        result[r][c] = (math.atan2(magnitude_y[r][c], magnitude_x[r][c]) * 180 / math.pi + 360) % 360\n",
        "\n",
        "\n",
        "@cuda.jit\n",
        "def edgemns(magnitude: np.array, orientation: np.array, result: np.array):\n",
        "    r, c = cuda.grid(2)\n",
        "    if r < magnitude.shape[0] and c < magnitude.shape[1]:\n",
        "        pixel_gradient = int(orientation[r][c] // 45) * 45 % 180\n",
        "        neighbour_one_i = r\n",
        "        neighbour_one_j = c\n",
        "        neighbour_two_i = r\n",
        "        neighbour_two_j = c\n",
        "\n",
        "        if pixel_gradient == 0:\n",
        "            neighbour_one_i = r - 1\n",
        "            neighbour_two_i = r + 1\n",
        "        elif pixel_gradient == 45:\n",
        "            neighbour_one_i = r + 1\n",
        "            neighbour_one_j = c - 1\n",
        "            neighbour_two_i = r - 1\n",
        "            neighbour_two_j = c + 1\n",
        "        elif pixel_gradient == 90:\n",
        "            neighbour_one_j = c - 1\n",
        "            neighbour_two_j = c + 1\n",
        "        elif pixel_gradient == 135:\n",
        "            neighbour_one_i = r - 1\n",
        "            neighbour_one_j = c - 1\n",
        "            neighbour_two_i = r + 1\n",
        "            neighbour_two_j = c + 1\n",
        "\n",
        "        neighbour_one_i = max(0, min(magnitude.shape[0] - 1, neighbour_one_i))\n",
        "        neighbour_one_j = max(0, min(magnitude.shape[1] - 1, neighbour_one_j))\n",
        "        neighbour_two_i = max(0, min(magnitude.shape[0] - 1, neighbour_two_i))\n",
        "        neighbour_two_j = max(0, min(magnitude.shape[1] - 1, neighbour_two_j))\n",
        "\n",
        "        if magnitude[r][c] >= magnitude[neighbour_one_i][neighbour_one_j] and magnitude[r][c] >= magnitude[neighbour_two_i][neighbour_two_j]:\n",
        "            result[r][c] = magnitude[r][c]\n",
        "        else:\n",
        "            result[r][c] = 0\n",
        "\n",
        "\n",
        "@cuda.jit\n",
        "def threshold(magnitude: np.array, threshold: int, result: np.array):\n",
        "    r, c = cuda.grid(2)\n",
        "    if r < magnitude.shape[0] and c < magnitude.shape[1]:\n",
        "        if magnitude[r][c] > threshold:\n",
        "            result[r][c] = 255\n",
        "        else:\n",
        "            result[r][c] = 0\n",
        "\n",
        "\n",
        "@cuda.jit\n",
        "def create_r_table(orientation: np.array, magnitude_threshold: np.array, width_template: int, height_template: int,\n",
        "                   r_table: np.array):\n",
        "    r, c = cuda.grid(2)\n",
        "    if r < orientation.shape[0] and c < orientation.shape[1]:\n",
        "        if magnitude_threshold[r][c] == 255:\n",
        "            phi = orientation[r][c] % 360\n",
        "            i_slice = int(phi // DELTA_ROTATION_ANGLE)\n",
        "\n",
        "            center_x = width_template // 2\n",
        "            center_y = height_template // 2\n",
        "            entry_x = center_x - c\n",
        "            entry_y = center_y - r\n",
        "\n",
        "            _r = math.sqrt(entry_x ** 2 + entry_y ** 2)\n",
        "            alpha = math.atan2(entry_y, entry_x)\n",
        "\n",
        "            r_table[r, c, PHI_R_TABLE_INDEX] = i_slice\n",
        "            r_table[r, c, R_R_TABLE_INDEX] = _r\n",
        "            r_table[r, c, ALPHA_R_TABLE_INDEX] = alpha\n",
        "        else:\n",
        "            r_table[r, c, PHI_R_TABLE_INDEX] = -1\n",
        "\n",
        "@cuda.jit\n",
        "def num_edge_pixels_and_convert_r_table_to_1D(magnitude_threshold: np.array, _num_edge_pixels: int, r_table_1D: np.array, r_table: np.array):\n",
        "    r, c = cuda.grid(2)\n",
        "    if r < magnitude_threshold.shape[0] and c < magnitude_threshold.shape[1]:\n",
        "        if magnitude_threshold[r][c] == 255:\n",
        "            index = cuda.atomic.add(_num_edge_pixels, 0, 1)\n",
        "            r_table_1D[index, PHI_R_TABLE_INDEX] = r_table[r, c, PHI_R_TABLE_INDEX]\n",
        "            r_table_1D[index, R_R_TABLE_INDEX] = r_table[r, c, R_R_TABLE_INDEX]\n",
        "            r_table_1D[index, ALPHA_R_TABLE_INDEX] = r_table[r, c, ALPHA_R_TABLE_INDEX]\n",
        "\n",
        "@cuda.jit\n",
        "def num_edge_pixels_and_get_pixel_index(magnitude_threshold: np.array, _num_edge_pixels: int, edge_pixels_1D: np.array):\n",
        "    r, c = cuda.grid(2)\n",
        "    if r < magnitude_threshold.shape[0] and c < magnitude_threshold.shape[1]:\n",
        "        if magnitude_threshold[r][c] == 255:\n",
        "            index = cuda.atomic.add(_num_edge_pixels, 0, 1)\n",
        "            edge_pixels_1D[index, 0] = r\n",
        "            edge_pixels_1D[index, 1] = c\n",
        "\n",
        "\n",
        "@jit(cache=True)\n",
        "def accumulate4D(mag_threshold: np.array, orient: np.array, width_src: int, height_src: int,\n",
        "                 accumulator: np.array, block_maxima: np.array, r_table: list):\n",
        "    _max = 0\n",
        "    for j in range(height_src):\n",
        "        for i in range(width_src):\n",
        "            if mag_threshold[j][i] == 255:\n",
        "                phi = orient[j][i]\n",
        "                for i_theta in range(N_ROTATION_SLICES):\n",
        "                    theta = i_theta * DELTA_ROTATION_ANGLE\n",
        "                    theta_r = math.radians(theta)\n",
        "                    i_slice = int(((phi - theta + 360) % 360) // DELTA_ROTATION_ANGLE)\n",
        "                    entries = r_table[i_slice]\n",
        "                    for entry in entries:\n",
        "                        r = entry['r']\n",
        "                        alpha = entry['alpha']\n",
        "                        for scale in range(N_SCALE_SLICE):\n",
        "                            s = scale * DELTA_SCALE_RATIO + MIN_SCALE\n",
        "                            xc = int(i + r * s * math.cos(alpha + theta_r))\n",
        "                            yc = int(j + r * s * math.sin(alpha + theta_r))\n",
        "\n",
        "                            if xc < 0 or xc >= width_src or yc < 0 or yc >= height_src:\n",
        "                                continue\n",
        "                            accumulator[scale][i_theta][yc // BLOCK_SIZE][xc // BLOCK_SIZE] += 1\n",
        "                            if accumulator[scale][i_theta][yc // BLOCK_SIZE][xc // BLOCK_SIZE] > \\\n",
        "                                    block_maxima[yc // BLOCK_SIZE][xc // BLOCK_SIZE]['hits']:\n",
        "                                block_maxima[yc // BLOCK_SIZE][xc // BLOCK_SIZE]['hits'] = \\\n",
        "                                    accumulator[scale][i_theta][yc // BLOCK_SIZE][xc // BLOCK_SIZE]\n",
        "                                block_maxima[yc // BLOCK_SIZE][xc // BLOCK_SIZE]['x'] = xc\n",
        "                                block_maxima[yc // BLOCK_SIZE][xc // BLOCK_SIZE]['y'] = yc\n",
        "                                if accumulator[scale][i_theta][yc // BLOCK_SIZE][xc // BLOCK_SIZE] > _max:\n",
        "                                    _max = accumulator[scale][i_theta][yc // BLOCK_SIZE][xc // BLOCK_SIZE]\n",
        "    maxima_threshold = round(_max * THRESHOLD_RATIO)\n",
        "\n",
        "    return block_maxima, maxima_threshold\n",
        "\n",
        "\n",
        "@cuda.jit\n",
        "def accumulate(edge_pixels: np.array, num_edge_pixels: int, orient: np.array, width_src: int, height_src: int,\n",
        "                 accumulator: np.array, r_table: list):\n",
        "    index = cuda.grid(1)\n",
        "    if (index >= num_edge_pixels):\n",
        "        return\n",
        "\n",
        "    row = edge_pixels[index, 0]\n",
        "    col = edge_pixels[index, 1]\n",
        "\n",
        "    phi = orient[row, col]\n",
        "    i_slice = int(phi // DELTA_ROTATION_ANGLE)\n",
        "    for entry in r_table:\n",
        "        if int(entry[PHI_R_TABLE_INDEX]) == i_slice:\n",
        "            r = entry[R_R_TABLE_INDEX]\n",
        "            alpha = entry[ALPHA_R_TABLE_INDEX]\n",
        "            xc = int(col + r * math.cos(alpha))\n",
        "            yc = int(row + r * math.sin(alpha))\n",
        "\n",
        "            if xc < 0 or xc >= width_src or yc < 0 or yc >= height_src:\n",
        "                continue\n",
        "            accumulator_index = (yc // BLOCK_SIZE, xc // BLOCK_SIZE)\n",
        "            value_accum = cuda.atomic.add(accumulator, accumulator_index, 1)\n",
        "\n",
        "\n",
        "src = cv2.imread(f'{IMAGE_DIR}/leaves.png')\n",
        "height_src = src.shape[0]\n",
        "width_src = src.shape[1]\n",
        "template = cv2.imread(f'{IMAGE_DIR}/leaf.png')\n",
        "height_template = template.shape[0]\n",
        "width_template = template.shape[1]\n",
        "r_table = np.zeros((height_template, width_template, 3), dtype=np.float64)\n",
        "block_size = (32, 32)\n",
        "grid_size_template = (math.ceil(height_template / block_size[0]), math.ceil(width_template / block_size[1]))\n",
        "grid_size_src = (math.ceil(height_src / block_size[0]), math.ceil(width_src / block_size[1]))\n",
        "wblock = (width_src + BLOCK_SIZE - 1) // BLOCK_SIZE\n",
        "hblock = (height_src + BLOCK_SIZE - 1) // BLOCK_SIZE\n",
        "\n",
        "print(\"----------Start processing template----------\\n\")\n",
        "time_process = 0\n",
        "\n",
        "# Gray convert\n",
        "gray_template = np.zeros(template.shape[:2], dtype=np.float64)\n",
        "start = time.time()\n",
        "convert_to_gray[grid_size_template, block_size](template, gray_template)\n",
        "end = time.time()\n",
        "print(f'\\t + Time of gray scale process: {round((end - start), 5)}')\n",
        "time_process += end - start\n",
        "\n",
        "# Sobel filter\n",
        "magnitude_x = np.zeros_like(gray_template)\n",
        "magnitude_y = np.zeros_like(gray_template)\n",
        "start = time.time()\n",
        "convolve[grid_size_template, block_size](sobel_filter_x, gray_template, magnitude_x)\n",
        "convolve[grid_size_template, block_size](sobel_filter_y, gray_template, magnitude_y)\n",
        "end = time.time()\n",
        "print(f'\\t + Time of sobel filter process: {round((end - start), 5)}')\n",
        "time_process += end - start\n",
        "\n",
        "# Magnitude and orientation\n",
        "magnitude_tpl = np.zeros_like(gray_template)\n",
        "orientation_tpl = np.zeros_like(gray_template)\n",
        "start = time.time()\n",
        "magnitude[grid_size_template, block_size](magnitude_x, magnitude_y, magnitude_tpl)\n",
        "orientation[grid_size_template, block_size](magnitude_x, magnitude_y, orientation_tpl)\n",
        "end = time.time()\n",
        "print(f'\\t + Time of magnitude and orientation process: {round((end - start), 5)}')\n",
        "time_process += end - start\n",
        "\n",
        "# Edge minmax\n",
        "edge_minmax_tpl = np.zeros_like(gray_template)\n",
        "start = time.time()\n",
        "edgemns[grid_size_template, block_size](magnitude_tpl, orientation_tpl, edge_minmax_tpl)\n",
        "end = time.time()\n",
        "time_process += end - start\n",
        "print(f'\\t + Time of edge minmax process: {round((end - start), 5)}')\n",
        "\n",
        "# Threshold\n",
        "mag_threshold_tpl = np.zeros_like(gray_template, dtype=np.int32)\n",
        "start = time.time()\n",
        "threshold[grid_size_template, block_size](edge_minmax_tpl, THRESHOLD, mag_threshold_tpl)\n",
        "end = time.time()\n",
        "time_process += end - start\n",
        "print(f'\\t + Time of threshold process: {round((end - start), 5)}')\n",
        "\n",
        "# Create R-tablel\n",
        "start = time.time()\n",
        "create_r_table[grid_size_template, block_size](orientation_tpl, mag_threshold_tpl, width_template, height_template,\n",
        "                                               r_table)\n",
        "end = time.time()\n",
        "time_process += end - start\n",
        "print(f'\\t + Time of creating R-table process: {round((end - start), 5)}')\n",
        "\n",
        "# Convert 2D R_table to 1D R_table\n",
        "_num_edge_pixels_tpl_np = np.zeros(1, dtype=np.int32)\n",
        "_num_edge_pixels_tpl = cuda.to_device(_num_edge_pixels_tpl_np)\n",
        "r_table_1D = np.zeros((height_template * width_template, 3), dtype=np.float64)\n",
        "num_edge_pixels_and_convert_r_table_to_1D[grid_size_template, block_size](mag_threshold_tpl, _num_edge_pixels_tpl, r_table_1D, r_table)\n",
        "num_edge_pixels_tpl = _num_edge_pixels_tpl.copy_to_host()[0]\n",
        "r_table_1D = r_table_1D[:num_edge_pixels_tpl]\n",
        "\n",
        "print(\"----------End processing template----------\\n\")\n",
        "print(f\"Time processing template: {time_process}\\n\")\n",
        "\n",
        "\n",
        "print(\"----------Start accumulating src----------\\n\")\n",
        "time_process = 0\n",
        "\n",
        "\n",
        "# Gray convert\n",
        "gray_src = np.zeros(src.shape[:2], dtype=np.float64)\n",
        "start = time.time()\n",
        "convert_to_gray[grid_size_src, block_size](src, gray_src)\n",
        "end = time.time()\n",
        "print(f'\\t + Time of gray scale process: {round((end - start), 5)}')\n",
        "time_process += end - start\n",
        "\n",
        "# Sobel filter\n",
        "magnitude_x = np.zeros_like(gray_src)\n",
        "magnitude_y = np.zeros_like(gray_src)\n",
        "start = time.time()\n",
        "convolve[grid_size_src, block_size](sobel_filter_x, gray_src, magnitude_x)\n",
        "convolve[grid_size_src, block_size](sobel_filter_y, gray_src, magnitude_y)\n",
        "end = time.time()\n",
        "print(f'\\t + Time of sobel filter process: {round((end - start), 5)}')\n",
        "time_process += end - start\n",
        "\n",
        "# Magnitude and orientation\n",
        "magnitude_src = np.zeros_like(gray_src)\n",
        "orientation_src = np.zeros_like(gray_src)\n",
        "start = time.time()\n",
        "magnitude[grid_size_src, block_size](magnitude_x, magnitude_y, magnitude_src)\n",
        "orientation[grid_size_src, block_size](magnitude_x, magnitude_y, orientation_src)\n",
        "end = time.time()\n",
        "print(f'\\t + Time of magnitude and orientation process: {round((end - start), 5)}')\n",
        "time_process += end - start\n",
        "\n",
        "# Edge minmax\n",
        "edge_minmax_src = np.zeros_like(gray_src)\n",
        "start = time.time()\n",
        "edgemns[grid_size_src, block_size](magnitude_src, orientation_src, edge_minmax_src)\n",
        "end = time.time()\n",
        "print(f'\\t + Time of edge minmax process: {round((end - start), 5)}')\n",
        "time_process += end - start\n",
        "\n",
        "# Threshold\n",
        "mag_threshold_src = np.zeros_like(gray_src, dtype=np.int32)\n",
        "start = time.time()\n",
        "threshold[grid_size_src, block_size](edge_minmax_src, THRESHOLD, mag_threshold_src)\n",
        "end = time.time()\n",
        "print(f'\\t + Time of threshold process: {round((end - start), 5)}')\n",
        "time_process += end - start\n",
        "\n",
        "# Edge pixels\n",
        "_num_edge_pixels_src_np = np.zeros(1, dtype=np.int32)\n",
        "_num_edge_pixels_src = cuda.to_device(_num_edge_pixels_src_np)\n",
        "edge_pixel_src = np.zeros((height_src * width_src, 2), dtype=np.int32)\n",
        "num_edge_pixels_and_get_pixel_index[grid_size_src, block_size](mag_threshold_src, _num_edge_pixels_src, edge_pixel_src)\n",
        "num_edge_pixels_src = _num_edge_pixels_src.copy_to_host()[0]\n",
        "edge_pixel_src = edge_pixel_src[:num_edge_pixels_src]\n",
        "\n",
        "# Accumulate\n",
        "_accumulator = np.zeros((hblock, wblock), dtype=np.int32)\n",
        "accumulator = cuda.to_device(_accumulator)\n",
        "thread_per_block = 32\n",
        "blocks = (hblock * wblock + thread_per_block - 1) // thread_per_block\n",
        "# block_maxima = np.zeros((hblock, wblock), dtype=[('x', int), ('y', int), ('hits', int)])\n",
        "start = time.time()\n",
        "accumulate[blocks, thread_per_block](edge_pixel_src, num_edge_pixels_src, orientation_src, width_src, height_src, accumulator, r_table_1D)\n",
        "end = time.time()\n",
        "print(f'\\t + Time of accumulate process: {round((end - start), 5)}')\n",
        "accumulator = accumulator.copy_to_host()\n",
        "\n",
        "maxima_threshold = THRESHOLD_RATIO * accumulator.max()\n",
        "time_process += end - start\n",
        "\n",
        "plt.savefig(f'{IMAGE_DIR}/output.png')\n",
        "plt.show()\n",
        "\n",
        "print(\"----------End accumulating src----------\\n\")\n",
        "print(f\"Time process: {time_process}s\\n\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "rdz-LIfiAtUU",
        "outputId": "000da32c-4409-4cb5-9f57-121c6eeeb36f"
      },
      "execution_count": 78,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Overwriting parallel_ght_gpu.py\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# 2. Đánh giá kết quả song song hóa."
      ],
      "metadata": {
        "id": "eR_RaXky-z2d"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 2.1 Sequential General Hough Transform"
      ],
      "metadata": {
        "id": "EhUF5DOo_LDK"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "!python sequence_ght.py"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "U-uyx7_2_qxS",
        "outputId": "e0444d0d-ff06-4436-cb66-58ccbb7bd206"
      },
      "execution_count": 48,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "----------Start processing template----------\n",
            "\n",
            "\t + Time of gray scale process: 0.00884\n",
            "\t + Time of sobel filter process: 0.00517\n",
            "\t + Time of magnitude and orientation process: 0.01388\n",
            "\t + Time of edge minmax process: 0.03744\n",
            "\t + Time of threshold process: 0.38301\n",
            "\t + Time of creating R-table process: 0.02853\n",
            "----------End processing template----------\n",
            "\n",
            "Time processing template: 0.4768655300140381\n",
            "\n",
            "----------Start accumulating src----------\n",
            "\n",
            "\t + Time of gray scale process: 0.06066\n",
            "\t + Time of sobel filter process: 0.02914\n",
            "\t + Time of magnitude and orientation process: 0.05777\n",
            "\t + Time of edge minmax process: 0.23251\n",
            "\t + Time of threshold process: 0.00371\n",
            "Figure(640x480)\n",
            "\t + Time of accumulate process: 33.0149\n",
            "----------End accumulating src----------\n",
            "\n",
            "Time process: 33.398699045181274s\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "out = cv2.imread('seq_output.png')\n",
        "plt.imshow(out)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 452
        },
        "id": "44a_EECHMyer",
        "outputId": "bdb97067-ac04-4951-f290-b227ec21fa09"
      },
      "execution_count": 55,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<matplotlib.image.AxesImage at 0x7fb9954e21d0>"
            ]
          },
          "metadata": {},
          "execution_count": 55
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 2.2 Sequential General Hough Transform with Numba"
      ],
      "metadata": {
        "id": "HK8yog_LKbfr"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "!python sequence_ght_numba.py"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "m4O5HEIJKlk4",
        "outputId": "df98f433-6469-4007-c1c4-46bc42034f2a"
      },
      "execution_count": 54,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "----------Start processing template----------\n",
            "\n",
            "\t + Time of gray scale process: 1.4727\n",
            "\t + Time of sobel filter process: 0.81645\n",
            "\t + Time of magnitude and orientation process: 0.90421\n",
            "\t + Time of edge minmax process: 0.77661\n",
            "\t + Time of threshold process: 0.39505\n",
            "\t + Time of creating R-table process: 1.29224\n",
            "----------End processing template----------\n",
            "\n",
            "----------Start accumulating src----------\n",
            "\n",
            "\t + Time of gray scale process: 0.01258\n",
            "\t + Time of sobel filter process: 0.04558\n",
            "\t + Time of magnitude and orientation process: 0.05056\n",
            "\t + Time of edge minmax process: 0.04129\n",
            "\t + Time of threshold process: 0.4198\n",
            "\t + Time of accumulate process: 5.06905\n",
            "Figure(640x480)\n",
            "----------End accumulating src----------\n",
            "\n",
            "Time process template: 5.657259941101074s\n",
            "\n",
            "Time process source: 5.638855218887329s\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "out = cv2.imread('seq_output_numba.png')\n",
        "plt.imshow(out)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 452
        },
        "id": "S8SaP0mdK-42",
        "outputId": "acf26f17-7915-4a54-f9d6-e8df43d76461"
      },
      "execution_count": 56,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<matplotlib.image.AxesImage at 0x7fb99539ab90>"
            ]
          },
          "metadata": {},
          "execution_count": 56
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 2.3 Parallel General Hough Transform on GPU"
      ],
      "metadata": {
        "id": "YvMQXTp0M6mX"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# chưa parallel accumulating\n",
        "!python parallel_ght_gpu.py"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "OetLnAO1NEdY",
        "outputId": "da01aa0d-ec27-4364-ea43-b3f5b6cb685e"
      },
      "execution_count": 61,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "----------Start processing template----------\n",
            "\n",
            "\t + Time of gray scale process: 0.38012\n",
            "\t + Time of sobel filter process: 0.15877\n",
            "\t + Time of magnitude and orientation process: 0.20784\n",
            "\t + Time of edge minmax process: 0.22644\n",
            "\t + Time of threshold process: 0.06917\n",
            "\t + Time of creating R-table process: 1.42414\n",
            "----------End processing template----------\n",
            "\n",
            "----------Start accumulating src----------\n",
            "\n",
            "\t + Time of gray scale process: 0.02911\n",
            "\t + Time of sobel filter process: 0.03951\n",
            "\t + Time of magnitude and orientation process: 0.05966\n",
            "\t + Time of edge minmax process: 0.02887\n",
            "\t + Time of threshold process: 0.01662\n",
            "\t + Time of accumulate process: 4.8373\n",
            "Figure(640x480)\n",
            "----------End accumulating src----------\n",
            "\n",
            "Time process template: 2.4664814472198486s\n",
            "\n",
            "Time process source: 5.01106333732605s\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# parallel accumulating\n",
        "!python parallel_ght_gpu.py"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3OWzPKdVX4w3",
        "outputId": "7080b932-8aba-4087-bcc8-a73cf9e9306f"
      },
      "execution_count": 79,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "----------Start processing template----------\n",
            "\n",
            "\t + Time of gray scale process: 0.47896\n",
            "\t + Time of sobel filter process: 0.15787\n",
            "\t + Time of magnitude and orientation process: 0.20535\n",
            "\t + Time of edge minmax process: 0.16477\n",
            "\t + Time of threshold process: 0.06934\n",
            "\t + Time of creating R-table process: 0.19041\n",
            "----------End processing template----------\n",
            "\n",
            "Time processing template: 1.2666983604431152\n",
            "\n",
            "----------Start accumulating src----------\n",
            "\n",
            "\t + Time of gray scale process: 0.02698\n",
            "\t + Time of sobel filter process: 0.04111\n",
            "\t + Time of magnitude and orientation process: 0.0541\n",
            "\t + Time of edge minmax process: 0.02863\n",
            "\t + Time of threshold process: 0.0208\n",
            "\t + Time of accumulate process: 0.14324\n",
            "Figure(640x480)\n",
            "----------End accumulating src----------\n",
            "\n",
            "Time process: 0.3148648738861084s\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "out = cv2.imread('parallel_output_gpu.png')\n",
        "plt.imshow(out)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 452
        },
        "id": "fhFJxE3eOW18",
        "outputId": "ae55854a-ac6e-421b-9916-8d958bdfe4e7"
      },
      "execution_count": 62,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<matplotlib.image.AxesImage at 0x7fb995417eb0>"
            ]
          },
          "metadata": {},
          "execution_count": 62
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    }
  ]
}