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

Un grupo de estudiantes de mi universidad recientemente demostró 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 mediano para eliminar completamente el texto en el papel (este fue texto escrito a mano en papel blanco con bastante buena iluminación y puede no funcionar con texto impreso, funcionó muy bien). La razón fue que hace que la detección de esquinas sea mucho más fácil.
• Hough Transformar para líneas
• Encuentre los picos en el espacio acumulador de Transformación de Hough y dibuje cada línea a través de toda la imagen.
• Analice las líneas y elimine las que estén muy cerca unas de otras y estén en un ángulo similar (agrupe las líneas en una). Esto es necesario porque la transformación de Hough no es perfecta, ya que está trabajando en un espacio de muestra discreto.
• Encuentre pares de rectas que son aproximadamente paralelas y que intersecan otros pares para ver qué rectas forman quads.

Esto parecía funcionar bastante bien y pudieron tomar una foto de un pedazo 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 detección de bordes, podría usar Detección de esquinas.

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

También puede usar MSER (Regiones extremales de máxima estabilidad) sobre el resultado del operador Sobel para encontrar las regiones estables de la imagen. Para cada región devuelta por MSER puede aplicar casco convexo y aproximación poly para obtener algunos como este:

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

Después de la detección de bordes, use Transformación de Hough. Luego, coloque esos puntos en un SVM (supporting vector machine) con sus etiquetas, si los ejemplos tienen líneas suaves en ellos, SVM no tendrá ninguna dificultad para dividir las partes necesarias del ejemplo y otras partes. Mi consejo sobre SVM, poner un parámetro como la conectividad y la longitud. Es decir, si los puntos están conectados y son largos, es probable que sean una línea del recibo. Entonces, usted puede eliminar todos los otros 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 a lab space

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

3. A continuación, utilizar contornos o hough en uno de los grupos (intenral)