Algorytm wykrywania narożników arkusza papieru na zdjęciu

Grupa studentów na mojej uczelni zademonstrowała niedawno aplikację na iPhone ' a (i aplikację OpenCV w Pythonie), którą napisali, aby dokładnie to zrobić. Z tego co pamietam to kroki byly cos takiego:

• Środkowy filtr, aby całkowicie usunąć tekst na papierze(był to odręczny tekst na białym papierze z dość dobrym oświetleniem i może nie działać z drukowanym tekstem, działał bardzo dobrze). Powodem było to, że znacznie ułatwia wykrywanie narożników.
• transformata Hougha dla linie
• Znajdź wierzchołki w przestrzeni Hough Transform i narysuj każdą linię na całym obrazie.
• przeanalizuj linie i usuń wszystkie, które są bardzo blisko siebie i są pod podobnym kątem(połącz linie w jedną). Jest to konieczne, ponieważ transformata Hougha nie jest idealna, ponieważ działa w dyskretnej przestrzeni próbek.
• Znajdź pary linii, które są mniej więcej równoległe i przecinają inne pary, aby zobaczyć, które linie tworzą quady.

To wydawało się, że działają dość dobrze i byli w stanie zrobić zdjęcie kawałka papieru lub książki, wykonać detekcję narożników, a następnie zmapować dokument na obrazie na płaską płaszczyznę w prawie czasie rzeczywistym (do mapowania była pojedyncza funkcja OpenCV). Nie było OCR, kiedy zobaczyłem, że działa.

Oto co wymyśliłem po kilku eksperymentach:

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

Nie idealne, ale przynajmniej działa dla wszystkich próbek:

Zamiast rozpoczynać od detekcji krawędzi można użyć detekcji narożników.

Marvin Framework dostarcza do tego celu implementację algorytmu Moravec. Jako punkt wyjścia można było znaleźć narożniki gazet. Poniżej wyjście algorytmu Moravec ' a:

Możesz również użyć MSER (maksymalnie stabilne ekstremalne regiony) nad operatorem Sobel result, aby znaleźć stabilne regiony obrazu. Dla każdego obszaru zwracanego przez MSER można zastosować wypukły kadłub i przybliżenie poly, aby otrzymać takie oto:

Ale ten rodzaj detekcji jest przydatny do wykrywania NA ŻYWO więcej niż jeden obraz, który nie zawsze zwraca najlepszy wynik.

Po wykryciu krawędzi użyj transformacji Hougha. Następnie umieść te punkty w SVM (supporting vector machine) z ich etykietami, jeśli przykłady mają gładkie linie na nich, SVM nie będzie miał żadnych trudności z podziałem niezbędnych części przykładu i innych części. Moja rada na SVM, umieścić parametr jak łączność i długość. Oznacza to, że jeśli punkty są połączone i długie, prawdopodobnie będą linią odbioru. Następnie możesz wyeliminować wszystkie pozostałe punkty.

Tutaj masz kod @ Vanuan używając 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. Convert to lab space

2. Use kmeans segment 2 cluster

3. następnie użyj konturów lub hough na jednym z klastrów (intenral)