Fast_Corner_Detection_SOLUTION.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/filippobrizzi/myutils/blob/master/Fast_Corner_Detection_SOLUTION.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#Interview\n",
        "\n",
        "Interview structure, 1 hour 30 min total:\n",
        "* 15 min introducing the problem.\n",
        "* 1 hour coding on your own.\n",
        "* 15 min discussing the solution together.\n",
        "\n",
        "##Question\n",
        "### FAST corner detection\n",
        "Given a grayscale image, detect all keypoints on the image using a FAST corner detector.\n",
        "\n",
        "###Details\n",
        "* Use only the standard C++ library in the implementation, plus the provided code. The code should not have third-party dependencies.\n",
        "  * Feel free to modify the provided code if needed.\n",
        "* You can browse the internet for any resource.\n",
        "* Work on the standard FAST algorithm (not the machine learning one).\n",
        "\n",
        "### Focus\n",
        "Your focus should be (in order of importance):\n",
        "* Correctness: the code does what it is expected.\n",
        "* Design: correctly break down the code into functions and classes.\n",
        "* Performance: the code is optimal in speed and accuracy\n",
        "\n",
        "> Consider the non-maximal suppression step as a bonus. Focus on design and performance of the other steps before tackling it.\n",
        "\n"
      ],
      "metadata": {
        "id": "7Vl2_kjJC4Xw"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Code"
      ],
      "metadata": {
        "id": "Nrv9LeBpD80y"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Prepare environment"
      ],
      "metadata": {
        "id": "jTy_Dz3qED-Q"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "%%script bash\n",
        "apt-get install -y -qq libopencv-dev python3-opencv\n",
        "\n",
        "wget -O van.webp https://public.das.arrival.com/src/images/2a36deb2-d9c4-429f-b13b-ef052c1eb646_Configurator_Image_1_1.webp\n"
      ],
      "metadata": {
        "id": "ruNCVwqWzBa-",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "09b5e16f-95d4-41d9-c3fe-bd1fd54445e6"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Selecting previously unselected package python3-numpy.\r\n",
            "(Reading database ... \r(Reading database ... 5%\r(Reading database ... 10%\r(Reading database ... 15%\r(Reading database ... 20%\r(Reading database ... 25%\r(Reading database ... 30%\r(Reading database ... 35%\r(Reading database ... 40%\r(Reading database ... 45%\r(Reading database ... 50%\r(Reading database ... 55%\r(Reading database ... 60%\r(Reading database ... 65%\r(Reading database ... 70%\r(Reading database ... 75%\r(Reading database ... 80%\r(Reading database ... 85%\r(Reading database ... 90%\r(Reading database ... 95%\r(Reading database ... 100%\r(Reading database ... 124016 files and directories currently installed.)\r\n",
            "Preparing to unpack .../python3-numpy_1%3a1.13.3-2ubuntu1_amd64.deb ...\r\n",
            "Unpacking python3-numpy (1:1.13.3-2ubuntu1) ...\r\n",
            "Selecting previously unselected package python3-opencv.\r\n",
            "Preparing to unpack .../python3-opencv_3.2.0+dfsg-4ubuntu0.1_amd64.deb ...\r\n",
            "Unpacking python3-opencv (3.2.0+dfsg-4ubuntu0.1) ...\r\n",
            "Setting up python3-numpy (1:1.13.3-2ubuntu1) ...\r\n",
            "/usr/lib/python3.8/subprocess.py:842: RuntimeWarning: line buffering (buffering=1) isn't supported in binary mode, the default buffer size will be used\r\n",
            "  self.stdin = io.open(p2cwrite, 'wb', bufsize)\r\n",
            "Setting up python3-opencv (3.2.0+dfsg-4ubuntu0.1) ...\r\n",
            "Processing triggers for man-db (2.8.3-2ubuntu0.1) ...\r\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "--2022-12-19 10:58:15--  https://public.das.arrival.com/src/images/2a36deb2-d9c4-429f-b13b-ef052c1eb646_Configurator_Image_1_1.webp\n",
            "Resolving public.das.arrival.com (public.das.arrival.com)... 172.64.153.193, 104.18.34.63, 2606:4700:4400::6812:223f, ...\n",
            "Connecting to public.das.arrival.com (public.das.arrival.com)|172.64.153.193|:443... connected.\n",
            "HTTP request sent, awaiting response... 200 OK\n",
            "Length: 45078 (44K) [image/webp]\n",
            "Saving to: ‘van.webp’\n",
            "\n",
            "     0K .......... .......... .......... .......... ....      100% 4.00M=0.01s\n",
            "\n",
            "2022-12-19 10:58:15 (4.00 MB/s) - ‘van.webp’ saved [45078/45078]\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Write your main code here\n",
        "\n",
        "This script writes the content of the code snipped to `main.cpp`"
      ],
      "metadata": {
        "id": "SUGD6LvPEGMD"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "%%writefile CMakeLists.txt\n",
        "\n",
        "cmake_minimum_required(VERSION 3.5)\n",
        "\n",
        "project(FAST_corner)\n",
        "\n",
        "set(CMAKE_CXX_STANDARD 17)\n",
        "find_package(OpenCV REQUIRED)\n",
        "include_directories(${OpenCV_INCLUDE_DIRS})\n",
        "add_executable(fast_corner main.cpp)\n",
        "target_link_libraries(fast_corner ${OpenCV_LIBS})\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "bBIE1PCvT8X9",
        "outputId": "67ab9a20-7e5c-427d-8dcf-c8343645a459"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Writing CMakeLists.txt\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "%%writefile fast_corner_support.h\n",
        "#include <vector>\n",
        "#include <cstdint>\n",
        "\n",
        "struct Corner {\n",
        "  Corner(int u, int v) : u(u), v(v) {}\n",
        "  int u = -1;\n",
        "  int v = -1;\n",
        "};\n",
        "\n",
        "//# NOTE: feel free to change or add code to this class if needed.\n",
        "struct Image {\n",
        "  Image(int cols, int rows) : cols(cols), rows(rows) {\n",
        "    data.resize(cols * rows, 0);\n",
        "  }\n",
        "  Image(int cols, int rows, std::vector<uint8_t> data) : cols(cols), rows(rows), data(std::move(data)) {\n",
        "  }\n",
        "  Image() = default;\n",
        "\n",
        "  auto operator()(int col, int row) -> uint8_t& {\n",
        "    return data[row * cols + col];\n",
        "  }\n",
        "  auto operator()(int col, int row) const -> uint8_t {\n",
        "    return data[row * cols + col];\n",
        "  }\n",
        "\n",
        "  int cols;\n",
        "  int rows;\n",
        "  std::vector<uint8_t> data;\n",
        "};\n",
        "\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "SM8nlRWz7lfY",
        "outputId": "24bcc463-aeb1-47e2-bd11-c558bf9902c0"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Writing fast_corner_support.h\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "%%writefile fast_corner.h\n",
        "#include \"fast_corner_support.h\"\n",
        "\n",
        "#include <vector>\n",
        "#include <array>\n",
        "\n",
        "struct FASTCornerDetectorParams{\n",
        "  int threshold = 10;\n",
        "  int contiguos_pixels = 12;\n",
        "};\n",
        "\n",
        "constexpr std::array<std::pair<int, int>, 16> circle_idx_offset = {{\n",
        "  {0, 3},\n",
        "  {1, 3},\n",
        "  {2, 2},\n",
        "  {3, 1},\n",
        "  {3, 0},\n",
        "  {3, -1},\n",
        "  {2, -2},\n",
        "  {1, -3},\n",
        "  {0, -3},\n",
        "  {-1, -3},\n",
        "  {-2, -2},\n",
        "  {-3, -1},\n",
        "  {-3, 0},\n",
        "  {-3, 1},\n",
        "  {-2, 2},\n",
        "  {-1, 3}\n",
        "}};\n",
        "\n",
        "auto bresenhamCircle(const Image& src, int u, int v) -> std::array<uint8_t, 16> {\n",
        "    std::array<uint8_t, 16> pixels;\n",
        "    for (int i = 0; i < 16; ++i) {\n",
        "        int uc = u + circle_idx_offset[i].first;\n",
        "        int vc = v + circle_idx_offset[i].second;\n",
        "        pixels[i] = src(uc, vc);\n",
        "    }\n",
        "    return pixels;\n",
        "}\n",
        "\n",
        "auto isFastCorner(const Image& src, int u, int v, int threshold, int contiguos_pixels) -> bool {\n",
        "    auto pixels = bresenhamCircle(src, u, v);\n",
        "    auto ip = src(u, v);\n",
        "    auto ip_plus_t = ip + threshold;\n",
        "    auto ip_minus_t = ip - threshold;\n",
        "    int current_contiguos_pixels = 0;\n",
        "    uint8_t previous = 0;\n",
        "    bool one_loop_completed = false;\n",
        "    for (int i = 0; i < 16; ++i) {\n",
        "        auto px = pixels[i];\n",
        "        if (px > ip_plus_t) {\n",
        "            if (previous > ip_plus_t) {\n",
        "                if (++current_contiguos_pixels >= contiguos_pixels) {\n",
        "                    return true;\n",
        "                }\n",
        "            } else {\n",
        "                current_contiguos_pixels = 1;\n",
        "            }\n",
        "        } else if (px < ip_minus_t) {\n",
        "            if (previous < ip_minus_t) {\n",
        "                if (++current_contiguos_pixels >= contiguos_pixels) {\n",
        "                    return true;\n",
        "                }\n",
        "            } else {\n",
        "                current_contiguos_pixels = 1;\n",
        "            }\n",
        "        } else {\n",
        "            current_contiguos_pixels = 0;\n",
        "        }\n",
        "        previous = px;\n",
        "\n",
        "        if (i == 15 && !one_loop_completed) {\n",
        "            i = -1;\n",
        "            one_loop_completed = true;\n",
        "        }\n",
        "    }\n",
        "    return false;\n",
        "}\n",
        "\n",
        "\n",
        "auto cornerFAST(const Image& src, const FASTCornerDetectorParams& params) -> std::vector<Corner> {\n",
        "  std::vector<Corner> corners;\n",
        "  for (int col = 3; col < src.cols-3; ++col) {\n",
        "      for (int row = 3; row < src.rows-3; ++row) {\n",
        "          if (isFastCorner(src, col, row, params.threshold, params.contiguos_pixels)) {\n",
        "              corners.emplace_back(Corner(col, row));\n",
        "          }\n",
        "      }\n",
        "  }\n",
        "  return corners;\n",
        "}\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "gtEliev9aWyM",
        "outputId": "0e130cf7-792e-4c0a-d937-4520a9b4f712"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Writing fast_corner.h\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "VICNItybxvwR",
        "outputId": "08d41aa0-ab4a-4069-939d-7328431c1b9e"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Writing main.cpp\n"
          ]
        }
      ],
      "source": [
        "%%writefile main.cpp\n",
        "#include \"fast_corner.h\"\n",
        "\n",
        "#include <algorithm>\n",
        "#include <iostream>\n",
        "#include <cstdint>\n",
        "#include <vector>\n",
        "#include <fstream>\n",
        "\n",
        "#include \"opencv2/highgui/highgui.hpp\"\n",
        "#include \"opencv2/opencv.hpp\"\n",
        "\n",
        "auto convert(const cv::Mat &mat) -> Image {\n",
        "  std::vector<uint8_t> array(mat.total() * mat.channels());\n",
        "  array.assign(mat.data, mat.data + mat.total() * mat.channels());\n",
        "  return Image(mat.cols, mat.rows, array);\n",
        "}\n",
        "\n",
        "auto paintCorners(const cv::Mat &mat, const std::vector<Corner> corners)\n",
        "    -> cv::Mat {\n",
        "  cv::Mat dst;\n",
        "  mat.copyTo(dst);\n",
        "  for (const auto &corner : corners) {\n",
        "    cv::circle(dst, cv::Point(corner.u, corner.v), 5, cv::Scalar(255, 255, 255), 2, 8, 0);\n",
        "  }\n",
        "  return dst;\n",
        "}\n",
        "\n",
        "auto cornerFAST_demo(const cv::Mat &src)\n",
        "    -> std::vector<Corner> {\n",
        "  auto fast = cv::FastFeatureDetector::create();\n",
        "  std::vector<cv::KeyPoint> keypoints;\n",
        "  fast->detect(src, keypoints);\n",
        "  std::vector<Corner> corners;\n",
        "  for (const auto& kp: keypoints) {\n",
        "    corners.emplace_back(Corner(kp.pt.x, kp.pt.y));\n",
        "  }\n",
        "  return corners;\n",
        "}\n",
        "\n",
        "auto getInputImage() -> cv::Mat {\n",
        "  cv::Mat img = cv::imread(\"van.webp\", cv::IMREAD_GRAYSCALE);\n",
        "  if (img.channels() == 3) {\n",
        "      cv::cvtColor(img, img, cv::COLOR_RGB2GRAY);\n",
        "  }\n",
        "  cv::resize(img, img, cv::Size(642, 400));\n",
        "  cv::imwrite(\"van.png\", img);\n",
        "  return img;\n",
        "}\n",
        "\n",
        "int main(int argc, char **argv) {\n",
        "  auto img = getInputImage();\n",
        "\n",
        "  auto corners_cv = cornerFAST_demo(img);\n",
        "  cv::imwrite(\"van_kp_cv.png\", paintCorners(img, corners_cv));\n",
        "\n",
        "  cv::Mat blur;\n",
        "  cv::blur(img, blur, cv::Size(3,3));\n",
        "  auto arr = convert(blur);\n",
        "  FASTCornerDetectorParams params{};\n",
        "  auto corners = cornerFAST(arr, params);\n",
        "  cv::imwrite(\"van_kp.png\", paintCorners(img, corners));\n",
        "  return 0;\n",
        "}\n"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Build and run\n",
        "\n",
        "Make sure you first run the `write main.cpp` script before"
      ],
      "metadata": {
        "id": "AuloXJ5PEwHu"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "%%script bash\n",
        "mkdir -p build\n",
        "cd build\n",
        "cmake ..\n",
        "make -j8"
      ],
      "metadata": {
        "id": "tb0PKaW5yVxB",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "d01d924b-888b-4844-df46-cf5d444612aa"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "-- The C compiler identification is GNU 7.5.0\n",
            "-- The CXX compiler identification is GNU 7.5.0\n",
            "-- Detecting C compiler ABI info\n",
            "-- Detecting C compiler ABI info - done\n",
            "-- Check for working C compiler: /usr/bin/cc - skipped\n",
            "-- Detecting C compile features\n",
            "-- Detecting C compile features - done\n",
            "-- Detecting CXX compiler ABI info\n",
            "-- Detecting CXX compiler ABI info - done\n",
            "-- Check for working CXX compiler: /usr/bin/c++ - skipped\n",
            "-- Detecting CXX compile features\n",
            "-- Detecting CXX compile features - done\n",
            "-- Found OpenCV: /usr (found version \"3.2.0\") \n",
            "-- Configuring done\n",
            "-- Generating done\n",
            "-- Build files have been written to: /content/build\n",
            "[ 50%] Building CXX object CMakeFiles/fast_corner.dir/main.cpp.o\n",
            "[100%] Linking CXX executable fast_corner\n",
            "[100%] Built target fast_corner\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "%%script bash\n",
        "./build/fast_corner"
      ],
      "metadata": {
        "id": "iXqtpzGbAuyg"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Check output"
      ],
      "metadata": {
        "id": "W5DxON-eEz4t"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from google.colab.patches import cv2_imshow\n",
        "import numpy as np\n",
        "import cv2\n",
        "\n",
        "img = cv2.imread('van.png', cv2.IMREAD_GRAYSCALE)\n",
        "img_kp_cv = cv2.imread('van_kp_cv.png', cv2.IMREAD_GRAYSCALE)\n",
        "img_kp = cv2.imread('van_kp.png', cv2.IMREAD_GRAYSCALE)\n",
        "horizontal = np.hstack((img, img_kp_cv, img_kp))\n",
        "cv2_imshow(horizontal)"
      ],
      "metadata": {
        "id": "jAHycBPY1wGB",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 390
        },
        "outputId": "e0e9de60-af51-436e-8c9e-12f0ac12e680"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<PIL.Image.Image image mode=L size=1926x400 at 0x7F52BFB047F0>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "2mcfXuSrV6bZ"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}