Оглавление: Уроки компьютерного зрения. Оглавление / Хабр (habr.com)
На предыдущем уроке я рассказал о своем пэт-проекте, связанном с компьютерным зрением. В этом уроке вы познакомились идей и наброском архитектуры этого пэт-проекта. Сегодня продолжу описывать, как я добавлял в проект новые классы и что из этого вышло. Напомню, что идея состояла в том, чтобы написать полноценный конвейер обработки изображений, начав с простой задачи, например, распознавание номеров. В результате эксперимента выяснилось, что известная библиотека для распознавания символов tesseract плохо распознает цифры. Было принято решение написать какую-то свою распознавалку для цифр. Но сначала надо как-то найти, где эти цифры расположены на изображении.
Напомню, какие шаги были сделаны на прошлом уроке:
Применить медианную фильтрацию к изображению.
Провести бинаризацию.
Сегодня мы пойдем чуть дальше: выделим контур и найдем на нем прямоугольник номерного знака. Для начала напишем класс, который производит выделение контура:
class ContourProcessingStep(ImageProcessingStep):
"""Шаг, отвечающий за выделение контуров"""
def process(self,info):
"""Выполнить обработку"""
contours, hierarchy = cv2.findContours(info.image, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
height, width = info.image.shape[:2]
contours_image = np.zeros((height, width, 3), dtype=np.uint8)
# отображаем контуры
cv2.drawContours(contours_image, contours, -1, (255, 0, 0), 1, cv2.LINE_AA, hierarchy, 1)
#Заполним данные
new_info=ImageInfo(contours_image)
new_info.contours=contours
new_info.hierarchy=hierarchy
return new_infoЭтот контур надо аппроксимировать, разработаем следующий класс:
class ContourApproximationProcessingStep(ImageProcessingStep):
"""Шаг, отвечающий за апроксимацию контуров"""
def __init__(self,eps = 0.005, filter=None):
"""Конструктор
eps - размер элемента контура от размера общей дуги"""
self.eps=eps
self.filter=filter
def process(self, info):
"""Выполнить обработку"""
approx_countours=[]
img_contours = np.uint8(np.zeros((info.image.shape[0], info.image.shape[1])))
for countour in info.contours:
arclen = cv2.arcLength(countour, True)
epsilon = arclen * self.eps
approx = cv2.approxPolyDP(countour, epsilon, True)
append=False
if not(self.filter is None):
if self.filter(approx):
append=True
else:
append=True
if append:
approx_countours.append(approx)
cv2.drawContours(img_contours, approx_countours, -1, (255, 255, 255), 1)
#Заполним данные
new_info=ImageInfo(img_contours)
new_info.contours=approx_countours
return new_infoВ качестве фильтра ссылка на функцию, которая по какому-либо критерию отберет контуры (нам нужен только прямоугольный контур).
Итак, испытываем, сначала без фильтра:
import cv2
from Libraries.Core import Engine
from Libraries.ImageProcessingSteps import MedianBlurProcessingStep, ThresholdProcessingStep, ContourProcessingStep, \
ContourApproximationProcessingStep
def my_filter(approx):
if len(approx)==4:
return True
return False
my_photo = cv2.imread('../Photos/car.jpg')
core=Engine()
core.steps.append(MedianBlurProcessingStep(5))
core.steps.append(ThresholdProcessingStep())
core.steps.append(ContourProcessingStep())
core.steps.append(ContourApproximationProcessingStep(0.02))
#core.steps.append(ContourApproximationProcessingStep(0.02,my_filter))
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()Смотрим, что у нас получилось:
Здесь для наглядности я показал уменьшенное фото машины. Попробуем обработать полноразмерную фотографию:
Итак, мы видим примерно прямоугольник (да, он кривой, но другие фигуры вообще не похожи на прямоугольник).
Теперь встает вопрос: а как нам среди всех этих линий найти наш «прямоугольник»? Для начала, давайте применим фильтр (вот он нам и понадобился), отбросив все фигуры, которые не являются четырехугольниками. Для этого, как вы заметили, в тексте программы есть такая функция:
def my_filter(approx):
if len(approx)==4:
return True
return FalseОсталось поменять вот эту строчку кода
core.steps.append(ContourApproximationProcessingStep(0.02))На эту:
core.steps.append(ContourApproximationProcessingStep(0.02,my_filter))И вуаля, у нас остались только четырехугольники:
Как видим, объектов осталось значительно меньше, но все еще много мусора. Отфильтруем его, убрав слишком маленькие объекты:
def my_filter(approx):
if len(approx)==4:
if abs(approx[2,0,0]-approx[0,0,0])<10:
return False
if abs(approx[2,0,1]-approx[0,0,1])<10:
return False
return True
return FalseИ вот что у нас получилось:
Осталось всего 5 объектов. По идее, конечно, можно применить дополнительную фильтрацию, например, исключив объекты, имеющие неправильные соотношения длины и ширины (номерной знак имеет конкретные размеры по ГОСТ, а значит, соотношение длины и ширины у него тоже конкретные). Можно так же исключить явно «кривые прямоугольники» у которых разница в длинах противоположных сторон значительно выше уровня погрешности. Правда, при этом следует помнить, что в попытке отфильтровать ненужные объекты можно заодно и нужные до кучи выкинуть. Так что тут надо соблюдать осторожность.
Тем не менее, попробуем. Для начала напишем функцию вычисления длины сторон:
def dist(point1,point2):
d1 = point1[0] - point2[0]
d2 = point1[1] - point2[1]
return math.sqrt(d1*d1+d2*d2)И внесем изменения в фильтр:
def my_filter(approx):
if len(approx)==4:
if abs(approx[2,0,0]-approx[0,0,0])<10:
return False
if abs(approx[2,0,1]-approx[0,0,1])<10:
return False
if abs(dist(approx[0,0],approx[1,0])/dist(approx[2,0],approx[3,0])-1)>0.4:
return False
if abs(dist(approx[0,0],approx[3,0])/dist(approx[1,0],approx[2,0])-1)>0.4:
return False
return True
return FalseВот что получилось:
Как видим, осталось только три объекта. Один из них, кстати, можно отфильтровать на расхождение с прямыми углами (если угол сильно отклоняется от 90 градусов). Но мы пока этого делать не будем, положим, что один лишний объект – не критично.
Визуализируем найденные номера. Для этого надо извлечь из контура точки. Вот как будет выглядеть извлечение из контура двух противоположных точек первого элемента:
x1=res.contours[0][0][0][0]
y1=res.contours[0][0][0][1]
x2=res.contours[0][2][0][0]
y2=res.contours[0][2][0][1]
cv2.rectangle(finish_result,(x1,y1),(x2,y2),(255,0,0),3)И вот что в итоге будет нарисовано:
Разумеется, так делать не надо. А надо, ну, хотя бы написать функцию, которая бы извлекала эти точки:
def get_rect(countur_item):
x1 = countur_item[0][0][0]
y1 = countur_item[0][0][1]
x2 = countur_item[2][0][0]
y2 = countur_item[2][0][1]
return (x1,y1), (x2,y2)И тогда мы можем нарисовать первую фигуру вот так:
p1,p2=get_rect(res.contours[0])
cv2.rectangle(finish_result,p1,p2,(255,0,0),3)А все фигуры вот так:
for item in res.contours:
p1,p2=get_rect(item)
cv2.rectangle(finish_result,p1,p2,(255,0,0),3)И вот что получится:
То есть, теперь нам надо проанализировать только эти три области, поискать там буковки и циферки. Но сначала хотелось бы навести порядок в коде. Вот как выглядит у нас запускаемый файл run2.py:
import cv2
import math
from Libraries.Core import Engine
from Libraries.ImageProcessingSteps import MedianBlurProcessingStep, ThresholdProcessingStep, ContourProcessingStep, \
ContourApproximationProcessingStep
def dist(point1,point2):
d1 = point1[0] - point2[0]
d2 = point1[1] - point2[1]
return math.sqrt(d1*d1+d2*d2)
def my_filter(approx):
if len(approx)==4:
if abs(approx[2,0,0]-approx[0,0,0])<10:
return False
if abs(approx[2,0,1]-approx[0,0,1])<10:
return False
if abs(dist(approx[0,0],approx[1,0])/dist(approx[2,0],approx[3,0])-1)>0.4:
return False
if abs(dist(approx[0,0],approx[3,0])/dist(approx[1,0],approx[2,0])-1)>0.4:
return False
return True
return False
def get_rect(countur_item):
x1 = countur_item[0][0][0]
y1 = countur_item[0][0][1]
x2 = countur_item[2][0][0]
y2 = countur_item[2][0][1]
return (x1,y1), (x2,y2)
my_photo = cv2.imread('../Photos/6108249.jpg')
#my_photo = cv2.imread('../Photos/car.jpg')
core=Engine()
core.steps.append(MedianBlurProcessingStep(5))
core.steps.append(ThresholdProcessingStep())
core.steps.append(ContourProcessingStep())
#core.steps.append(ContourApproximationProcessingStep(0.02))
core.steps.append(ContourApproximationProcessingStep(0.02,my_filter))
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)
finish_result = history[0].image.copy()
for item in res.contours:
p1,p2=get_rect(item)
cv2.rectangle(finish_result,p1,p2,(255,0,0),3)
cv2.imshow('Finish', finish_result)
cv2.waitKey()
cv2.destroyAllWindows()Не очень красиво, проведем некоторый рефакторинг. Добавим в папку Libraries файл Utils.py и перенесем туда функции get_rect и dist. Импортируем эти функции:
from Libraries.Utils import dist, get_rectТеперь запускаемый файл выглядит так:
import cv2
from Libraries.Core import Engine
from Libraries.ImageProcessingSteps import MedianBlurProcessingStep, ThresholdProcessingStep, ContourProcessingStep, \
ContourApproximationProcessingStep
from Libraries.Utils import dist, get_rect, show_history
def my_filter(approx):
if len(approx)==4:
if abs(approx[2,0,0]-approx[0,0,0])<10:
return False
if abs(approx[2,0,1]-approx[0,0,1])<10:
return False
if abs(dist(approx[0,0],approx[1,0])/dist(approx[2,0],approx[3,0])-1)>0.4:
return False
if abs(dist(approx[0,0],approx[3,0])/dist(approx[1,0],approx[2,0])-1)>0.4:
return False
return True
return False
my_photo = cv2.imread('../Photos/6108249.jpg')
#my_photo = cv2.imread('../Photos/car.jpg')
core=Engine()
core.steps.append(MedianBlurProcessingStep(5))
core.steps.append(ThresholdProcessingStep())
core.steps.append(ContourProcessingStep())
#core.steps.append(ContourApproximationProcessingStep(0.02))
core.steps.append(ContourApproximationProcessingStep(0.02,my_filter))
res,history=core.process(my_photo)
show_history(res,history)
finish_result = history[0].image.copy()
for item in res.contours:
p1, p2 = get_rect(item)
cv2.rectangle(finish_result, p1, p2, (255, 0, 0), 3)
cv2.imshow('Finish', finish_result)
cv2.waitKey()
cv2.destroyAllWindows()А файл утилит вот так:
import math
import cv2
def get_rect(countur_item):
x1 = countur_item[0][0][0]
y1 = countur_item[0][0][1]
x2 = countur_item[2][0][0]
y2 = countur_item[2][0][1]
return (x1,y1), (x2,y2)
def dist(point1,point2):
d1 = point1[0] - point2[0]
d2 = point1[1] - point2[1]
return math.sqrt(d1*d1+d2*d2)
def show_history(res,history):
i = 1
for info in history:
cv2.imshow('image' + str(i), info.image) # выводим изображение в окно
i = i + 1
cv2.imshow('res', res.image)Теперь можно подумать о том, как «расшифровать» номер. На этом уроке я расскажу, как при помощи нейросети распознавать цифры, а распознавалку будем писать на следующем уроке.
И так, знакомитесь, его Величество Keras. Чтобы установить его под Windows, cсначала ставим TensorFlow:
pip3 install tensorflow
а затем и сам Keras:
pip3 install Keras
Ну, и собственно, пример кода обучения нейросети на встроенном в керас стандартном датасете minst:
from keras import layers
from keras import models
from keras.datasets import mnist
import tensorflow as tf
model = models.Sequential()
model.add(layers.Conv2D(32, (3, 3), activation='relu', input_shape=(28, 28, 1)))
model.add(layers.MaxPooling2D((2, 2)))
model.add(layers.Conv2D(64, (3, 3), activation='relu'))
model.add(layers.MaxPooling2D((2, 2)))
model.add(layers.Conv2D(64, (3, 3), activation='relu'))
model.add(layers.Flatten())
model.add(layers.Dense(64, activation='relu'))
model.add(layers.Dense(10, activation='softmax'))
(train_images, train_labels), (test_images, test_labels) = mnist.load_data()
train_images = train_images.reshape((60000, 28, 28, 1))
train_images = train_images.astype('float32') / 255
test_images = test_images.reshape((10000, 28, 28, 1))
test_images = test_images.astype('float32') / 255
train_labels = tf.keras.utils.to_categorical(train_labels)
test_labels = tf.keras.utils.to_categorical(test_labels)
model.compile(optimizer='rmsprop', loss='categorical_crossentropy', metrics=['accuracy'])
model.fit(train_images, train_labels, epochs=5, batch_size=64)
test_loss, test_acc = model.evaluate(test_images, test_labels)
print(test_acc)Здесь используется сверточная нейросеть, на входе которой черно-белая картинка 28 на 28 пикселей, на выходе десятизначный вектор вероятностей, что на картинке та или иная цифра. Модель показывает точность порядка 99% на тестовой выборке.
Если вы не верите, что в mnist действительно цифры, это можно проверить, визуализировав какой-нибудь элемент датасета:
from keras.datasets import mnist
import cv2
(train_images, train_labels), (test_images, test_labels) = mnist.load_data()
print(train_labels)
cv2.imshow("Цифра", train_images[0])
cv2.waitKey(0)
cv2.destroyAllWindows()Для элемента номер нуль мы увидим цифру 5:
И этому элементу действительно соответствует лэйбл 5:
Попробуем скормить какое-нибудь изображение обученной нейросети. Кстати, после того, как мы нейросеть обучили, ее хорошо бы сохранить:
model.save('cats_and_dogs_small_1.h5')Ну а теперь попробуем загрузить картинку с цифрой и дать нейросетке распознать ее:
import cv2
from keras import models
my_photo = cv2.imread('imgs/Digit0.png',cv2.IMREAD_GRAYSCALE) #загрузим изображение
#приведем изображение к формату для нейросети
normal_photo=my_photo/255.0
input=normal_photo.reshape(1,28,28)
#скормим изображение нейросетке и получим результат
model = models.load_model('mnist_model.bin')
result=model.predict(input)
print(result)Вот картинка:
На выходе:
[[9.9990845e-01 1.4144711e-08 8.4316625e-08 3.7920216e-11 2.4454723e-06
4.7663391e-08 8.7873021e-05 4.1903621e-07 3.8488349e-08 6.0560058e-07]]
Видно, в первой (то есть нулевой, счет с нуля) ячейке (соответствует цифре 0) вероятность почти 1, в остальных почти 0.
Посмотрим как распознает единицу:
[[5.2682775e-08 9.9998152e-01 9.0230742e-07 1.2926430e-09 9.7749239e-07
6.3665328e-07 5.2730784e-06 1.0716837e-05 2.0985880e-08 1.3917042e-11]]
Как видим, и тут распознал циферку правильно.
На этом все, засовывать нейросеть в проект с «красивым» кодом будем в следующий раз.
Напомню, что примеры можно скачать здесь: megabax/CVContainer: It is my pet computer vision project. (github.com)
