Algoritmo para detectar las esquinas de la hoja de papel en la foto

¿Cuál es la mejor manera de detectar las esquinas de una factura / recibo / hoja de papel en una foto? Esto se utilizará para la corrección de perspectiva posterior, antes del OCR.

Mi enfoque actual ha sido:

RGB> Gray> Canny Edge Detection con umbralización> Dilate (1)> Elimina objetos pequeños (6)> clear boarder objects> elige un blog grande basado en el área convexa. > [detección de esquinas - No implementado]

No puedo evitar pensar que debe haber un enfoque "inteligente" / estadístico más sólido para manejar este tipo de segmentación. No tengo muchos ejemplos de entrenamiento, pero probablemente podría juntar 100 imágenes.

Contexto mas amplio:

Estoy usando matlab para crear prototipos y planeo implementar el sistema en OpenCV y Tesserect-OCR. Este es el primero de una serie de problemas de procesamiento de imágenes que necesito resolver para esta aplicación específica. Así que estoy buscando desarrollar mi propia solución y volver a familiarizarme con los algoritmos de procesamiento de imágenes.

Aquí hay una imagen de muestra que me gustaría que manejara el algoritmo: Si desea aceptar el desafío, las imágenes grandes están en http://madteckhead.com/tmp

_{(fuente: madteckhead.com )}

_{(fuente: madteckhead.com )}

_{(fuente: madteckhead.com )}

_{(fuente: madteckhead.com )}

En el mejor de los casos, esto da:

_{(fuente: madteckhead.com )}

_{(fuente: madteckhead.com )}

_{(fuente: madteckhead.com )}

Sin embargo, falla fácilmente en otros casos:

_{(fuente: madteckhead.com )}

_{(fuente: madteckhead.com )}

_{(fuente: madteckhead.com )}

¡Gracias de antemano por todas las grandes ideas! ¡Me gusta tanto!

EDITAR: Hough Transform Progress

P: ¿Qué algoritmo agruparía las suficientes líneas para encontrar esquinas? Siguiendo los consejos de las respuestas, pude usar la transformación de Hough, seleccionar líneas y filtrarlas. Mi enfoque actual es bastante tosco. Supuse que la factura siempre estará a menos de 15 grados fuera de alineación con la imagen. Termino con resultados razonables para las líneas si este es el caso (ver más abajo). Pero no estoy completamente seguro de un algoritmo adecuado para agrupar las líneas (o votar) para extrapolar las esquinas. Las líneas de Hough no son continuas. Y en las imágenes ruidosas, puede haber líneas paralelas, por lo que se requiere alguna forma o distancia de las métricas del origen de la línea. ¿Algunas ideas?

_{(fuente: madteckhead.com )}

Soy el amigo de Martin que estaba trabajando en esto a principios de este año. Este fue mi primer proyecto de codificación, y terminó con un poco de prisa, por lo que el código necesita algo errr ... decodificación ... Daré algunos consejos de lo que ya te he visto hacer, y luego ordenar mi código en mi día libre mañana.

El primer consejo, OpenCVy pythones genial, muévete hacia ellos lo antes posible. :RE

En lugar de eliminar objetos pequeños o ruido, baje las astutas restricciones, para que acepte más bordes, y luego encuentre el contorno cerrado más grande (en OpenCV use findcontour()con algunos parámetros simples, creo que usé CV_RETR_LIST). aún podría tener problemas cuando está en una hoja de papel blanco, pero definitivamente estaba brindando mejores resultados.

Para la Houghline2()Transformación, intente con el CV_HOUGH_STANDARDen lugar de CV_HOUGH_PROBABILISTIC, le dará valores rho y theta , definiendo la línea en coordenadas polares, y luego puede agrupar las líneas dentro de una cierta tolerancia a esos.

Mi agrupación funcionó como una tabla de búsqueda, para cada línea generada por la transformación hough daría un par rho y theta. Si estos valores estaban dentro de, digamos, el 5% de un par de valores en la tabla, se descartaron, si estaban fuera de ese 5%, se agregó una nueva entrada a la tabla.

A continuación, puede analizar las líneas paralelas o la distancia entre líneas con mucha más facilidad.

Espero que esto ayude.

Un grupo de estudiantes de mi universidad demostró recientemente una aplicación para iPhone (y una aplicación Python OpenCV) que habían escrito para hacer exactamente esto. Según recuerdo, los pasos eran algo así:

• Filtro de mediana para eliminar completamente el texto en el papel (este era texto escrito a mano en papel blanco con bastante buena iluminación y puede que no funcione con texto impreso, funcionó muy bien). La razón es que facilita mucho la detección de curvas.
• Transformación de Hough para líneas
• Encuentre los picos en el espacio del acumulador Hough Transform y dibuje cada línea a lo largo de toda la imagen.
• Analice las líneas y elimine las que estén muy cerca entre sí y que formen un ángulo similar (agrupe las líneas en una). Esto es necesario porque la transformación de Hough no es perfecta, ya que funciona en un espacio de muestra discreto.
• Encuentra pares de líneas que sean aproximadamente paralelas y que se crucen con otros pares para ver qué líneas forman cuadrículas.

Esto pareció funcionar bastante bien y pudieron tomar una foto de una hoja de papel o libro, realizar la detección de esquinas y luego mapear el documento en la imagen en un plano casi en tiempo real (había una sola función OpenCV para realizar el mapeo). No había OCR cuando lo vi funcionar.

Esto es lo que se me ocurrió después de un poco de experimentación:

import cv, cv2, numpy as np
import sys

def get_new(old):
    new = np.ones(old.shape, np.uint8)
    cv2.bitwise_not(new,new)
    return new

if __name__ == '__main__':
    orig = cv2.imread(sys.argv[1])

    # these constants are carefully picked
    MORPH = 9
    CANNY = 84
    HOUGH = 25

    img = cv2.cvtColor(orig, cv2.COLOR_BGR2GRAY)
    cv2.GaussianBlur(img, (3,3), 0, img)


    # this is to recognize white on white
    kernel = cv2.getStructuringElement(cv2.MORPH_RECT,(MORPH,MORPH))
    dilated = cv2.dilate(img, kernel)

    edges = cv2.Canny(dilated, 0, CANNY, apertureSize=3)

    lines = cv2.HoughLinesP(edges, 1,  3.14/180, HOUGH)
    for line in lines[0]:
         cv2.line(edges, (line[0], line[1]), (line[2], line[3]),
                         (255,0,0), 2, 8)

    # finding contours
    contours, _ = cv2.findContours(edges.copy(), cv.CV_RETR_EXTERNAL,
                                   cv.CV_CHAIN_APPROX_TC89_KCOS)
    contours = filter(lambda cont: cv2.arcLength(cont, False) > 100, contours)
    contours = filter(lambda cont: cv2.contourArea(cont) > 10000, contours)

    # simplify contours down to polygons
    rects = []
    for cont in contours:
        rect = cv2.approxPolyDP(cont, 40, True).copy().reshape(-1, 2)
        rects.append(rect)

    # that's basically it
    cv2.drawContours(orig, rects,-1,(0,255,0),1)

    # show only contours
    new = get_new(img)
    cv2.drawContours(new, rects,-1,(0,255,0),1)
    cv2.GaussianBlur(new, (9,9), 0, new)
    new = cv2.Canny(new, 0, CANNY, apertureSize=3)

    cv2.namedWindow('result', cv2.WINDOW_NORMAL)
    cv2.imshow('result', orig)
    cv2.waitKey(0)
    cv2.imshow('result', dilated)
    cv2.waitKey(0)
    cv2.imshow('result', edges)
    cv2.waitKey(0)
    cv2.imshow('result', new)
    cv2.waitKey(0)

    cv2.destroyAllWindows()

No es perfecto, pero al menos funciona para todas las muestras:

En lugar de comenzar desde la detección de bordes, puede utilizar la detección de esquinas.

Marvin Framework proporciona una implementación del algoritmo Moravec para este propósito. Podrías encontrar las esquinas de los papeles como punto de partida. Debajo de la salida del algoritmo de Moravec:

También puede utilizar MSER (regiones extremas máximamente estables) sobre el resultado del operador Sobel para encontrar las regiones estables de la imagen. Para cada región devuelta por MSER, puede aplicar un casco convexo y una aproximación de poli para obtener algunos como este:

Pero este tipo de detección es útil para la detección en vivo más que una sola imagen que no siempre arroja el mejor resultado.

Después de la detección de bordes, use Hough Transform. Luego, coloque esos puntos en una SVM (máquina de vectores de soporte) con sus etiquetas, si los ejemplos tienen líneas suaves, SVM no tendrá ninguna dificultad para dividir las partes necesarias del ejemplo y otras partes. Mi consejo sobre SVM, pon un parámetro como conectividad y longitud. Es decir, si los puntos están conectados y son largos, es probable que sean una línea del recibo. Luego, puede eliminar todos los demás puntos.

Aquí tienes el código de @Vanuan usando C ++:

cv::cvtColor(mat, mat, CV_BGR2GRAY);
cv::GaussianBlur(mat, mat, cv::Size(3,3), 0);
cv::Mat kernel = cv::getStructuringElement(cv::MORPH_RECT, cv::Point(9,9));
cv::Mat dilated;
cv::dilate(mat, dilated, kernel);

cv::Mat edges;
cv::Canny(dilated, edges, 84, 3);

std::vector<cv::Vec4i> lines;
lines.clear();
cv::HoughLinesP(edges, lines, 1, CV_PI/180, 25);
std::vector<cv::Vec4i>::iterator it = lines.begin();
for(; it!=lines.end(); ++it) {
    cv::Vec4i l = *it;
    cv::line(edges, cv::Point(l[0], l[1]), cv::Point(l[2], l[3]), cv::Scalar(255,0,0), 2, 8);
}
std::vector< std::vector<cv::Point> > contours;
cv::findContours(edges, contours, CV_RETR_EXTERNAL, CV_CHAIN_APPROX_TC89_KCOS);
std::vector< std::vector<cv::Point> > contoursCleaned;
for (int i=0; i < contours.size(); i++) {
    if (cv::arcLength(contours[i], false) > 100)
        contoursCleaned.push_back(contours[i]);
}
std::vector<std::vector<cv::Point> > contoursArea;

for (int i=0; i < contoursCleaned.size(); i++) {
    if (cv::contourArea(contoursCleaned[i]) > 10000){
        contoursArea.push_back(contoursCleaned[i]);
    }
}
std::vector<std::vector<cv::Point> > contoursDraw (contoursCleaned.size());
for (int i=0; i < contoursArea.size(); i++){
    cv::approxPolyDP(Mat(contoursArea[i]), contoursDraw[i], 40, true);
}
Mat drawing = Mat::zeros( mat.size(), CV_8UC3 );
cv::drawContours(drawing, contoursDraw, -1, cv::Scalar(0,255,0),1);

1. Convertir en espacio de laboratorio

2. Utilice el clúster del segmento 2 de kmeans

3. Luego use contornos o hough en uno de los grupos (intenral)