Corrigiendo 1000 examenes - el libro de la pelicula.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# importar los paquetes necesarios\n",
    "\n",
    "import numpy as np\n",
    "import imutils\n",
    "import cv2\n",
    "\n",
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "\n",
    "# Definir funciones útiles\n",
    "\n",
    "\n",
    "def get_center(points):\n",
    "    '''\n",
    "    calcula el punto medio de una nube de puntos 2D.\n",
    "    También admite arrays de 3 coordenadas, como los obtenidos\n",
    "    al buscar contornos con opencv\n",
    "    '''\n",
    "    if len(points.shape) == 3:\n",
    "        x_med = np.mean(points[:,0,0])\n",
    "        y_med = np.mean(points[:,0,1])\n",
    "        return np.array([x_med, y_med])\n",
    "    if len(points.shape) == 2:\n",
    "        x_med = np.mean(points[:,0])\n",
    "        y_med = np.mean(points[:,1])\n",
    "        return np.array([x_med, y_med])\n",
    "    \n",
    "def get_center_y(points):\n",
    "    '''\n",
    "    Calcula la posicion en coordenadas y del centro de una nube de puntos.\n",
    "    se usa como clave para ordenar las columnas de izquierda a derecha.\n",
    "    '''\n",
    "    center = get_center(points)\n",
    "    return center[0]\n",
    "    \n",
    "def get_dist(p1, p2):\n",
    "    '''\n",
    "    Calcula la distancia euclidea entre 2 puntos 2D\n",
    "    '''\n",
    "    d_x = p1[0]-p2[0]\n",
    "    d_y = p1[1]-p2[1]\n",
    "    return np.sqrt(d_x**2 + d_y**2)\n",
    "\n",
    "def get_submatrix(matrix,rectangle):\n",
    "    '''\n",
    "    Recorta de una matriz un rectángulo de forma aproximada a \"rectangle\"\n",
    "    '''\n",
    "    x_max = np.max(rectangle[:,0,0])\n",
    "    x_min = np.min(rectangle[:,0,0])\n",
    "    y_max = np.max(rectangle[:,0,1])\n",
    "    y_min = np.min(rectangle[:,0,1])\n",
    "    \n",
    "    return matrix[y_min:y_max,x_min:x_max].copy()\n",
    "\n",
    "def enderezar(mat, direction):\n",
    "    '''\n",
    "    Reorienta una matriz dependiendo de la dirección\n",
    "    '''\n",
    "    if direction == 0:\n",
    "        return mat\n",
    "    if direction == 1:\n",
    "        return mat.T[:,::-1]\n",
    "    if direction == 2:\n",
    "        return mat[::-1,::-1]\n",
    "    if direction == 3:\n",
    "        return mat.T[::-1,:]\n",
    "\n",
    "def get_rectangles(image):\n",
    "    '''\n",
    "    Obtiene una lista de los contornos rectangulares \n",
    "    ordenados de mayor a menor\n",
    "    '''\n",
    "    # Primero buscamos todos los contornos y los guardamos\n",
    "    cnts = cv2.findContours(image.copy(), cv2.RETR_EXTERNAL,\n",
    "        cv2.CHAIN_APPROX_SIMPLE)\n",
    "    cnts = cnts[0] if imutils.is_cv2() else cnts[1]\n",
    "    \n",
    "    rectangulos = []#Aquí guardaremos los rectangulos\n",
    "    \n",
    "    # Aseguramos que hemos encontrado al menos\n",
    "    # un contorno\n",
    "    if len(cnts) > 0:\n",
    "        \n",
    "        #Ordenar los contornos de mayor a menor tamaño\n",
    "        cnts = sorted(cnts, key=cv2.contourArea, reverse=True)\n",
    "\n",
    "        for c in cnts:\n",
    "            # Aprximar el contorno\n",
    "            peri = cv2.arcLength(c, True)\n",
    "            approx = cv2.approxPolyDP(c, 0.02 * peri, True)            \n",
    "            # Si el contorno tiene cuatro esquinas,\n",
    "            # lo añadimos a la lista de rectángulos\n",
    "            if len(approx) == 4:\n",
    "                rectangulos.append(approx)\n",
    "    return rectangulos\n",
    "\n",
    "def get_orientation(rectangle):\n",
    "    '''Calcula la orientación vertical u horizontal \n",
    "    de un rectángulo dado\n",
    "    '''\n",
    "    # 3 puntos del rectángulo\n",
    "    big_r_p0 = rectangle[0,0,:]\n",
    "    big_r_p1 = rectangle[1,0,:]\n",
    "    big_r_p2 = rectangle[2,0,:]\n",
    "    \n",
    "    # Longitud de los lados\n",
    "    big_r_l1 = get_dist(big_r_p0, big_r_p1)\n",
    "    big_r_l2 = get_dist(big_r_p1, big_r_p2)\n",
    "    # Buscar cual de los dos puntos es más lejano\n",
    "    big_r_p_far = big_r_p0 if big_r_l1>big_r_l2 else big_r_p2\n",
    "\n",
    "    big_r_long = np.abs(big_r_p_far - big_r_p1)\n",
    "    \n",
    "    #Buscar si es horizontal o vertical\n",
    "    if big_r_long[0] > big_r_long[1]:\n",
    "        orientation, coord = 'hor', 0\n",
    "    else:\n",
    "        orientation, coord = 'vert', 1\n",
    "    \n",
    "    # Calcular el ángulo exacto\n",
    "    big_r_long_sign = big_r_p_far - big_r_p1\n",
    "    angle = np.rad2deg(np.arctan(big_r_long_sign[1-coord]/big_r_long_sign[coord]))\n",
    "    angle = -angle if orientation == 'hor' else angle\n",
    "        \n",
    "    return orientation, coord, angle\n",
    "\n",
    "def get_direction(image, rectangulos, coord, orientation):\n",
    "    '''\n",
    "    Obtiene la direccion del folio a partir de medir \n",
    "    a qué lado de las columnas hay mayor cantidad de tinta.\n",
    "    devuelve la direccion como un int:\n",
    "        0 = de pie\n",
    "        1 = girado a la derecha\n",
    "        2 = girado 180º\n",
    "        3 = girado a la izquierda\n",
    "    '''\n",
    "    min_coord = max(image.shape)\n",
    "    max_coord = 0\n",
    "    for ii in range(5):\n",
    "        element = rectangulos[ii]\n",
    "        min_coord = min(min_coord, np.min(element[:,0,coord]))    \n",
    "        max_coord = max(max_coord, np.max(element[:,0,coord]))\n",
    "    \n",
    "    #Calculamos la luminosidad de los espacios a ambos lados de las columnas\n",
    "    corner_space_1 = np.array(image.shape)-1\n",
    "    corner_space_1[1 - coord] = min_coord\n",
    "    space_1 = image[:corner_space_1[0], :corner_space_1[1]]\n",
    "\n",
    "    corner_space_2 = np.array([0,0])\n",
    "    corner_space_2[1 - coord] = max_coord\n",
    "    space_2 = image[corner_space_2[0]:, corner_space_2[1]:]\n",
    "\n",
    "    #El lado más oscuro es la cabecera\n",
    "    \n",
    "    if orientation == 'vert':\n",
    "        if np.mean(space_1) < np.mean(space_2):\n",
    "            direction = 0\n",
    "        else:\n",
    "            direction = 2\n",
    "    else:\n",
    "        if np.mean(space_1) < np.mean(space_2):\n",
    "            direction = 1\n",
    "        else:\n",
    "            direction = 3\n",
    "    return direction\n",
    "\n",
    "def giro_recorte(image, angle):\n",
    "    '''\n",
    "    Gira una imagen y recorta los márgenes necesarios \n",
    "    para que no aparezca información espurea en las esquinas.\n",
    "    '''\n",
    "    \n",
    "    if abs(angle)>0.05:        \n",
    "        rows,cols = image.shape\n",
    "        M = cv2.getRotationMatrix2D((cols/2,rows/2),-angle,1)\n",
    "        giro_rect = cv2.warpAffine(image,M,(cols,rows))\n",
    "\n",
    "        margins = np.ceil(np.array(image.shape)*np.sin(np.deg2rad(abs(angle)))).astype(int)\n",
    "        giro_margin = giro_rect[margins[0]:-margins[0], margins[1]:-margins[1]]\n",
    "    else:\n",
    "        giro_margin = image\n",
    "    return giro_margin\n",
    "                \n",
    "def get_rect_contour(rectangle):\n",
    "    '''\n",
    "    Genera una matriz que contiene los puntos necesarios para\n",
    "    dibujar un rectangulo orientado circunscrito a los \n",
    "    puntos dados.\n",
    "    '''\n",
    "    x_max = np.max(rectangle[:,0,0])\n",
    "    x_min = np.min(rectangle[:,0,0])\n",
    "    y_max = np.max(rectangle[:,0,1])\n",
    "    y_min = np.min(rectangle[:,0,1])\n",
    "    \n",
    "    rect = np.array([\n",
    "        [x_max, y_max],\n",
    "        [x_max, y_min],\n",
    "        [x_min, y_min],\n",
    "        [x_min, y_max],\n",
    "        [x_max, y_max]\n",
    "    ])\n",
    "    return rect"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#Podemos usar estas funciones para representar gráficamente lo que estamos haciendo:\n",
    "\n",
    "def print_im(image):\n",
    "    '''\n",
    "    muestra una imagen\n",
    "    '''\n",
    "    plt.figure(figsize=[20,30])\n",
    "    plt.imshow(image, cmap=plt.cm.gray)\n",
    "    \n",
    "def print_cont(cont_list, num):\n",
    "    '''\n",
    "    Dibuja contornos\n",
    "    '''\n",
    "    for n in range(num):\n",
    "        rectangle = get_rect_contour(cont_list[n])        \n",
    "        plt.plot(rectangle[:,0], rectangle[:,1],'r', lw = 5)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def analizar_casilla(n, casillas):\n",
    "    '''\n",
    "    Calcula una fila de datos buscar la contestación a la pregunta.\n",
    "        - n es el número de la pregunta\n",
    "        - casillas es la lista de todas las preguntas\n",
    "    '''\n",
    "    #La fila de datos se compodrá del número de la pregunta,\n",
    "    #la solución propuesta y posibles alertas.\n",
    "    \n",
    "    fila = [n+1,]\n",
    "    sol_casilla = ''\n",
    "    alerta_casilla = ''\n",
    "    malas_casillas = ''\n",
    "    \n",
    "    #Obtenemos la imagen de la casilla a analizar y la difuminamos\n",
    "    pregunta_prev = casillas[n]    \n",
    "    pregunta = cv2.GaussianBlur(pregunta_prev, (35, 35), 0)\n",
    "    \n",
    "    #Definimos las secciones de la imagen que analizamos en busca de \n",
    "    #trazos escritos\n",
    "    alto,ancho = pregunta.shape\n",
    "    \n",
    "    #Estos valores son experimentales, se han obtenido\n",
    "    #con un algoritmo de optimización para minimizar\n",
    "    #los falsos positivos\n",
    "    alto_cas = round(alto/1.737)\n",
    "    ancho_cas = round(ancho/7.768)\n",
    "    y_cas = round(alto/2.543)\n",
    "    x_cas = round(ancho/3.633)\n",
    "    ancho_pos = round((ancho - x_cas)/4)\n",
    "    \n",
    "    #Guardamos en una lista las imágenes de las casillitas\n",
    "    #de respuesta que se van a medir\n",
    "    recuadros = []\n",
    "    for ii in range(4):\n",
    "        recuadros.append(pregunta[y_cas:y_cas + alto_cas,x_cas+ ii*ancho_pos: x_cas + ancho_cas+ ii*ancho_pos ])\n",
    "    \n",
    "    #Guardamos el valor de la luminosidad media de cada casilla\n",
    "    medias_cuadros = []\n",
    "    for ii in range(4):\n",
    "        medias_cuadros.append(recuadros[ii].mean())\n",
    "\n",
    "    #Comparamos la luminosidad de cada casilla con la de la\n",
    "    #casilla más clara de la pregunta.\n",
    "    #Suponemos que si la diferencia pasa de cierto umbral, es porque \n",
    "    #la casilla ha sido oscurecida por trazos escritos.\n",
    "    \n",
    "    #Además, supondremos que de todas las casillas con trazos,\n",
    "    #la más clara es la correcta, ya que para anular se escriben\n",
    "    #trazos adicionales en la casilla.\n",
    "    \n",
    "    num_found = 0 #Número de casillas con trazos \n",
    "    found_cell_value = 500 #Guardaremos el valor más claro de casilla con trazos\n",
    "    found_bad_cell_value = 500 #Esto nos sirve para guardar valores de casillas anuladas\n",
    "    for ii in enumerate('ABCD'):\n",
    "        dif = medias_cuadros[ii[0]]-min(medias_cuadros) \n",
    "        if dif > 11:\n",
    "            num_found += 1 #Hemos encontrado una casilla con trazos\n",
    "            if dif < found_cell_value: #Si es la más clara, es la buena\n",
    "                found_bad_cell_value = found_cell_value\n",
    "                found_cell_value = dif\n",
    "                malas_casillas += sol_casilla\n",
    "                sol_casilla = ii[1]\n",
    "            else:\n",
    "                found_bad_cell_value = min(found_bad_cell_value, dif)\n",
    "                malas_casillas += ii[1]\n",
    "        if 11 < dif <= 13 and len(alerta_casilla) == 0: #dejamos un margen de duda\n",
    "            alerta_casilla += 'cuadros dudosos: ' + ii[1] + ' '\n",
    "    \n",
    "    #Añadimos alerta por múltiples respuestas si es necesario         \n",
    "    if num_found >= 2:\n",
    "        alerta_casilla += 'varias respuestas detectadas: ' + str(num_found)\n",
    "    \n",
    "    #La luminosidad de casillas que consideramos como respuesta\n",
    "    #se guarda para hacer más análisis después.    \n",
    "    if num_found >= 1:\n",
    "        ok_cell_value = found_cell_value        \n",
    "    else:\n",
    "        ok_cell_value = max(medias_cuadros)\n",
    "\n",
    "    fila.append(sol_casilla)\n",
    "    fila.append(alerta_casilla)    \n",
    "    fila.append(malas_casillas)\n",
    "    \n",
    "    return fila, ok_cell_value\n",
    "        \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def gen_corr_image(image, solucion, rectangulos, root):\n",
    "    '''\n",
    "    Guarda una imagen del examen corregido con un código\n",
    "    de colores sobreimpreso para facilitar la \n",
    "    supervisión manual.\n",
    "    En el notebook también se muestra la imagen generada\n",
    "    si está activado matplotlib inline o similar.\n",
    "    '''\n",
    "    #generar una ruta de guardado a partir de la original\n",
    "    root_divided = root.split('/')\n",
    "    new_root = 'examenes_coloreados/' + root_divided[-1]\n",
    "    \n",
    "    #Representar el examen\n",
    "    plt.figure(figsize=[20,30])\n",
    "    plt.imshow(image, cmap=plt.cm.gray)\n",
    "    letras = {'A':0, 'B':1, 'C':2, 'D':3}\n",
    "    \n",
    "    #Destacar las columnas\n",
    "    for n in range(5):\n",
    "        rectangle = get_rect_contour(rectangulos[n])        \n",
    "        plt.plot(rectangle[:,0], rectangle[:,1],'r', lw = 2)\n",
    "        \n",
    "    #Sobreimprimir los colores\n",
    "    for n in range(5):        \n",
    "        rectangle = rectangulos[n][:,0,:]\n",
    "        x_max = np.max(rectangle[:,0])\n",
    "        x_min = np.min(rectangle[:,0])\n",
    "        y_max = np.max(rectangle[:,1])\n",
    "        y_min = np.min(rectangle[:,1])\n",
    "        \n",
    "        alto = (y_max - y_min)/20\n",
    "        ancho = x_max - x_min\n",
    "        \n",
    "        #Para cada pregunta:\n",
    "        for ii in range(20):\n",
    "            jj = n*20 + ii\n",
    "            y_center = y_min + alto * (ii)\n",
    "            #Si tiene alertas o comentarios, destacarla en amarillo\n",
    "            if len(solucion[jj][2])>0:                \n",
    "                plt.bar(x_min + ancho/2, alto * 0.7, ancho , y_center, alpha = 0.3, color = 'y')\n",
    "                \n",
    "            #Si se han detectado respuestas:\n",
    "            if len(solucion[jj][1])>0:\n",
    "                alto_cas = (alto/1.737)\n",
    "                ancho_cas = (ancho/7.768)\n",
    "                y_cas = (alto/2.543)\n",
    "                x_cas = (ancho/3.633)\n",
    "                ancho_pos = ((ancho - x_cas)/4)\n",
    "                \n",
    "                #Si se han detectado respuestas afirmativas, señalar en verde\n",
    "                kk = letras[solucion[jj][1]]\n",
    "                plt.bar(x_min +x_cas+ kk*ancho_pos + ancho_cas/2 , alto_cas, ancho_cas ,\n",
    "                        y_center + y_cas, alpha = 0.5, color = 'g')\n",
    "                \n",
    "                #Si se han detectado respuestas tachadas, señalar en rojo\n",
    "                if len(solucion[jj][3])>0:\n",
    "                    kk = letras[solucion[jj][3]]\n",
    "                    plt.bar(x_min +x_cas+ kk*ancho_pos + ancho_cas/2 , alto_cas, ancho_cas ,\n",
    "                            y_center + y_cas, alpha = 0.5, color = 'r')\n",
    "    \n",
    "    plt.axis('off')\n",
    "    plt.savefig(new_root, bbox_inches = 'tight')\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def evaluar(root):\n",
    "    '''\n",
    "    Calcula la lista de respuestas de una imagen contenida en root.\n",
    "    También analiza posibles problemas de la lectura.\n",
    "    '''\n",
    "    #  Cargamos la imagen desde root:\n",
    "        \n",
    "    image = cv2.imread(root)\n",
    "    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)\n",
    "    blurred = cv2.GaussianBlur(gray, (11, 11), 0)\n",
    "    thresh = cv2.threshold(blurred, 0, 255,\n",
    "        cv2.THRESH_BINARY_INV | cv2.THRESH_OTSU)[1]\n",
    "    \n",
    "    #Lo primero de todo es enderezar el papel:\n",
    "    \n",
    "    #Buscamos contornos rectangulares\n",
    "    rectangulos = get_rectangles(thresh)\n",
    "    \n",
    "    #Calculamos la orientación vertical u horizontal del folio\n",
    "    orientation, coord, angle = get_orientation(rectangulos[0])           \n",
    "    \n",
    "    #Calculamos la orientación exacta del papel\n",
    "    direction = get_direction(gray, rectangulos, coord, orientation)\n",
    "     \n",
    "    #Giramos la imagen para que quede una hoja perfectamente vertical\n",
    "    giro_margin = giro_recorte(blurred, angle)\n",
    "    papel = enderezar(giro_margin, direction)\n",
    "    \n",
    "    #Hemos girado la imagen difuminada porque si rotáramos \n",
    "    \n",
    "    #Binarizamos la imagen con un threshold\n",
    "    thresh = cv2.threshold(papel, 0, 255,\n",
    "        cv2.THRESH_BINARY_INV | cv2.THRESH_OTSU)[1]\n",
    "    \n",
    "    #Obtenemos la posición de las columnas\n",
    "    rectangulos = get_rectangles(thresh)\n",
    "    rectangulos = sorted(rectangulos[:5], key=get_center_y, reverse=False)\n",
    "    \n",
    "    #Podemos representar lo que hemos hecho:\n",
    "    #print_im(255-thresh)\n",
    "    #print_cont(rectangulos,5)\n",
    "    \n",
    "    #Guardamos las columnas en sí en una lista\n",
    "    columns_gray_ok = []\n",
    "    for ii in range(5):\n",
    "        columns_gray_ok.append(get_submatrix(thresh, rectangulos[ii]))\n",
    "        \n",
    "    #Columna a columna, guardamos todas las casillas en un lista\n",
    "    casillas = []\n",
    "    for n in range(5):\n",
    "        long = columns_gray_ok[n].shape[0]\n",
    "        for ii in range(20):\n",
    "            long_y = (long/20)\n",
    "            min_y = round(long_y*ii)\n",
    "            max_y = round(min_y + long_y)\n",
    "            casillas.append(columns_gray_ok[n][min_y:max_y,:])\n",
    "\n",
    "    #Analizamos cada casilla a priori           \n",
    "    solucion = []\n",
    "    ok_cell_list = []\n",
    "    \n",
    "    for n in range(100):        \n",
    "        fila, ok_cell_value = analizar_casilla(n, casillas)        \n",
    "        ok_cell_list.append(ok_cell_value)        \n",
    "        solucion.append(fila)\n",
    "    \n",
    "    \n",
    "    #Con los datos obtenidos, podemos buscar información adicional\n",
    "    #por ejemplo, buscar posibles respuestas tachadas a partir\n",
    "    #de casillas tomadas como correctas anormalmente oscuras\n",
    "        \n",
    "    ok_cell_max = sorted(ok_cell_list, reverse = True)\n",
    "    ok_cell_difs = [ok_cell_max[ii] - ok_cell_max[ii+1] for ii in range(7)]\n",
    "\n",
    "#---- Codigo para debuggear o sacar info adicional ---------  \n",
    "\n",
    "#    ok_cell_avg = np.mean(ok_cell_list)  \n",
    "#    for line in solucion:\n",
    "#        alerta_casilla = line[2]\n",
    "#        if len(alerta_casilla) > 0:\n",
    "#            alerta_casilla += '     ok-avg: ' + str(round(ok_cell_avg, 3))\n",
    "#            alerta_casilla += '     ok-max: ' + str(round(ok_cell_max[0], 3))\n",
    "#            alerta_casilla += '      difs: '\n",
    "#            for ii in range(5):\n",
    "#                dif_cell = ok_cell_difs[ii]\n",
    "#                alerta_casilla += str(round(dif_cell, 3)) + '  '\n",
    "#            line[2] = alerta_casilla\n",
    "\n",
    "#---- Fin del bloque adicional --------------\n",
    "\n",
    "    max_cell_acc = ok_cell_max[0] + 10\n",
    "    for ii in enumerate(ok_cell_difs):\n",
    "        if ii[1] > 7:\n",
    "            max_cell_acc = ok_cell_max[ii[0]]\n",
    "    for ii in enumerate(ok_cell_list):\n",
    "        if ii[1]>= max_cell_acc:\n",
    "            solucion[ii[0]][2] += 'posible casilla tachada'\n",
    "    gen_corr_image(papel, solucion, rectangulos, root)        \n",
    "    #Se devuelven todos los datos obtenidos\n",
    "    return solucion"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "x = evaluar('examenes/ejemplo-001.jpg')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}