Algorithme pour détecter les coins de la feuille de papier en photo

Un groupe d'étudiants de mon université a récemment démontré une application iPhone (et une application Python OpenCV) qu'ils avaient écrite pour faire exactement cela. Si je me souviens bien, les étapes étaient quelque chose comme ceci:

• Filtre médian pour supprimer complètement le texte sur le papier (ce texte était écrit à la main sur du papier blanc avec un éclairage assez bon et peut ne pas fonctionner avec du texte imprimé, il a très bien fonctionné). La raison en était que cela rend la détection de coin beaucoup plus facile.
• transformation Hough pour lignes
• Trouvez les pics dans L'espace de L'accumulateur Hough Transform et tracez chaque ligne sur toute l'image.
• analysez les lignes et supprimez celles qui sont très proches les unes des autres et qui sont à un angle similaire (regroupez les lignes en une seule). Ceci est nécessaire car la transformation Hough n'est pas parfaite car elle fonctionne dans un espace d'échantillon discret.
• trouvez des paires de lignes qui sont à peu près parallèles et qui croisent d'autres paires pour voir quelles lignes forment des quads.

Ce semblait fonctionner assez bien et ils ont pu prendre une photo d'un morceau de papier ou d'un livre, effectuer la détection de coin, puis mapper le document dans l'image sur un plan plat en presque temps réel (il y avait une seule fonction OpenCV pour effectuer le mappage). Il n'y avait pas D'OCR quand je l'ai vu fonctionner.

Voici ce que j'ai trouvé après un peu d'expérimentation:

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()

Pas parfait, mais au moins fonctionne pour tous les échantillons:

Au lieu de partir de la détection de bord, vous pouvez utiliser la détection de coin.

Marvin Framework fournit une implémentation de l'algorithme Moravec à cet effet. Vous pouvez trouver les coins des papiers comme point de départ. En dessous de la sortie de l'algorithme de Moravec:

Vous pouvez également utiliser MSER (régions extrêmes stables au maximum) sur le résultat de l'opérateur Sobel pour trouver les régions stables de l'image. Pour chaque région renvoyée par MSER, vous pouvez appliquer une approximation de coque convexe et de poly pour en obtenir un peu comme ceci:

Mais ce type de détection est utile pour la détection en direct plus d'une seule image qui ne renvoie pas toujours le meilleur résultat.

Après la détection des arêtes, utilisez la transformation Hough. Ensuite, mettez ces points dans une SVM (supporting vector machine) avec leurs étiquettes, si les exemples ont des lignes lisses sur eux, SVM n'aura aucune difficulté à diviser les parties nécessaires de l'exemple et d'autres parties. Mon conseil sur SVM, mettre un paramètre comme la connectivité et la longueur. Autrement dit, si les points sont connectés et longs, ils sont susceptibles d'être une ligne de la réception. Ensuite, vous pouvez éliminer tous les autres points.

Ici, vous avez le code de @ Vanuan en utilisant 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 espace laboratoire

2. Utilisation kmeans segment 2 cluster

3. ensuite, utilisez des contours ou hough sur l'un des clusters (intenral)