number-plate-study/Мальцев-лабы copy.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Лаба 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import cv2 as cv\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "img = cv.imread('img/coins.jpg', cv.IMREAD_GRAYSCALE)\n",
    "\n",
    "sift = cv.SIFT_create()\n",
    "\n",
    "kp, des = sift.detectAndCompute(img, None)\n",
    "\n",
    "img2 = cv.drawKeypoints(img, kp, None, (255, 0, 0), 4)\n",
    "plt.imshow(img2)\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#https://docs.opencv.org/3.4/df/d0c/tutorial_py_fast.html\n",
    "import cv2 as cv\n",
    "from matplotlib import pyplot as plt\n",
    "\n",
    "img = cv.imread('img/blox.jpg', cv.IMREAD_GRAYSCALE)\n",
    "\n",
    "fast = cv.FastFeatureDetector_create()\n",
    "kp = fast.detect(img, None)\n",
    "img2 = cv.drawKeypoints(img, kp, None, color=(255, 0, 0))\n",
    "plt.imshow(img2)\n",
    "plt.show()\n",
    "\n",
    "fast.setNonmaxSuppression(0)\n",
    "kp = fast.detect(img, None)\n",
    "img3 = cv.drawKeypoints(img, kp, None, color=(255, 0, 0))\n",
    "plt.imshow(img3)\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYUAAAGFCAYAAAASI+9IAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOz9eZxkVX03jr+rqmvtvXumZ5/p2RlmGDZZZB0EBUEERE3UiEs0ouGJy6Nx/SYmT/YEEw1iHqOJBEUEIygoi8gyLDPADMwwzL5vva9V1bVX3d8f/fuc+dxPnXPr3uqeEZ/c9+vVr666de+5Z/3s53MClmVZ8OHDhw8fPgAEf9sV8OHDhw8fbxz4TMGHDx8+fCj4TMGHDx8+fCj4TMGHDx8+fCj4TMGHDx8+fCj4TMGHDx8+fCj4TMGHDx8+fCj4TMGHDx8+fCg0uL1xfHzcdaGBQKCuyvjw4cOHj5OHlpaWmvf4moIPHz58+FDwmYIPHz58+FDwmYIPHz58+FDwmYIPHz58+FDwmYIPHz58+FDwmYIPHz58+FDwmYIPHz58+FDwmYIPHz58+FDwmYIPHz58+FDwmYIPHz58+FA4KUzBP/bZhw8fPn434Tr3kVd4YQx+riQfPnz4eGPANx/58OHDhw8Fnyn48OHDhw8Fnyn48OHDhw8Fnyn48OHDhw8Fnyn48OHDhw8Fnyn48OHDhw8Fnyn48OHDhw8Fnyn48OHDhw8Fnyn48OHDhw8Fnyn48OHDhw+Fk5bmwgv8lBg+fPjwUR+mO9fc75ym4Cfb8+HDh4+Th985puDDhw8fPk4efKbgw4cPHz4UfKbgw4cPHz4UfKbgw4cPHz4UfKbgw4cPHz4UfKbgw4cPHz4UfKbgw4cPHz4UfKbgw4cPHz4UfKbgw4cPHz4UfueYgp/mwocPHz5OHt4QuY98Qu/Dhw8fbwz8zmkKPnz48OHj5MFnCj58+PDhQ8FnCj58+PDhQ8FnCj58+PDhQ8FnCj58+PDhQ8FnCj58+PDhQ8FnCj58+PDhQ8FnCj58+PDhQ8FnCj58+PDhQ8FnCj58+PDhQ+ENkebChw8fPnxMwrKs3+r7fU3Bhw8fPnwo+EzBhw8fPnwo+EzBhw8fPnwo+EzBhw8fPnwo+EzBhw8fPnwo+EzBhw8fPnwo+EzBhw8fPnwo+EzBhw8fPnwo+EzBhw8fPnwo+EzBhw8fPnwo+EzBhw8fPnwovCFyH3nN9REIBE5STXz48OFjevHbzmXkFb6m4MOHDx8+FHym4MOHDx8+FHym4MOHDx8+FHym4MOHDx8+FHym4MOHDx8+FHym4MOHDx8+FHym4MOHDx8+FHym4MOHDx8+FHym4MOHDx8+FHym4MOHDx8+FFynufCyVdtPQ+HDhw8fv5t4Q+Q+8gqfQfnw4cPHyYFvPvLhw4cPHwo+U/Dhw4cPHwo+U/Dhw4cPHwo+U/Dhw4cPHwo+U/Dhw4cPHwo+U/Dhw4cPHwo+U/Dhw4cPHwo+U/Dhw4cPHwo+U/Dhw4cPHwo+U/Dhw4cPHwonJc2FlzQUwMlNRfFGqosXBAIBW10sy0KlUoFlWapNwWBQ3Uf3yvby7/RZll0L/J1u6z5VmMqQdTF9pjICgUDVPbxs+Vn3G38nfQ4GgwgGg7brsg68rGBQL3+ZxkvXFhOoTro5w99Pv5XLZdvzfF4FAgF1bygU8jz2/1PwRuqT6a7L72Tuo/8JoIWqW+REYCRDoGtuy/cCL0TKa9leIIlrrbbXukafZT9WKhVtO/h9kklLuFmsTkzcBFObdEwhHA4jHA5r51GlUkGhUKhifrx9Pv7nwWcKb1DQAuUSICdg9L8WE+ALXif51oJ8p+43WW8v8Hp/pVKpeq+bPuBaUq3nuFYm7+Xah7zHC5w0HK+guukYZkNDA8LhsPa5SqWCcrmsiD+1idfrjaI5+zh18JnCGxTcNOFEmLnU5xZELE4WpkOd1ZVhWRZKpZJR0uf/3Zan+65jmsQMiClJqVr3bmm+cYKpz2oR5WAwiEqlYjMl8vKcng8Gg0gkEshkMiiXy28ok4iP3x58pvAGBdl2pT0bmFzM8Xhc+1ylUsHExETN8qVdeToJglfp0mQH1yEUCmmfNb3T5GuRsCwL5XJZEdaGhgatJsbNejrtTZbp5r1ef+fXqD58PCORCKLRqPJ91EIsFkOhUEA2mwVwggHSsz6z+J8Fnym8wSGZAhEfSRwJwWAQDQ0NWp+E0ztMUq6JsNTjEHV6v9N3Wb7ud5Om5MZBSyCmQFJ3JBJBKBSyaQb0R+/jDlz6XyqVkM/nbW0plUrGOui+S2YmGYFTOwDYhAbLsmwEPxgMIhKJ2MxOujE29bWP/7fhM4U3KIjw6CJDnBAIBNDU1IR8Po9isai9R5ahI6imKBrTPbrvXiDf5xRhpPuNE2wTnKKJgBPaExHJeDyOaDTquS35fB4DAwO2Opqc0k715XXU2f11bbcsC11dXWhtbVXllMtlHD16FKFQCKFQCLFYDJ2dnYhEIra+oWgjgu9o/p8Jnym8QcEJCS3Y5uZmAO6kcZJyk8mkKo+gM6mYiC2AKoeqkx9DmjJqQRLLWsygUCgYiaHpOm8zL09GGMnn1qxZUxdTiEQiWLBgga3cF154QUnrsh68LwjkK+C/cS3F1F+k2S1cuFBdL5fLOHz4MEKhECKRCJqamtDc3FzFFEjDpL9yuaw0JR//c+AzhTcwuFlCp+Kn02mUy2UVQZJIJJBIJNQzlmVhbGwMQLVUKR2LToSeE3mdhC3LqYcp6EwiurLJDFOLCUimKqEjsAAwc+ZMdHR0oFKp2IimFwQCgaqIn66uLhQKBVQqFezfv1/1kU5zkEybawa6dvJnASjTFaFSqSCZTCIYDCIcDqNUKlWZsyqVitIs5Xt8pvA/Cz5TeINChkDqFubo6CgmJiaQz+eRz+cxd+5cxRSASTt2X19flTSss3nzz5JAS6agYwz8uxczku4ZySScTFlOTIokXukQ5u+UzHHZsmU4/fTTbe+gurgJATaByiwWi9ixYwfy+bw2pJVrNk5mMl39CNJsaFkWMpkMAKChoUEJEhzlchnZbNbmYJ9Ke3387sJnCr/D6OnpwcjICCYmJlAoFBCPxzF//nz1e6FQwN69e6vMDbpNTvRfR1yJUPB7dJ+BqYW71mI2VL7Ts6ZrOqZAJhKCrt7pdBrbtm0DAHR0dGDlypVem2VDOBzGu9/9brzyyivYsWNHFfF3CrfV3QNAMTYZNURIJBJ473vfa3tWakG5XA6jo6NobGxEJBJBJBJBOBz2xOB9/L+Bk8YUfAmjGjzEzxTaSKDfKbpF52BOJpMYGxtDJpOBZVlVEmKlUkEul6tyTOqYQi3zkZuwUWqP/L1WBJCX79zWzk0bfFMZ9W8oFFJhvdJhL01y5KDX+RDIAesmvNMNYrEYFi5ciFAohNdff10xpnA4bCPwbvtE9sfAwABeeeUVnHnmmSpKLRaLGeuze/dupFIpZLNZJVzQH3CC0UvBgEdq8brp5ofTHhsfbyycFKbgM4RqkLOY25K5Y1C3G7WWPbdYLKJUKsGyLEUAdfc4LVInZkBwu8hN99fa4OWGOEQiETQ0NFQRedpQxm3kZBaiPiGfC3+moaEBoVBIlRkMBtHW1lbFFEKhEOLxOCqVinFncD2YP38+Ojo6cODAAWVKCgaDajwlnBiD7MO+vj4MDw9jyZIlaGpqMmpulUoF+Xweu3btQi6XQzQaRalUQlNTk+pPmrdcA+QCC1DtFNfVUSeI+CGvb0z45qNTBMuykM/nlWTFFyqZMbjUGw6HEQwGkc/nlSbA/QUAcM0119gWlVdJ1qv9/2Sg1gYwYLKeF1xwQZWtn3DgwAE88cQTtmsNDQ0oFAqq7+g9FJIZjUaRSCRUFE4kEkEwGNRqCjqJeDrAzTpDQ0N48MEHlbbH66HTHGppbqVSCffddx8uuOACnHnmmdr39/T0qH4LBAIoFovKt5BOp5FKpdDY2IhYLIZyuYxYLKYYBB830m6IsVGdZPSUzgzmC5BvPPhM4RRCF80h7fjcDEILdHx8HJlMBseOHcPKlSvR0tI
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# https://docs.opencv.org/3.4/dc/d7d/tutorial_py_brief.html\n",
    "import cv2 as cv\n",
    "import numpy as np\n",
    "from matplotlib import pyplot as plt\n",
    "\n",
    "def brief_descriptor(image, keypoints, patch_size=31, pairs=256):\n",
    "    descriptors = []\n",
    "    for kp in keypoints:\n",
    "        x, y = int(kp.pt[0]), int(kp.pt[1])\n",
    "        patch = image[y - patch_size // 2:y + patch_size // 2 + 1,\n",
    "                      x - patch_size // 2:x + patch_size // 2 + 1]\n",
    "        if patch.shape != (patch_size, patch_size):\n",
    "            continue\n",
    "        patch = cv.GaussianBlur(patch, (5, 5), 0)\n",
    "        desc = []\n",
    "        for _ in range(pairs):\n",
    "            p1 = np.random.randint(0, patch_size, 2)\n",
    "            p2 = np.random.randint(0, patch_size, 2)\n",
    "            desc.append(1 if patch[p1[0], p1[1]] < patch[p2[0], p2[1]] else 0)\n",
    "        descriptors.append(desc)\n",
    "    return np.array(descriptors, dtype=np.uint8)\n",
    "\n",
    "img = cv.imread('img/blox.jpg', cv.IMREAD_GRAYSCALE)\n",
    "\n",
    "fast = cv.FastFeatureDetector_create()\n",
    "keypoints = fast.detect(img, None)\n",
    "descriptors = brief_descriptor(img, keypoints)\n",
    "\n",
    "img_with_circles = img.copy()\n",
    "for kp in keypoints:\n",
    "    x, y = int(kp.pt[0]), int(kp.pt[1])\n",
    "    radius = int(kp.size / 2)\n",
    "    cv.circle(img_with_circles, (x, y), radius, (255, 0, 0), 2)\n",
    "\n",
    "plt.imshow(img_with_circles, cmap='gray')\n",
    "plt.axis('off')\n",
    "plt.show()\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Лаба 11"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(290, 32)\n",
      "Descriptor size: 32 bytes (default for BRIEF)\n",
      "Descriptor shape: (290, 32)\n"
     ]
    },
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#https://docs.opencv.org/3.4/d1/d89/tutorial_py_orb.html\n",
    "import cv2 as cv\n",
    "from matplotlib import pyplot as plt\n",
    "\n",
    "img = cv.imread('img/blox.jpg', cv.IMREAD_GRAYSCALE)\n",
    "\n",
    "orb = cv.ORB_create()\n",
    "kp, des = orb.detectAndCompute(img, None)\n",
    "\n",
    "print(des.shape)\n",
    "print(f\"Descriptor size: {des.shape[1]} bytes (default for BRIEF)\")\n",
    "print(f\"Descriptor shape: {des.shape}\")\n",
    "img_with_keypoints = cv.drawKeypoints(img, kp, None, color=(255, 0, 0))\n",
    "plt.imshow(img_with_keypoints)\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#https://docs.opencv.org/3.4/dc/dc3/tutorial_py_matcher.html\n",
    "import cv2 as cv\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "img1 = cv.imread('img/box.png', cv.IMREAD_GRAYSCALE)\n",
    "img2 = cv.imread('img/box_in_scene.png', cv.IMREAD_GRAYSCALE)\n",
    "\n",
    "orb = cv.ORB_create()\n",
    "kp1, des1 = orb.detectAndCompute(img1, None)\n",
    "kp2, des2 = orb.detectAndCompute(img2, None)\n",
    "\n",
    "bf = cv.BFMatcher(cv.NORM_HAMMING, crossCheck=True)\n",
    "matches = bf.match(des1, des2)\n",
    "matches = sorted(matches, key=lambda x: x.distance)\n",
    "\n",
    "img3 = cv.drawMatches(img1, kp1, img2, kp2, matches[:10], None, flags=cv.DrawMatchesFlags_NOT_DRAW_SINGLE_POINTS)\n",
    "plt.imshow(img3)\n",
    "plt.axis('off')\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import cv2 as cv\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "img1 = cv.imread('img/box.png', cv.IMREAD_GRAYSCALE)\n",
    "img2 = cv.imread('img/box_in_scene.png', cv.IMREAD_GRAYSCALE)\n",
    "\n",
    "sift = cv.SIFT_create()\n",
    "kp1, des1 = sift.detectAndCompute(img1, None)\n",
    "kp2, des2 = sift.detectAndCompute(img2, None)\n",
    "\n",
    "bf = cv.BFMatcher()\n",
    "matches = bf.knnMatch(des1, des2, k=2)\n",
    "\n",
    "good_matches = []\n",
    "for m, n in matches:\n",
    "    if m.distance < 0.75 * n.distance:\n",
    "        good_matches.append([m])\n",
    "\n",
    "img3 = cv.drawMatchesKnn(img1, kp1, img2, kp2, good_matches, None, flags=cv.DrawMatchesFlags_NOT_DRAW_SINGLE_POINTS)\n",
    "plt.imshow(img3)\n",
    "plt.axis('off')\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import cv2 as cv\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "img1 = cv.imread('img/box.png', cv.IMREAD_GRAYSCALE)\n",
    "img2 = cv.imread('img/box_in_scene.png', cv.IMREAD_GRAYSCALE)\n",
    "\n",
    "sift = cv.SIFT_create()\n",
    "kp1, des1 = sift.detectAndCompute(img1, None)\n",
    "kp2, des2 = sift.detectAndCompute(img2, None)\n",
    "\n",
    "FLANN_INDEX_KDTREE = 1\n",
    "index_params = dict(algorithm=FLANN_INDEX_KDTREE, trees=5)\n",
    "search_params = dict(checks=50)\n",
    "flann = cv.FlannBasedMatcher(index_params, search_params)\n",
    "\n",
    "matches = flann.knnMatch(des1, des2, k=2)\n",
    "\n",
    "matchesMask = [[0, 0] for _ in range(len(matches))]\n",
    "for i, (m, n) in enumerate(matches):\n",
    "    if m.distance < 0.7 * n.distance:\n",
    "        matchesMask[i] = [1, 0]\n",
    "\n",
    "draw_params = dict(matchColor=(0, 255, 0),\n",
    "                   singlePointColor=(255, 0, 0),\n",
    "                   matchesMask=matchesMask,\n",
    "                   flags=cv.DrawMatchesFlags_DEFAULT)\n",
    "\n",
    "img3 = cv.drawMatchesKnn(img1, kp1, img2, kp2, matches, None, **draw_params)\n",
    "plt.imshow(img3)\n",
    "plt.axis('off')\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Краткое описание методов:\n",
    "\n",
    "    Brute-Force Matching с ORB:\n",
    "        Используется Hamming Distance для бинарных дескрипторов.\n",
    "        Подходит для ORB, BRIEF, BRISK.\n",
    "\n",
    "    Brute-Force Matching с SIFT:\n",
    "        Используется L2 расстояние для вещественных дескрипторов.\n",
    "        Применяется knnMatch и тест отношения Дэвида Лоу (Ratio Test).\n",
    "\n",
    "    FLANN Matcher:\n",
    "        Быстрее для больших наборов данных.\n",
    "        Использует K-D деревья для вещественных дескрипторов (например, SIFT, SURF).\n",
    "        Использует LSH для бинарных дескрипторов (например, ORB)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#https://docs.opencv.org/3.4/d1/de0/tutorial_py_feature_homography.html\n",
    "import numpy as np\n",
    "import cv2 as cv\n",
    "from matplotlib import pyplot as plt\n",
    "\n",
    "MIN_MATCH_COUNT = 10\n",
    "\n",
    "img1 = cv.imread('img/box.png', cv.IMREAD_GRAYSCALE)  # queryImage\n",
    "img2 = cv.imread('img/box_in_scene.png', cv.IMREAD_GRAYSCALE)  # trainImage\n",
    "\n",
    "sift = cv.SIFT_create()\n",
    "\n",
    "kp1, des1 = sift.detectAndCompute(img1, None)\n",
    "kp2, des2 = sift.detectAndCompute(img2, None)\n",
    "\n",
    "FLANN_INDEX_KDTREE = 1\n",
    "index_params = dict(algorithm=FLANN_INDEX_KDTREE, trees=5)\n",
    "search_params = dict(checks=50)\n",
    "\n",
    "flann = cv.FlannBasedMatcher(index_params, search_params)\n",
    "\n",
    "matches = flann.knnMatch(des1, des2, k=2)\n",
    "\n",
    "good = []\n",
    "for m, n in matches:\n",
    "    if m.distance < 0.7 * n.distance:\n",
    "        good.append(m)\n",
    "\n",
    "if len(good) > MIN_MATCH_COUNT:\n",
    "    src_pts = np.float32([kp1[m.queryIdx].pt for m in good]).reshape(-1, 1, 2)\n",
    "    dst_pts = np.float32([kp2[m.trainIdx].pt for m in good]).reshape(-1, 1, 2)\n",
    "\n",
    "    M, mask = cv.findHomography(src_pts, dst_pts, cv.RANSAC, 5.0)\n",
    "    matchesMask = mask.ravel().tolist()\n",
    "\n",
    "    h, w = img1.shape\n",
    "    pts = np.float32([[0, 0], [0, h - 1], [w - 1, h - 1], [w - 1, 0]]).reshape(-1, 1, 2)\n",
    "    dst = cv.perspectiveTransform(pts, M)\n",
    "\n",
    "    img2 = cv.polylines(img2, [np.int32(dst)], True, 255, 3, cv.LINE_AA)\n",
    "else:\n",
    "    print(f\"Not enough matches are found - {len(good)}/{MIN_MATCH_COUNT}\")\n",
    "    matchesMask = None\n",
    "\n",
    "draw_params = dict(matchColor=(0, 255, 0),\n",
    "                   singlePointColor=None,\n",
    "                   matchesMask=matchesMask,\n",
    "                   flags=cv.DrawMatchesFlags_NOT_DRAW_SINGLE_POINTS)\n",
    "\n",
    "img3 = cv.drawMatches(img1, kp1, img2, kp2, good, None, **draw_params)\n",
    "\n",
    "plt.imshow(img3, 'gray')\n",
    "plt.axis('off')\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Лаба 12"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "ename": "",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31mThe Kernel crashed while executing code in the current cell or a previous cell. \n",
      "\u001b[1;31mPlease review the code in the cell(s) to identify a possible cause of the failure. \n",
      "\u001b[1;31mClick <a href='https://aka.ms/vscodeJupyterKernelCrash'>here</a> for more info. \n",
      "\u001b[1;31mView Jupyter <a href='command:jupyter.viewOutput'>log</a> for further details."
     ]
    }
   ],
   "source": [
    "#https://docs.opencv.org/3.4/db/d28/tutorial_cascade_classifier.html\n",
    "import cv2 as cv\n",
    "\n",
    "def detectAndDisplay(frame):\n",
    "    frame_gray = cv.cvtColor(frame, cv.COLOR_BGR2GRAY)\n",
    "    frame_gray = cv.equalizeHist(frame_gray)\n",
    "\n",
    "    faces = face_cascade.detectMultiScale(frame_gray)\n",
    "    for (x, y, w, h) in faces:\n",
    "        center = (x + w // 2, y + h // 2)\n",
    "        frame = cv.ellipse(frame, center, (w // 2, h // 2), 0, 0, 360, (255, 0, 255), 4)\n",
    "\n",
    "        faceROI = frame_gray[y:y + h, x:x + w]\n",
    "        eyes = eyes_cascade.detectMultiScale(faceROI)\n",
    "        for (x2, y2, w2, h2) in eyes:\n",
    "            eye_center = (x + x2 + w2 // 2, y + y2 + h2 // 2)\n",
    "            radius = int(round((w2 + h2) * 0.25))\n",
    "            frame = cv.circle(frame, eye_center, radius, (255, 0, 0), 4)\n",
    "\n",
    "    cv.imshow('Capture - Face detection', frame)\n",
    "\n",
    "face_cascade = cv.CascadeClassifier()\n",
    "eyes_cascade = cv.CascadeClassifier()\n",
    "\n",
    "face_cascade_name = 'data/haarcascade_frontalface_alt.xml'\n",
    "eyes_cascade_name = 'data/haarcascade_eye_tree_eyeglasses.xml'\n",
    "\n",
    "if not face_cascade.load(cv.samples.findFile(face_cascade_name)):\n",
    "    print('--(!)Error loading face cascade')\n",
    "    exit(0)\n",
    "if not eyes_cascade.load(cv.samples.findFile(eyes_cascade_name)):\n",
    "    print('--(!)Error loading eyes cascade')\n",
    "    exit(0)\n",
    "\n",
    "cap = cv.VideoCapture(0)\n",
    "if not cap.isOpened():\n",
    "    print('--(!)Error opening video capture')\n",
    "    exit(0)\n",
    "\n",
    "while True:\n",
    "    ret, frame = cap.read()\n",
    "    if frame is None:\n",
    "        print('--(!) No captured frame -- Break!')\n",
    "        break\n",
    "\n",
    "    detectAndDisplay(frame)\n",
    "\n",
    "    if cv.waitKey(10) & 0xFF == ord('q'):  # Нажмите 'q' для выхода\n",
    "        break\n",
    "\n"
   ]
  },
  {
   "attachments": {
    "image.png": {
     "image/png": "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
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![image.png](attachment:image.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 1000x1000 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#https://docs.opencv.org/3.4/d6/d10/tutorial_py_houghlines.html\n",
    "import cv2 as cv\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "img = cv.imread('img/sudoku.png')\n",
    "gray = cv.cvtColor(img, cv.COLOR_BGR2GRAY)\n",
    "edges = cv.Canny(gray, 50, 150, apertureSize=3)\n",
    "\n",
    "lines = cv.HoughLines(edges, 1, np.pi / 180, 200)\n",
    "for line in lines:\n",
    "    rho, theta = line[0]\n",
    "    a = np.cos(theta)\n",
    "    b = np.sin(theta)\n",
    "    x0 = a * rho\n",
    "    y0 = b * rho\n",
    "    x1 = int(x0 + 1000 * (-b))\n",
    "    y1 = int(y0 + 1000 * (a))\n",
    "    x2 = int(x0 - 1000 * (-b))\n",
    "    y2 = int(y0 - 1000 * (a))\n",
    "    cv.line(img, (x1, y1), (x2, y2), (0, 0, 255), 2)\n",
    "\n",
    "plt.figure(figsize=(10, 10))\n",
    "plt.imshow(cv.cvtColor(img, cv.COLOR_BGR2RGB))\n",
    "plt.title(\"Hough Lines\")\n",
    "plt.axis(\"off\")\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 1000x1000 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import cv2 as cv\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "img = cv.imread('img/sudoku.png')\n",
    "gray = cv.cvtColor(img, cv.COLOR_BGR2GRAY)\n",
    "edges = cv.Canny(gray, 50, 150, apertureSize=3)\n",
    "\n",
    "lines = cv.HoughLinesP(edges, 1, np.pi / 180, 100, minLineLength=100, maxLineGap=10)\n",
    "for line in lines:\n",
    "    x1, y1, x2, y2 = line[0]\n",
    "    cv.line(img, (x1, y1), (x2, y2), (0, 255, 0), 2)\n",
    "\n",
    "plt.figure(figsize=(10, 10))\n",
    "plt.imshow(cv.cvtColor(img, cv.COLOR_BGR2RGB))\n",
    "plt.title(\"Probabilistic Hough Lines\")\n",
    "plt.axis(\"off\")\n",
    "plt.show()\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 800x800 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#https://docs.opencv.org/3.4/da/d53/tutorial_py_houghcircles.html\n",
    "import numpy as np\n",
    "import cv2 as cv\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "img = cv.imread('img/geometric_shapes.jpg', cv.IMREAD_GRAYSCALE)\n",
    "assert img is not None, \"Image could not be read. Check the file path.\"\n",
    "\n",
    "img = cv.medianBlur(img, 5)\n",
    "cimg = cv.cvtColor(img, cv.COLOR_GRAY2BGR)\n",
    "\n",
    "circles = cv.HoughCircles(img, cv.HOUGH_GRADIENT, 1, 20,\n",
    "                          param1=50, param2=30, minRadius=0, maxRadius=0)\n",
    "\n",
    "if circles is not None:\n",
    "    circles = np.uint16(np.around(circles))\n",
    "    for i in circles[0, :]:\n",
    "        cv.circle(cimg, (i[0], i[1]), i[2], (0, 255, 0), 2)  # Draw the circle\n",
    "        cv.circle(cimg, (i[0], i[1]), 2, (0, 0, 255), 3)    # Draw the center\n",
    "\n",
    "plt.figure(figsize=(8, 8))\n",
    "plt.imshow(cv.cvtColor(cimg, cv.COLOR_BGR2RGB))\n",
    "plt.title(\"Detected Circles\")\n",
    "plt.axis(\"off\")\n",
    "plt.show()\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": ".venv",
   "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.9.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}