Image_Deciphers_Search_Engines.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "f5e49232",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-12-07T22:13:19.693029Z",
     "start_time": "2021-12-07T22:13:19.689832Z"
    }
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import cv2\n",
    "import imutils, os\n",
    "import numpy as np\n",
    "import csv\n",
    "import ast\n",
    "import json\n",
    "from skimage.feature import hog\n",
    "\n",
    "\n",
    "import PIL\n",
    "from PIL import Image\n",
    "import imagehash\n",
    "from imagehash import hex_to_hash\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "be4d4c78",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-12-07T19:32:50.251377Z",
     "start_time": "2021-12-07T19:32:50.051158Z"
    }
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "48cf54d4",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-12-07T22:01:30.317371Z",
     "start_time": "2021-12-07T22:01:30.313033Z"
    }
   },
   "outputs": [],
   "source": [
    "\n",
    "def list_directories(path):\n",
    "    \"\"\"list files and directories in a given path\"\"\"\n",
    "    arr = os.listdir(path)\n",
    "    return arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "f7526190",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-12-07T22:01:30.811254Z",
     "start_time": "2021-12-07T22:01:30.784618Z"
    }
   },
   "outputs": [],
   "source": [
    "def sift(image):\n",
    "    \n",
    "    img1 = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)\n",
    "    sft = cv2.xfeatures2d.SIFT_create()\n",
    "    keypoints, features = sft.detectAndCompute(img1, None)\n",
    "    return features\n",
    "\n",
    "\n",
    "def calculate_sift_indexies():\n",
    "    dicte = {}\n",
    "\n",
    "    images = []\n",
    "    file = 'images/'\n",
    "    indexies_path = 'indexies/'\n",
    "    imgs = list_directories(file)\n",
    "    \n",
    "    \n",
    "    for i in imgs:\n",
    "        \n",
    "        pth = f\"{file}{i}\"\n",
    "        images.append(pth)\n",
    "#         print(images)\n",
    "        \n",
    "    for imagePath, imageID in zip(images, imgs):\n",
    "        \n",
    "        image = cv2.imread(imagePath)\n",
    "        features = sift(image)\n",
    "        dicte[imageID] = features.tolist()\n",
    "        \n",
    "    with open(f'{indexies_path}sift_indexies.json', 'w') as f:\n",
    "        json.dump(dicte, f)\n",
    "        \n",
    "def search_sift(query_image='gf.jpg'):\n",
    "    \n",
    "    best_matches = []\n",
    "    temp_matches = {}\n",
    "    \n",
    "    \n",
    "    file = 'images/'\n",
    "    indexies_path = 'indexies/'\n",
    "    \n",
    "#     query = cv2.imread('images/gf.jpg')\n",
    "    query = cv2.imread(f'images/{query_image}')\n",
    "\n",
    "    \n",
    "    query_features = np.array(sift(query),np.float32)\n",
    "    \n",
    "    \n",
    "    f = open (f'{indexies_path}sift_indexies.json', \"r\")\n",
    "    data = json.loads(f.read())\n",
    "    \n",
    "    for ID,f in data.items():\n",
    "        \n",
    "        indexed_features = np.array(f,np.float32)\n",
    "        \n",
    "        bf = cv2.BFMatcher(cv2.NORM_L2, crossCheck=False)\n",
    "        matches = bf.knnMatch(query_features,indexed_features, k=2)\n",
    "        \n",
    "        good = []\n",
    "        for m,n in matches:  ## read indivusal distance for each detected match between 2 images\n",
    "            if m.distance < 0.75*n.distance:\n",
    "                good.append([m])\n",
    "        temp_matches[ID] = len(good)\n",
    "        \n",
    "    sorted_temp_matches = sorted(temp_matches.items(), key=lambda kv: kv[1])\n",
    "    print(sorted_temp_matches[-1][0],sorted_temp_matches[-1][1])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6edf749b",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-12-07T21:17:53.828651Z",
     "start_time": "2021-12-07T21:17:50.777944Z"
    }
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "19121bb0",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-12-07T22:16:17.198321Z",
     "start_time": "2021-12-07T22:16:17.189985Z"
    }
   },
   "outputs": [],
   "source": [
    "def surf(image):\n",
    "    \n",
    "    img1 = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)\n",
    "    surf = cv2.xfeatures2d.SURF_create()\n",
    "    keypoints, features = surf.detectAndCompute(img1, None)\n",
    "#     print(type(features),len(features))\n",
    "    return features\n",
    "\n",
    "\n",
    "def calculate_surf_indexies():\n",
    "    \n",
    "    dicte = {}\n",
    "\n",
    "    images = []\n",
    "    file = 'images/'\n",
    "    indexies_path = 'indexies/'\n",
    "    imgs = list_directories(file)\n",
    "    \n",
    "    \n",
    "    for i in imgs:\n",
    "        \n",
    "        pth = f\"{file}{i}\"\n",
    "        images.append(pth)\n",
    "        \n",
    "    for imagePath, imageID in zip(images, imgs):\n",
    "        \n",
    "        image = cv2.imread(imagePath)\n",
    "        features = surf(image)\n",
    "        dicte[imageID] = features.tolist()\n",
    "        \n",
    "    with open(f'{indexies_path}surf_indexies.json', 'w') as f:\n",
    "        json.dump(dicte, f)\n",
    "        \n",
    "        \n",
    "        \n",
    "def search_surf(query_image = 'gf.jpg' ):\n",
    "    \n",
    "    best_matches = []\n",
    "    temp_matches = {}\n",
    "    \n",
    "    \n",
    "    file = 'images/'\n",
    "    indexies_path = 'indexies/'\n",
    "    \n",
    "    query = cv2.imread(f'images/{query_image}')\n",
    "    query_features = np.array(surf(query),np.float32)\n",
    "    \n",
    "    f = open (f'{indexies_path}surf_indexies.json', \"r\")\n",
    "    data = json.loads(f.read())\n",
    "    \n",
    "    for ID,f in data.items():\n",
    "        \n",
    "        indexed_features = np.array(f,np.float32)\n",
    "        \n",
    "        bf = cv2.BFMatcher(cv2.NORM_L2, crossCheck=False)\n",
    "        matches = bf.knnMatch(query_features,indexed_features, k=2)\n",
    "        \n",
    "        good = []\n",
    "        for m,n in matches:  ## read indivusal distance for each detected match between 2 images\n",
    "            if m.distance < 0.75*n.distance:\n",
    "                good.append([m])\n",
    "        temp_matches[ID] = len(good)\n",
    "        \n",
    "    sorted_temp_matches = sorted(temp_matches.items(), key=lambda kv: kv[1])\n",
    "#     print(sorted_temp_matches)\n",
    "    print(sorted_temp_matches[-1][0],sorted_temp_matches[-1][1])\n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "0b804d8c",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-12-07T22:16:17.434031Z",
     "start_time": "2021-12-07T22:16:17.408537Z"
    }
   },
   "outputs": [],
   "source": [
    "def hog_d(image):\n",
    "    \n",
    "    image = cv2.resize(image, (250, 250))\n",
    "    features, hog_image2 = hog(image, orientations=9, pixels_per_cell=(8, 8),cells_per_block=(2, 2), visualize=True, multichannel=True)\n",
    "    return features\n",
    "\n",
    "def calculate_hog_indexies():\n",
    "    \n",
    "    dicte = {}\n",
    "    images = []\n",
    "    file = 'images/'\n",
    "    indexies_path = 'indexies/'\n",
    "    imgs = list_directories(file)\n",
    "    \n",
    "    for i in imgs:\n",
    "        pth = f\"{file}{i}\"\n",
    "        images.append(pth)\n",
    "        \n",
    "    for imagePath, imageID in zip(images, imgs):\n",
    "        image = cv2.imread(imagePath)\n",
    "        features = hog_d(image)\n",
    "        dicte[imageID] = features.tolist()\n",
    "        \n",
    "    with open(f'{indexies_path}hog_indexies.json', 'w') as f:\n",
    "        json.dump(dicte, f)\n",
    "        \n",
    "        \n",
    "def search_hog(query_image = 'gf.jpg' ):\n",
    "    \n",
    "    best_matches = []\n",
    "    temp_matches = {}\n",
    "    \n",
    "    \n",
    "    file = 'images/'\n",
    "    indexies_path = 'indexies/'\n",
    "    \n",
    "    query = cv2.imread(f'images/{query_image}')\n",
    "    query_features = np.array(hog_d(query),np.float32)\n",
    "    \n",
    "    f = open (f'{indexies_path}hog_indexies.json', \"r\")\n",
    "    data = json.loads(f.read())\n",
    "    \n",
    "    for ID,f in data.items():\n",
    "        \n",
    "        indexed_features = np.array(f,np.float32)\n",
    "        \n",
    "        bf = cv2.BFMatcher(cv2.NORM_L2, crossCheck=False)\n",
    "        matches = bf.knnMatch(query_features,indexed_features, k=2)\n",
    "        \n",
    "        good = []\n",
    "        for m,n in matches:  ## read indivusal distance for each detected match between 2 images\n",
    "            if m.distance < 0.75*n.distance:\n",
    "                good.append([m])\n",
    "        temp_matches[ID] = len(good)\n",
    "        \n",
    "    sorted_temp_matches = sorted(temp_matches.items(), key=lambda kv: kv[1])\n",
    "#     print(sorted_temp_matches)\n",
    "    print(sorted_temp_matches[-1][0],sorted_temp_matches[-1][1])   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "id": "061d817f",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-12-07T22:26:52.411717Z",
     "start_time": "2021-12-07T22:26:52.405653Z"
    }
   },
   "outputs": [],
   "source": [
    "def phash(image):\n",
    "    \n",
    "    image_one_hash = imagehash.phash(image)\n",
    "    return image_one_hash\n",
    "    \n",
    "\n",
    "def calculate_phash_indexies():\n",
    "    \n",
    "    dicte = {}\n",
    "    images = []\n",
    "    file = 'images/'\n",
    "    indexies_path = 'indexies/'\n",
    "    imgs = list_directories(file)\n",
    "    \n",
    "    for i in imgs:\n",
    "        pth = f\"{file}{i}\"\n",
    "        images.append(pth)\n",
    "        \n",
    "    for imagePath, imageID in zip(images, imgs):\n",
    "        \n",
    "        image = Image.open(imagePath)\n",
    "        features = phash(image)\n",
    "        dicte[imageID] = str(features)\n",
    "        \n",
    "    with open(f'{indexies_path}phash_indexies.json', 'w') as f:\n",
    "        json.dump(dicte, f)\n",
    "        \n",
    "        \n",
    "def search_phash(query_image = 'gf.jpg' ):\n",
    "    \n",
    "    \n",
    "    best_matches = []\n",
    "    temp_matches = {}\n",
    "    \n",
    "    file = 'images/'\n",
    "    indexies_path = 'indexies/'\n",
    "    \n",
    "    query_image = Image.open(f'images/{query_image}')\n",
    "    query_image_features = phash(query_image)\n",
    "    \n",
    "    f = open (f'{indexies_path}phash_indexies.json', \"r\")\n",
    "    data = json.loads(f.read())\n",
    "    for ID,f in data.items():\n",
    "        indexed_features = hex_to_hash(f)\n",
    "        distance = query_image_features - indexed_features\n",
    "        temp_matches[ID] = int(distance)\n",
    "    sorted_temp_matches = sorted(temp_matches.items(), key=lambda kv: kv[1])\n",
    "\n",
    "    print(sorted_temp_matches[0])\n",
    "        \n",
    "        \n",
    "            \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "id": "96f1e835",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-12-07T22:26:36.802977Z",
     "start_time": "2021-12-07T22:26:36.704314Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('gf.jpg', 0)\n"
     ]
    }
   ],
   "source": [
    "# calculate_phash_indexies()\n",
    "search_phash()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "cd0fa41d",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-12-07T22:16:29.417208Z",
     "start_time": "2021-12-07T22:16:23.518602Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "gf.jpg 24722\n"
     ]
    }
   ],
   "source": [
    "# calculate_hog_indexies()\n",
    "search_hog()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "f12e760f",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-12-07T21:44:53.393004Z",
     "start_time": "2021-12-07T21:44:52.402079Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "gf.jpg 1916\n"
     ]
    }
   ],
   "source": [
    "# calculate_surf_indexies()\n",
    "search_surf()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "b051c1e7",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-12-07T21:44:54.383879Z",
     "start_time": "2021-12-07T21:44:53.394506Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "gf.jpg 385\n"
     ]
    }
   ],
   "source": [
    "# calculate_sift_indexies()\n",
    "search_sift()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1abdf829",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "hide_input": false,
  "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.6.9"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}