gate_detection_orb_test.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import cv2\n",
    "from matplotlib import pyplot as plt\n",
    "import glob, os\n",
    "import time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Found 308 image files in the directory \"WashingtonOBRace\"\n",
      "Found 308 mask files in the directory \"WashingtonOBRace\"\n",
      "loaded 308 images\n",
      "loaded 308 masks\n",
      "['WashingtonOBRace/mask_6.png', 'WashingtonOBRace/mask_8.png', 'WashingtonOBRace/mask_9.png', 'WashingtonOBRace/mask_10.png', 'WashingtonOBRace/mask_11.png', 'WashingtonOBRace/mask_12.png', 'WashingtonOBRace/mask_13.png', 'WashingtonOBRace/mask_14.png', 'WashingtonOBRace/mask_18.png', 'WashingtonOBRace/mask_19.png']\n"
     ]
    }
   ],
   "source": [
    "# LOAD AND SORT IMAGES FILENAMES INTO LISTS\n",
    "image_dir = 'WashingtonOBRace'\n",
    "\n",
    "img_filenames = glob.glob(os.path.join(image_dir, 'img_[0-9]*.png'))\n",
    "img_filenames = sorted(img_filenames, key=lambda x:int(x[21:-4]))\n",
    "print(f'Found {len(img_filenames)} image files in the directory \"{image_dir}\"')\n",
    "\n",
    "mask_filenames = glob.glob(os.path.join(image_dir, 'mask_*.png'))\n",
    "mask_filenames = sorted(mask_filenames, key=lambda x:int(x[22:-4]))\n",
    "print(f'Found {len(mask_filenames)} mask files in the directory \"{image_dir}\"')\n",
    "\n",
    "# READ AND STORE IMAGES AND MASKS INTO LISTS\n",
    "imgs = [cv2.imread(filename, flags=cv2.IMREAD_COLOR) \\\n",
    "                                for filename in img_filenames]\n",
    "imgs = [cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) for img in imgs]\n",
    "print('loaded %d images' % len(imgs))\n",
    "\n",
    "masks = [cv2.imread(filename, flags=cv2.IMREAD_GRAYSCALE) \\\n",
    "                                 for filename in mask_filenames]\n",
    "print('loaded %d masks' % len(masks))\n",
    "\n",
    "print(mask_filenames[:10])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WashingtonOBRace/img_295.png\n",
      "WashingtonOBRace/img_296.png\n",
      "WashingtonOBRace/mask_295.png\n",
      "WashingtonOBRace/mask_296.png\n"
     ]
    }
   ],
   "source": [
    "queryImg = imgs[209] # queryImage\n",
    "trainImg = imgs[210] # trainImage\n",
    "queryMask = masks[209] # maskImage\n",
    "trainMask = masks[210]\n",
    "print(img_filenames[209])\n",
    "print(img_filenames[210])\n",
    "print(mask_filenames[209])\n",
    "print(mask_filenames[210])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "# SETUP\n",
    "orb = cv2.ORB_create(nfeatures=300, WTA_K=2, scoreType=0)\n",
    "\n",
    "queryKp = orb.detect(queryImg,None)\n",
    "queryKps, queryDes = orb.compute(queryImg, queryKp)\n",
    "\n",
    "index_params = dict(algorithm=6,\n",
    "                    table_number=6,\n",
    "                    key_size=12,\n",
    "                    multi_probe_level=2)\n",
    "search_params = {}\n",
    "matcher = cv2.FlannBasedMatcher(index_params, search_params)\n",
    "\n",
    "MIN_MATCH_COUNT = 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "In 0.025719165802001953 seconds.\r"
     ]
    }
   ],
   "source": [
    "# PROCESS INCOMING IMAGE FRAME\n",
    "start_time = time.time()\n",
    "trainKp = orb.detect(trainImg,None)\n",
    "trainKps, trainDes = orb.compute(trainImg, trainKp)\n",
    "\n",
    "# MATCH FEATURES\n",
    "matches = matcher.knnMatch(queryDes, trainDes, k=8)\n",
    "\n",
    "# FILTER GOOD MATCHES\n",
    "good_matches = []\n",
    "\n",
    "for candidates in matches:\n",
    "    scores = np.zeros((len(candidates),))\n",
    "    vert_popularity = np.zeros((len(candidates),))\n",
    "    vert_similarity = np.zeros((len(candidates),))\n",
    "    query_y = (queryKp[candidates[0].queryIdx].pt)[1] # NOTE: m.queryIdx == n.queryIdx\n",
    "    \n",
    "    for idx, candidate in enumerate(candidates):\n",
    "        scores[idx] = candidate.distance\n",
    "        train_cy = (trainKp[candidate.trainIdx].pt)[1]\n",
    "        vert_popularity[idx] = train_cy\n",
    "        vert_similarity[idx] = abs(query_y - train_cy)\n",
    "    vert_popularity = abs(vert_popularity - np.median(vert_popularity))\n",
    "    scores += 1 *vert_popularity + 0*vert_similarity\n",
    "    \n",
    "    scores = -scores\n",
    "    scores -= np.min(scores)\n",
    "    best_candidate = np.argmax(scores)\n",
    "    best_score = scores[best_candidate]\n",
    "    scores[best_candidate] = float('-inf')\n",
    "    second_candidate = np.argmax(scores)\n",
    "    if best_score > 1.25 * scores[second_candidate]:\n",
    "        good_matches.append(candidates[best_candidate])\n",
    "        \n",
    "if len(good_matches) > MIN_MATCH_COUNT:\n",
    "    src_pts = np.float32([queryKp[m.queryIdx].pt for m in good_matches]).reshape(-1,1,2)\n",
    "    dst_pts = np.float32([trainKp[m.trainIdx].pt for m in good_matches]).reshape(-1,1,2)\n",
    "\n",
    "    M, mask = cv2.findHomography(src_pts, dst_pts, cv2.RANSAC, 5.0)\n",
    "    matchesMask = mask.ravel().tolist()\n",
    "\n",
    "    h,w = queryImg.shape\n",
    "    pts = np.float32([ [0,0],[0,h-1],[w-1,h-1],[w-1,0] ]).reshape(-1,1,2)\n",
    "    dst = cv2.perspectiveTransform(pts,M)\n",
    "    \n",
    "    PredMask = cv2.warpPerspective(queryMask, M, (trainImg.shape[1], trainImg.shape[0]))\n",
    "    \n",
    "else:\n",
    "    print(\"Not enough matches are found - %d/%d\" % (len(good_matches),MIN_MATCH_COUNT))\n",
    "    matchesMask = None\n",
    "    \n",
    "end_time = time.time()\n",
    "print(\"In {0} seconds.\".format(end_time - start_time), end='\\r')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.imshow(queryMask, 'gray')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.imshow(PredMask, 'gray')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.imshow(trainMask, 'gray')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "import ROC\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# Change ONLY the following line:\n",
    "Values = PredMask\n",
    "\n",
    "# make it a flat list of values, in the right order:\n",
    "Values = Values.flatten();\n",
    "\n",
    "classes = trainMask\n",
    "classes[classes > 0] = 1\n",
    "classes = classes.flatten()\n",
    "\n",
    "# get the ROC curve:\n",
    "TP, FP = ROC.get_ROC_curve(Values, classes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5, 0, 'FP')"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# plot the ROC curve:\n",
    "plt.figure()\n",
    "plt.plot(FP, TP, 'b')\n",
    "plt.ylabel('TP')\n",
    "plt.xlabel('FP')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}