Gyakorlat_4_Képelemzés_haladó.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Többváltozós analízis mérnöki alkalmazásai - 4. gyakorlat\n",
    "\n",
    "## RGB varázslat\n",
    "\n",
    "A következőben azt nézhetjük meg, hogy hogy lehet a kijelzőn színt keverni. Ehhez 4 csúszkát használunk, egy-egy a színcsatornákra és egy a ki-bekapcsolásra.\n",
    "\n",
    "Érdemes használni az OpenCV megjelenítő ablakjának RGB érték kiíró tulajdonságát, elég az egeret a pont felé vinni és megadja annak RGB értéketit.\n",
    "\n",
    "Amit még az ügyesebbek észrevehetnek, hogy a megjelenítésnél is vigyázni kell a csatornák sorrendjének cseréjével."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import cv2\n",
    "import numpy as np\n",
    "\n",
    "def nothing(x):\n",
    "    pass\n",
    "\n",
    "# Create a black image, a window\n",
    "img = np.zeros((300,512,3), np.uint8)\n",
    "cv2.namedWindow('image')\n",
    "\n",
    "# create trackbars for color change\n",
    "cv2.createTrackbar('R','image',0,255,nothing)\n",
    "cv2.createTrackbar('G','image',0,255,nothing)\n",
    "cv2.createTrackbar('B','image',0,255,nothing)\n",
    "\n",
    "# create switch for ON/OFF functionality\n",
    "switch = '0 : OFF \\n1 : ON'\n",
    "cv2.createTrackbar(switch, 'image',0,1,nothing)\n",
    "\n",
    "while(1):\n",
    "    cv2.imshow('image',img)\n",
    "    k = cv2.waitKey(1) & 0xFF\n",
    "    # mit jelent a 27? \n",
    "    if k == 27:\n",
    "        break\n",
    "\n",
    "    # get current positions of four trackbars\n",
    "    r = cv2.getTrackbarPos('R','image')\n",
    "    g = cv2.getTrackbarPos('G','image')\n",
    "    b = cv2.getTrackbarPos('B','image')\n",
    "    s = cv2.getTrackbarPos(switch,'image')\n",
    "\n",
    "    if s == 0:\n",
    "        img[:] = 0\n",
    "    else:\n",
    "        img[:] = [b,g,r]\n",
    "\n",
    "cv2.destroyAllWindows()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Feladat\n",
    "Készítsünk hasonló megoldást, de csak szürke árnyalatosra.\n",
    "Segítség: ugyanaz, mint az RGB megjelnítés, csak egy csatornába megy a 3 szín."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# megoldás\n",
    "import cv2\n",
    "import numpy as np\n",
    "\n",
    "def nothing(x):\n",
    "    pass\n",
    "\n",
    "# Create a black image, a window\n",
    "img = np.zeros((300,512,3), np.uint8)\n",
    "cv2.namedWindow('image')\n",
    "\n",
    "# create trackbars for color change\n",
    "cv2.createTrackbar('GRAY','image',0,255,nothing)\n",
    "\n",
    "\n",
    "# create switch for ON/OFF functionality\n",
    "switch = '0 : OFF \\n1 : ON'\n",
    "cv2.createTrackbar(switch, 'image',0,1,nothing)\n",
    "\n",
    "while(1):\n",
    "    cv2.imshow('image',img)\n",
    "    k = cv2.waitKey(1) & 0xFF\n",
    "    # mit jelent a 27? \n",
    "    if k == 27:\n",
    "        break\n",
    "\n",
    "    # get current positions of four trackbars\n",
    "    gray = cv2.getTrackbarPos('GRAY','image')\n",
    "\n",
    "    s = cv2.getTrackbarPos(switch,'image')\n",
    "\n",
    "    if s == 0:\n",
    "        img[:] = 0\n",
    "    else:\n",
    "        img[:] = [gray,gray,gray]\n",
    "\n",
    "cv2.destroyAllWindows()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Színszűrés segítő\n",
    "\n",
    "A következő kóddal a felső és alsó határokat könnyen meghatározhatjátok egy szín kiválasztásánál. Ez jól jön majd később, ha ilyen alkalmazást fejlesztetek - gyorsan meg tudjátok nézni, hogy egy kód mit is jelent."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# legszuperebb színkiválasztó.py\n",
    "\n",
    "import cv2\n",
    "import numpy as np\n",
    "\n",
    "def nothing(x):\n",
    "    pass\n",
    "\n",
    "# Create a black image, a window\n",
    "#img = np.zeros((300,512,3), np.uint8)\n",
    "image = cv2.imread(r\"kepem.jpg\") #kép\n",
    "img = cv2.resize(image, (0,0), fx=0.5, fy=0.5) \n",
    "img_ = cv2.resize(image, (0,0), fx=0.5, fy=0.5) \n",
    "# cap = cv2.VideoCapture(0)\n",
    "\n",
    "cv2.namedWindow('image')\n",
    "\n",
    "# create trackbars for color change\n",
    "cv2.createTrackbar('H_low','image',0,255,nothing)\n",
    "cv2.createTrackbar('S_low','image',0,255,nothing)\n",
    "cv2.createTrackbar('V_low','image',0,255,nothing)\n",
    "cv2.createTrackbar('H_high','image',0,255,nothing)\n",
    "cv2.createTrackbar('S_high','image',0,255,nothing)\n",
    "cv2.createTrackbar('V_high','image',0,255,nothing)\n",
    "\n",
    "# create switch for ON/OFF functionality\n",
    "switch = '0 : OFF \\n1 : ON'\n",
    "cv2.createTrackbar(switch, 'image',0,1,nothing)\n",
    "\n",
    "while(1):\n",
    "    cv2.imshow('image',img)\n",
    "    k = cv2.waitKey(1) & 0xFF\n",
    "    # itt már \n",
    "    if k == 27:\n",
    "        break\n",
    "\n",
    "    # get current positions of four trackbars\n",
    "    H_low = cv2.getTrackbarPos('H_low','image')\n",
    "    S_low = cv2.getTrackbarPos('S_low','image')\n",
    "    V_low = cv2.getTrackbarPos('V_low','image')\n",
    "    H_high = cv2.getTrackbarPos('H_high','image')\n",
    "    S_high = cv2.getTrackbarPos('S_high','image')\n",
    "    V_high = cv2.getTrackbarPos('V_high','image')\n",
    "    s = cv2.getTrackbarPos(switch,'image')\n",
    "\n",
    "    if s == 0:\n",
    "        img[:] = img_\n",
    "    else:\n",
    "        hsv = cv2.cvtColor(img_, cv2.COLOR_BGR2HSV)\n",
    "        lower_blue = np.array([H_low, S_low, V_low])\n",
    "        upper_blue = np.array([H_high, S_high, V_high])\n",
    "        #print(lower_blue)\n",
    "        mask = cv2.inRange(hsv, lower_blue, upper_blue)\n",
    "        res = cv2.bitwise_and(img_,img_, mask= mask)\n",
    "        #cv.imshow('hsv',hsv)\n",
    "        img[:] = res[:]\n",
    "\n",
    "cv2.destroyAllWindows()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Feladat\n",
    "\n",
    "Készítsétek el az előző példát, csak HSV-ben!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "ename": "ModuleNotFoundError",
     "evalue": "No module named 'cv2'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mModuleNotFoundError\u001b[0m                       Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-1-a475b4bf16dd>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0;32mimport\u001b[0m \u001b[0mcv2\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      2\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mnumpy\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mnothing\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m     \u001b[0;32mpass\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mModuleNotFoundError\u001b[0m: No module named 'cv2'"
     ]
    }
   ],
   "source": [
    "import cv2\n",
    "import numpy as np\n",
    "\n",
    "def nothing(x):\n",
    "    pass\n",
    "\n",
    "# Create a black image, a window\n",
    "img = np.zeros((300,512,3), np.uint8)\n",
    "cv2.namedWindow('image')\n",
    "\n",
    "# create trackbars for color change\n",
    "cv2.createTrackbar('H','image',0,255,nothing)\n",
    "cv2.createTrackbar('S','image',0,255,nothing)\n",
    "cv2.createTrackbar('V','image',0,255,nothing)\n",
    "\n",
    "# create switch for ON/OFF functionality\n",
    "switch = '0 : OFF \\n1 : ON'\n",
    "cv2.createTrackbar(switch, 'image',0,1,nothing)\n",
    "\n",
    "while(1):\n",
    "    cv2.imshow('image',img)\n",
    "    k = cv2.waitKey(1) & 0xFF\n",
    "    # mit jelent a 27? \n",
    "    if k == 27:\n",
    "        break\n",
    "\n",
    "    # get current positions of four trackbars\n",
    "    h = cv2.getTrackbarPos('H','image')\n",
    "    S = cv2.getTrackbarPos('S','image')\n",
    "    v = cv2.getTrackbarPos('V','image')\n",
    "    s = cv2.getTrackbarPos(switch,'image')\n",
    "\n",
    "    if s == 0:\n",
    "        img[:] = 0\n",
    "    else:\n",
    "        img[:] = [h,S,v]\n",
    "        img = cv2.cvtColor(img, cv2.COLOR_HSV2BGR)\n",
    "# ctrl+x izgi dolog\n",
    "cv2.destroyAllWindows()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Videó a webkamerából"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import cv2\n",
    "\n",
    "# több kamera esetén a szám jelöli a kamerát - ha -1 van ott akkor az utolsó kamera lesz akitiválva\n",
    "cap = cv2.VideoCapture(0)\n",
    "\n",
    "# végtelen ciklus inítása a képek beolvasására\n",
    "# fúj fúj végtelen ciklus\n",
    "while(True):\n",
    "    # a videocapture read függvényével megkaphatjuk a képet\n",
    "    ret, frame = cap.read()\n",
    "    \n",
    "    # ha kiíratjuk háthatjuk, hogy a ret azt adja meg, hogy sikerült-e olvasni\n",
    "    # print(ret)\n",
    "\n",
    "    # Múlt órai átalakítás\n",
    "    gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)\n",
    "\n",
    "    # az OpenCV beépített megjelenítőjét használhatjuk, ezzel a legkönnyebb megnézni.\n",
    "    cv2.imshow('frame',gray)\n",
    "    \n",
    "    # várunk egy 'q'-ra a kilépéshez a ciklusból\n",
    "    if cv2.waitKey(1) & 0xFF == ord('q'):\n",
    "        break\n",
    "\n",
    "# A kamerát elengedi, nem fog a led mellette tovább világítani.\n",
    "cap.release()\n",
    "# Ha sok ablak lenne, ez a leghasznosabb parancs \n",
    "# Érdemes megpróbálni lekapcsolni kézzel az ablakokat még futás közben - elég nehéz\n",
    "cv2.destroyAllWindows()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Videó kimentése fájlba"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "ename": "error",
     "evalue": "OpenCV(3.4.2) /tmp/build/80754af9/opencv-suite_1535558553474/work/modules/highgui/src/window.cpp:626: error: (-2:Unspecified error) The function is not implemented. Rebuild the library with Windows, GTK+ 2.x or Carbon support. If you are on Ubuntu or Debian, install libgtk2.0-dev and pkg-config, then re-run cmake or configure script in function 'cvDestroyAllWindows'\n",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31merror\u001b[0m                                     Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-1-09ca3914950e>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m     29\u001b[0m \u001b[0mcap\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrelease\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     30\u001b[0m \u001b[0mout\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrelease\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 31\u001b[0;31m \u001b[0mcv2\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdestroyAllWindows\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31merror\u001b[0m: OpenCV(3.4.2) /tmp/build/80754af9/opencv-suite_1535558553474/work/modules/highgui/src/window.cpp:626: error: (-2:Unspecified error) The function is not implemented. Rebuild the library with Windows, GTK+ 2.x or Carbon support. If you are on Ubuntu or Debian, install libgtk2.0-dev and pkg-config, then re-run cmake or configure script in function 'cvDestroyAllWindows'\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "import cv2\n",
    "\n",
    "cap = cv2.VideoCapture(0)\n",
    "\n",
    "# VideoWriter objektum létrehozása - argumentumban a kódolás van\n",
    "fourcc = cv2.VideoWriter_fourcc(*'XVID')\n",
    "# egy_tobbvaltozos_elete.avi legyen a neve\n",
    "# 15 fps felett \"úgyse\" lát az ember, úgyhogy jó lesz a 20 (kivéve a gamerek, ők 69^420 fpst látnak, ezért kell nekik drága monitor)\n",
    "# a 4k és 8k közt nincs akkora különbség, úgyhogy a 480p és a 1080p közt se lehet akkora.\n",
    "out = cv2.VideoWriter('egy_tobbvaltozos_elete.avi',fourcc, 20.0, (640,480))\n",
    "\n",
    "while(cap.isOpened()):\n",
    "    ret, frame = cap.read()\n",
    "    if ret==True:\n",
    "        # nem semmi, megfordul a kép\n",
    "        # ha nagyon viccesek vagyunk akkor csak minden második képet fordítunk meg\n",
    "        frame = cv2.flip(frame,0)\n",
    "        out.write(frame)\n",
    "\n",
    "        cv2.imshow('frame',frame)\n",
    "        if cv2.waitKey(1) & 0xFF == ord('q'):\n",
    "            break\n",
    "    # ha nem jön vissza  kép akkor is kilép\n",
    "    else:\n",
    "        break\n",
    "\n",
    "# ha ez nincs akkor hibásan is mentheti a videót\n",
    "cap.release()\n",
    "out.release()\n",
    "cv2.destroyAllWindows()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## A konvolúció\n",
    "\n",
    "Akinek régen volt az általános, átnézzük azért, hogy mit is jelent, és megnézzük az általános alakot is. A konvolúció (diszkrét és folytonos is) egy olyan művelet, amely $f$ és $g$ függvények egymásra hatását fejezi ki: megmutatja, hogy az egyik függvényt a másikon \"végigtolva\" milyen időfüggvényt kapok. A konvolvált $h$ függvényt a következő \"konvolúciós integrál\" adja:\n",
    "$$h(t)=\\int_{-\\infty}^{\\infty}f(\\tau)*g(t-\\tau)d\\tau$$\n",
    "Mi is történik ebben a kifejezésben? Azt jelenti, hogy $h(t)$ időfüggvény egy $t$ időpillanatbeli értékének kiszámításához $g$ t körüli részeinek értékeit mind megszorozzuk $f$ megfelelő értékeivel. Szemléltető ábra:\n",
    "\n",
    "![kep1](http://ertedmar.hu/assets/content/konvolucio/konvolucio_animation2.gif)\n",
    "\n",
    "Általában mind $f$, mind $g$ csak egy szűk intervallumon nem nulla - ezért nem kell folyton improprius integrálokkal varázsolni. Diszkrét időben még egyszerűbb ez az elképzelés.\n",
    "\n",
    "![kep2](https://i.stack.imgur.com/0RTyh.png)\n",
    "\n",
    "De mihez is lehet ennek köze? Nézzük meg alaposan a 2. órán írt kódot - találunk egy diszkrét konvolúciót! Ez a mozgó átlag. (egy $n$ elemből álló, $1/n$ értékekkel feltöltött vektor konvolúciós integrálja bármely $a$ vektorral $a$ mozgó átlaga $n$ elemenként számítva.\n",
    "\n",
    "Mivel ezt a mozgó átlagot két, 1D-s vektort összeműveletelve kaptuk, érezzük, hogy akár ki is terjeszthetjük $n$ dimenzióra a konvolúciót - de most maradjuk csak meg 2D-ben. Mit jelentene ez 2D-ben? Legyenek $A$ és $K$ kvadratikus mátrixok (jóval több sorral/oszloppal rendelkezik, mint $K$) számoljuk ki $A$ minden eleménél a $K$ transzponáltjával vett \"súlyozott mozgó átlagot\" és kész is vagyunk! [Itt](http://www.songho.ca/dsp/convolution/convolution2d_example.html) végig van csinálva egy példa két 3x3-as mátrixra, ebből biztosan érthető.\n",
    "\n",
    "## 1 D konvolúció\n",
    "\n",
    "Kicsit siettünk a második órán, de talán emlékeztek, hogy volt szó jelek simításáról és a mozgó átlagról. Erre teljesen jó egy konvolúció is!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7f69e7432940>]"
      ]
     },
     "execution_count": 41,
     "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": [
    "import matplotlib.pyplot as plt\n",
    "# legyen egy zajos sin fg\n",
    "num_of_pts=10000\n",
    "\n",
    "time=np.linspace(0,2*np.pi, num_of_pts)\n",
    "sign=np.sin(time)+1*np.sin(1*time) #a kód így nem egészen jó. módosítsátok úgy, hogy valóban \"szőrös\" legyen a jel!\n",
    "\n",
    "%matplotlib inline\n",
    "plt.plot(time, sign)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7f69e7309940>]"
      ]
     },
     "execution_count": 42,
     "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": [
    "kernel=np.ones(80)\n",
    "kernel/=80 #próbáljátok ki, hogy a kernel méretének változtatása hogy hat!\n",
    "\n",
    "moving_avg = np.convolve(sign, kernel, mode='same')\n",
    "%matplotlib inline\n",
    "plt.plot(time,moving_avg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2D konvolúció és képelemzés \n",
    "\n",
    "Dolgozzunk az egyszerűség kedvéért fekete-fehér képekkel. Láthattuk, hogy ezeket mátrixokban tároltuk. Mossuk el a képünket, definiáljunk egy olyan mátrixot, amit egy konvolúció kerneljeként használva egy \"átlagolt\" képet kapunk vissza!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import cv2\n",
    "\n",
    "\n",
    "#most kerítsünk elő egy képet\n",
    "img=cv2.imread('kepem.jpg', 0)\n",
    "cv2.imshow('Szürkeárnyalatos', img)\n",
    "cv2.waitKey(0)\n",
    "cv2.destroyAllWindows()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.01 0.01 0.01 0.01 0.01 0.01 0.01 0.01 0.01 0.01]\n",
      " [0.01 0.01 0.01 0.01 0.01 0.01 0.01 0.01 0.01 0.01]\n",
      " [0.01 0.01 0.01 0.01 0.01 0.01 0.01 0.01 0.01 0.01]\n",
      " [0.01 0.01 0.01 0.01 0.01 0.01 0.01 0.01 0.01 0.01]\n",
      " [0.01 0.01 0.01 0.01 0.01 0.01 0.01 0.01 0.01 0.01]\n",
      " [0.01 0.01 0.01 0.01 0.01 0.01 0.01 0.01 0.01 0.01]\n",
      " [0.01 0.01 0.01 0.01 0.01 0.01 0.01 0.01 0.01 0.01]\n",
      " [0.01 0.01 0.01 0.01 0.01 0.01 0.01 0.01 0.01 0.01]\n",
      " [0.01 0.01 0.01 0.01 0.01 0.01 0.01 0.01 0.01 0.01]\n",
      " [0.01 0.01 0.01 0.01 0.01 0.01 0.01 0.01 0.01 0.01]]\n"
     ]
    }
   ],
   "source": [
    "#mossuk el!\n",
    "from scipy import signal\n",
    "\n",
    "#kernel def\n",
    "kernel=np.ones((10,10))\n",
    "kernel=kernel/100\n",
    "print(kernel)\n",
    "\n",
    "blur = signal.convolve2d(np.asarray(img), kernel, boundary='symm', mode='same')\n",
    "#blur = blur.astype('uint8') - mit rontok el?\n",
    "\n",
    "cv2.imshow('Szürkeárnyalatos - elmosva', blur)\n",
    "cv2.waitKey(0)\n",
    "cv2.destroyAllWindows()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "#A profik nem írják meg ezeket:\n",
    "blur_cv2blur=cv2.blur(img,(10,10)) #a kernel mérete!\n",
    "\n",
    "cv2.imshow('Szürkeárnyalatos - elmosva_2', blur_cv2blur)\n",
    "cv2.waitKey(0)\n",
    "cv2.destroyAllWindows()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Gauss - ugyanaz, csak nem konstans az array értéke ->kicsit szebb szélek\n",
    "blur_cv2gauss=cv2.GaussianBlur(img,(11,11),0) #a kernel mérete - módosítani kell, pltan kegyen!\n",
    "\n",
    "cv2.imshow('Szürkeárnyalatos - elmosva_3', blur_cv2gauss)\n",
    "cv2.waitKey(0)\n",
    "cv2.destroyAllWindows()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Konvolúció és élkeresés\n",
    "\n",
    "Nem csak az elmosásra jó: ha a kernel megfelelő, kiválaszthatjuk azokat a területeket vele, ahol nagy az eltérés a szomszédos értékek között $\\longrightarrow$ élkeresés!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXcAAADLCAYAAACVv9NEAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvOIA7rQAAIABJREFUeJztnXlYFFe6/78HaBBothYEAQUVEBIcjAt4EQ1XnesWo8YFSTI3Y0azjObOiMuYmzFxmWS8xiT+NJNlMONkUTHRGJMY48QYosYRYjIaMVHQaMsiuCDKDsL5/VHdPQ32Rnd1narifJ6nHqWrus7bXae+/dZ73vMeQikFh8PhcNSFB2sDOBwOhyM+XNw5HA5HhXBx53A4HBXCxZ3D4XBUCBd3DofDUSFc3DkcDkeFcHGXGYSQ/yWEbBb7WAfORQkhcWKci6M8CCEXCSHjDP8XrV8pCUJIHSGkv4jnY3pPcXF3M4SQXxNCThFCGgghlYSQ1wkhwdaOp5S+QCmd58i5u3IsR7kQQuYQQgoIIfWEkCuG//+WEELc0Z5Y/YoQEmsQOC8x7HI3lFItpfRnACCE/J0Q8ifWNrkCF3c3QghZDOD/ACwFEARgBIAYAF8QQrwtHK+Im4AjHYY+9P8AvAggAkA4gCcAjARwRx8yvMdTMgM58oVSyjc3bAACAdQBmN3pdS2AKwAeBbASwE4A7wG4BWCe4bX3zI7/bwB6ANcBrABwEcA4wz7TsQBiAVAAjwC4BOAagGfMzpMK4J8AagBcBvAqAG+z/RRAHOvvjW8d+koQgHoAM+wc93cArwP4zHD8OACTAfzL0K9KAazs9J5fmfWrZ6z1K8PfIwAcNfSdkwAyzfblA1gD4BsAtQD+ASDUsO+SoV/VGbb/sGD7SgAfGO6BWgCnACQAeNpwn5QC+C+z4+cC+Mlw7M8AHu90vmWG/l1huJ9M/drwPf0FwF7D+wsADOh8DwB4DEArgBaD3Z9YukcM5/uT2d9Lzdp+tFPbPgDWG76TKgBvAPB1Z//hnrv7SAfQA8CH5i9SSusA7APwS8NLUyEIfDCArebHEkLuAvAagIcA9IZws0fZaTcDwEAAYwE8SwhJMrzeBmARgFAA/2HY/1snPhdHOv4DgijsceDYBwE8DyAAwBEIIv/fEPrVZABPEkKmAaZ+9ToEgY8E0BNAtKWTEkKiIIjhnwDoACwBsIsQEtap7bkAekF4mlhieH204d9gKoQ8/mnF9ikA3gUQAuEHaT+EqEIUgNUA3jQ79gqA+yA4T3MBvEIIGWKwdQKAHAg/bnEA7rXQVjaAVYa2zkH4zjpAKf0rhHtxncHuKVbsNmFoewmE+zreYIM5/wfhR2uwwbYoAM/aO68rcHF3H6EArlFKb1vYd9mwHwD+SSn9iFLaTilt7HTcTAhewxFKaQuEzmCvGNAqSmkjpfQkBC8rBQAopd9RSo9RSm9TSi9CuGEsdX6OfLijDxFCjhJCagghjYSQ0WbH7qGUfmPoR02U0nxK6SnD3z8A2I5/X++ZAD6llB6ilDZDeCJst2LDwwA+o5R+ZjjXFwCOA5hkdswWSmmxof++D0HAusJhSul+w+f8AEAYgLWU0lYAeQBijeNUlNK9lNLzVOBrCE8KowznmW2w5TSltAGCiHfmQ0ppoaGtrU7Yag1j20WU0noITyQAAMPYyHwAiyil1ZTSWgAvAJgjUtsW4TFe93ENQCghxMuCwPc27AeEx05rRJrvp5Q2EEKu22m30uz/DRDCQCCEJAB4GcAwAH4Qrv139j4EhynX0akPUUrTAYAQUoaOzlmHfkQISQOwFkAyBG/aB4JwAnf2q3ob/SoGwCxCiLn3qgHwldnfFvtcF6gy+38jhB+0NrO/YThnDSFkIoDnIHjBHhD68inDMZEQfniMWLq3XLXVGpHoeD/pzf4fBsHO78zGwAkAt46NcM/dffwTQDOAB8xfJIT4A5gI4EvDS7Y88cswe1wmhPhCeIR2htcBnAEQTykNBPC/EDoYR74Y+9BUB47t3I+2AfgYQB9KaRCEGK/xel8G0Md4ICHED9b7VSmAdymlwWabP6V0rRM2uQQhxAfALgix63BKaTCEcQbzz2UeXuoD57FkewMEkTYSYfb/Dt8pgL5m/78G4UfqbrPvMIhSKtYPi0W4uLsJSulNCI+FmwghEwghGkJILATvqQxCjNEeOwFMIYSkG7JrVsF5QQ6AMLhWRwhJBPCkk+fhSASltAbCNX+NEDKTEKIlhHgQQgYD8Lfz9gAA1ZTSJkJIKoS4uJGdAO4jhGQY+tVqWNeC9yD0wfGEEE9CSA9CSCYhxGKMvhNXIYR7xModNz6BXAVw2+DF/5fZ/vcBzCWEJBl+sFyJaVfhTrtPAHjQ8D1MQMew5vsAfk0IucvQ9nPGHZTSdgC5EMYHegHCWAYhZLwL9tmFi7sboZSug+Ahr4cgrAUQPKGxhlinvfefBvAUhLjjZQgj/FcgeHNdZQmEG7wWQkfb4cQ5OBJj6EM5ELJArkAQnTcB/AFCBos1fgtgNSGkFoLIvW92ztMAFkDw7i8DuAHB4bDUfimEJ4f/hSCqpRCyQuxqhyHu/TyAbwzjBCPsvcfO+WoB/I/hs9yA0J8/Ntu/D8BGCCGjcxCefADn7pe3ANxlsPsjw2u/gzD4WwMhycH4urHtDQAOGto+2Ol8fzC8fowQcgvAAQiJD26DGNJ0OAqAEKKF0LHiKaUXWNvD4cgZQ6ZYEQAfK4kNqoZ77jKHEDKFEOJniNWvhzB4dJGtVRyOPCGETCeEeBNCQiCkH37SHYUd4OKuBKZCmBRRASF/dg7lj1scjjUehxA+Og9hbke3HVviYRkOh8NRIdxz53A4HBXCxZ3D4XBUiFxmqComNqTX61FTU4OffvoJDQ0NKCsrQ0lJCerq6lBWJmSTRUdHQ6vVIj4+HtHR0fDz80NSUhKCg4MRExPD+BP8m+vXr6OxsRGVlZWora1FY2MjysvLTfsAoGdPYW5LVFQUfH19ERAQgIiICPj6+pr2KQQmE7YIIbLt2ykpKYiJicGAAQNQXFyMsrIy3Lx5EwDg7e0NjUaD+vp6+Pj44OzZswCAgQMHorm5Gf7+/mhtbUVLSwsAICgoCNHR0UhISMD58+eh1+tx8uRJyT5LdHQ0dDodwsLCUFlZiRs3bqC1tRWenp5ob2/H7dv/HlOtrq4GAOh0OtNrXl5e8PDwQFtbGzQaDUJCQhAREYGrV6+iurradG/LEUqpxb4tF3GXHSdPnsR3332H119/vcvvNXaEM2fO2D32ySefxNChQ5GSktLldrpiz6VLl3Do0KEuv9co8sZ/bTF69Gj07dsX0dGOzG/hSElmZibGjh0LHx8fLFu2zOIxjoixUeQtYe26r1u3Ds3Nzfjyyy+Rn5/vkL22SExMREJCAggh2LPnzppqhBBUVFTYPY9R5C1hLvzmTJ06FZRSFBcXO3R/s0QuA6qyMKKhoQGFhYX4+OOPcfjwYUnbHjVqFO6//36kpqbCz8/P/hvs0NraivPnz+P06dMoKSkRwULHiY+Px913340BAwZAo9FI2rYNuqXnnpmZiSlTpmD37t04cuQIAGDu3LmIiYlBbm6u6UlNbKKiojB//nzo9Xps2bIFAJCRkYHp06fjk08+cUrkExIScPfdd+PUqVM4d+4cPDw8kJqaipCQEBQUFNgUa1fQ6XRIS0vDjRs3UFhYiPb2dsTFxWHQoEE4ffo0iouL3dKuo3DP3Qp6vR4zZ85kbQYOHz58xw/Kzp07uxTGuX79OnJzc8U2rcuUlJTc8YMyf/58pYVxFEtaWhoefvhhvPrqqxb3G8XWnZSXl2PlypVW9w8cOBALFy7Ee++9h4KCAqvHxcbGIi0tDV988cUd+9rb23Hs2DExzLVJdXU19u3bZ3W/TqfDL3/5SxQUFODixYtut8dRurXn/qtf/Ur2j1aJiYl49137ZWhyc3MdCp2wpGfPnpg/fz6r5ruF515YWIj8/Hz85S9/wfTp01FVVYXt27dLaYJdsrOzER4ejt27d2PBggXIzMxEamrqHcctX74cZ8+exaFDh/CLX/wC9fX1KCwsZGCxdVJTU+Hv748ffvgBo0ePxsCBA7F2rSM11cSDe+4G8vPzsXTpUtZmOMyZM2cwfPhwAMCLL76IzMxM077i4mJ8+OGHVt4pP65fv27q+A888AASEhIYW6QOdu/ejWvXrnXwlPV6PTZs2MDOKBtY+rGJiorCypUrkZubi/j4+A6e8vXr1/HVV1/d8R45YOnHRqfTYeLEifj666+ZDsR2G8/95MmTWLlypaxHvR0hOjoamzZtwr59+2TvqdtDYk9edZ67n58f1qxZg927d8PLywvr1q2z6AErgXfffRe7du1CdXU1ysvLMWvWLMk9YLFYvnw5PvzwQ0yePBmXLl3Cxx9/jNbWVre1Z81z7xZ57g0NDZg3b57ihR0A/P39UV1drXhhBwSPbNeuXW7t+GomPz8fN2/exOLFi/HQQw9h+vTprE1ymitXrqBnz55oampC79698e2337I2yWn++te/Yvjw4fjggw9QU1ODxYsXM7FD1WEZuQyWisGIESOQk5Nj+jsrKwsAcODAAUULfUlJCV566SUAwMKFC6HVunX9AlVQWFiITz/91PS3kkU9Ly8Pr7zyCqKiovD++++jsLAQffv2xYgRI0z/vv/++/ZPJCOqq6uxdauwHPLAgUJV37Fjx2L48OGSPo2oNizz6aefYtUqS0soKo+cnByMGGG9FLZer5cka0AKxo0bh2HDhrnj1IoPyxjDMBs2bMDGjRuxcOFCt6UyupuEhAQsXboUL730ElauXIk5czouJ+rp6Yn7778fX375JcaOHYvdu3czstR1dDodZsyYgU8++QQjR44UPUxjLSyjOnFXk7c+YcIEPProow4ff+rUKfz4449utEg65s2bh9DQUPsHOo6ixX3y5MlISkpC7969O+SsK5FFixZhy5YtePHFF5GTk4Pa2lqrxxpF/rvvvkPv3r1tpk3Knbi4OKSkpKChoQEXLlwQLVOv24i7MbNEDTjzOLpjh3oWWFq+fLmYp1OsuP/+97/Hgw8Kq+Tp9XrMmjXLZbtYsWHDBkRECEuP7t+/36Gc++TkZNx1110AgNraWps553LnN7/5DcLCwgAABQUFomQBqV7cc3JyJJ9V6i42b96MwMBAp99/+/Zt7Nq1S0SL2BEfH48ZM2aIcSrFibufnx+2bt2KrVu3YtmyZYrNhDGSl5eHyspKRERE3BGGcYTZs2ejpqYG/v7+ig7TAILjsm/fPqSmpuKtt95Ce3u70+dSdbZMQ0ODaoQdgEvCDghFkNRCSUmJSx1fqfj5+SE/Px8hISFYtmxZh8F0pZGQkIC8vDwUFxcjIiLC6fTXXbt2ITg4GBqNBrNnzxbZSmnZuXMnJk6cCK1Wi2XLlrmlTIeiPfeGhgbce++99g9UAAMHDsSaNWtEP6+awjSLFy925SZQjOfu5+eHnTt3IjQ0FA0NDR0mrimNhIQEDB8+HFOmTEFxcTGeffZZl89pLuxKy6TpzKJFi+Dj44O6ujq8+eabTg20qjIs093j646iJoF3IQ6vGHE3znpUurADQigGgGjCbkSNAg8IFTS7+qSqOnGfPn26KiYlAe7vnGqKwbswq1UR4l5YWIjDhw8zm/giJnl5eaitrXXrLOTp06dDo9EoXuABYMaMGejfvz9efPHFLr1PVTH3nJwc1Qj75s2b3d6Gl5eXWIOSzDHOalUjv//977Fu3TqMGjWKtSkus2HDBlRWViIgIMCt7Wg0GlRWVuI///M/3dqOFMTHx+Mf//iHaJ9FkSNvfPC066htkFVtTJ482ZTuqOTBU0AIMxjTHd1dO2jXrl0mxyUtLU3RefA7d+40zdG5fPmyy3nwivLc9Xq9auLsEyZMkPxRMisry5QvrHTWrl2La9eusTZDNIYOHQpAKCGr5AlKAHD06FEAwJw5c2xOUBKDtrY20310+fJlt7blbs6dO2cqTxAfHw8PD9fkWVHirpaZpwC6NPNUTAYNGsSkXXcgRUhLCl566SUEBQVBr9ezNsVlcnNzMW/ePOzfv1/Sdn/88UfcfffdmDhxoqTtuoOrV6/C29vb5ZpBinlWNy+UpHRYP3aPGDFCNbVozpw5g8TERNZmOE1hYSGeeOIJ+Pn5Kd5jz8vLw8qVK1FeXu52j70zRUVFplWQZs+eregB1rfeegtxcXGoq6vD8uXLnS42pgjPvaGhQTVFwEaMGGGzCJgUdGXpPrnz0Ucfoa6ujrUZTvPpp59i0aJFihd2AHjllVewePFiyYXdSF1dHX75y1+qwnE5d+4cpkyZgp9++snpcygiFVItcXZAXjm53Sz/XVapkMYZqICw3OPZs2elNEtUEhISsHr1agDCACorcQeEQmPGAVY53WvOoNPp8NhjjwEQQnfWJjgpdpm9hoYG1iaIhrG2M0d8Wltb3TKF210sWbLEFGpUsrADwG9/+1u88sorAMBU2AFhgNXouU+cOFHRRcaqq6tNnvu4ceO6/FlkHZbR6/WqKS8wYcIEt5QXcAU1Zc+89NJLisqe+e677xAfH2/yeJXMn//8ZyxatEg2aYiXLl3C0KFDVZEyvWfPHvTq1QulpaVdfq+sxf2Pf/wjaxNEg1V2jD2SkpJYmyAaSqkUmJaWhmvXrqFHjx6sTXGZuXPnYtKkSZJnx9ijpKQEAwYMQEpKCmtTXKa9vR11dXWIjY3t0vtkHZYRq5g9xzpqmtykhOUG09LS8PDDDwOAouuyA4KwV1RUAIDsxL2oqAgJCQkAgJSUFJw8eZKxRc7z1ltvmZbVBGDKCrKHbO9suTziiYFcvXYjgwcPxokTJ1ibIQoXL17ssocjJcuXL8fChQtZmyEK48ePd6ouu1ScP38eAHD//fcrWtyBfyc/zJ8/H7m5uQ69R7ZhGSkXknU3EyZMYG2CTQYMGMDaBNH44osvWJtglZSUFJSVlSE0NFSxa58aycrKwpYtWzp4lHKjra0N8fHxOH36tKLnQhiJjo7GrVu3EB0d7dDxshR3XhhMWry8vDBp0iTWZoiCnAuLLVy4EOvXr1eF597S0oKamhq0tLSwNsUmXl5euHbtmirCj/feey8+/fRTh5NMZCfuer1eFaPcgDBhSarCYK4SEBCAnj17sjZDFEpKSmQ5sentt9/GmDFj8Pbbb7M2xWUOHDiAiRMn4sCBA6xNscnFixeRkpLicJxazhQUFCAlJcXhkLXsJjHxCUtsUfHEJqaTmNLS0gAA99xzD9544w0WpojG3LlzAQD//Oc/FZH0EBoaiqioKABQfOw9IyPDFNUw/mApdhITh6MGjCsHqWERjvT0dADAli1bGFviGNeuXTM5jUoX9yNHjphm4Np7GpGVuPPZqBwxkcus1czMTMXk4Ntj7ty5zAvfOYMx1Kv0tEjg3z9QCQkJKC4utnqcrGLuxrUj1cDIkSNZm+AUgwcPZm2CaFy4cIG1CQCAYcOG4ciRI6ooDtajRw/U1tYyLzPQVerq6lBXV4fIyEjWprjMuXPncO7cObsFAGUl7kuXLmVtgmjIPf3RGmp64vjwww9ZmwAA+Omnn1QxUxIQvlM5pz/aIjExUTXJGtHR0XYXJ5GNuCv9UckcOU/scAS11JsBIIuU2r1796qmzENVVZViP0vv3r1lmUXlDJGRkSgqKrJ5jGzEff369axNEI0HHniAtQkuodSb1xJyqQrYu3dv1iaIRl5eHmsTnOLUqVOsTRANf39/eHh42FyKTzYDqkpIqeouqGHChxHW9WaM4ZjPPvuMqR1iYAzHKDVd9saNG6aZqkrXm5MnT0Kn09k8Rj13MYcjQ4xTxffu3cvYEtdR+mBkW1sbgoKCWJshCtXV1XaTH7i4czhuJCIigrUJonH06FHWJriMHMZgpIKLO4fjRiorK1mbIBpqmMJ/8+ZN1iaIxu3bt23ul8WAql6vZ22CaLBe/Fos1FJnBgDTDImysjJVhGSysrJQVVWFqqoql87j4+ODwMBA+Pj4wMfHB56envD09AQhHWfQE0JM+4zHGt/nCsZ8dzVUiSwqKkJNTY3V/bLw3G0ZqDTEqiXu4+MDf39/eHp6wtvb2+rIeHt7O9rb29HS0oK2tjbU19ejubnZ5fbDw8OZD0aKRU1NDbRaLZO21eIpuuKAhYaGorGxEZRSNDc3O9Q/KaVoa2sDANO/zc3N8PT0hJ+fHwgh8PX1dXppRXter1KwVRtMFuJuXARWDXQ1jTAsLAy+vr7w9PR0qj2j4Ht7ewOAxQGjtrY2NDY24urVqw6fNyIiAj/++KNTNsmNyspKh2tgcyxjb8KMEZ1OZ+pvUpYD9vb2Nt1H1dXVdo83riCldGz9UMpC3NVUUyYkJMSh46KiokyC7G48PT2h1Wqh1WrR0tKi+IUiugrLmuNSXWN3Y8/TNYp6XV0dWlpaEBgYCF9fX9y+fVvUhcvb2tpMelFfXw9/f394eXmBUoqbN2/C29sbQUFBdkXe+DSgdGSf525vppWS8PPzs/h6ZGSky/FCMfD29ka/fv1Mf9fV1Vn06B39kVICjnqd7qC9vZ1Z22Jy69atDn8HBQUhMDAQ9fX1FkW08/Huor6+3uZ+nU4Hf39/3Lp1q0OIzJYoKglbhfFkIe5dCRfInc6LcxhvArlODNJqtejRo8cdnV9NOPKY7i7UEts1x+ill5eXQ6PRIDIyEtevXxdlrMdVWlpa0NLSAn9/f5NdNTU1CAgIgE6nM/UFua8g5SiNjY1W98lCcZQ+W6wzQUFBCA4OVox34OXlBZ1OB51Oh/b2dtTU1KhK6FkODLe2tjJrW0wIIejbt+8dIb3m5mZZxq/r6+tNXr35fejp6YmoqCjU1NRI9nTBCmWoj4IIDAyETqdTjLB3xsPDAzqdTjHLA8odtYxv6HQ63LhxwzQwffPmTcWEnNrb203OSnR0NK5evWp36r5SsPVUqkwFkilhYWGqyQ/v2bOnqopdcZwjKCgIsbGxuH79OlJTU1FWVsY0zOUK1dXVKCsrQ2hoKK5fv47Y2FhVOzGyEHelp6lFRUWhf//+GDp0KGtTRKVHjx7o16+f4q8Pyx9cpdbHN4q6kdraWpSWlio+y6StrQ2lpaUdFhtRssjbegKRhbizmmAiBiEhIaYsGFtLXikZjUajmoJLUiOHQcauEhERgZCQEFy+fBkhISGyjKmLQXl5OXQ6HS5fvgydTqeqOkCATAZU4+PjFTeoGhMT4/TEIyViPuCqtHIRUVFRzNpWkqcbFBSEkJAQNDU1mV4z1pPRaDSqcl48PDzQ2tqKixcvdkhRjo2NRXV1tSoGW2XhuSvtkSgkJMSqsKslO8LaYJmHh4fivHhfX99u2XZXMXrpnp6euHTpUoenDiV9Dkcwzw9vbm7GpUuX0NDQgIqKCkUNttpK3JCFuMfFxbE2wWH69+9vc4KPWqoA2pocotPpOkyEkjssB4aVkE8dFRVliq97e3ujvLz8jh93NU1qA4TxJHPa29tx69Ytk+jHxsYyfeJzlM4F18yRhbiHhYWxNsEhHBlYvHHjhgSWuB9HSkIoZaC1840sJUoYT9JoNGhoaMDly5etVtBUs+duTn19PS5fvoz6+nqbsz+VgCzEfdCgQaxNsEv//v0dqhNy4sQJCaxxP45M2ddoNIrw4Fl6YOZZGXKjb9++Jo/92rVrNgd/Q0NDJbJKGmxVb21ubjale8bGxqJv374SWdV1bM01kIW4W6vHIhdiYmIcPrakpMSNlkjH2bNnHT62K98PC1h6YD179kRGRgaz9m3h4eGB27dv49KlS3YnJCltnMUe9gZM29racOnSJbS2tsp2QmJcXBz8/f2t7pdFtoyc6d+/f5eOV1NGgaN4eHigX79+uHDhAmtTZIccx5MiIyNNT6EVFRUOzTTdu3cvfvGLXwAAfvjhB7fa507Cw8MBOHaftre3o7KyEn369EFsbCyamppkNaZmLxFFnj9JMkEJAypygs9ovRNri6ywxNvbG9XV1RYHTm3h6+ur+Nh7SEhIlwaHjZOebt26xXTsxhL2Fj6RV6+TEWFhYbIo0askevTogV69erE2Q1ZcuHBBVk80QUFBqKqqgk6n63Labp8+fdCnTx83WSYN4eHhJu/dUdra2hAYGIiKigpZpW2bF0ezhGzE/aGHHmJtgglvb28EBAQ4/X6Wa3aKgSsFofz9/WVVXyctLY1p+wUFBSgoKMC6deuY2gEIg4OEEPj4+Di12PUPP/yAH374QbElFcLDw/H111/j66+/7vJ7L168CK1WCy8vL9GW0nSF6dOn4+LFizavo2zEffDgwaxNMOFqip/SKwG6Wl9fTt6NXEJrrAfaIyMj0draCj8/P6fXLC4uLkZxcTHuuusuka2Thq567J2prq42hbRYlypwRGNkI+6ZmZnM86Z1Ol2XB1At8eyzz4pgDTvy8/NdPke/fv2YT3zp2bMnEhISmNoAAIsWLcLWrVuZtR8VFYWWlhZoNBqXl7yLiIhQxMQsSzQ1Nbn0RA4I81h0Oh1u3brFdCbr6dOnMXbsWJvHyEbcASArK4tp+8HBwaKdS06j6l1BzLxsMb9PZ7jnnnuYtm+kb9++zNcJ9vHxwY0bN1wW5pSUFOzdu1ckq6SluLjY5ZBhc3Mzbty4gZ49e9pMQ3Q39fX1ysqWmTNnDrO2xf4V/t3vfifq+aTis88+E/V8LL33YcOGMWvbnA0bNmDRokVYtGiR5G3HxsbiypUruHLliiira0VGRiIiIoJ5WKKrBAQEICAgQJTJWDdv3kRFRQUqKiqYxN/Hjh2LsWPH4tChQzaPk5W4s4S1l6lW+PcK6PV6TJ06FVOnTpW8baOXKVZBuy1btmDEiBEYMWKEKOeTigEDBmDAgAE4fvy4KOdra2tDWFgYk3IjSUlJSEpKsrt8pOzEfdSoUZK3KUacnWMdFiUK4uPjJW/TFpMmTcKkSZOwadMmydrs27cvgoKCRBcgY767cVKT3AkPD0dDQ4PoobEbN24gMDBQ0vTQrKwsbNmyBVu2bLF7rOzEnXXcXUyUNpOvqqqKtQmiIbdVsYziItVgZFBQEBobG9HY2Cj6giEqsM+xAAAX8ElEQVTbt2/H9u3bMWvWLFHP6y4yMzNNmT5i0tzcjKamJjQ1NUmWIXb79m27+e1GZCfuaWlpWLx4sWTtubMuyvPPP6+YgdXa2lpRsmSsIWX9mXHjxskiF7kzhYWFWLx4MQoLC93eFiEELS0tLqe1WuPxxx/Hu+++i8cff9wt5xeLIUOGYMeOHRgyZIhbzn/16lU0NzfDy8v9lVyWLl2KXbt2YenSpQ4dLztxB6QbWLW16IZY7Nmzx63nFwt352FLuciHu25kV3n55ZfxxBNP4OWXX3Z7W7du3XLr952UlITKykokJSW5rQ0xCA8Ph4+Pj8s57rYIDg52eu5AV/jqq6+QkZGBr776yqHjZSnuAPDkk0+6vQ0pHqUOHjwo+yW7mpubJZlkI8Xg6ujRo2VXy8VIXl4e5syZg7y8PLe2ExQUhICAALf2uz179mDatGmyd15KSkqQlJTk1v5dV1cHrVbrdj35/vvvMXz4cHz//fcOHU8opW41yEEsGjF8+HC3NirlQOqOHTska6urSGmbu+usLF++3Nou60vWuBFCSIe+7efnZ0o3zczMFL09jUZjyr92tzc5efJk08TDN998061tOYPxCa6urs7t1VrNU6mNteDFxJhG++qrr96R+UQptdi35eniSIAjC29wxEdOdWdY0NDQgLfffhtvv/22W/Lee/bs6fCAm6vs3bsXw4YNw7Bhw2SX9x4QEGAqdCZFGe7a2lrU1ta6RVfGjh1rqlHUlZRWWYv7t99+67ZzS13qYMWKFZK25yhSP1G489HVhtcuK7Zs2YL09HSHVrvqKjdu3IC/v79kC7XPnz8fmzZtkt13n5GRgWPHjkkWNmptbYW/v79b8t5v3ryJfv364ejRo116n6zFHQA2b94s+jlZ1IQoLi6WXWokq9RHd8xaffjhh0U/pztJSUlBWVmZ6Ks0NTc3Sz4t/plnnsFrr70maZv22Ldvn1vCXrbw9/cXPe00Li4ONTU1TuXSyzrmbkTs2DvLSUtyir2ztEXs2LsDnqMsYu7mvPTSSwCE2Y7Lli1zuS3jgHV9fb1knrsRY19asmQJSktLJW3bnICAAEyaNKmDTVIh9njH1KlTTSmWu3btsnqcomPuL774ImsTRINlxzdHzgs3d5Vp06axNsEpVqxYga1bt4rmYfr7+0sakjHnnXfewTvvvIP169dL3rY5kyZNwr/+9S/861//krxtY2hGrCenpKQkfPvtt/j444+der8iPHdAGIi69957RWmMdbmBMWPGMJ388f333zOvLy6W57548WJHF8CWnecOCN67cRxi/vz5TrcTFBRkml7PQtwBwVN+/vnnAbCZnW3MZc/MzGT2VGrsi76+vi6lohoXL2pqarLptQMK99wBIYVMDFjXGAeE3HeWsBZ2AKJNsHFQ2GXLihUrkJKSgpSUFDzxxBNOn8fX1xetra3MhB0A3njjDTzzzDN45plnJF+wxcfHB5mZmcjMzMR3330nadvmGK+BK3qVkZFhyvRx1msHFCTugJA942phMbmsEsSqho5cYv6uTmiKj4+XXYaGMzQ0NCA1NRUAXBqMY1GdsDNfffUVsrKycPDgQdN4glRMmDABJSUl2LFjB86dOydp25Zw5Xq0t7ejra0Na9eudenHWlHiDsDlqdvuLjfQFaSe+OHozDYpcHUW6fTp00WyRB4cPnwYjzzyiFP1fYKCgtDa2ipZeQd7jBkzBnv37pVsLGTw4MHQ6/WyqQQaGBjotCgvXLgQQ4YMwc8//+yyHYoTd1eQQ0jGHKnDM3IIx5jjihjJtcSAsyxevBh+fn7w8/PDBx980KX3ajQatLe3yyZE9cYbbyA7OxvZ2dluX6A8PDwcAwcOxMCBA5mGY8zx8fFxapH53/zmN9BqtdBqtdi9e7fLdijyDvn222/x6quvdvl9LJfFskZWVhbOnj3r1jaqqqpkE44xx5n1LOfMmaOKcIwljOGZgwcPYt26dQ6/r6mpqcO/rDGGZwCYYsfuICAgAL179wYA2YRjADhVN37q1Kn46aefAABr16516sehM4oUdwBOeQRyLTng7gW13VnK1xWc8TTlWMpXTJ566inMnTsXmZmZDvcLY6xe7Ak0rnL27FnMmjUL69evF13gjfnsAwcOlF1Z7a7W7J86dSqSkpIwevRoUYvKKVbcAcGDf+655xw6VqvVutka18jKyhI9B762tlaWHrszTJs2TbUeuzkFBQUmDz4/P9+h2u+tra0IDg5mmiljiWeffdbkwT/wwAOi9cWsrCykpKQAEDz2r7/+WpTzioXxejiSNLB8+XLTk/vatWtx8eJF0exQtLgDwH333efQJCe5eu3miDm7r7a2VvTFrlnxwAMPIDExkbUZkrJq1SqsX78ezz//PHJzc+0eLzev3ZzS0lKkp6dj7969Li/NFx4ejrNnzyIqKkrWpbRbWlrsevAPPfQQ/vGPf2DatGn46KOPRLdBMZOY7KHX6zFz5kyr+yMjI9GjRw9Xm5GERx99FOPHj3f6/RcuXJBktR8xsDeZaf78+WJVkpTlJCZ7pKSkYO7cuYiJicHChQtRXl5u8Thvb2/JlvBzlmeeecY0i9WZVOCsrCzs27cP99xzj+y89c4YQ46WnqZ0Oh1mzJiBmzdv4ujRoygrK3OpLcVPYrJHTEyMzQuupOyKv/3tb3jnnXeceu+JEycUI+z2WLx4cbcvEXzy5Emkp6fj9u3b2L17NyZPnmzxOJk4aTZ5/vnnsX79evzhD3/AmjVrHB5z8fDwQFZWFgoKCjBx4kTZCzsgXA9L1yQ5ORmPPfYYKKXo37+/y8JuC+UongP4+flZjcPLKb/dEfbu3dulOLwxvu7uzBspMMbX5ZLax5rU1FTTYtR6vd5iqmRbW5vUZjlFVlaWKUSalZVl9wk1NjYWgwcPBgBcvHhRMWNIlsR94cKFqKurAyBUu127dq1bbVCVuBu577777nhNaeJuZMmSJQ4dp5b4OoBuF193lFWrVuFvf/sbPvvsM0U/nRUXF8PX1xdTpkzBzJkzsWbNGovHGQdO4+PjZR1ft0RncV++fDm+//57zJkzxy3xdUuoJuZuDWO5YNbFwsTAkteiFE/GGuYxdzdnwygy5m6JuXPn4sknn8TLL7+MnJwcU3aNEsnNzUVlZSUiIiJQWVmJP/3pT5g2bRqamprQo0cPNDU1yX6dVmuMHTsWw4cPx4EDBzBu3DgcOnSoywtuOIK1mLvqxR0QFiYWY8YXaxISErB06VIEBgaiublZMg/AnVy4cAHjxo3DsGHD3N2UasQdEMaY1q9fj0ceeQSfffYZ7rvvPtMjv9JYtGgRjh49iv79+2PXrl3o1asXvLy8EBoaiuPHj7M2zynCw8OxfPly/PGPf8ScOXOwZ88eXLt2zS1tdWtxB4Q6z87MiJQjv/vd72RTF95VJk+eLNUcBFWJOyDM1s3JyUFSUhLmzp2LoqIinDlzxl3NuZXDhw8jLCwMq1atwnvvvYcdO3bgwQcfZG2WU2RlZWHq1KlITU3F5s2bceDAAbf+SHV7cSfk359/5syZisqeAYRKcTt37rzj9W3btinysxhvXAn7n+rE3UhycjISExNRVFQELy8vJCYmYteuXbLPoCGEYMaMGThz5gxu376N5ORktLW1YdasWdizZw88PDwwfvx4PP7447LO4weEejJvvvkm9u/fj/b2dkydOlWyHycu7qTj509OTsZdd93l7mZF4ccff0RRUZHV/dnZ2Zg6daqEFjnPnj17sH37dtPfXNzFIS4uDj169MDt27dx9uxZTJgwAdevX5ftwGtqaip69uyJzz//HAMHDoSXl1eHPv7II4/gypUr2L9/P15++WWcOHECf//739kZbINf//rXGDx4MHJycjB+/Hj06tUL33zzDQBIUu/Gmrh7ub1lmTB+/Hjs37/f9HdRUZGpM40ePRq9evWSjQfc3t6OK1eu4NChQw4dv337dpNgLlmyBEOGDJHVZ/n++++ZL7+mdoKDg60++sfExCA8PBx6vZ7Zoujh4eGIiYlBVVUV9Hq96XVKqcVQ0ttvv23xPJmZmUhMTER+fj6zEFRiYiIyMzNx5syZDnWb2tvbsW/fPgCQYgzJLt3Gc3/wwQc7eIyWGD16NCIiItxtik0qKysdFnVbPPvss8yfTH788UesXr3a5jHccxeHwYMH48SJE3e8PnPmTBw+fBhVVVWIiYlBTEwMzp49i5qaGreHOnx8fBAcHIyBAwdCr9dDr9cjPDwco0aNshhitEVcXBx+9atf4ZNPPsHx48eRmZmJYcOGIT8/H6dOnZLkswwaNAiZmZk4fvw48vPzMWzYMEyZMgXvvvvuHR66MTff0jURm27vuWdkZNgVd0uiOnr0aAQHB4teuqCpqQk1NTWiCLklOotqWFgYnnzySURGRrq8ClJnampqUFFRgddffx1Xr14V9dwc13BERJOTk3Hr1i3cvHkTbW1tXc660Wq18PT0RFBQEAIDA22GEKuqqros7IAQ3nCkSGB2djbKy8tRXV2Nq1evdvlJJTw8HGFhYdDpdIiKirKpGcePH5d1Nk+38dzff/99l5a2i4mJQUBAAPr06QONRtNlsW9qakJraytKS0tRW1vb4dFUalJTUzFgwACkpaU59cNl/GEqKCjA+fPnXYrrcs9dHIYMGdKllbaSk5NRV1eHxsbGOwQwJiYGAFBdXY3a2toOdWuM/w8ICIBOpwOAO/pyeHg4fH19odVqbQq9GISFhSEjIwMNDQ3Q6/V3hGrGjx+PsrIyXLhwAZ6enmhqajKNv1FK0aNHD7S1taFfv36Ijo7uELoFhBBMTEwM/Pz8cOTIEYedlyFDhgCQZvWzbu+5p6enu/R+Ywd2d2eVgsLCQhQWFtp9kuEoh66WanBnP5Yyrn/16lW3zmE5c+aMU7F9OZTO6DaeO3BnxgyHPdxzd5309HTo9XrExMS4ZQYkp2sYrwcAq1U8xUT1VSEd4emnn2ZtAscMfj3EYfjw4SgvLzeV2uCwxXg9pBB2W3QrcTeOYHPkAb8e4mAsqqW04lpqRS7XoVuJu3GQgyMP+PUQh/r6+g7/ctgim+tgLE3JeJOMrKwsCiHGzzeGW1ZWlpSXnVJGfVuq7zM3N5f5NeUbm+thre91K88dAMaNG8faBA74dRCbyspK1iZwzJDD9ehW2TJGeNYMexj0O9VmywDCDE7jak1//vOfpWiSYwFjksAHH3wgSV0ZALxwmDlc3NnDxV18jh07BgAYMWKEVE1yOsHiGnBxN4OLO3u4uItPWloaAGDMmDHce2fA008/jYMHDwIACgoKJGvXmrizHkiVfECVUkqffvpp5gMu3Xl7+umnpb7klKp8QNV8O3XqFPNr3B03Vt+71b7HqtN32iQnLCyMeWfojltYWBiLy01pNxH33NxcmpyczPw6d8ctOTmZSdaStb7X7bJljLzwwgusTeiW8O/dvUyYMEEV9Y+USFFRESZMmMDaDBPdMuZuhMfepYdhf1N9zB0QClb9/PPPAIA+ffpI2XS3xrimcf/+/dHa2ipp27S7V4XkcLoDra2tyMvLAyDUNueVP91Pdna26TuXWthtwioW2WljQnZ2NvM4XXfasrOzWV1qSrtJzB0AjYqKolFRUbSkpIT5Ne8OW0lJiek7Z9G+1b7HqtN32pjByxFIszEoN9CZbiPuAGhpaSmNi4tjft27wxYXF0dLS0uZtW+t73XrmDsAlJWV8dikBJSWliI6OpqlCd0i5m4kLy8Phw8fBgD85S9/YWFCt2DBggUAgFGjRmHOnDlMbKB8EpN1+MCq+5FBP+tW4g4AmzZtAgB4eHiYRIgjHrm5uWhqagIAPPXUU8zs4OJug9dee413fjeSm5uLefPmsTaj24m7VqtFW1sbGhoauAPjBiil8PPzg6enZ5cXFRfZDi7utigqKsKgQYNYm6E6Tp06heTkZNZmAN1Q3AHgypUrWLduHQBg/fr1LE1RFUuWLAEALFu2DL169WJqCxd3B+DejfjIpH8B3VTck5OTcerUKaMtLE1RFcZ+PWjQIOaTxqyJe7edoWoJ403AEQf+fbKnqKgIhBBs2rQJlFJs3LiRtUmKZuPGjaCUYtOmTSCEMBd2m7BKEeu0yYaNGzcyT61Sw7Zx40bWl7Iz3SoVsvNGKaVRUVHCFyEDe5S6yfF7tNb3eFjGAq2trfD29mZthmJpaWmBRqNhbUZnumVYxpzPP/8cAwYMAADEx8cztkZ5lJSUAADOnz8vqxoylMfcuwaPTzqPTPpUZ7q9uGs0GrS0tAAADh48iLFjxzK2SDl8+eWXGDNmDADA29tbVmUGrIk7j7lb4csvv2RtgiLh35t8aW1tRXx8PHJyckxCxXGMMWPGICcnB/Hx8bISdltwcbfCmDFj5OqByhZKKRcNmXPu3DnTxBtKKZ/fYYcFCxaYdKCpqUmydVFFgdVAU6dNtixYsID5gIkStgULFrC+VPbo1gOqnbcXXniBJicnC1+MDOyR60YppcnJyfSFF15gbosNGy33PVadvtMme1hfQDlvCoGLe6dt27Ztpi+HOzEdN3NnZdu2bcztsbVZ7XusOn2nTfbwzm//JpA5XNwtbNu2baOJiYnCFyQDe+SyUUppYmKi7IXdYCsXdzFgfSHltCkMLu5WttWrV5u+pGPHjjG3h+V27Ngx03exevVq5vY4slnrezwVsosUFBRgxIgRrM1gzrFjx5CWlsbajK7Q7VMhbTFv3jxER0fjueee69ZpwJRSrFq1CmVlZdi8eTNrcxyCWkmFZO2xK85zN9JdF/mQwaIbzsI9dzubcealccUsJYQkxNiMYw/Gz81qRSVnN6t9j1Wn77Qpku7S+TvfBAqFi7vjYkEzMjJocXGx6ldziouLo8XFxTQjI0PoJDKwyYnrZbHv8Tx3F8jOzgal6i/GZCyWlJ2dzdoUjgQQQnDhwgUAQEVFBb755hukp6cztkpc0tPT8c0336CiogIAcOHCBfWFo1h5NJ02xcNyDUV3bqWlpay/WrHgnrtzXqGpCNyOHTuY2yPGtmPHjg6fi7U9Ilwj7rm7k+joaOzYsYO1GaKyY8cO1uuechgTHR2NoUOHYuTIkThy5Ijin1I3btyII0eOYOTIkRg6dKiq+zcXdxGZPXs2KKWora3FihUrWJvjFCtWrEBtbS0opZg9ezZrcziMKS8vx8iRI3H06FHTa1qtFrW1tVizZg1DyxxnzZo1qK2thVarNb129OhRjBw5EuXl5Qwtcy9c3N2AVqvF6tWrFdP5jaxZswarV6/ucBNwOEY2bdqEmpoaXL58GTqdDnq93lRlUq60tLRAr9dDp9Ph8uXLqKmpMS0crnpYxSI7barn2LFjNDs7m3l8znzLzs7uMGlD5fCYu4ibRqOh8+bNoy0tLRQA1Wq19PPPP2eeQbZt2zb6+eefU61WSwHQlpYWOm/ePKrRaJh/Z+7arPY9Vp2+09Zt2LZtG01PT2faGdLT05We1ugMXNzdtG3bts00s1Wr1dLNmzdLPvi6Y8cOunnzZpOoHzt2jPkPjVSbtb7nBY6kZGdnd0gpLCgoQGFhIf7nf/7HbW1u3LgRqampSptRylEIDz74oM39cXFx6NOnD8LDw3H33XejqKjIqeSDrKwsJCcn4/Tp06iqqkJpaanVErx8FjlfiUlWnDt3DpcuXcJf//pXlzJvsrKy8Nhjj6Fv376Ii4sT0UJFw8sPSMxTTz2F0NBQHD16FPv37++wLzk5Ga2trWhubkZjYyMIIWhoaEBDQwP8/Pzg5+cHSil8fX3h4+MDjUZzx2LU48ePR3p6Oq5du9Z94ugWoHyZPU43h4u7jBBD3DkCXNw53R0u7hxVYk3ceSokh8PhqBAu7hwOh6NCuLhzOByOCuHizuFwOCqEizuHw+GoEC7uHA6Ho0K4uHM4HI4K4eLO4XA4KkQuk5g4HA6HIyLcc+dwOBwVwsWdw+FwVAgXdw6Hw1EhXNw5HA5HhXBx53A4HBXCxZ3D4XBUCBd3DofDUSFc3DkcDkeFcHHncDgcFcLFncPhcFQIF3cOh8NRIVzcORwOR4VwcedwOBwVwsWdw+FwVAgXdw6Hw1EhXNw5HA5HhXBx53A4HBXCxZ3D4XBUCBd3DofDUSFc3DkcDkeFcHHncDgcFcLFncPhcFQIF3cOh8NRIf8fFSdN17nNlCsAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "\n",
    "%matplotlib inline\n",
    "from scipy import signal\n",
    "from scipy import misc\n",
    "\n",
    "\n",
    "\n",
    "image = cv2.imread(\"rgb_venn.png\",0)\n",
    "kernel = np.array([[ 10, 0, -10],\n",
    "                   [ 0, 0, 0],\n",
    "                   [ -10, 0, 10]]) \n",
    "\n",
    "\n",
    "grad = signal.convolve2d(np.asarray(image), kernel, boundary='symm', mode='same')#boundary: milyen padding, mode: kimenet mérete\n",
    "grad = np.absolute(grad)\n",
    "#innentől ez csak a plot\n",
    "#módosítsatok úgy, hogy csak a víszintes, majd úgy is, hogy csak a függőleges éleket emeljem ki!\n",
    "import matplotlib.pyplot as plt\n",
    "fig, (ax_orig, ax_mag) = plt.subplots(1, 2)\n",
    "ax_orig.imshow(image, cmap='gray')\n",
    "ax_orig.set_title('Original')\n",
    "ax_orig.set_axis_off()\n",
    "\n",
    "ax_mag.imshow(grad, cmap='gray')\n",
    "ax_mag.set_title('Gradient magnitude')\n",
    "ax_mag.set_axis_off()\n",
    "'''ax_ang.imshow(np.angle(grad), cmap='hsv') # hsv is cyclic, like angles\n",
    "ax_ang.set_title('Gradient orientation')\n",
    "ax_ang.set_axis_off()'''\n",
    "\n",
    "fig.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python [conda env:root]",
   "language": "python",
   "name": "conda-root-py"
  },
  "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.7.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}