Алгоритм определения углов листа бумаги на фото

Как лучше всего определить углы накладной / чека / листа бумаги на фотографии? Это должно использоваться для последующей коррекции перспективы перед OCR.

Мой нынешний подход был:

RGB> Серый> Обнаружение Canny Edge с установлением порога> Расширить (1)> Удалить мелкие объекты (6)> очистить объекты границы> выбрать большой блог на основе Convex Area. > [определение угла - не реализовано]

Я не могу не думать, что должен быть более надежный «интеллектуальный» / статистический подход для обработки этого типа сегментации. У меня не так много обучающих примеров, но я, вероятно, смог бы собрать вместе 100 изображений.

Более широкий контекст:

Я использую Matlab для создания прототипа и планирую реализовать систему в OpenCV и Tesserect-OCR. Это первая из ряда проблем обработки изображений, которые мне нужно решить для этого конкретного приложения. Итак, я собираюсь развернуть собственное решение и заново ознакомиться с алгоритмами обработки изображений.

Вот пример изображения, которое я бы хотел обработать с помощью алгоритма: Если вы хотите принять вызов, большие изображения находятся на http://madteckhead.com/tmp

_{(источник: madteckhead.com )}

_{(источник: madteckhead.com )}

_{(источник: madteckhead.com )}

_{(источник: madteckhead.com )}

В лучшем случае это дает:

_{(источник: madteckhead.com )}

_{(источник: madteckhead.com )}

_{(источник: madteckhead.com )}

Однако он легко терпит неудачу в других случаях:

_{(источник: madteckhead.com )}

_{(источник: madteckhead.com )}

_{(источник: madteckhead.com )}

Заранее спасибо за все отличные идеи! Я так люблю!

РЕДАКТИРОВАТЬ: прогресс преобразования Хафа

В: Какой алгоритм будет кластеризовать горизонтальные линии для поиска углов? Следуя советам из ответов, я смог использовать преобразование Хафа, выбрать линии и отфильтровать их. Мой нынешний подход довольно груб. Я сделал предположение, что счет-фактура всегда будет меньше 15 градусов от выравнивания с изображением. Я получаю разумные результаты для строк, если это так (см. Ниже). Но я не совсем уверен в подходящем алгоритме для кластеризации линий (или голосования) для экстраполяции углов. Линии Хафа не непрерывны. А на зашумленных изображениях могут быть параллельные линии, поэтому требуются метрики какой-либо формы или расстояния от начала линии. Любые идеи?

_{(источник: madteckhead.com )}

Я друг Мартина, который работал над этим в начале этого года. Это был мой первый проект кодирования, и закончился он немного спешно, поэтому код нуждается в некотором ошибочном ... декодировании ... Я дам несколько советов из того, что я уже видел, что вы делаете, а затем отсортируйте мой код в мой выходной завтра.

Первый совет, OpenCVи pythonони классные, переходите к ним как можно скорее. : D

Вместо того, чтобы удалять мелкие объекты и / или шум, опустите хитрые ограничения, чтобы он принял больше краев, а затем найдите самый большой замкнутый контур (в OpenCV используйте findcontour()с некоторыми простыми параметрами, я думаю, что использовал CV_RETR_LIST). может по-прежнему испытывать затруднения, когда он находится на белом листе бумаги, но определенно давал наилучшие результаты.

Для Houghline2()Transform попробуйте использовать CV_HOUGH_STANDARDвместо CV_HOUGH_PROBABILISTIC, это даст rho и theta , определяя линию в полярных координатах, а затем вы можете сгруппировать линии с определенным допуском к ним.

Моя группировка работала как справочная таблица, для каждой строки, выведенной из преобразования hough, она давала пару ро и тета. Если эти значения были в пределах, скажем, 5% пары значений в таблице, они были отброшены, если они были вне этих 5%, в таблицу добавлялась новая запись.

Тогда вам будет намного проще анализировать параллельные линии или расстояние между линиями.

Надеюсь это поможет.

Студенческая группа в моем университете недавно продемонстрировала приложение для iPhone (и приложение OpenCV на Python), которое они написали именно для этого. Насколько я помню, шаги были примерно такими:

• Срединный фильтр для полного удаления текста на бумаге (это был рукописный текст на белой бумаге с довольно хорошим освещением и может не работать с печатным текстом, он работал очень хорошо). Причина в том, что это значительно упрощает обнаружение углов.
• Преобразование Хафа для линий
• Найдите пики в пространстве аккумулятора преобразования Хафа и проведите каждую линию по всему изображению.
• Проанализируйте линии и удалите те, которые расположены очень близко друг к другу и находятся под одинаковым углом (сгруппируйте линии в одну). Это необходимо, потому что преобразование Хафа несовершенно, поскольку оно работает в дискретном пространстве выборки.
• Найдите пары линий, которые примерно параллельны и пересекают другие пары, чтобы увидеть, какие линии образуют четырехугольники.

Это работало довольно хорошо, и они смогли сделать снимок листа бумаги или книги, выполнить определение угла, а затем сопоставить документ на изображении на плоской плоскости почти в реальном времени (для выполнения была единственная функция OpenCV. отображение). Когда я увидел, что он работает, оптического распознавания текста не было.

Вот что я пришел к выводу после небольшого экспериментирования:

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

Не идеально, но, по крайней мере, работает для всех образцов:

Вместо того, чтобы начинать с обнаружения краев, вы можете использовать обнаружение углов.

Marvin Framework предоставляет для этой цели реализацию алгоритма Moravec. Вы можете найти уголки бумаги как отправную точку. Ниже результат алгоритма Моравека:

Также вы можете использовать MSER (Максимально устойчивые экстремальные области) над результатом оператора Собеля, чтобы найти стабильные области изображения. Для каждой области, возвращаемой MSER, вы можете применить аппроксимацию выпуклой оболочки и поли, чтобы получить что-то вроде этого:

Но этот вид обнаружения полезен для обнаружения в реальном времени более одного изображения, которое не всегда дает лучший результат.

После обнаружения края используйте преобразование Хафа. Затем поместите эти точки в SVM (поддерживающую векторную машину) с их метками, если в примерах есть плавные линии на них, у SVM не возникнет проблем с разделением необходимых частей примера и других частей. Мой совет по SVM, поставьте такие параметры, как подключение и длина. То есть, если точки связаны и длинные, они, скорее всего, будут линией квитанции. Затем вы можете удалить все остальные точки.

Вот код @Vanuan на 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. Преобразовать в лабораторное пространство

2. Использовать кластер сегмента 2 kmeans

3. Затем используйте контуры или hough на одном из кластеров (внутренний)