Visión Artificial/Cuadernos/intro_opencv.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "abc8dbda-6dd3-4702-8e2f-55370afcb39f",
   "metadata": {},
   "source": [
    "<figure>\n",
    "<img src=\"../Imagenes/logo-final-ap.png\"  width=\"80\" height=\"80\" align=\"left\"/> \n",
    "</figure>\n",
    "\n",
    "# <span style=\"color:blue\"><left>Aprendizaje Profundo</left></span>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6c838b6a-1d80-4db0-8194-337cb95bacf7",
   "metadata": {},
   "source": [
    "# <span style=\"color:red\"><center>Visión por Computadora</center></span>\n",
    "## <span style=\"color:red\"><center>Introducción a OpenCV</center></span>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6a89216b-51c8-45b8-8589-838aa385a4a9",
   "metadata": {},
   "source": [
    "##   <span style=\"color:blue\">Profesores</span>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ca6806ba-cc9c-4750-bbd9-9879c68d8bfc",
   "metadata": {},
   "source": [
    "### Coordinador\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8a729efa-6736-40a5-ba21-d7f86962bd5f",
   "metadata": {},
   "source": [
    "- Campo Elías Pardo Turriago, cepardot@unal.edu.co "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d250cd69-307d-41c6-a732-5456db4c0f2e",
   "metadata": {},
   "source": [
    "### Conferencistas\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b7bc285d-e97f-4363-a9ed-e766d5a9cb23",
   "metadata": {},
   "source": [
    "- Alvaro  Montenegro, PhD, ammontenegrod@unal.edu.co\n",
    "- Daniel  Montenegro, Msc, dextronomo@gmail.com \n",
    "- Oleg Jarma, Estadístico, ojarmam@unal.edu.co "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f841b51b-1886-4b0e-ad5e-3af8855a8ac8",
   "metadata": {},
   "source": [
    "## <span style=\"color:blue\">Asesora Medios y Marketing digital</span>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c71d8286-f0c7-4597-9be5-96d122256046",
   "metadata": {},
   "source": [
    "- Maria del Pilar Montenegro, pmontenegro88@gmail.com \n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f8b30a8d-3288-4d48-bfa0-7aef8c68df32",
   "metadata": {},
   "source": [
    "## <span style=\"color:blue\">Asistentes</span>\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "44f653a8-9eb8-491c-bdaa-b59175fe9811",
   "metadata": {},
   "source": [
    "- Nayibe Yesenia Arias, naariasc@unal.edu.co\n",
    "- Venus Celeste Puertas, vpuertasg@unal.edu.co "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "02f7244e-06bb-4d83-a2b4-d3cec0b44fba",
   "metadata": {},
   "source": [
    "## <span style=\"color:blue\">Contenido</span>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "88c17ef0-c9c1-46d2-99b9-26877d9123b8",
   "metadata": {},
   "source": [
    "## <span style=\"color:blue\">Prólogo</span>\n",
    "\n",
    "OpenCV es la base y espina de los proyectos de visión artificial, por sus capacidades básicas de entrada y salida(I/O), hasta sus funciones complejas de transformaciones, procesamiento y deployment. Se comenzará el estudio de este paquete con la creación, lectura y procesamiento de imágenes"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "950db278-ca39-478a-a82f-d0515a2b191d",
   "metadata": {},
   "source": [
    "## <span style=\"color:blue\">Lectura/Escritura de archivos de imagen</span>\n",
    "\n",
    "OpenCV tiene dos funciones esenciales cuando se trabajan con imagenes fijas, y una que es buena de tener:\n",
    "\n",
    "- `imread` para cargar una imagen desde un archivo\n",
    "- `imwrite` para escribir una imagen a un archivo especificado\n",
    "- `imshow` para mostrar la imágen en un cuadro\n",
    "\n",
    "Aunque vamos a usar, principalmente OpenCV, es posible crear una imagen usando numPy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "ae1423c7-88ac-49d9-a0e9-ec6aba713346",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0 0 0]\n",
      " [0 0 0]\n",
      " [0 0 0]]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "import cv2\n",
    "\n",
    "img = np.zeros((3,3), dtype = np.uint8)\n",
    "\n",
    "print(img)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "86842772-f0ea-4f4f-b9c9-185a07c38664",
   "metadata": {},
   "source": [
    "Acabamos de crear un cuadro negro de 3x3 pixeles. Lo importante es el argumento \"dtype\", el cual definimos como números enteros de 8 bits. Significa que tienen un rango de 0 a 255. 0 es negro y 255 es blanco, con el resto siendo rangos de gris. Cambiemos esto un poco"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "2a188f8f-c9ac-414d-a425-d5c08e88bd99",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[255 255 255]\n",
      " [255 255 255]\n",
      " [255 255 255]]\n",
      "[[198  67 223  85 252 164 102 206 215 170]\n",
      " [207 242  79 232  36 179 210  30  80 211]\n",
      " [ 36  23 232 139 191  89  49  17 197  94]\n",
      " [149 180 223 147  81 139 246  84  89 190]\n",
      " [ 82 196 113  61  34  36   9   6 106  19]\n",
      " [212 216 171  92  30 123  56  85 171 205]\n",
      " [  3 110 193  39 100 118  30  83 140 204]\n",
      " [248 185 192  96 137 243  86  16 219 237]\n",
      " [207 154 148 248  94  53 204  36 223  16]\n",
      " [ 21  60  13 192 147  52 215 124 205 184]]\n"
     ]
    }
   ],
   "source": [
    "img2 = np.full((3, 3), 255, dtype = np.uint8) # cuadro 3x3 de color blanco\n",
    "img3 = np.random.randint(0,255, (10,10),dtype = np.uint8) # cuadro 3x3 de colores aleatorios\n",
    "print(img2)\n",
    "print(img3)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8bbad36a-4d67-4f45-8be0-2648d2671b4f",
   "metadata": {},
   "source": [
    "En este momento solo tenemos la idea \"empirica\" del color a partir de los números. Vamos a ver los números como colores "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "caf270ac-6c7f-4dea-a3e8-64b8fa84d7bf",
   "metadata": {},
   "outputs": [],
   "source": [
    "cv2.imshow('black box',img) # pedimos que se abra una ventana con la imagen negra\n",
    "cv2.imshow('white box',img2) # pedimos que se abra una ventana con la imagen blanca\n",
    "cv2.imshow('random box',img3) # pedimos que se abra una ventana con la imagen aleatoria\n",
    "cv2.waitKey(0) #le decimos que espere a continuar la interpretación del código hasta que se use una tecla\n",
    "cv2.destroyAllWindows() # se cierran todas las ventanas creadas"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9922db2e",
   "metadata": {},
   "source": [
    "Podemos también utilizar matplotlib para mostrar las imágenes como si fuera un gráfico"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "827462f6",
   "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": [
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "\n",
    "plt.imshow(img3, cmap=\"gray\")\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0368625d",
   "metadata": {},
   "source": [
    "Vamos ahora a pasar una imagen de escala de grises a color en la escala BGR y veamos cómo cambia(CUIDADO, DIFERENTE A RGB)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "2e59e689-392d-4d0e-8f7d-35c195fd9ec9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[255, 255, 255],\n",
       "        [255, 255, 255],\n",
       "        [255, 255, 255]],\n",
       "\n",
       "       [[255, 255, 255],\n",
       "        [255, 255, 255],\n",
       "        [255, 255, 255]],\n",
       "\n",
       "       [[255, 255, 255],\n",
       "        [255, 255, 255],\n",
       "        [255, 255, 255]]], dtype=uint8)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "img2 = cv2.cvtColor(img2, cv2.COLOR_GRAY2BGR)\n",
    "\n",
    "img2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "dd99e903",
   "metadata": {},
   "outputs": [],
   "source": [
    "cv2.imshow('white box BGR',img2) \n",
    "cv2.waitKey(0) \n",
    "cv2.destroyAllWindows()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d55c3de2",
   "metadata": {},
   "source": [
    "Como vemos, ahora la imagen no está compuesta de una matríz 3x3, pero 3 matrices 3x3. LA primera matriz representa los tonos de azul, la segunda de verde, y la tercera de rojo\n",
    "\n",
    "Podemos ver la estructura de las imágenes usando la función `shape`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "e9c4ca9e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(10, 10)\n",
      "(3, 3, 3)\n"
     ]
    }
   ],
   "source": [
    "print(img3.shape)\n",
    "print(img2.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4ba8c0ac-70cc-4807-aff3-08b11c28e7f3",
   "metadata": {},
   "source": [
    "guardemos la última imagen en formato `.png`. Si no se define un directorio en específico, las imagenes se guardarán en el directorio de trabajo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "aee3638f-d5ba-444e-9c2a-69f0783da350",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cv2.imwrite(\"../Imagenes/random_box.png\", img3)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8363f2fe",
   "metadata": {},
   "source": [
    "con esta función podemos también guardar imagenes con otro formato"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "f7c3bd8f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "image = cv2.imread('../Imagenes/logo-final-ap.png')\n",
    "cv2.imwrite('../Imagenes/logo-final-ap.jpg', image)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bba38f1c",
   "metadata": {},
   "source": [
    "cuando leemos una imagen usando `imread`, por default va a leer las imagenes y transformarlas en formato BGR(Recuerden, diferente a RGB), pero podemos ciertos cambios si eso no es lo que queremos\n",
    "\n",
    "- `cv2.IMREAD_BGR` es la opción por default, la imagen se carga con los 3 canales BGR\n",
    "- `cv2.IMREAD_GRAYSCALE` cuando solo se quiere el canal de grises\n",
    "- `cv2.IMREAD_ANYCOLOR` Si quieren que el computador detecte el tipo de escala, de acuerdo a la metadata de las imagenes\n",
    "\n",
    "Volvamos a cargar el logo de \"Aprendizaje profundo\", esta vez en escala de grises, veámosla y luego guardémosla"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "2bb311ca",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "grayImage = cv2.imread('../Imagenes/logo-final-ap.png', cv2.IMREAD_GRAYSCALE)\n",
    "\n",
    "cv2.imshow('GRAY IMAGE',grayImage)\n",
    "cv2.waitKey(0) \n",
    "cv2.destroyAllWindows()\n",
    "\n",
    "cv2.imwrite('../Imagenes/logo-final-ap-gris.png', grayImage)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1b74e688",
   "metadata": {},
   "source": [
    "## <span style=\"color:blue\">Datos de imagen con numpy</span>\n",
    "\n",
    "Ya vimos que las imágenes en python pueden ser representadas numericamente como arrays en numpy, y por tanto pueden ser afectadas o \"manipuladas\" de la misma forma que se le haría a un array común y corriente. \n",
    "\n",
    "Vamos poco a poco con las manipulaciuones de datos. Comencemos cambiando un pixel de color, usemos el cuadro blanco que creamos al inicio"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "7f4a6ecc",
   "metadata": {},
   "outputs": [],
   "source": [
    "img2[0, 1] = [0,255,0]\n",
    "cv2.imshow('CHANGED IMAGE',img2)\n",
    "cv2.waitKey(0) \n",
    "cv2.destroyAllWindows()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9bec7164",
   "metadata": {},
   "source": [
    "Se cambió el pixel de la posición 0,0 de negro a blanco. Esta es una forma decente de hacerlo, pero hay una forma mejor, y tal vez más rápida de hacer cambios en canales específicos\n",
    "\n",
    "\n",
    "vamos ahora a hacer un cambio de color en el Canal \"Azul\". Podemos hacer esto con dos métodos de numpy:\n",
    "\n",
    "- `item` tiene tres parametros, $(x,y)$ son la posición en la matriz, y el indice de en cuál canal vamos a revisar. Imprime el número en el punto que se da\n",
    "- `itemset` tiene una tupla de dos parametros. el primer elemento son los parametros de `item` y el segundo es el nuevo valor que queremos asignarle."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "c1f0f5ce",
   "metadata": {},
   "outputs": [],
   "source": [
    "img2.itemset((0,0,0), 255)\n",
    "cv2.imshow('CHANGED IMAGE',img2)\n",
    "cv2.waitKey(0) \n",
    "cv2.destroyAllWindows()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "149b9dc3",
   "metadata": {},
   "source": [
    "Esta operación es buena para casos de rangos pequeños, Si se quieren hacer cambios más grandes es mejor usar las funciones de OpenCV(Que veremos luego) o usar slicing en numpy.\n",
    "\n",
    "Cambiemos, por ejemplo, el canal verde del logo de Aprendizaje profundo a 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "6947ed54",
   "metadata": {},
   "outputs": [],
   "source": [
    "image[:, :, 1] = 0\n",
    "\n",
    "cv2.imshow('CHANGED IMAGE',image)\n",
    "cv2.waitKey(0) \n",
    "cv2.destroyAllWindows()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fd68dca3",
   "metadata": {},
   "source": [
    "## <span style=\"color:blue\">Lectura y escritura de archivos de video</span>\n",
    "\n",
    "La mayoría, si no todo, lo que hemos visto sobre procesamiento de imagenes tiene un equivalente para el procesamiento de video.\n",
    "\n",
    "- `VideoCapture` para la lectura de los archivos de video\n",
    "- `VideoWriter` Para la creación de archivos de video\n",
    "\n",
    "En la lectura lo que hace es tomar cada fotograma y tratarlas como una imagen en formato BGR(De nuevo, NO ES RGB). En la escritura, se irán procesando los fotogramas en orden y se reconstruyen en otro formato\n",
    "\n",
    "Tomemos un video de ejemplo, y hagamos una copia "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "a7024395",
   "metadata": {},
   "outputs": [],
   "source": [
    "videoCapture = cv2.VideoCapture('../Imagenes/MyInputVid.avi') # se da el directorio para la lectura de video\n",
    "\n",
    "fps = videoCapture.get(cv2.CAP_PROP_FPS) #obtenemos los fotogramas por segundo del video original\n",
    "size = (int(videoCapture.get(cv2.CAP_PROP_FRAME_WIDTH)),\n",
    "        int(videoCapture.get(cv2.CAP_PROP_FRAME_HEIGHT))) #tomamos las dimensiones del video original\n",
    "\n",
    "videoWriter = cv2.VideoWriter(\n",
    "    '../Imagenes/MyOutputVid.avi', cv2.VideoWriter_fourcc('I', '4', '2', '0'), #creamos un \"escritor de video\", le damos la dirección del archivo nuevo, el codificador de video\n",
    "    fps, size) #, los fotogramas por segundo y el tamaño que se quiere\n",
    "\n",
    "success, frame = videoCapture.read() #se comienza a leer cada fotograma\n",
    "while success: #hacemos un loop para cada fotograma del video\n",
    "    videoWriter.write(frame) #escribimos el nuevo footograma del nuevo video\n",
    "    success, frame = videoCapture.read() #continuamos el loop"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c3c247f2",
   "metadata": {},
   "source": [
    "## <span style=\"color:blue\">Trabajando con la camara web</span>\n",
    "\n",
    "Es posible \"grabar\" videos con opencv usando nuestra propia cámara web de la misma forma que acabamos de hacer. Solo que, en lugar de darle al capturador la dirección a un video, le damos el índice de la cámara. Vamos a grabar 10 segundos de video con nuestra cámara web y lo guardamos en un archivo AVI"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "e68c5a4c",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[ WARN:0@1682.226] global /io/opencv/modules/videoio/src/cap_v4l.cpp (889) open VIDEOIO(V4L2:/dev/video0): can't open camera by index\n",
      "[ERROR:0@1682.251] global /io/opencv/modules/videoio/src/cap.cpp (595) open VIDEOIO(CV_IMAGES): raised OpenCV exception:\n",
      "\n",
      "OpenCV(4.5.5) /io/opencv/modules/videoio/src/cap_images.cpp:253: error: (-5:Bad argument) CAP_IMAGES: can't find starting number (in the name of file): /home/thejarmanitor/Videos/MyTestVideo.avi in function 'icvExtractPattern'\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "import cv2\n",
    "\n",
    "videoCapture = cv2.VideoCapture(0) # se da el indice de la cámara web \n",
    "\n",
    "fps = 30 #se supone esta rata ya que es un estándar de mercado\n",
    "size = (int(videoCapture.get(cv2.CAP_PROP_FRAME_WIDTH)),\n",
    "        int(videoCapture.get(cv2.CAP_PROP_FRAME_HEIGHT))) #tomamos las dimensiones de la cámara web\n",
    "\n",
    "videoWriter = cv2.VideoWriter(\n",
    "    '/home/thejarmanitor/Videos/MyTestVideo.avi', cv2.VideoWriter_fourcc('I', '4', '2', '0'),\n",
    "    fps, size)\n",
    "\n",
    "success, frame = videoCapture.read() \n",
    "framesRemaining = 10 * fps - 1 #definimos el límite a 10 segundos\n",
    "while success and framesRemaining > 0: \n",
    "    videoWriter.write(frame) \n",
    "    success, frame = videoCapture.read() \n",
    "    framesRemaining -= 1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e76f482b",
   "metadata": {},
   "source": [
    "El código si nos grabó, pero no pudimos ver lo que estaba viendo la cámara hasta que ya se hizo el proceso. Igual como hicimos con las imagenes, podemos abrir ventanas que \n",
    "muestren video\n",
    "\n",
    "crearemos una ventana que muestre la cámara web, y que se cierre cuando le hagamos click o usemos una tecla"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "4af53eca",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mostrando cámara. Por favor haga click en la ventana o use una tecla para acabar el proceso\n"
     ]
    }
   ],
   "source": [
    "import cv2\n",
    "\n",
    "clicked = False #booleana para ver si se usó el mouse\n",
    "def onMouse(event, x, y, flags, param): #función para detectar el click del botón izquierdo\n",
    "    global clicked \n",
    "    if event == cv2.EVENT_LBUTTONUP: #se revisa si se hizo un click\n",
    "        clicked = True #se cambia la booleana\n",
    "cameraCapture = cv2.VideoCapture(0) #tomamos el indice de la cámara\n",
    "cv2.namedWindow('MyWindow') #le damos un nombre a la ventana\n",
    "cv2.setMouseCallback('MyWindow', onMouse) # usamos la función que creamos para que la ventana reconozca el acto\n",
    "print('Mostrando cámara. Por favor haga click en la ventana o use una tecla para acabar el proceso')\n",
    "success, frame = cameraCapture.read()\n",
    "while success and cv2.waitKey(1) == -1 and not clicked: #se mostrará video mientras \n",
    "    cv2.imshow('MyWindow', frame)\n",
    "    success, frame = cameraCapture.read()\n",
    "    \n",
    "cv2.destroyWindow('MyWindow')\n",
    "cameraCapture.release()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bc54f02a-75cb-4242-92c3-8a5768889360",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.10.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}