{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3oN7GzpIY-tW"
      },
      "source": [
        "# Introducción rápida a skimage"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "J-Wrv926Y-tX"
      },
      "source": [
        "## Imports"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "7vPwSlAoY-tY"
      },
      "outputs": [],
      "source": [
        "import os\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "from skimage import color, feature\n",
        "from skimage.transform import rescale, resize, rotate\n",
        "from skimage.transform import integral_image\n",
        "from skimage.feature import haar_like_feature\n",
        "from skimage.feature import haar_like_feature_coord\n",
        "from skimage.feature import draw_haar_like_feature\n",
        "from skimage.exposure import equalize_hist\n",
        "from sklearn.decomposition import PCA"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vjdk2oxpY-tZ"
      },
      "source": [
        "## Una imagen como matriz de pixels"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZZNcFPeFY-tZ"
      },
      "source": [
        "### Imágenes RGB"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "6El6yI1QY-tZ"
      },
      "outputs": [],
      "source": [
        "# Podemos cargar una imagen desde un archivo jpg\n",
        "filename = 'solo_manzana.jpg'\n",
        "with open(filename, 'rb') as jpg:\n",
        "    image_rgb = plt.imread(jpg)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tg-7OEseY-tZ"
      },
      "source": [
        "La imagen se carga como una numpy array cuyo shape es (H,W,C) en donde:\n",
        "- H = height, es la altura o el número de filas de la imagen,\n",
        "- W = width, es el ancho o el número de columnas de la imagen,\n",
        "- C = channel, es el número de canales (colores en una imagen RGB) de la imagen."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "b5d9ao8JY-tZ"
      },
      "outputs": [],
      "source": [
        "# La imagen es un 3D numpy array\n",
        "print('Tipo: ', type(image_rgb))\n",
        "print('Shape: ', image_rgb.shape)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "MAEhVgQVY-ta"
      },
      "outputs": [],
      "source": [
        "# Podemos visualizar la imagen en colores\n",
        "plt.imshow(image_rgb)\n",
        "plt.title('Imagen Input')\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "QnCXMIfEY-ta"
      },
      "outputs": [],
      "source": [
        "# Extraemos el canal R (red)\n",
        "image_red = image_rgb[:,:,0]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "jr1s5wZ2Y-tb"
      },
      "outputs": [],
      "source": [
        "# La imagen resultante es un 2D numpy array\n",
        "print('Tipo: ', type(image_red))\n",
        "print('Shape: ', image_red.shape)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ylhXVxzHY-tb"
      },
      "outputs": [],
      "source": [
        "# Veamos un extracto\n",
        "image_red[200:205,200:205]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "xGF1d3EZY-tb"
      },
      "outputs": [],
      "source": [
        "# Visualización\n",
        "plt.imshow(image_red)\n",
        "plt.title('Imagen Input - Canal R')\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "bQqYSRRPY-tf"
      },
      "outputs": [],
      "source": [
        "# Extraemos el canal G (green)\n",
        "image_green = image_rgb[:,:,1]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "xFfgsOwYY-tf"
      },
      "outputs": [],
      "source": [
        "# Visualización\n",
        "plt.imshow(image_green)\n",
        "plt.title('Imagen Input - Canal G')\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "oPKHqyRsY-tf"
      },
      "outputs": [],
      "source": [
        "# Extraemos el canal B (blue)\n",
        "image_blue = image_rgb[:,:,2]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "jTvqH1c1Y-tf"
      },
      "outputs": [],
      "source": [
        "# Visualización\n",
        "plt.imshow(image_blue)\n",
        "plt.title('Imagen Input - Canal B')\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0ZpT4ht1Y-tf"
      },
      "source": [
        "### Pasando a escala de grises"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ymElEcZBY-tg"
      },
      "source": [
        "Podemos transformar una imagen color (RGB) en una imagen en escala de grises. En skimage la función rgb2gray combina los tres canales R, G y B de la siguiente manera:\n",
        "\n",
        "Y = 0.2125 R + 0.7154 G + 0.0721 B"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "NkwZwZu3Y-tg"
      },
      "outputs": [],
      "source": [
        "# Transformarla a escala de grises\n",
        "image_gray = color.rgb2gray(image_rgb)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "HzGh6dcOY-tg"
      },
      "outputs": [],
      "source": [
        "# La imagen en escala de grises tiene un solo canal\n",
        "print('Tipo: ', type(image_gray))\n",
        "print('Shape: ', image_gray.shape)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "l7J6RrySY-tg"
      },
      "outputs": [],
      "source": [
        "# Visualización de la imagen en escala de grises\n",
        "plt.imshow(image_gray, cmap='gray')\n",
        "plt.title('Imagen en escala de grises')\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "QAuxjjjZY-tg"
      },
      "outputs": [],
      "source": [
        "# Hagamos zoom en una ventana\n",
        "window = image_gray[25:40,100:115]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "2Lsm0fUbY-tg"
      },
      "outputs": [],
      "source": [
        "# Visualización de la imagen en escala de grises\n",
        "plt.imshow(window, cmap='gray')\n",
        "plt.title('Haciendo zoom')\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "2Yalbf2SY-tg"
      },
      "outputs": [],
      "source": [
        "fig, ax = plt.subplots(figsize=(7,7))\n",
        "\n",
        "H = window.shape[0]\n",
        "W = window.shape[1]\n",
        "\n",
        "ax.matshow(window, cmap='gray')\n",
        "\n",
        "for i in range(H):\n",
        "    for j in range(W):\n",
        "        c = window[j,i]\n",
        "        col = 'black' if c>0.15 else 'white'\n",
        "        ax.text(i, j, str(round(c,ndigits=2)), va='center', ha='center', color=col)\n",
        "\n",
        "ax.set_title('Valores de los pixels')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cyVUxhPYY-th"
      },
      "source": [
        "## Transformaciones básicas"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zjFfBadEY-th"
      },
      "source": [
        "### Rescalado"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "EJ85g0fhY-th"
      },
      "outputs": [],
      "source": [
        "# Podemos bajar la resolución de una imagen\n",
        "rescaled_image = rescale(image_gray, 0.1)\n",
        "print('Shape original: ',image_gray.shape)\n",
        "print('Shape rescalado: ',rescaled_image.shape)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "K54A5N7GY-th"
      },
      "outputs": [],
      "source": [
        "# Visualización\n",
        "plt.imshow(rescaled_image, cmap='gray')\n",
        "plt.title('Imagen Input - Rescalado')\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "gy_wuFK-Y-th"
      },
      "outputs": [],
      "source": [
        "# Podemos \"aumentar\" artificialmente la resolución de una imagen\n",
        "rescaled_image = rescale(image_gray, 10)\n",
        "print('Shape original: ',image_gray.shape)\n",
        "print('Shape rescalado: ',rescaled_image.shape)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "5V0SBdBhY-th"
      },
      "outputs": [],
      "source": [
        "# Visualización\n",
        "plt.imshow(rescaled_image, cmap='gray')\n",
        "plt.title('Imagen Input - Rescalado')\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "T-OVV0YEY-th"
      },
      "source": [
        "### Resize"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "vNPPIysyY-th"
      },
      "outputs": [],
      "source": [
        "# Podemos transformar el shape de la imagen\n",
        "resized_image = resize(image=image_gray, output_shape=(128,64))\n",
        "print('Shape original: ',image_gray.shape)\n",
        "print('Shape resized: ',resized_image.shape)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "2FSKQvYuY-ti"
      },
      "outputs": [],
      "source": [
        "# Visualización\n",
        "plt.imshow(resized_image, cmap='gray')\n",
        "plt.title('Imagen Input - Resize')\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3cAIpvhlY-ti"
      },
      "source": [
        "### Rotación"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "pYoMibrVY-ti"
      },
      "outputs": [],
      "source": [
        "# Podemos rotar una imagen\n",
        "rotated_image = rotate(image=image_gray,angle=60)\n",
        "print('Shape original: ',image_gray.shape)\n",
        "print('Shape resized: ',rotated_image.shape)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "pDNYvo4ZY-ti"
      },
      "outputs": [],
      "source": [
        "# Visualización\n",
        "plt.imshow(rotated_image, cmap='gray')\n",
        "plt.title('Imagen Input - Rotation')\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "IipC5r84Y-ti"
      },
      "outputs": [],
      "source": [
        "# Podemos rotar una imagen\n",
        "rotated_image = rotate(image=image_gray,angle=180)\n",
        "print('Shape original: ',image_gray.shape)\n",
        "print('Shape resized: ',rotated_image.shape)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "PEAdFxttY-ti"
      },
      "outputs": [],
      "source": [
        "# Visualización\n",
        "plt.imshow(rotated_image, cmap='gray')\n",
        "plt.title('Imagen Input - Rotation')\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nN8vBQjhY-tm"
      },
      "source": [
        "### Flip"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ikPLKpXDY-tm"
      },
      "outputs": [],
      "source": [
        "# Con numpy podemos invertir la orientación de una imagen\n",
        "image_ud = np.flipud(image_gray)\n",
        "print('Shape original: ',image_gray.shape)\n",
        "print('Shape flipped: ',image_ud.shape)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "1utwQ25qY-tn"
      },
      "outputs": [],
      "source": [
        "# Visualización\n",
        "plt.imshow(image_ud, cmap='gray')\n",
        "plt.title('Imagen Input - Up Down')\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Snx8kKI6Y-tn"
      },
      "outputs": [],
      "source": [
        "# Con numpy podemos ivertir la orientación de una imagen\n",
        "image_lr = np.fliplr(image_gray)\n",
        "print('Shape original: ',image_gray.shape)\n",
        "print('Shape flipped: ',image_lr.shape)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "lxghHvQVY-tn"
      },
      "outputs": [],
      "source": [
        "# Visualización\n",
        "plt.imshow(image_lr, cmap='gray')\n",
        "plt.title('Imagen Input - Left Right')\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wvDIzdj2Y-tn"
      },
      "source": [
        "## Una tontería: agregar un rectángulo a una imagen"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "noGS8lFxY-tn"
      },
      "outputs": [],
      "source": [
        "# Ejemplo de cómo agregar rectángulos a una imagen\n",
        "fig, ax = plt.subplots()\n",
        "ax.imshow(image_gray, cmap='gray')\n",
        "\n",
        "ax.add_patch(plt.Rectangle((200, 150), int(100), int(100), edgecolor='red', alpha=0.3, lw=2, facecolor='none'))\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eFS74efkY-tn"
      },
      "source": [
        "## Normalización: Histogram equalization"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "S9RIwOaFY-tn"
      },
      "source": [
        "La ecualización es una técnica para normalizar una imagen. Consiste en transformar los pixels de la imagen de forma tal que su histograma sea uniforme. La idea básica se explica en los siguientes diagramas:"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Cgb9EImTY-tn"
      },
      "source": [
        "![Cuantiles_1.png](attachment:Cuantiles_1.png)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "onrHosbBY-to"
      },
      "source": [
        "![Cuantiles_2.png](attachment:Cuantiles_2.png)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XcU6S68fY-to"
      },
      "source": [
        "![Cuantiles_3.png](attachment:Cuantiles_3.png)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NO1mPWJkY-to"
      },
      "source": [
        "Ver [Histogram Equalization - Wikipedia](https://en.wikipedia.org/wiki/Histogram_equalization)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "SmUoWnf2Y-to"
      },
      "outputs": [],
      "source": [
        "# Visualización de la imagen en escala de grises\n",
        "plt.imshow(image_gray, cmap='gray')\n",
        "plt.title('Imagen en escala de grises')\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "QbwXJMZ4Y-to"
      },
      "outputs": [],
      "source": [
        "# Visualización de la imagen ecualizada\n",
        "image_eq = equalize_hist(image_gray)\n",
        "plt.imshow(image_eq, cmap='gray')\n",
        "plt.title('Imagen ecualizada')\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ibv-b_G1Y-tq"
      },
      "source": [
        "## Ejemplo de extracción de features: PCA"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "J0wU7rnqY-tq"
      },
      "outputs": [],
      "source": [
        "def image_to_vector(image_path):\n",
        "    with open(image_path, 'rb') as jpg:\n",
        "        image_rgb = plt.imread(jpg)\n",
        "    return np.array(color.rgb2gray(image_rgb)).flatten()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "RlosyGecY-tq"
      },
      "outputs": [],
      "source": [
        "with open('manzana_04.jpg', 'rb') as jpg:\n",
        "        image_rgb = plt.imread(jpg)\n",
        "\n",
        "image_shape = color.rgb2gray(image_rgb).shape"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "1YXMrL2kY-tq"
      },
      "outputs": [],
      "source": [
        "def vector_to_image(vector, shape):\n",
        "    return vector.reshape(shape)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "hMooznIcY-tq"
      },
      "outputs": [],
      "source": [
        "#Preprocesamiento de las imágenes\n",
        "paths = ['manzana_01.jpg',\n",
        "         'manzana_02.jpg',\n",
        "         'manzana_03.jpg',\n",
        "         'manzana_04.jpg',\n",
        "         'banana_01.jpg',\n",
        "         'banana_02.jpg',\n",
        "         'banana_03.jpg',\n",
        "         'banana_04.jpg'] # Lista con las rutas de las imagenes\n",
        "\n",
        "image_matrix = np.array([image_to_vector(path) for path in paths])\n",
        "etiquetas = 4*['Manzana']+4*['Banana']"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "GCcio8svY-tq"
      },
      "outputs": [],
      "source": [
        "image_matrix.shape"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "oJmCQAY2Y-tr"
      },
      "outputs": [],
      "source": [
        "# Cálculo de la imagen promedio\n",
        "mean_image_vector = np.mean(image_matrix, axis=0)\n",
        "mean_manzanas_vector = np.mean(image_matrix[:4,], axis=0)\n",
        "mean_bananas_vector = np.mean(image_matrix[4:8,], axis=0)\n",
        "mean_image_shape = image_shape\n",
        "mean_image = vector_to_image(mean_image_vector, mean_image_shape)\n",
        "mean_manzanas = vector_to_image(mean_manzanas_vector, mean_image_shape)\n",
        "mean_bananas = vector_to_image(mean_bananas_vector, mean_image_shape)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "yPKww4f0Y-tr"
      },
      "outputs": [],
      "source": [
        "# 6. Visualización\n",
        "plt.imshow(mean_image, cmap='gray')\n",
        "plt.title(\"Imagen Promedio\")\n",
        "plt.show()\n",
        "\n",
        "plt.imshow(mean_manzanas, cmap='gray')\n",
        "plt.title(\"Manzana Promedio\")\n",
        "plt.show()\n",
        "\n",
        "plt.imshow(mean_bananas, cmap='gray')\n",
        "plt.title(\"Banana Promedio\")\n",
        "plt.show()\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ru3eU5b6Y-tr"
      },
      "outputs": [],
      "source": [
        "# Centrar las imágenes\n",
        "centered_matrix = image_matrix - mean_image_vector"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ZqImRq-cY-tr"
      },
      "outputs": [],
      "source": [
        "# PCA\n",
        "pca = PCA(n_components=2)\n",
        "pca.fit(centered_matrix)\n",
        "components = pca.components_"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "XMPmOqd0Y-tr"
      },
      "outputs": [],
      "source": [
        "# Imagen de componentes\n",
        "first_component_image = vector_to_image(components[0], mean_image_shape)\n",
        "second_component_image = vector_to_image(components[1], mean_image_shape)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "RNLSTJ9AY-tr"
      },
      "outputs": [],
      "source": [
        "# Proyección\n",
        "projected_data = pca.transform(centered_matrix)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "JairRsdGY-tr"
      },
      "outputs": [],
      "source": [
        "plt.imshow(first_component_image)\n",
        "plt.title(\"Primera Componente Principal\")\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "BgcqbPsuY-ts"
      },
      "outputs": [],
      "source": [
        "plt.imshow(second_component_image)\n",
        "plt.title(\"Segunda Componente Principal\")\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "TeufwluIY-ts"
      },
      "outputs": [],
      "source": [
        "# Scatter plot de la proyección\n",
        "plt.scatter(projected_data[:4, 0], projected_data[:4, 1], color='red', label='Manzanas')  # Suponiendo las primeras 4 son manzanas\n",
        "plt.scatter(projected_data[4:, 0], projected_data[4:, 1], color='blue', label='Bananas')  # Suponiendo las últimas 4 son bananas\n",
        "plt.xlabel(\"Primera Componente Principal\")\n",
        "plt.ylabel(\"Segunda Componente Principal\")\n",
        "plt.legend()\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "k6MiiXVCY-ts"
      },
      "source": [
        "## Ejemplo de extracción de features: las Haar features"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uu94BYDyY-ts"
      },
      "source": [
        "#### La integral image"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1DAC8UF_Y-ts"
      },
      "source": [
        "La integral image $S$ de una imagen $X$ contiene la suma de todos los elementos arriba y a la izquierda de un píxel dado:\n",
        "\n",
        "$$\n",
        "S[m, n]=\\sum_{i \\leq m} \\sum_{j \\leq n} X[i, j]\n",
        "$$\n",
        "\n",
        "* Parámetros:\n",
        "    + Input image $X$ (ndarray)\n",
        "* Devuelve:\n",
        "    + Integral image $S$ (ndarray mismo shape que Input image)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "KrJKTMnyY-ts"
      },
      "outputs": [],
      "source": [
        "fig, ax = plt.subplots(figsize=(7,7))\n",
        "\n",
        "H = window.shape[0]\n",
        "W = window.shape[1]\n",
        "\n",
        "ax.matshow(window, cmap='gray')\n",
        "\n",
        "for i in range(H):\n",
        "    for j in range(W):\n",
        "        c = window[j,i]\n",
        "        col = 'black' if c>0.15 else 'white'\n",
        "        ax.text(i, j, str(round(c,ndigits=2)), va='center', ha='center', color=col)\n",
        "\n",
        "ax.set_title('Valores de los pixels')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "LXKk2wl8Y-ts"
      },
      "outputs": [],
      "source": [
        "ii = integral_image(window)\n",
        "\n",
        "fig, ax = plt.subplots(figsize=(7,7))\n",
        "\n",
        "ax.matshow(ii, cmap='gray')\n",
        "\n",
        "for i in range(H):\n",
        "    for j in range(W):\n",
        "        c = np.round(ii[j,i],1)\n",
        "        ax.text(i, j, str(c), va='center', ha='center', c='white', fontsize=10)\n",
        "\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WGoRVLFVY-tt"
      },
      "source": [
        "#### Haar feature"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "o8WSwP0JY-tt"
      },
      "source": [
        "La función **haar_like_feature** calcula la Haar feature de una región de interés de una integral image.\n",
        "\n",
        "* Parámetros:\n",
        "    + int_image (M,N) (ndarray). Es la integral image para la cual se calcula la feature.\n",
        "    + r (int). Fila del vértice arriba-izquierda de la subventana de interés.\n",
        "    + c (int). Columna del vértice arriba-izquierda de la subventana de interés.\n",
        "    + width (int). Ancho de la subventana de interés.\n",
        "    + height (int). Altura de la subventana de interés.\n",
        "    + feature_type (str or list of str or None), opcional. El tipo de la feature a considerar:\n",
        "        + 'type-2-x': 2 rectángulos variando a lo largo del eje x;\n",
        "        + 'type-2-y': 2 rectángulos variando a lo largo del eje y;\n",
        "        + 'type-3-x': 3 rectángulos variando a lo largo del eje x;\n",
        "        + 'type-3-y': 3 rectángulos variando a lo largo del eje y;\n",
        "        + 'type-4': 4 rectángulos variando a lo largo de ambos ejes;.\n",
        "    + feature_coord (ndarray of list of tuples or None), opcional. Array de coordenadas a ser extraídas. Es útil cuando se quiere computar un sibconjunto de features.\n",
        "    \n",
        "* Devuelve:\n",
        "    + haar_features (n_features,) ndarray"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "DSDXTVktY-tt"
      },
      "outputs": [],
      "source": [
        "haar = haar_like_feature(ii, 0, 0, H, W)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "hTDWZWIjY-tt"
      },
      "outputs": [],
      "source": [
        "haar.shape"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "9gpoLv8IY-tt"
      },
      "outputs": [],
      "source": [
        "haar[0]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "_rn0-rfyY-tt"
      },
      "outputs": [],
      "source": [
        "feature_coord, feature_type = haar_like_feature_coord(width=W,height=H)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "hH2uQBHyY-tt"
      },
      "outputs": [],
      "source": [
        "feature_coord.shape"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Lxlg5CeiY-tt"
      },
      "outputs": [],
      "source": [
        "feature_coord[0]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "0y7tLk5kY-tu"
      },
      "outputs": [],
      "source": [
        "feature_type[0]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "VikN9avdY-tu"
      },
      "outputs": [],
      "source": [
        "plt.figure(figsize = (7,7))\n",
        "\n",
        "feature_image = draw_haar_like_feature(window, 0, 0,\n",
        "                                       W,\n",
        "                                       H,\n",
        "                                       [feature_coord[0]]\n",
        "                                      )\n",
        "\n",
        "plt.imshow(feature_image, cmap='gray')\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ER-TELiAY-tv"
      },
      "source": [
        "## Otro ejemplo: Histogram of oriented gradients"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "laYUB8q2Y-tw"
      },
      "outputs": [],
      "source": [
        "hog_vec, hog_vis = feature.hog(image_gray, visualize=True)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "SVQpA1SdY-tw"
      },
      "outputs": [],
      "source": [
        "plt.imshow(hog_vis)\n",
        "plt.title('Imagen Input - HOG')\n",
        "plt.show()"
      ]
    }
  ],
  "metadata": {
    "kernelspec": {
      "display_name": "base",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.8.15"
    },
    "orig_nbformat": 4,
    "colab": {
      "provenance": []
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}