Уроки компьютерного зрения на Python + OpenCV с самых азов. Часть 9. Мой пэт-проект

Оглавление: Уроки компьютерного зрения. Оглавление / Хабр (habr.com)

Начиная с этого урока, я буду рассказывать о компьютерном зрении на примере моего пэт-проекта. Для начала, что это будет за проект. На первом уроке я рассказал о стадиях обработки изображения в компьютерном зрении. В своем пэт-проекте я создам специальный конвейер, где эти стадии будут реализованы. Напомню кратко об этих стадиях:

• Предобработка изображения.

• Промежуточная фильтрация.

• Выявления специальных признаков (фич).

• Высокоуровневый анализ.

Разумеется, это не окончательный список стадий обработки. В будущем сюда может что-то добавиться, а так же некоторые стадии могут иметь подстадии.

Естественно, делать конвейер ради самого конвейера как-то бессмысленно. Надо, чтобы моя программа делала хоть что-то условно полезное. Сначала я хотел написать пэт-проект, который бы анализировал фотографии со спутников и БЛА и превращал их в граф (это перекликается с темой моей магистерской диссертации). Правда, это слишком уж амбициозная задумка для пэт-проекта. Надо что-то по- проще. В комментариях к одному из уроков мне посоветовали добавить в финале пару глав про выделение отдельных символов и распознавание их при помощи общедоступных нейронок. И вот я и подумал, может, начать пэт-проект именно с этой задачи? Распознавание текстов? Это гораздо проще.

Итак, для начала я создал пустой проект и добавил туда две папки: Exec и Libraries. В первой у меня будет запускаемый файл/файлы, во втором всякие библиотечные файлы. В качестве первого библиотечного файла создал Core.py:

class Engine:
    """"Движок"""
    pass

class ImageProcessingStep:
    """Шаг обработки изображений"""
    pass

class ImageInfo:
    """Содержимое картинки, включая результаты обработки"""
    pass

Может, не совсем удачно разместить эти в Core.py, но пока нет видимости, какова будет окончательная структура, а потом просто сделаю рефакторинг.

Итак, начнем программирование:

class Engine:
    """"Движок"""

    def __init__(self):
        """Конструктор"""

        self.steps=[]

    def process(self, image):
        """Выполнить обработку.
        image - изображение"""

        current_info=ImageInfo(image)
        for step in self.steps:
            current_info=step.process(current_info)
        return current_info

Из этого фрагмента кода видно, что нужно создать конструктор класса ImageInfo, а у класса ImageProcessingStep надо предусмотреть метод process. И, разумеется, ImageProcessingStep должен быть абстрактным классом, а реализовывать методы будет уже каждый конкретный класс. Стоить заметить, что в Python абстрактных классов нет как таковых (в отличии от C#), они эмулируются при помощи декораторов. Но я этого делать не буду, так как использование декораторов приводит к излишнему расходу процессорного времени. Просто представлю, что раз «нет» значит «нет».

Абстрактный класс я сделаю путем добавления псевдоабстрактных методов, помеченных pass:

class ImageProcessingStep:
    """Шаг обработки изображений"""

    def process(self,info):
        """Выполнить обработку"""
        pass

Теперь займемся классом ImageInfo. По идее, это тоже должны быть псевдоабстрактный класс, в зависимости от шага, должен содержать, кроме картинки, еще какие-то дополнительные данные. А пока реализую конструктор:

class ImageInfo:
    """Содержимое картинки, включая результаты обработки"""

    def __init__(self,image):
        """Конструктор"""

        self.image=image

Ну а теперь попробую «натянуть» на эту схему какое-нибудь простейшее действие, ну, например, фильтрацию. Но для начала небольшой рефакторинг, в частности, перенесем класс ImageProcessingStep в файл перенес в ImageProcessingSteps.

Создадим класс, отвечающий за медианную фильтрацию:

class MedianBlurProcessingStep(ImageProcessingStep):
    """Шаг, отвечающий за предобработку типа Медианная фильтрация"""

    def __init__(self,ksize):
        """Конструктор
        ksize - размер ядра фильтра"""

        self.ksize=ksize

    def process(self,info):
        """Выполнить обработку"""

        median_image = cv2.medianBlur(info.image, self.ksize)
        info.filtered_image=median_image
        return info

Далее, создаем папку Exec, а в ней файл run.py. Вот так теперь будет выглядеть структура папок:

Ну и само содержимое файла run.py:

import cv2

from Libraries.Core import Engine
from Libraries.ImageProcessingSteps import MedianBlurProcessingStep

my_photo = cv2.imread('../Photos/MyPhoto1.jpg')
core=Engine()
core.steps.append(MedianBlurProcessingStep(5))
info=core.process(my_photo)

cv2.imshow('origin', info.image) # выводим исходное изображение в окно
cv2.imshow('res', info.filtered_image) # выводим итоговое изображение в окно

cv2.waitKey()
cv2.destroyAllWindows()

Запускаем программу и видим две картинки, одну с царапинами, другую после медианной фильтрации. Да, это уже было на уроке 3, только на этот раз все сделано в соответствии с парадигмой ООП. Теперь пора идти дальше и реализовывать идею распознаванием текста. Для начала попробуем стандартным способом, через tesseract. Прежде всего, я расскажу, как вообще работать с tesseract. И так, ставим библиотеку:

pip install pytesseract

Заходим по этой ссылке: Home · UB-Mannheim/tesseract Wiki (github.com) и качаем оттуда саму tesseract. Если внезапно окажется, что ссылка не актуальная (мало ли, все течет, все меняется), тогда просто погуглите.

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

import cv2
import pytesseract

pytesseract.pytesseract.tesseract_cmd = "D:\\Program Files\\Tesseract-OCR\\tesseract.exe"

img = cv2.imread('image.jpg')
print(pytesseract.image_to_string(img, lang = 'rus'))

А вот демонстрация результатов работы программы вместе с исходным изображением:

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

Попробуем распознать сфотографированную страницу книги:

Вот что мы получим на выходе:

Как видим, где-то слова распознались хорошо, где-то довольно криво.

И еще один, немаловажный нюанс. На выходе сплошной текст. Но в реальности может потребоваться делить текст на какие-то блоки. Например, я однажды писал программу, которая позволяет распознавать текст на чертежах, чтобы потом этот чертеж оцифровать и занести в базу данных. В этом случае требовалось отдельно найти и распознать штампик чертежа, отдельно надписи на выносках, чтобы все эти надписи занести в нужные поля базы данных. Как данная задача решалась практически? При помощи алгоритмов компьютерного зрения изображение делилось на зоны, и эти зоны уже отдельно скармливались tesseract.

Но в моем пэт-проекте я попробую распознавать автомобильные номера. Знаю, это уже вообще баянестый баян, но, тем не менее, студенты до сих пор пишут лабораторные на эту тему. И даже целые курсовые. Да и вообще, надо же с чего-то начинать. А задача это довольно простая для того, чтобы создать некую основу для более сложного проекта.

Поступлю я, пожалуй, следующим образом. Нагуглю готовый пример распознавания номеров, или даже несколько, выберу наиболее удачный, и перенесу код в мой ООП-шаблон. Поехали. Нашел любопытный ролик:

[Python] Изучение OpenCV | Распознавание автомобильных номеров смотреть онлайн видео от Boris Bochkarev | BeTry в хорошем качестве. (rutube.ru)

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

Автор рассказывает все по шагам. Приведу эти шаги. Сначала он предлагает преобразовать текст в оттенки серого и произвести бинаризацию:

import cv2

img = cv2.imread('cars/6108249.jpg')
height,width,_=img.shape
gray = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)
thresh = cv2.threshold(gray,0,255,cv2.THRESH_OTSU)[1]
cv2.imshow('MyPhoto', thresh)
cv2.waitKey(0)

cv2.destroyAllWindows()

Исходное изображение:

Результат бинаризации:

Нетрудно предугадать следующий шаг. Полагаю, автор предложит найти вот этот вот белый прямоугольник:

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

В принципе, неплохо, хотя местами есть помехи:

А в последнем случае номерной знак теряется на белом фоне. Хотя, если приглядеться внимательно, вокруг него есть черный контур:

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

Оказалось, парень предложил просто выделить контуры, и исследовать каждый прямоугольник контура с достаточно большой площадью. В общем, что-то наподобие того:

import cv2
from imutils import contours
import pytesseract

pytesseract.pytesseract.tesseract_cmd = "D:\\Program Files\\Tesseract-OCR\\tesseract.exe"

img = cv2.imread('cars/6108249.jpg')
height,width,_=img.shape
gray = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)
thresh = cv2.threshold(gray,0,255,cv2.THRESH_OTSU)[1]
cnts=cv2.findContours(thresh,cv2.RETR_TREE,cv2.CHAIN_APPROX_SIMPLE)
cnts,_=contours.sort_contours(cnts[0])

for c in cnts:
    area=cv2.contourArea(c)
    x,y,w,h=cv2.boundingRect(c)
    if area>20:
        img_area=img[y:y+h,x:x+h]
        result=pytesseract.image_to_string(img_area,lang="rus+eng")
        if len(result)>3:
            print(result)

У него, правда, были немного другие пороги. И все работало, он прямо показал в ролике, все работает. На моих фотографиях это не сработало, поэтому я и заменил пороги. И получил странный вывод:

Можно добавить просмотр картинок, чтобы увидеть, где tesseract находит эти надписи:

…
print(result)
cv2.imshow('MyPhoto', img_area)
cv2.waitKey(0)
…

Смотрим фрагменты картинки:

В общем, цифры tesseract почему то не хочет идентифицировать. А он вообще, понимает цифры? Давайте проверим. Создадим в paint-е картинку из цифр:

Скармливаем tesseract. И видим, что вывод пуст.  Погуглил данную тему. Как оказалось, tesseract работает с цифрами через одно место. Можно поискать какие-то другие версия, но это не вариант. Лучше написать какую-то свою распознавалку, например, с использованием нейросетей.

Но, даже в этом случае встает вопрос, а каким же образом найти местоположение автомобильного номера? Может быть, искать белый прямоугольник на бинарной карте, как я предположил вначале? В любом случае, необходимо сначала вставить наработки в уже написанный ООП-контейнер, чтобы потом анализировать и исследовать.

И тут я понял, что вот такой вот код:

def process(self, image):
    """Выполнить обработку.
    image - изображение"""

    current_info=ImageInfo(image)
    for step in self.steps:
        current_info=step.process(current_info)
    return current_info

...
...
  
def process(self,info):
    """Выполнить обработку"""

    median_image = cv2.medianBlur(info.image, self.ksize)
    info.filtered_image=median_image
    return info

Это плохая идея. Почему? Допустим, я решил сделать бинаризацию картинки. Я могу сделать бинаризацию исходной картинки, а могу после фильтрации. Но после фильтрации она называется не image, а filtered_image. И спрашивается, откуда на шаге бинаризации можно знать, надо обрабатывать image или filtered_image? Поэтому, они должны называется одинаково. А вот историю обработки надо где-то сохранять, чтобы потом восстановить цепочку обработок и проанализировать, как работает вся система.

Для начала исправим метод process класса Engine:

def process(self, image):
    """Выполнить обработку.
    image - изображение"""

    current_info=ImageInfo(image)
    history=[]
    for step in self.steps:
        history.append(current_info)
        current_info=step.process(current_info)
    return current_info, history

Затем файл: ImageProcessingSteps.py

import cv2
from Libraries.Core import ImageInfo


class ImageProcessingStep:
    """Шаг обработки изображений"""

    def process(self,info):
        """Выполнить обработку"""
        pass

class MedianBlurProcessingStep(ImageProcessingStep):
    """Шаг, отвечающий за предобработку типа Медианная фильтрация"""

    def __init__(self,ksize):
        """Конструктор
        ksize - размер ядра фильтра"""

        self.ksize=ksize

    def process(self,info):
        """Выполнить обработку"""

        median_image = cv2.medianBlur(info.image, self.ksize)
        return ImageInfo(median_image)

Ну, и наконец run.py:

import cv2

from Libraries.Core import Engine
from Libraries.ImageProcessingSteps import MedianBlurProcessingStep

my_photo = cv2.imread('../Photos/MyPhoto1.jpg')
core=Engine()
core.steps.append(MedianBlurProcessingStep(5))
res,history=core.process(my_photo)

i=1
for info in history:
    cv2.imshow('image'+str(i), info.image) # выводим изображение в окно
    i=i+1
cv2.imshow('res', res.image)



cv2.waitKey()
cv2.destroyAllWindows()

Теперь можно показать всю цепочку изображений, и сейчас мы испытаем это на примере обработки изображения автомобиля. Сначала класс для вычисления бинарной карты:

class ThresholdProcessingStep(ImageProcessingStep):
    """Шаг, отвечающий за бинаризацию"""

    def process(self,info):
        """Выполнить обработку"""

        gray = cv2.cvtColor(info.image, cv2.COLOR_BGR2GRAY)
        image = cv2.threshold(gray, 0, 255, cv2.THRESH_OTSU)[1]
        return ImageInfo(image)

И новый запускаемый файл run1.py:

import cv2

from Libraries.Core import Engine
from Libraries.ImageProcessingSteps import MedianBlurProcessingStep, ThresholdProcessingStep

my_photo = cv2.imread('../Photos/car.jpg')
core=Engine()
core.steps.append(MedianBlurProcessingStep(5))
core.steps.append(ThresholdProcessingStep())
res,history=core.process(my_photo)

i=1
for info in history:
    cv2.imshow('image'+str(i), info.image) # выводим изображение в окно
    i=i+1
cv2.imshow('res', res.image)

cv2.waitKey()
cv2.destroyAllWindows()

При запуске мы увидим вот такую картинку:

Код этого примера можно взять отсюда: https://github.com/megabax/CVContainer

А теперь подытожим: Мы создали ООП-контейнер для обработки изображений, в будущих уроках прикрутим к нему находилку номера и распознавалку цифр на нейросетях.