2D_Image_Transformation.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "2D_Image_Transformation.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "authorship_tag": "ABX9TyMFMP9+mMuK4op/GiAYopXn",
      "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/RaiShra1/Computer-Vision-and-Image-Processing/blob/main/2D_Image_Transformation.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3AMJIhYWi3ce"
      },
      "source": [
        "import numpy as np\n",
        "import cv2\n",
        "import matplotlib.pyplot as plt\n",
        "from PIL import Image, ImageDraw\n",
        "from scipy import signal\n",
        "from scipy.spatial import distance\n",
        "import math"
      ],
      "execution_count": 1,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 281
        },
        "id": "o5x74i6osURf",
        "outputId": "62e9ef29-8ec0-4171-fed3-f804cec594e6"
      },
      "source": [
        "# Create new Image of size 300x300\n",
        "img = Image.new('L', (300,300), 0)\n",
        "\n",
        "draw = ImageDraw.Draw(img)\n",
        "\n",
        "draw.polygon([(100,135),(150, 100), (180, 185), (115, 175)], outline=1, fill =1)\n",
        "\n",
        "plt.imshow(img, cmap='gray')\n",
        "plt.title(\"Irregular Quadrilateral\")\n",
        "plt.show()"
      ],
      "execution_count": 31,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 281
        },
        "id": "Bp1g1n6NtiI9",
        "outputId": "cbf5972d-83cc-45dd-ee3a-ec2135d9d14f"
      },
      "source": [
        "# translate the image by 30,100\n",
        "\n",
        "translation_Matrix =np.float32([[1, 0, 30], [0, 1, 100]])\n",
        "\n",
        "translated_img = cv2.warpAffine(np.array(img), translation_Matrix, (300,300))\n",
        "\n",
        "plt.imshow(translated_img, cmap='gray')\n",
        "plt.title(\"Translated Image\")\n",
        "plt.show()\n"
      ],
      "execution_count": 32,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAQEAAAEICAYAAABf40E1AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAXh0lEQVR4nO3df5BV5Z3n8feHphHld4MiAUIj6ei6aAEimoRxpTD+Wi3IJEvUZaS2tEjWWGuqdLNkk6w/48RMkZkxm7EkDooaZKJgRR0zBtioqc0mCilU1AVhgG0IIFFRdJQB+rt/3NN6u2m6+3bf2+d2P59X1VN97nPPj28fuJ8+5znn3quIwMzS1S/vAswsXw4Bs8Q5BMwS5xAwS5xDwCxxDgGzxDkEEiLpWUnX9tC2bpH0cE9sy7rHIdBDJL1f1JokfVj0+D/mXV9rkrZLuqBC6z5f0s5KrNtK1z/vAlIREYObpyVtB66NiDWt55PUPyIO92RtljYfCeSs+a+ipP8maQ9wv6QRkp6StE/SO9n0uKJlnpV0u6T/LemApF9JGpU9N1DSw5LekrRf0ouSRrex3UmS/lc2358k/UzS8Oy5h4BPA09mRyrfyvrPlfTbbL0vSTq/aH0TJT2X1bMaGFXCPnhW0h3Zut+X9KSkkVlN72W/Q33R/H8rqTF7br2kPyt67nhJy7L99rqkbxUfdUj6lKSV2b7dJum/dLbOvsohUB1OBuqACcBCCv8u92ePPw18CPzPVstcBfwn4CRgAHBT1r8AGAaMB0YCX8+Wb03AXwKfAv5NNv8tABHxF8D/Ay6PiMER8UNJY4F/BO7Iar0JWCnpxGx9y4H1FF78t2d1lOIK4C+AscAk4P9k+6AOeB24uWjeF4Ep2XPLgUclDcyeuxmoB04BvgjM//gXlvoBTwIvZduZDXxT0kUl1tqnOASqQxNwc0QcjIgPI+KtiFgZEf8SEQeA7wP/rtUy90fE5oj4EPg5hRcFwCEKL/7PRMSRiFgfEe+13mBEbImI1dk29wE/amMbxeYDT0fE0xHRFBGrgXXApZI+DZwNfC9b3/MUXmyluD8itkbEu8Avga0RsSY7NXoUmFpU+8PZPjocEYuB44BTs6fnAXdGxDsRsRO4u2gbZwMnRsRtEfGvEfHPwE8pBFCyPCZQHfZFxEfNDySdAPw1cDEwIuseIqkmIo5kj/cULf8vQPOYw0MU/qqvyA7vHwa+ExGHijeYnSL8LfBnwBAKfxDeaafGCcB/kHR5UV8t8GsKRxPvRMQHRc/tyOrorL1F0x+28bh4TOUm4JpsuwEM5ZPTj08BjUXLFk9PAD4laX9RXw3wmxLq7HN8JFAdWr+V80YKf9nOiYihwHlZvzpcUcShiLg1Ik4HPg9cBlzdxqx3Zts9I9vG/Fbrb11TI/BQRAwvaoMi4gfAbmCEpEFF83+6o1q7Ijv//xaFv/gjImI48G5R7buBcUWLFAdRI7Ct1e8wJCIurUStvYVDoDoNofDXb7+kOlqeD7dL0ixJZ0iqAd6jcHrQdIxtvA+8m53v/9dWz++lcF7d7GHgckkXSarJBiDPlzQuInZQODW4VdIASTOBy6mMIcBhYB/QX9L/oHAk0OznwLezwdWxwPVFz70AHMgGYY/Pfo/Jks6uUK29gkOgOv0NcDzwJ+B3wD+VsOzJwGMUAuB14DkKpwit3QpMo/BX9B+BVa2e/0vgu9mVgJsiohGYA/x3Ci/ARgrB0fx/6CrgHOBtCqH1YAk1l+IZCvtjM4VTjo9oech/G7AT2AasobAvDgJkp1KXURg/2UZh/95HYSA1WfKHilhfJuk/A1dERHuDnknzkYD1KZLGSPqCpH6STqUwvvJ43nVVM18dsL5mAHAvMBHYD6wA/i7XiqpcxU4HJF1M4RJUDXBfNopsZlWmIiGQjUxvpnDH1k4Kd3hdGRGvlX1jZtYtlTodmAFsye7IQtIKCiPLbYaAJI9OmlXenyLixNadlRoYHEvLyzY7s76PSVooaZ2kdRWqwcxa2tFWZ24DgxGxBFgCPhIwy1OljgR20fJ2zXFZn5lVmUqFwItAQ/Ye8wEU3qX1RIW2ZWbdUJHTgYg4LOl6Crd41gBLI+LVSmzLzLqnKm4b9piAWY9YHxHTW3f6tmGzxDkEzBLnEDBLnEPALHEOAbPEOQTMEucQMEucQ8AscQ4Bs8Q5BMwS5xAwS5xDwCxxDgGzxDkEzBLnEDBLnEPALHEOAbPEOQTMEucQMEucQ8AscQ4Bs8Q5BMwS5xAwS5xDwCxxDgGzxDkEzBLnEDBLXLe+kFTSduAAcAQ4HBHTJdUB/wDUA9uBeRHxTvfKNLNKKceRwKyImFL0RYeLgLUR0QCszR6bWZWqxOnAHGBZNr0MmFuBbZhZmXQ3BAL4laT1khZmfaMjYnc2vQcY3daCkhZKWidpXTdrMLNu6NaYADAzInZJOglYLen/Fj8ZESEp2lowIpYASwCONY+ZVV63jgQiYlf2803gcWAGsFfSGIDs55vdLdLMKqfLISBpkKQhzdPAhcBG4AlgQTbbAuAX3S3SzCqnO6cDo4HHJTWvZ3lE/JOkF4GfS7oG2AHM636ZZlYpisj/dNxjAmY9Yn3RpfyP+Y5Bs8Q5BMwS5xAwS5xDwCxxDgGzxDkEzBLnEDBLnEPALHEOAbPEOQTMEucQMEucQ8AscQ4Bs8Q5BMwS5xAwS5xDwCxxDgGzxDkEzBLnEDBLnEPALHEOAbPEOQTMEucQMEucQ8AscQ4Bs8Q5BMwS5xAwS1yHISBpqaQ3JW0s6quTtFrSG9nPEVm/JN0taYuklyVNq2TxZtZ9nTkSeAC4uFXfImBtRDQAa7PHAJcADVlbCNxTnjLNrFI6DIGIeB54u1X3HGBZNr0MmFvU/2AU/A4YLmlMuYo1s/Lr6pjA6IjYnU3vAUZn02OBxqL5dmZ9R5G0UNI6Seu6WIOZlUH/7q4gIkJSdGG5JcASgK4sb2bl0dUjgb3Nh/nZzzez/l3A+KL5xmV9ZlaluhoCTwALsukFwC+K+q/OrhKcC7xbdNpgZtUoItptwCPAbuAQhXP8a4CRFK4KvAGsAeqyeQX8BNgKvAJM72j92XLh5uZW8baurdefshdhrjwmYNYj1kfE9NadvmPQLHEOAbPEOQTMEucQMEucQ8AscQ4Bs8Q5BMwS5xAwS5xDwCxxDgGzxDkEzBLnEDBLnEPALHEOAbPEOQTMEucQMEucQ8AscQ4Bs8Q5BMwS5xAwS5xDwCxxDgGzxDkEzBLnEDBLnEPALHEOAbPEOQTMEtdhCEhaKulNSRuL+m6RtEvShqxdWvTctyVtkbRJ0kWVKtzMyqMzRwIPABe30f/XETEla08DSDoduAL4t9kyfyepplzFmln5dRgCEfE88HYn1zcHWBERByNiG7AFmNGN+syswrozJnC9pJez04URWd9YoLFonp1Z31EkLZS0TtK6btRgZt3U1RC4B5gETAF2A4tLXUFELImI6W19X7qZ9ZwuhUBE7I2IIxHRBPyUTw75dwHji2Ydl/WZWZXqUghIGlP08EtA85WDJ4ArJB0naSLQALzQvRLNrJL6dzSDpEeA84FRknYCNwPnS5oCBLAd+BpARLwq6efAa8Bh4BsRcaQypZtZOSgi8q4BSfkXYdb3rW9rDM53DJolziFgljiHgFniHAJmiXMImCXOIWCWOIeAWeIcAmaJcwiYJc4hYJY4h4BZ4hwCZolzCJglziFgljiHgFniHAJmiXMImCXOIWCWOIeAWeIcAmaJcwiYJc4hYJY4h4BZ4hwCZolzCJglziFgljiHgFniHAJmieswBCSNl/RrSa9JelXSDVl/naTVkt7Ifo7I+iXpbklbJL0saVqlfwkz67rOHAkcBm6MiNOBc4FvSDodWASsjYgGYG32GOASoCFrC4F7yl61mZVNhyEQEbsj4g/Z9AHgdWAsMAdYls22DJibTc8BHoyC3wHDJY0pe+XW50yaNIkrr7wy7zKSU9KYgKR6YCrwe2B0ROzOntoDjM6mxwKNRYvtzPpar2uhpHWS1pVYs/Uxo0aNYsaMGTz77LNceOGFDB48OO+S0hIRnWrAYGA98OfZ4/2tnn8n+/kUMLOofy0wvYN1h1uabciQIfH4449HsZkzZ+ZeVx9t69p6/fWnEyTVAiuBn0XEqqx7r6QxEbE7O9x/M+vfBYwvWnxc1mf2sZqaGm688UbmzZvHWWed1eK5E044IaeqEtWJIwABDwJ/06r/r4BF2fQi4IfZ9L8Hfpktdy7wQie2kXdCuvVg+8IXvhA333xzNDU1RVv2798ftbW1udfZB1ubRwKdCYGZ2QpeBjZk7VJgJIVD/TeANUBdUWj8BNgKvEIHpwIOgbTahRdeGH/84x/bfPE3O3DggEOgMq1rIdATrQp2jluF24knnhizZ8+Ot99+u90AiIhoamqKpUuX5l5zH2xthoDvGLSKO/XUU3n66adZs2YNI0aM6HB+SZx99tlMnjy5B6ozh4BVTL9+/fjxj3/M8uXLmT59eknLTp48mVmzZlWoMivWqasDZqXo168f06ZN47rrrmPBggX069e1vzX19fUMHDiQjz76qMwVWgt5jwd4TKDvtWuvvTYOHz7c4bl/Z3zmM5/J/ffpQ63r9wmYdcbQoUP56le/yuLFi6mpqSnLOn33YOUp+0ucbxFS/kVYt0yfPp1nnnmGESNGIKls692xYwf19fVlW1/i1kfEUYMzPhKwbhk6dCh33XUXF1xwAXV1dWVff7mOKKwdeY8HeEygd7bjjz8+6uvr4ze/+U1Zzv2P5fDhw/GDH/wg99+3jzTfJ2DlUVNTw/e//322bdvGzJkzK76tUaNGVXQbqXMIWEn69+/P7bffzg033NBj27zgggv4/Oc/32PbS43HBKzTvvzlL7N06VIGDRrU5Wv/XTFhwgTGjj3qIymsTHwkYB0688wzufXWW3nggQcYOnRoLoN1X/nKVzj++ON7fLsp8CVCO6aBAwdy8skns2bNGiZNmpRrLU1NTdTX19PY2NjxzHYsbV4i9JGAtenEE0/kkUceYevWrbkHABRuRV65cmXeZfRJHhOwo/Tv3597772XuXPndjxzD+rJcYiUeK/ax2pra1m0aBFbt26tugAAOOOMM7jxxhvzLqPP8ZGAATB79mzOP/98vvvd7+ZdyjENGDCA4cOH511G35PXXYLFjfzvpEq21dTUxKxZs6KxsbFyt/2V0ebNm+O0007Lfb/10uZ3EVpLEyZM4Mknn6ShoYGBAwfmXU6nNDQ0MHLkyLzL6FM8JpCw6667jjPOOKPXBECzq6++2oOEZeT7BBI2duxYnnvuuaq4BFiK999/n7q6Og4dOpR3Kb2N7xOwlnbt2sUzzzyTdxkl69+/P5/73OfyLqPP8JFA4k466ST27NlT1g8C6QlPPfUUl19+ed5l9DY+ErCjHTlyhL179+ZdRskGDRrEsGHD8i6jT3AIJO6tt97ipptuyruMks2aNYv58+fnXUaf4BAwmpqaaGpqyruMkn39619nzJgxeZfR6zkEjEcffZQVK1bkXUbJJk+e7G8wLoMOQ0DSeEm/lvSapFcl3ZD13yJpl6QNWbu0aJlvS9oiaZOkiyr5C1j3HT58mBUrVvD+++/nXUrJrrnmmrxL6P3auo0wWt7SOwaYlk0PATYDpwO3ADe1Mf/pwEvAccBECt9OXNPBNvK+ndINYs+ePT1y62857dixI/f91ota1z5oNCJ2R8QfsukDwOtAe5/1NAdYEREHI2IbsAWY0dF2LH/PPvts3iWU7IQTTuCss87Ku4xeraQxAUn1wFTg91nX9ZJelrRUUvPXzY4Fij/+ZSdthIakhZLWSVpXctVWEbfffnveJZRs1KhRfO1rX8u7jF6t0yEgaTCwEvhmRLwH3ANMAqYAu4HFpWw4IpZExPRo4+YFy8fBgwfZt29f3mWUbNiwYf66sm7oVAhIqqUQAD+LiFUAEbE3Io5ERBPwUz455N8FjC9afFzWZ1Vuy5Yt3HXXXXmXUbJ58+bxxS9+Me8yeq3OXB0Q8PfA6xHxo6L+4gu0XwI2ZtNPAFdIOk7SRKABeKF8JVslrVy5kg0bNuRdRslqa2vzLqH3amu0MFqO3M+kMLL4MrAha5cCDwGvZP1PAGOKlvkOhasCm4BLOrGNvEdN3Yra6tWrKzqiXwkffPBBDBs2LPd9V+WtzasDfgORHWX+/Pncf//99O/fez5z5siRI4waNYr9+/fnXUo18xuIrHMee+yxXvde/ZqaGu655568y+iVHAJ2lCNHjvD888/nXUbJZsyYweTJk/Muo9dxCNhRDh061CuvEpxyyinMmzcv7zJ6HYeAtem3v/0t9957b95llGzkyJG97jMT8+YQsDYdPHiwV76h6LrrrmPKlCl5l9GrOATsmJYsWcKOHTvyLqNkAwYMyLuEXsUhYMe0efNmDhw4kHcZJXvsscd61eXNvDkErF333Xdf3iWU7Ljjjsu7hF7FIWDtWr58Oe+9917eZZRk8ODBLF5c0vvZkuYQsHbt27eP66+/Pu8yStKvXz/q6+vzLqPXcAhYh6rh1vJSTZ06lVmzZuVdRq/gELAOrVy5klWrVuVdRknGjx/PaaedlncZvYKHUK1DH374IatWrTrqcuF5551X1R/tNXv2bJYvX867776bdylVze8itC777Gc/2+Lcu76+nrvvvrvFPJJyvW5/2mmnsWnTpty2X2XafBehQ8DKRtJRt+yOHDmSZcuWtfiuw6lTpzJ8+PAeqWnTpk0+LfiEQ8Cqw5VXXsm4ceNa9M2fP58zzzyz7Nvavn07EydOLPt6eymHgFWv8ePHt/iC0XPOOYc777yzxTy1tbWMGDGi9aLtOnToEHfccQe33XZbWers5doMAQ8MWlVobGyksfGTT6rfuHEjS5cubTHPhAkTjvpY9Llz57b7ScO1tbWMHdve12SYjwSsV5s7dy5Dhgxp0fe9732PhoaGjx9v3ryZq666ivXr1/d0edXGpwOWhrq6uhafPnzZZZexfft21q5dm2NVVcEhYJY4f9ComR3NIWCWOIeAWeIcAmaJcwiYJc4hYJY4h4BZ4hwCZolzCJglrlreQPQn4IPsZ7UYhetpT7XVA9VXU7XVM6Gtzqq4bRhA0rq2bmnMi+tpX7XVA9VXU7XVcyw+HTBLnEPALHHVFAJL8i6gFdfTvmqrB6qvpmqrp01VMyZgZvmopiMBM8uBQ8AscbmHgKSLJW2StEXSopxq2C7pFUkbJK3L+uokrZb0RvaztI+5Lb2GpZLelLSxqK/NGlRwd7bPXpY0rYfquUXSrmw/bZB0adFz387q2STpogrUM17SryW9JulVSTdk/bnso3bqyW0fdVlE5NaAGmArcAowAHgJOD2HOrYDo1r1/RBYlE0vAu6qcA3nAdOAjR3VAFwK/BIQcC7w+x6q5xbgpjbmPT37tzsOmJj9m9aUuZ4xwLRsegiwOdtuLvuonXpy20ddbXkfCcwAtkTEP0fEvwIrgDk519RsDrAsm14GzK3kxiLieeDtTtYwB3gwCn4HDJc0pgfqOZY5wIqIOBgR24AtFP5ty1nP7oj4QzZ9AHgdGEtO+6ideo6l4vuoq/IOgbFAY9HjnbS/IyslgF9JWi9pYdY3OiJ2Z9N7gNE51HWsGvLcb9dnh9dLi06RerQeSfXAVOD3VME+alUPVME+KkXeIVAtZkbENOAS4BuSzit+MgrHc7leS62GGoB7gEnAFGA3sLinC5A0GFgJfDMi3it+Lo991EY9ue+jUuUdAruA8UWPx2V9PSoidmU/3wQep3CYtrf58DH7+WZP19VODbnst4jYGxFHIqIJ+CmfHM72SD2Saim84H4WEauy7tz2UVv15L2PuiLvEHgRaJA0UdIA4ArgiZ4sQNIgSUOap4ELgY1ZHQuy2RYAv+jJujLHquEJ4OpsBPxc4N2iQ+KKaXVO/SUK+6m5niskHSdpItAAvFDmbQv4e+D1iPhR0VO57KNj1ZPnPuqyvEcmKYzibqYwWvqdHLZ/CoVR25eAV5trAEYCa4E3gDVAXYXreITC4eMhCueL1xyrBgoj3j/J9tkrwPQequehbHsvU/hPPaZo/u9k9WwCLqlAPTMpHOq/DGzI2qV57aN26sltH3W1+bZhs8TlfTpgZjlzCJglziFgljiHgFniHAJmiXMImCXOIWCWuP8PZNW1UotOP9kAAAAASUVORK5CYII=\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 281
        },
        "id": "mowF0TYuvEkk",
        "outputId": "bf7a93a4-c3d9-426e-fb0a-83e1e4efebfa"
      },
      "source": [
        "#rotate the image by 45 degrees\n",
        "rotation_matrix = cv2.getRotationMatrix2D((150,150), 45, 1)\n",
        "rotated_img= cv2.warpAffine(translated_img,rotation_matrix,(300,300))\n",
        "\n",
        "plt.imshow(rotated_img, cmap='gray')\n",
        "plt.title(\"Rotated Image\")\n",
        "plt.show()"
      ],
      "execution_count": 33,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yX-X_gomxDAN"
      },
      "source": [
        "# Define function to find angles of corners using Euclidean distances\n",
        "def getAngles(points):\n",
        "    # Find Euclidean distances between all points\n",
        "    euclidean_dist = distance.cdist(points, points, 'euclidean')\n",
        "    print('Euclidean Distances between Corner Points', euclidean_dist)\n",
        "    #Init  \n",
        "    angles = np.empty((0,1), dtype='float32')\n",
        "    # For current corner\n",
        "    for i in range(points.shape[0]):\n",
        "        # Reset max angle\n",
        "        angle = 0\n",
        "        # Find index in Euclidean matrix for all other corners\n",
        "        corners = np.nonzero(euclidean_dist[i,:])\n",
        "        \n",
        "        # For combinations of 2 other corner points\n",
        "        for j in range(points.shape[0]-1):\n",
        "            # Order for other 2 point combinations - [1,2], [1,3], [2,3]\n",
        "            if j == points.shape[0] - 2:\n",
        "                k = 1\n",
        "                m = j\n",
        "            else:\n",
        "                k = 0\n",
        "                m = j+1\n",
        "            \n",
        "            # Find line 1 between current corner and other corner 1 \n",
        "            l1 = euclidean_dist[i,corners[0][k]]\n",
        "            # Find line 2 between current corner and other corner 2 \n",
        "            l2 = euclidean_dist[i,corners[0][m]]\n",
        "            # Find line 3 between other corner 1 and other corner 2 \n",
        "            l3 = euclidean_dist[corners[0][k], corners[0][m]]\n",
        "            # Use Law of Cosines to find angle of current corner\n",
        "            tmp_angle = np.arccos((l3**2 - l1**2 - l2**2) / (-2 * l1 * l2))\n",
        "            \n",
        "            # Use largest angle for current corner from combinations of other corners \n",
        "            if tmp_angle > angle:\n",
        "                angle = tmp_angle\n",
        "                \n",
        "            print(i, j, 'Corners:', corners)\n",
        "            print('Point1', corners[0][k], 'Point2', corners[0][m],\n",
        "                  'Dist 1:', l1, 'Dist2:', l2, 'Angle:', tmp_angle)\n",
        "    \n",
        "        # Add final angle for current corner to final angle array\n",
        "        angles = np.concatenate((angles,[[angle]]), axis=0)\n",
        "    return angles"
      ],
      "execution_count": 35,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "uShY_9q6cjHr"
      },
      "source": [
        "def getCornerCoordinates(img):\n",
        "    # Initialize Matrix for max values at each corner to assign single point\n",
        "    corners = np.empty((0,2), dtype = 'uint16')\n",
        "    # For each corner:\n",
        "    for i in range(4):\n",
        "        # Find the max pixel value coordinate in the entire image\n",
        "        max_ind = np.unravel_index(np.argmax(img, axis=None), img.shape)\n",
        "        # Store coordinate in corners matrix\n",
        "        corners = np.concatenate((corners, [[max_ind[0], max_ind[1]]]), axis=0)\n",
        "        # Assign intensities for that cluster (pixels around current max) to 0 \n",
        "        img[max_ind[0]-5:max_ind[0]+5, max_ind[1]-5:max_ind[1]+5] = 0\n",
        "        # Repeat for new max pixel intensity coordinate\n",
        "    return corners"
      ],
      "execution_count": 9,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "l8GiEihdc26o"
      },
      "source": [
        "# Function to find detect corners and assign descriptors to each point\n",
        "def cornerDetector(img, threshold):\n",
        "\n",
        "    h = img.shape[0]\n",
        "    w = img.shape[1]\n",
        "    # Determine convolution kernels for x and y direction\n",
        "    kern_x = np.array([[-1, 0, 1], [-2, 0, 2], [-1, 0, 1]])\n",
        "    kern_y = np.array([[1, 2, 1], [0, 0, 0], [-1, -2, -1]])\n",
        "    \n",
        "    # Convolve to get x and y image gradients\n",
        "    I_x = signal.convolve2d(img, kern_x, mode='same')\n",
        "    I_y = signal.convolve2d(img, kern_y, mode='same')\n",
        "    \n",
        "    # Calculate Ix^2, Iy^2, and Ixy\n",
        "    I_xx = I_x**2\n",
        "    I_yy = I_y**2\n",
        "    I_xy = I_x * I_y\n",
        "    \n",
        "    k = 0.05\n",
        "    # If section size = 3x3, offset = 3/2 = 1\n",
        "    offset = 1\n",
        "    # Initialize matrix for response at each coordinate\n",
        "    h_r = np.empty((0,3), dtype='uint16')\n",
        "    \n",
        "    for y in range(offset, h - offset):\n",
        "        for x in range(offset, w - offset):\n",
        "            # Find sum of Ix^2, Iy^2, and Ixy at each sectionin each image \n",
        "            S_xx = np.sum(I_xx[y - offset:y + 1 + offset,\\\n",
        "                               x - offset:x + 1 + offset])\n",
        "            S_yy = np.sum(I_yy[y - offset:y + 1 + offset,\\\n",
        "                               x - offset:x + 1 + offset])\n",
        "            S_xy = np.sum(I_xy[y - offset:y + 1 + offset,\\\n",
        "                               x - offset:x + 1 + offset])\n",
        "            \n",
        "            # determinant\n",
        "            det = (S_xx * S_yy) - (S_xy**2)\n",
        "            # Trace\n",
        "            trace = S_xx + S_yy\n",
        "            # Response\n",
        "            r = det - k * (trace**2)\n",
        "            # Combine with current image coordinate\n",
        "            resp = [[x, y, r]]\n",
        "            # Add to response matrix\n",
        "            h_r = np.concatenate((h_r, resp), axis=0)\n",
        "              \n",
        "    #Initialize matrix to view corners\n",
        "    img_copy = np.zeros((h,w))\n",
        "    img_corners = np.zeros((h,w))\n",
        "    \n",
        "    # For response in response matrix\n",
        "    for i in range(h_r.shape[0]):\n",
        "        x, y, r = h_r[i,0].astype('uint16'), h_r[i,1].astype('uint16'), h_r[i,2]\n",
        "        # If response is larger than threshold, it is probably a corner\n",
        "        if r > threshold:\n",
        "            img_corners[y,x] = 1\n",
        "            img_copy[y,x] = r / np.amax(h_r[:,2])\n",
        "\n",
        "    \n",
        "    # Find single coordinate for each corner\n",
        "    corners = getCornerCoordinates(img_copy)\n",
        "    # Find angles for each corner    \n",
        "    angles = getAngles(corners)\n",
        "\n",
        "    # print(corners, angles)\n",
        "    # print(angles)\n",
        "        \n",
        "    # Add angle to each image corner coordinate\n",
        "    corner_descript = np.concatenate((corners, angles), axis=1)\n",
        "    print('Corner Points and Angle Descriptor')\n",
        "    print(corner_descript)\n",
        "    \n",
        "    #     # Plot Gradients, Image, and Corners\n",
        "    #     plot([I_x, I_y, I_xx, I_yy, img, img_corners],\\\n",
        "    #          cmap='gray', subplot_size=(3,2), figsize=(20,20),\n",
        "    #          title=['Image Gradient Ix',\n",
        "    #                 'Image Gradient Iy',\n",
        "    #                 'Image Gradient Ixx',\n",
        "    #                 'Image Gradient Iyy',\n",
        "    #                 'Image',\n",
        "    #                 'Image Corners'])\n",
        "    # Plot original, translated and rotated images\n",
        "    plt.figure(figsize=(10,10))\n",
        "    plt.subplot(1,2,1)\n",
        "    plt.imshow(img, cmap ='gray')\n",
        "    plt.title(\"Image\")\n",
        "    plt.subplot(1,2,2)\n",
        "    plt.imshow(img_corners, cmap ='gray')\n",
        "    plt.title('Image Corners')\n",
        "          \n",
        "        \n",
        "    return corner_descript"
      ],
      "execution_count": 40,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8dO6eFvZfOnf"
      },
      "source": [
        "#Match Corners found\n",
        "def matchFeatures(corners1, corners2):\n",
        "    # Initialize location arrays for sorted image 1 and 2 matches\n",
        "    loc1 = np.zeros((corners1.shape[0], 2))\n",
        "    loc2 = np.zeros((corners1.shape[0], 2))\n",
        "    # For each corner in image 1\n",
        "    for i in range(corners1.shape[0]):\n",
        "        # Initialize high initial angle error\n",
        "        angle_error = 10\n",
        "        # Compare to each corner in image 2\n",
        "        for j in range(corners2.shape[0]):\n",
        "            # Find error between descriptors (angle) of the two features\n",
        "            tmp_error = np.abs(corners1[i,2] - corners2[j,2])\n",
        "            # If error is less than previous error\n",
        "            if tmp_error < angle_error:\n",
        "                # Current coordinates match \n",
        "                angle_error = tmp_error\n",
        "                # Assign current corner coordinates for image 1\n",
        "                loc1[i,:] = corners1[i, 0:2]\n",
        "                # Assign current corner coordinates for image 2\n",
        "                loc2[i,:] = corners2[j, 0:2]\n",
        "\n",
        "        print('Corner Location Matches Check:')\n",
        "        for j in range(loc1.shape[0]): print(loc1[j,:], loc2[j,:])\n",
        "    return loc1, loc2"
      ],
      "execution_count": 37,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NIqdsfGufdaH"
      },
      "source": [
        "def drawMatches(img1, img2, matches, inliers = None):\n",
        "    # Create a new output image that concatenates the two images together\n",
        "    rows1 = img1.shape[0]\n",
        "    cols1 = img1.shape[1]\n",
        "    rows2 = img2.shape[0]\n",
        "    cols2 = img2.shape[1]\n",
        "    img1 = img1.astype('uint8') * 255\n",
        "    img2 = img2.astype('uint8') * 255\n",
        "    out = np.zeros((max([rows1,rows2]),cols1+cols2,3), dtype='uint8')\n",
        "\n",
        "    # Place the first image to the left\n",
        "    out[:rows1,:cols1,:] = np.dstack([img1, img1, img1])\n",
        "\n",
        "    # Place the next image to the right of it\n",
        "    out[:rows2,cols1:cols1+cols2,:] = np.dstack([img2, img2, img2])\n",
        "\n",
        "    # draw circles, then connect a line between them\n",
        "    for i in range(matches.shape[0]):\n",
        "        \n",
        "        (y1,x1) = matches[i,0:2]\n",
        "        (y2,x2) = matches[i,2:4]\n",
        "        \n",
        "        # Draw circle at both co-ordinates\n",
        "        cv2.circle(out, (int(x1),int(y1)), 4, (255, 0, 0), 1)\n",
        "        cv2.circle(out, (int(x2)+cols1,int(y2)), 4, (255, 0, 0), 1)\n",
        "\n",
        "        # Draw line between the two points\n",
        "        if inliers is not None and inlier:\n",
        "            cv2.line(out, (int(x1),int(y1)), (int(x2)+cols1,int(y2)),\\\n",
        "                     (0, 255, 0), 1)\n",
        "        elif inliers is not None:\n",
        "            cv2.line(out, (int(x1),int(y1)), (int(x2)+cols1,int(y2)),\\\n",
        "                     (0, 0, 255), 1)\n",
        "\n",
        "        if inliers is None:\n",
        "            cv2.line(out, (int(x1),int(y1)), (int(x2)+cols1,int(y2)),\\\n",
        "                     (255, 0, 0), 1)\n",
        "\n",
        "    return out"
      ],
      "execution_count": 38,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 879
        },
        "id": "aDBk4HWzfs73",
        "outputId": "19c7fa71-dbd0-4c1f-bc7d-e0b74d038c9d"
      },
      "source": [
        "corners_original = cornerDetector(np.array(img), 600)"
      ],
      "execution_count": 41,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Euclidean Distances between Corner Points [[ 0.         87.92041856 60.46486583 81.85963596]\n",
            " [87.92041856  0.         92.96235797 64.62971453]\n",
            " [60.46486583 92.96235797  0.         42.72001873]\n",
            " [81.85963596 64.62971453 42.72001873  0.        ]]\n",
            "0 0 Corners: (array([1, 2, 3]),)\n",
            "Point1 1 Point2 2 Dist 1: 87.92041856133307 Dist2: 60.4648658313239 Angle: 1.309757719487787\n",
            "0 1 Corners: (array([1, 2, 3]),)\n",
            "Point1 1 Point2 3 Dist 1: 87.92041856133307 Dist2: 81.85963596303125 Angle: 0.7779312163030114\n",
            "0 2 Corners: (array([1, 2, 3]),)\n",
            "Point1 2 Point2 3 Dist 1: 60.4648658313239 Dist2: 81.85963596303125 Angle: 0.5318265031847753\n",
            "1 0 Corners: (array([0, 2, 3]),)\n",
            "Point1 0 Point2 2 Dist 1: 87.92041856133307 Dist2: 92.9623579735368 Angle: 0.6794796998887241\n",
            "1 1 Corners: (array([0, 2, 3]),)\n",
            "Point1 0 Point2 3 Dist 1: 87.92041856133307 Dist2: 64.6297145282261 Angle: 1.094949401720165\n",
            "1 2 Corners: (array([0, 2, 3]),)\n",
            "Point1 2 Point2 3 Dist 1: 92.9623579735368 Dist2: 64.6297145282261 Angle: 0.415469701831441\n",
            "2 0 Corners: (array([0, 1, 3]),)\n",
            "Point1 0 Point2 1 Dist 1: 60.4648658313239 Dist2: 92.9623579735368 Angle: 1.1523552342132821\n",
            "2 1 Corners: (array([0, 1, 3]),)\n",
            "Point1 0 Point2 3 Dist 1: 60.4648658313239 Dist2: 42.720018726587654 Angle: 1.8092023146170018\n",
            "2 2 Corners: (array([0, 1, 3]),)\n",
            "Point1 1 Point2 3 Dist 1: 92.9623579735368 Dist2: 42.720018726587654 Angle: 0.6568470804037199\n",
            "3 0 Corners: (array([0, 1, 2]),)\n",
            "Point1 0 Point2 1 Dist 1: 81.85963596303125 Dist2: 64.6297145282261 Angle: 1.2687120355666166\n",
            "3 1 Corners: (array([0, 1, 2]),)\n",
            "Point1 0 Point2 2 Dist 1: 81.85963596303125 Dist2: 42.720018726587654 Angle: 0.8005638357880162\n",
            "3 2 Corners: (array([0, 1, 2]),)\n",
            "Point1 1 Point2 2 Dist 1: 64.6297145282261 Dist2: 42.720018726587654 Angle: 2.0692758713546326\n",
            "Corner Points and Angle Descriptor\n",
            "[[101.         150.           1.30975772]\n",
            " [184.         179.           1.0949494 ]\n",
            " [135.         100.           1.80920231]\n",
            " [175.         115.           2.06927587]]\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 720x720 with 2 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 879
        },
        "id": "KpCsjJDVf5h3",
        "outputId": "bc4c4981-d406-4754-a59c-f9de5b9d48b6"
      },
      "source": [
        "corners_rotated = cornerDetector(np.array(rotated_img), 600)"
      ],
      "execution_count": 42,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Euclidean Distances between Corner Points [[ 0.         88.5663593  93.62157871 65.        ]\n",
            " [88.5663593   0.         61.         81.93289938]\n",
            " [93.62157871 61.          0.         42.54409477]\n",
            " [65.         81.93289938 42.54409477  0.        ]]\n",
            "0 0 Corners: (array([1, 2, 3]),)\n",
            "Point1 1 Point2 2 Dist 1: 88.56635930193812 Dist2: 93.62157870918435 Angle: 0.6806551353033823\n",
            "0 1 Corners: (array([1, 2, 3]),)\n",
            "Point1 1 Point2 3 Dist 1: 88.56635930193812 Dist2: 65.0 Angle: 1.0869494452130226\n",
            "0 2 Corners: (array([1, 2, 3]),)\n",
            "Point1 2 Point2 3 Dist 1: 93.62157870918435 Dist2: 65.0 Angle: 0.4062943099096404\n",
            "1 0 Corners: (array([0, 2, 3]),)\n",
            "Point1 0 Point2 2 Dist 1: 88.56635930193812 Dist2: 61.0 Angle: 1.3086677647766487\n",
            "1 1 Corners: (array([0, 2, 3]),)\n",
            "Point1 0 Point2 3 Dist 1: 88.56635930193812 Dist2: 81.93289937503738 Angle: 0.7785769867912514\n",
            "1 2 Corners: (array([0, 2, 3]),)\n",
            "Point1 2 Point2 3 Dist 1: 61.0 Dist2: 81.93289937503738 Angle: 0.5300907779853972\n",
            "2 0 Corners: (array([0, 1, 3]),)\n",
            "Point1 0 Point2 1 Dist 1: 93.62157870918435 Dist2: 61.0 Angle: 1.1522697535097624\n",
            "2 1 Corners: (array([0, 1, 3]),)\n",
            "Point1 0 Point2 3 Dist 1: 93.62157870918435 Dist2: 42.5440947723653 Angle: 0.6482713462735085\n",
            "2 2 Corners: (array([0, 1, 3]),)\n",
            "Point1 1 Point2 3 Dist 1: 61.0 Dist2: 42.5440947723653 Angle: 1.800541099783271\n",
            "3 0 Corners: (array([0, 1, 2]),)\n",
            "Point1 0 Point2 1 Dist 1: 65.0 Dist2: 81.93289937503738 Angle: 1.2760662215855192\n",
            "3 1 Corners: (array([0, 1, 2]),)\n",
            "Point1 0 Point2 2 Dist 1: 65.0 Dist2: 42.5440947723653 Angle: 2.087026997406644\n",
            "3 2 Corners: (array([0, 1, 2]),)\n",
            "Point1 1 Point2 2 Dist 1: 81.93289937503738 Dist2: 42.5440947723653 Angle: 0.8109607758211251\n",
            "Corner Points and Angle Descriptor\n",
            "[[203.         287.           1.08694945]\n",
            " [165.         207.           1.30866776]\n",
            " [225.         196.           1.8005411 ]\n",
            " [242.         235.           2.087027  ]]\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlYAAAEtCAYAAADKqC6AAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAetElEQVR4nO3dfZBcdZ3v8feXZCBKgJDAhpDETZYbBda1AgsxalZF94qycpNUISISWMu67HLVWqpWr4B10cVdCyhc0QIfgnITLBHZSyIRcRVBamEpwoNkeX4IEExCICBIEiAJSb73jz7BBmYyT7/p0z3zflWdmp5fnz79nUPmy2d+59fdkZlIkiRp8HaruwBJkqThwmAlSZJUiMFKkiSpEIOVJElSIQYrSZKkQgxWkiRJhRisJEmSCjFYaUAiYlVE/HXddUgaXjqlt0TE3hFxYUT8LiI2RcSj1ff71V2b6mWwkiSpHyJid+B64M+BDwN7A+8Cfg/MGsDxRhWsbXSpY2lgDFYalIj424j4z4j4RkT8ISIei4h3V+OrI2J9RJzStP/fRMRdEbGhuv8rrzveyRHxRET8PiL+T/NfrxGxW0ScUf1l+PuIuDIixrf4R5bUIm3cX04G3gLMz8z7M3NHZq7PzK9m5rXV8Q6JiBuruu+LiP/RVMeiiPhORFwbES8CR1W1fD4i7o6IFyLiJxExpukxH42IFdXxbomIdzTdtyoivhgRdwMvRsTo6vu1EbExIh6KiA8O/r+I+sJgpRLeCdwNTAAuB64AjgT+G3AScFFEjK32fZFGUxoH/A1wWkTMA4iIQ4FvA58EJgH7AJObnudzwDzgfcCBwPPAxUP5g0mqXTv2l78G/j0zN3V3Z0R0AT8DfgX8SXXsH0XE25p2OxH4F2Av4OZq7HgaM2DTgXcAf1sd7zDgUuDvqvPwPWBZROzRdLxPVD/zOOAg4LPAkZm5F3A0sKqHn0WFGaxUwuOZ+X8zczvwE2AqcE5mbsnMXwFbaTRBMvPGzLyn+gvvbuDHNBoZwHHAzzLz5szcCpwNNH+Y5d8DX8rMNZm5BfgKcJxT39Kw1o79ZQKwbhc1zwbGAudm5tbMvAG4hkb42enqzPzPqtbN1di3MvPJzHyORjCbWY2fCnwvM5dn5vbMXAxsqZ6HpseuzsyXge3AHsChEdGVmasy89Fd1KuCDFYq4emm2y8DZObrx8YCRMQ7I+I3EfFMRLxAo5ntXOx5ILB654My8yUaaxZ2+lNgaTUV/gfgARoNZGLhn0dS+2jH/vJ7GrNePTkQWJ2ZO5rGnuC1M2SreaOnmm6/tPPnqmr7x521VfVNrZ7nDcfLzJXA6TTC4fqIuCIimvfVEDJYqdUuB5YBUzNzH+C7QFT3rQOm7NwxIt5E4y/DnVYDH8nMcU3bmMxc26LaJbW3VvWXXwNHR8SePdTxJDA1Ipr/H/sWoPlYSd+tBv7ldbW9OTN/3NPxMvPyzJxDI5QlcF4/nk+DYLBSq+0FPJeZmyNiFo11Bjv9P+DYanHq7jT+2oqm+78L/EtE/ClAROwfEXNbVLek9teq/vJDGmHnqog4uFr4PiEizoqIY4DlNGac/ndEdEXE+4FjaawPG4hLgL+vZuQiIvasFurv1d3OEfG2iPhAtQZrM41ZvR3d7avyDFZqtf8FnBMRG2mscbhy5x2ZeR+NRZ5X0PjrchOwnsZaAoBv0vhr9FfV42+lsbBVkqBF/aVag/XXwIPAdcAG4DYalx2XV2u4jgU+AjxLY9H8yZn54EB+qMy8A/ifwEU0FtWvpFrY3oM9gHOr536KxgL6Mwfy3Oq/yOzPbKTUOtUrff4AzMjMx+uuR9LwYX/RUHHGSm0lIo6NiDdXaxcuAO7BlwlLKsD+olYwWKndzKWx8PNJYAZwQjqtKqkM+4uG3JBdCoyID9O4Zj0K+H5mnjskTyRJhdm/JA3UkASraHzu0cPAfwfWALcDn8jM+4s/mSQVZP+SNBhDdSlwFrAyMx+rXh1xBY0pWElqd/YvSQM2VB8FMpnXvqvsGnbxsviI8Bq3NPI8m5n7111EN/rVv8AeJo1EmRndjdf2GWsRcSqNzz+SNDI9UXcBg2EPk9SdoQpWa2l8jtFOU3jtW/mTmQuBheBfe5LaSq/9C+xhkro3VGusbgdmRMT06qMDTqDxjraS1O7sX5IGbEhmrDJzW0R8FvgljZcrX1p9nIAktTX7l6TBaIuPtHEaXRqR7szMI+ouogR7mDTy9LR43XdelyRJKsRgJUmSVIjBSpIkqRCDlSRJUiEGK0mSpEIMVpIkSYUYrCRJkgoxWEmSJBVisJIkSSrEYCVJklSIwUqSJKkQg5UkSVIhBitJkqRCDFaSJEmFGKwkSZIKMVhJkiQVYrCSJEkqxGAlSZJUiMFKkiSpEIOVJElSIQYrSZKkQgxWkiRJhRisJEmSCjFYSZIkFWKwkiRJKsRgJUmSVIjBSpIkqRCDlSRJUiEGK0mSpEIMVpIkSYUYrCRJkgoxWEmSJBVisJIkSSpk9GAeHBGrgI3AdmBbZh4REeOBnwDTgFXA8Zn5/ODKlKTy7GGSSisxY3VUZs7MzCOq788Ars/MGcD11feS1K7sYZKKGYpLgXOBxdXtxcC8IXgOSRoq9jBJAzbYYJXAryLizog4tRqbmJnrqttPARMH+RySNFTsYZKKGtQaK2BOZq6NiD8BrouIB5vvzMyMiOzugVUTO7W7+ySpRexhkooa1IxVZq6tvq4HlgKzgKcjYhJA9XV9D49dmJlHNK1rkKSWsodJKm3AwSoi9oyIvXbeBj4E3AssA06pdjsFuHqwRUpSafYwSUNhMJcCJwJLI2LncS7PzH+PiNuBKyPi08ATwPGDL1OSirOHSSouMrtdPtDaInpYwyBpWLtzuFxGs4dJI09mRnfjvvO6JElSIQYrSZKkQgxWkiRJhRisJEmSCjFYSZIkFWKwkiRJKsRgJUmSVIjBSpIkqRCDlSRJUiEGK0mSpEIMVpIkSYUYrCRJkgoxWEmSJBVisJIkSSrEYCVJklSIwUqSJKkQg5UkSVIhBitJkqRCDFaSJEmFGKwkSZIKMVhJkiQVYrCSJEkqxGAlSZJUiMFKkiSpEIOVJElSIQYrSZKkQgxWkiRJhRisJEmSCjFYSZIkFWKwkiRJKsRgJUmSVIjBSpIkqRCDlSRJUiG9BquIuDQi1kfEvU1j4yPiuoh4pPq6bzUeEfGtiFgZEXdHxOFDWbwk9cYeJqmV+jJjtQj48OvGzgCuz8wZwPXV9wAfAWZU26nAd8qUKUkDtgh7mKQW6TVYZeZ/AM+9bngusLi6vRiY1zR+WTbcCoyLiEmlipWk/rKHSWqlga6xmpiZ66rbTwETq9uTgdVN+62pxiSpndjDJA2J0YM9QGZmRGR/HxcRp9KYapek2tjDJJU00Bmrp3dOj1df11fja4GpTftNqcbeIDMXZuYRmXnEAGuQpIGyh0kaEgMNVsuAU6rbpwBXN42fXL2yZjbwQtN0uyS1C3uYpCHR66XAiPgx8H5gv4hYA3wZOBe4MiI+DTwBHF/tfi1wDLASeAn41BDULEl9Zg+T1EqR2e+lBeWLGMD6Bkkd787hchnNHiaNPJkZ3Y37zuuSJEmFGKwkSZIKMVhJkiQVYrCSJEkqxGAlSZJUiMFKkiSpEIOVJElSIQYrSZKkQgxWkiRJhRisJEmSCjFYSZIkFWKwkiRJKsRgJUmSVIjBSpIkqRCDlSRJUiEGK0mSpEIMVpIkSYUYrCRJkgoxWEmSJBVisJIkSSrEYCVJklSIwUqSJKkQg5UkSVIhBitJkqRCDFaSJEmFGKwkSZIKMVhJkiQVYrCSJEkqxGAlSZJUiMFKkiSpEIOVJElSIQYrSZKkQgxWkiRJhfQarCLi0ohYHxH3No19JSLWRsSKajum6b4zI2JlRDwUEUcPVeGS1Bf2MEmt1JcZq0XAh7sZ/0Zmzqy2awEi4lDgBODPq8d8OyJGlSpWkgZgEfYwSS3Sa7DKzP8Anuvj8eYCV2Tmlsx8HFgJzBpEfZI0KPYwSa00mDVWn42Iu6tp9n2rscnA6qZ91lRjktRu7GGSihtosPoOcBAwE1gHfL2/B4iIUyPijoi4Y4A1SNJA2cMkDYkBBavMfDozt2fmDuAS/jhVvhaY2rTrlGqsu2MszMwjMvOIgdQgSQNlD5M0VAYUrCJiUtO384Gdr7ZZBpwQEXtExHRgBnDb4EqUpLLsYZKGyujedoiIHwPvB/aLiDXAl4H3R8RMIIFVwN8BZOZ9EXElcD+wDfhMZm4fmtIlqXf2MEmtFJlZdw1ERP1FSGq1O4fLZTR7mDTyZGZ0N+47r0uSJBVisJIkSSrEYCVJklSIwUqSJKkQg5UkSVIhBitJkqRCDFbSIOy///5EdPuKW0lqe/vvvz8HHnhg3WUMKwYraRCuueYa5s2bx+zZs+suRZL67ZprrmHlypV1lzGs9PrO65J2bcmSJaxfv57zzz+fm2++meXLl9ddkiT1yeWXX84BBxxQdxnDiu+8Lg3Qpz/9ac477zwmTJjw6tiKFSv41Kc+xYoVK2qsrGP4zuuSOlZP77zujJU0QO9617teE6oAZs6cyZIlS9iwYQPPPfccH/jAB2qqTpJUB4OVVNj06dMByEw2bNjAokWLOOusswDYtGlTnaVJkoaYi9elAZgwYQLjx4/f5T4RwV577cXnPvc5Nm7cyMaNG5kzZw5vfetbW1SlJKnVDFbSAHziE59g/vz5/X7cTTfdxI033sicOXOGoCpJUt28FCi12KRJk7j00kv56U9/CsD555/Ps88+W3NVkqQSDFZSDWbMmMEXvvAFoLEIft26dRx//PE1VyVJGiyDlVSzOXPmsGPHDpYsWcJxxx336viOHTtqrEqSNBCusZLawG677cb8+fPZsmXLq9uhhx5ad1mSpH4yWEltZPTo0a9uK1as4KijjuLtb3973WVJkvrIS4FSP02ePJmjjjpqyJ+nq6uLG264gXvvvZcf/OAHACxevJjnn39+yJ9bkjQwfqSN1E9z5szhpptuquW5ly5dyvHHH8+2bdtqef7C/EgbSR2rp4+08VKg1EHmz5/P7bffzqJFi+ouRZLUDYOV1A8RwZvf/OZaa5g5cyYnnXQSL7zwAqeddhp77rln7TVJkhq8FCj1w8SJE3nqqafqLuMNXnnlFQ4//HA2bNjA7373u7rL6SsvBUrqWF4KlIaxrq4u7rnnHpYuXcrb3/523vOe97D33nvXXZYkjTjOWEn90K4zVs1uueUWJkyYwE033cRpp53WzgvdnbGS1LF6mrHy7RakPooILrvssrrL6NW73/1uAN72trfxlre8hQceeIDTTz+95qok1S0iWLx4MSeffHLdpQxrzlhJfRQRvPzyy+yxxx51l9IvW7duZd26dQB8/OMfZ/ny5TVX9CpnrKQWmzx5MmvXrq27jGGhpxkrg5XUDzNnzuSuu+6qu4wB2759OzNnzuTpp5/mmWeeqbscg5WkjmWwkgYpItiyZQtdXV11lzJo69at48QTT2TVqlWsWrWqrjIMVpI6lsFKGqThFKx2uu666/j5z38OwMUXX9zqhe4GK0kdy2AlDdJwDFbNfvjDH7Jy5UrOOeecVj2lwUpSx/JVgZJ2acGCBbz00ktkJl/96lfrLkeSOpIzVlIf3XXXXcycObPuMobc1q1beemllwBeXei+efPmoXgqZ6wkdawBv/N6REyNiN9ExP0RcV9E/EM1Pj4irouIR6qv+1bjERHfioiVEXF3RBxe9keR6jFS3sl89913Z9y4cYwbN45Vq1bxyCOPMHXq1LrLGhD7l6RW68tH2mwD/jEzDwVmA5+JiEOBM4DrM3MGcH31PcBHgBnVdirwneJVS2qZKVOmsGzZMj72sY91YsCyf0lqqV7XWGXmOmBddXtjRDwATAbmAu+vdlsM3Ah8sRq/LBvXGG+NiHERMak6jtSRTj75ZMaPH193GbWZOXMmV155JT/96U+5//772bx5c0esw7J/SWq1fi1ej4hpwGHAcmBiU7N5CphY3Z4MrG562JpqzMakjvWxj32McePG1V1G7ebNm8e8efPYtm0bs2bN4oYbbuAb3/hG3WX1if1LUiv05VIgABExFrgKOD0zNzTfV/1116/FmxFxakTcERF39Odxkuo3evRoPvrRj3LOOefw2GOP8dhjjzFx4kQiul3LWbvS/as6pj1MGmYiYtB9rE/BKiK6aDSlH2Xmkmr46YiYVN0/CVhfja8FmhdiTKnGXiMzF2bmEcPlVUHSSDR27FimT5/O9OnTWbNmDY8++mjbzewNRf8Ce5g03EyaNImXX36ZZcuWDeo4fXlVYAA/AB7IzH9tumsZcEp1+xTg6qbxk6tX18wGXnB9gjT8jRo1ijVr1vClL32p7lJeZf+S1Fff/va3ue2223jwwQcHd6DM3OUGzKExTX43sKLajgEm0Hg1zSPAr4Hx1f4BXAw8CtwDHNGH50g3t3befvazn6V27ZJLLsnq/Zz6ut2RvfSGwW60oH+lPczNbURuPfWDvrwq8GYazaY7H+xm/wQ+09txJQ0fF1xwAWefffbOkNE27F+SWs2PtJF6cdppp/FXf/VXdZfRdh588EEWLFgAwEMPPcTLL79cc0WSVD+DldSLKVOmsM8++9RdRltZv349s2bNYuPGjXWXIkltpc9vtyBJAI8//jjTpk0zVElSNwxW0i5MmTKFQw45pO4y2sby5ct53/ve52U/SeqBlwKlXZg9ezbz58+vu4zaPfLIIyxevJilS5eyevXq3h8gSSOUwUrSLq1fv56TTjqJ2267re5SJKntGawkdSsz2bZtG+985ztZtWpV3eVIUkdwjZXUg1GjRo3IVwNu3ryZ0047jTFjxjB27FhDldShRo0axd577113GSOOwUrqwYwZM/j+979fdxkttWnTJs455xy++93vsnXrVrZu3Vp3SZIGaOrUqXzhC1+ou4wRJ9rhnZKrj8GQ2soBBxzAokWLOProo+supSW2bNnC2Wefzfnnn9+qp7wzh8kHGNvDpJEnM7v9VAfXWEk9iAhGjx4ZvyJf/vKXWbVqFZdddlndpUhSRxsZ/9eQBmCfffbhgx98w8fJDTtnnXUWF154oe9NJUkFGKykEWrHjh1ccMEFfP3rX3ctlSQVYrCSuhERTJ8+ve4yhszDDz/MjTfeyBe/+MW6S5GkYcXF61I33vSmN/HSSy/VXcaQuPrqq5k3b17dZYCL16Uhc+yxxzJ69GiefPJJli9fXnc5w1JPi9d9uwVpBLn00kv55Cc/WXcZkobYO97xDpYsWcLnP//5uksZcbwUKHVj69atzJ07F4AFCxZw3HHH1VzR4C1cuJCzzjqLF198se5SJA2xc889l3vuuYcnn3yy7lJGHC8FSr0YP34848eP5/rrr2fq1KlEdDv725b+8Ic/cOSRRwLwzDPP8MILL9Rc0Wt4KVBSx+rpUqDBSuqjrq4uIoJZs2axdOlSxo4dy5gxY+ouq0fPP/8806ZNY8OGDXWX0hODlaSO5RoraZBeeeUVtm7dys0338z+++/PP/3TP3HLLbdw66231l3aGzz00EMcdthh7RyqJGlYcsZKGqSuri6++c1vctBBB/GhD32o1lqeeOIJrr32WhYuXMiKFStqraUPnLGS1LG8FCgNsWnTpnHxxRdzzDHH1PL8zzzzDAsWLOCXv/xlLc8/AAYrSR3LYCW1wNSpU5k8eTL/9m//xpQpU1r2vK+88gqzZ8/mt7/9bcueswCDlaSOZbCSWmjfffdl1KhRHHnkkSxdupSuri52263sksYdO3bwyiuvAI33rHn44YeLHr8FDFaSOpaL16UWev7553n22Wf5xS9+wZgxY/ja177GypUrefTRR4scf/PmzXzta19jzJgxjBkzphNDlSQNS85YSS3U1dXFlVdeyYEHHsisWbMGdIytW7dy4YUXDofP+XPGSlLH8lKg1EYOPvhgvve97/He9763X4+76KKLWL16Neeff/4QVdZSBitJHctgJbWZgw8+mEMOOYSLL76YSZMm9br/eeedxz//8z+zadOmFlTXEgYrSR3LYCW1qWnTpjF69Gj+8i//kiuuuKLbfS666CLOPPPM4RSqwGAlqYMZrKQ2FxHsvvvunHfeeZx00klEBOPGjeMnP/kJCxYsYPv27XWXWJrBShrGdt99d+68807+4i/+ou5ShoSvCpTaXGayZcsWTj/9dPbbbz8OOOAArrrqKk488cThGKokDXOZyQMPPFB3GS3njJWkujhjJaljOWMlSZI0xHoNVhExNSJ+ExH3R8R9EfEP1fhXImJtRKyotmOaHnNmRKyMiIci4uih/AEkqSf2L0mt1uulwIiYBEzKzN9GxF7AncA84HhgU2Ze8Lr9DwV+DMwCDgR+Dbw1M3tcJOI0ujQiDfmlwFb0r+px9jBphBnwpcDMXJeZv61ubwQeACbv4iFzgSsyc0tmPg6spNGkJKml7F+SWq1fa6wiYhpwGLC8GvpsRNwdEZdGxL7V2GRgddPD1rDrRiZJQ87+JakV+hysImIscBVwemZuAL4DHATMBNYBX+/PE0fEqRFxR0Tc0Z/HSVJ/le5f1THtYZLeoE/BKiK6aDSlH2XmEoDMfDozt2fmDuAS/jhdvhaY2vTwKdXYa2Tmwsw8Yri83FpSexqK/lUdwx4m6Q368qrAAH4APJCZ/9o03vzhZvOBe6vby4ATImKPiJgOzABuK1eyJPWN/UtSq43uwz7vARYA90TEimrsLOATETETSGAV8HcAmXlfRFwJ3A9sAz7T2ytqJGmI2L8ktZTvvC6pLr7zuqSO5TuvS5IkDTGDlSRJUiEGK0mSpEIMVpIkSYUYrCRJkgoxWEmSJBVisJIkSSrEYCVJklSIwUqSJKkQg5UkSVIhBitJkqRCDFaSJEmFGKwkSZIKMVhJkiQVYrCSJEkqxGAlSZJUiMFKkiSpEIOVJElSIQYrSZKkQgxWkiRJhRisJEmSCjFYSZIkFWKwkiRJKsRgJUmSVIjBSpIkqRCDlSRJUiEGK0mSpEIMVpIkSYUYrCRJkgoxWEmSJBVisJIkSSrEYCVJklSIwUqSJKkQg5UkSVIhBitJkqRCDFaSJEmFGKwkSZIKGV13AZVngRerr+1uP6yzpE6pEzqn1k6p80/rLqCgTcBDdRfRB53ybwM6p1brLKtT6uyxf0VmtrKQHkXEHZl5RN119MY6y+qUOqFzau2UOoeTTjnnnVIndE6t1llWp9S5K14KlCRJKsRgJUmSVEg7BauFdRfQR9ZZVqfUCZ1Ta6fUOZx0yjnvlDqhc2q1zrI6pc4etc0aK0mSpE7XTjNWkiRJHa32YBURH46IhyJiZUScUXc9zSJiVUTcExErIuKOamx8RFwXEY9UX/etqbZLI2J9RNzbNNZtbdHwreoc3x0Rh9dc51ciYm11XldExDFN951Z1flQRBzdwjqnRsRvIuL+iLgvIv6hGm+rc7qLOtvunI4E7dy/oH17mP2reJ0d0b96qbXtzuuAZWZtGzAKeBT4M2B34L+AQ+us6XX1rQL2e93Y+cAZ1e0zgPNqqu29wOHAvb3VBhwD/AIIYDawvOY6vwJ8vpt9D63+DewBTK/+bYxqUZ2TgMOr23sBD1f1tNU53UWdbXdOh/vW7v2rqrEte5j9q3idHdG/eqm17c7rQLe6Z6xmASsz87HM3ApcAcytuabezAUWV7cXA/PqKCIz/wN47nXDPdU2F7gsG24FxkXEpBrr7Mlc4IrM3JKZjwMrafwbGXKZuS4zf1vd3gg8AEymzc7pLursSW3ndAToxP4FbdDD7F9ldUr/6qXWnnRcD6s7WE0GVjd9v4Zdn+BWS+BXEXFnRJxajU3MzHXV7aeAifWU1q2eamvH8/zZagr60qZLEW1RZ0RMAw4DltPG5/R1dUIbn9NhqhPObSf1sLb9XetG2/6udUr/guHbw+oOVu1uTmYeDnwE+ExEvLf5zmzMU7blyyrbuTbgO8BBwExgHfD1esv5o4gYC1wFnJ6ZG5rva6dz2k2dbXtOVauO7GHtWlelbX/XOqV/wfDuYXUHq7XA1Kbvp1RjbSEz11Zf1wNLaUw/Pr1zyrT6ur6+Ct+gp9ra6jxn5tOZuT0zdwCX8Mdp3VrrjIguGr/oP8rMJdVw253T7ups13M6zLX9ue2wHtZ2v2vdadfftU7pXz3V2q7ndSDqDla3AzMiYnpE7A6cACyruSYAImLPiNhr523gQ8C9NOo7pdrtFODqeirsVk+1LQNOrl4JMht4oWl6uOVedy1/Po3zCo06T4iIPSJiOjADuK1FNQXwA+CBzPzXprva6pz2VGc7ntMRoG37F3RkD2ur37WetOPvWqf0r13V2o7ndcBavVr+9RuNVyc8TGOl/5fqrqeprj+j8UqE/wLu21kbMAG4HngE+DUwvqb6fkxjuvQVGtecP91TbTRe+XFxdY7vAY6ouc4fVnXcTeOXZlLT/l+q6nwI+EgL65xDY5r8bmBFtR3Tbud0F3W23TkdCVu79q+qtrbtYfav4nV2RP/qpda2O68D3XzndUmSpELqvhQoSZI0bBisJEmSCjFYSZIkFWKwkiRJKsRgJUmSVIjBSpIkqRCDlSRJUiEGK0mSpEL+PxPUtdXWz/49AAAAAElFTkSuQmCC\n",
            "text/plain": [
              "<Figure size 720x720 with 2 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 683
        },
        "id": "1g2beoTJluE2",
        "outputId": "43ab961e-266f-4dd0-e5b8-c4390c38a350"
      },
      "source": [
        "#match features\n",
        "matches1, matches2 = matchFeatures(corners_original,corners_rotated)\n",
        "matches = np.concatenate((matches1,matches2), axis =1)\n",
        "\n",
        "matched_img = drawMatches(np.array(img), np.array(rotated_img), matches)\n",
        "plt.figure(figsize=(10,10))\n",
        "plt.imshow(matched_img, cmap='gray')\n",
        "plt.title(\"Feature Matches\")\n",
        "plt.show()"
      ],
      "execution_count": 54,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Corner Location Matches Check:\n",
            "[101. 150.] [165. 207.]\n",
            "[0. 0.] [0. 0.]\n",
            "[0. 0.] [0. 0.]\n",
            "[0. 0.] [0. 0.]\n",
            "Corner Location Matches Check:\n",
            "[101. 150.] [165. 207.]\n",
            "[184. 179.] [203. 287.]\n",
            "[0. 0.] [0. 0.]\n",
            "[0. 0.] [0. 0.]\n",
            "Corner Location Matches Check:\n",
            "[101. 150.] [165. 207.]\n",
            "[184. 179.] [203. 287.]\n",
            "[135. 100.] [225. 196.]\n",
            "[0. 0.] [0. 0.]\n",
            "Corner Location Matches Check:\n",
            "[101. 150.] [165. 207.]\n",
            "[184. 179.] [203. 287.]\n",
            "[135. 100.] [225. 196.]\n",
            "[175. 115.] [242. 235.]\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 720x720 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9FSjk8gbmsEV"
      },
      "source": [
        "def LeastSqaures(match_points, num_points):\n",
        "    loc1, loc2 = match_points[:, 0:2], match_points[:, 2:4]\n",
        "    # Initialize matrices for A and B\n",
        "    A = np.empty((0,4)); B = np.empty((0,1))\n",
        "    # Construct Matrix A and B\n",
        "    for i in range(num_points):\n",
        "        A_tmp = np.array([[loc1[i,0],  loc1[i,1], 1, 0],\n",
        "                          [loc1[i,1], -loc1[i,0], 0, 1]])\n",
        "        B_tmp = np.array([[loc2[i,0]], \n",
        "                          [loc2[i,1]]])\n",
        "        # Add to final A and B matrix \n",
        "        A = np.concatenate((A, A_tmp), axis=0)\n",
        "        B = np.concatenate((B, B_tmp), axis=0)\n",
        "\n",
        "    print('Matrix A'); print(A); print('')\n",
        "    print('Matrix B'); print(B); print('')\n",
        "    return A, B"
      ],
      "execution_count": 59,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "tOhH-ZrNnhPV",
        "outputId": "9aa1e974-f66e-49d5-aff0-0f78d9ee4a72"
      },
      "source": [
        "A,B = LeastSqaures(matches,2)"
      ],
      "execution_count": 60,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Matrix A\n",
            "[[ 101.  150.    1.    0.]\n",
            " [ 150. -101.    0.    1.]\n",
            " [ 184.  179.    1.    0.]\n",
            " [ 179. -184.    0.    1.]]\n",
            "\n",
            "Matrix B\n",
            "[[165.]\n",
            " [207.]\n",
            " [203.]\n",
            " [287.]]\n",
            "\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "TtlliotaoXUm",
        "outputId": "9fc22835-a3eb-4fe5-e24d-9e4021908134"
      },
      "source": [
        "#Solve with Linear Least Squares Optimization\n",
        "(x, residuals, rank, s) = np.linalg.lstsq(A,B,None)\n",
        "\n",
        "# Print Results from Linear Least Squares Optimization\n",
        "print('Paramater Values:'); print(x); print('')\n",
        "\n",
        "# Solve for Theta\n",
        "angle1 = np.degrees((np.arccos(x[0])))\n",
        "angle2 = np.degrees((np.arcsin(x[1])))\n",
        "\n",
        "print('angle =', angle1, 'or ',angle2)\n",
        "\n",
        "print('')\n",
        "\n",
        "\n",
        "ty = x[2]\n",
        "tx = x[3]\n",
        "print('tx =', tx)\n",
        "print('ty =', ty)"
      ],
      "execution_count": 61,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Paramater Values:\n",
            "[[  0.70815006]\n",
            " [ -0.7164295 ]\n",
            " [200.94126779]\n",
            " [ 28.41811125]]\n",
            "\n",
            "angle = [44.91540185] or  [-45.76047432]\n",
            "\n",
            "tx = [28.41811125]\n",
            "ty = [200.94126779]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nLrplEHJprR0"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}