Извлечение текста OpenCV

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

версия c ++

The MIT License (MIT)

Copyright (c) 2014 Dhanushka Dangampola

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.

#include "stdafx.h"
#include <opencv2/core/core.hpp>
#include <opencv2/highgui/highgui.hpp>
#include <opencv2/imgproc/imgproc.hpp>
#include <iostream>

using namespace cv;
using namespace std;

#define INPUT_FILE              "1.jpg"#define OUTPUT_FOLDER_PATH      string("")

int _tmain(int argc, _TCHAR* argv[])
{
Mat large = imread(INPUT_FILE);
Mat rgb;
// downsample and use it for processing
pyrDown(large, rgb);
Mat small;
cvtColor(rgb, small, CV_BGR2GRAY);
// morphological gradient
Mat grad;
Mat morphKernel = getStructuringElement(MORPH_ELLIPSE, Size(3, 3));
morphologyEx(small, grad, MORPH_GRADIENT, morphKernel);
// binarize
Mat bw;
threshold(grad, bw, 0.0, 255.0, THRESH_BINARY | THRESH_OTSU);
// connect horizontally oriented regions
Mat connected;
morphKernel = getStructuringElement(MORPH_RECT, Size(9, 1));
morphologyEx(bw, connected, MORPH_CLOSE, morphKernel);
// find contours
Mat mask = Mat::zeros(bw.size(), CV_8UC1);
vector<vector<Point>> contours;
vector<Vec4i> hierarchy;
findContours(connected, contours, hierarchy, CV_RETR_CCOMP, CV_CHAIN_APPROX_SIMPLE, Point(0, 0));
// filter contours
for(int idx = 0; idx >= 0; idx = hierarchy[idx][0])
{
Rect rect = boundingRect(contours[idx]);
Mat maskROI(mask, rect);
maskROI = Scalar(0, 0, 0);
// fill the contour
drawContours(mask, contours, idx, Scalar(255, 255, 255), CV_FILLED);
// ratio of non-zero pixels in the filled region
double r = (double)countNonZero(maskROI)/(rect.width*rect.height);

if (r > .45 /* assume at least 45% of the area is filled if it contains text */
&&
(rect.height > 8 && rect.width > 8) /* constraints on region size */
/* these two conditions alone are not very robust. better to use something
like the number of significant peaks in a horizontal projection as a third condition */
)
{
rectangle(rgb, rect, Scalar(0, 255, 0), 2);
}
}
imwrite(OUTPUT_FOLDER_PATH + string("rgb.jpg"), rgb);

return 0;
}

версия на питоне

The MIT License (MIT)

Copyright (c) 2017 Dhanushka Dangampola

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.

import cv2
import numpy as np

large = cv2.imread('1.jpg')
rgb = cv2.pyrDown(large)
small = cv2.cvtColor(rgb, cv2.COLOR_BGR2GRAY)

kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (3, 3))
grad = cv2.morphologyEx(small, cv2.MORPH_GRADIENT, kernel)

_, bw = cv2.threshold(grad, 0.0, 255.0, cv2.THRESH_BINARY | cv2.THRESH_OTSU)

kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (9, 1))
connected = cv2.morphologyEx(bw, cv2.MORPH_CLOSE, kernel)
# using RETR_EXTERNAL instead of RETR_CCOMP
contours, hierarchy = cv2.findContours(connected.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)

mask = np.zeros(bw.shape, dtype=np.uint8)

for idx in range(len(contours)):
x, y, w, h = cv2.boundingRect(contours[idx])
mask[y:y+h, x:x+w] = 0
cv2.drawContours(mask, contours, idx, (255, 255, 255), -1)
r = float(cv2.countNonZero(mask[y:y+h, x:x+w])) / (w * h)

if r > 0.45 and w > 8 and h > 8:
cv2.rectangle(rgb, (x, y), (x+w-1, y+h-1), (0, 255, 0), 2)

cv2.imshow('rects', rgb)

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

1. Преобразовал изображение в оттенки серого
2. прикладной порог (простой двоичный порог, с выбранным вручную значением 150 в качестве порогового значения)
3. прикладной расширение сгущать линии на изображении, приводя к более компактным объектам и меньшим фрагментам белого пространства. Использовалось большое значение для числа итераций, поэтому расширение очень тяжелое (13 итераций, также выбираемых вручную для достижения оптимальных результатов).
4. Выявленные контуры объектов в полученном изображении с помощью opencv findContours функция.
5. Нарисовал Ограничительная рамка (прямоугольник), описывающий каждый контурный объект — каждый из них создает блок текста.
6. Необязательно отбрасываемые области, которые вряд ли будут объектом, который вы ищете (например, текстовые блоки), учитывая их размер, так как алгоритм выше также может найти пересекающиеся или вложенные объекты (например, всю верхнюю область для первой карты), некоторые из которых могут быть неинтересно для ваших целей.

Ниже приведен код, написанный на python с помощью pyopencv, его легко перенести на C ++.

import cv2

image = cv2.imread("card.png")
gray = cv2.cvtColor(image,cv2.COLOR_BGR2GRAY) # grayscale
_,thresh = cv2.threshold(gray,150,255,cv2.THRESH_BINARY_INV) # threshold
kernel = cv2.getStructuringElement(cv2.MORPH_CROSS,(3,3))
dilated = cv2.dilate(thresh,kernel,iterations = 13) # dilate
_, contours, hierarchy = cv2.findContours(dilated,cv2.RETR_EXTERNAL,cv2.CHAIN_APPROX_NONE) # get contours

# for each contour found, draw a rectangle around it on original image
for contour in contours:
# get rectangle bounding contour
[x,y,w,h] = cv2.boundingRect(contour)

# discard areas that are too large
if h>300 and w>300:
continue

# discard areas that are too small
if h<40 or w<40:
continue

# draw rectangle around contour on original image
cv2.rectangle(image,(x,y),(x+w,y+h),(255,0,255),2)

# write original image with added contours to disk
cv2.imwrite("contoured.jpg", image)

Исходное изображение — первое изображение в вашем посте.

После предварительной обработки (оттенки серого, порог и расширение — после шага 3) изображение выглядело так:

Ниже приведено изображение («contoured.jpg» в последней строке); последние ограничительные рамки для объектов на изображении выглядят так:

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

Используя тот же сценарий с теми же параметрами (за исключением типа порога, который был изменен для второго изображения, как описано ниже), вот результаты для двух других карт:

Настройка параметров

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

Для порога (шаг 2) я использовал черный порог. Для изображений, где текст светлее фона, например второе изображение в сообщении, следует использовать белый порог, поэтому замените тип удержания на cv2.THRESH_BINARY). Для второго изображения я также использовал немного более высокое значение для порога (180). Изменение параметров для порогового значения и количества итераций для расширения приведет к различной степени чувствительности при разграничении объектов на изображении.

Поиск других типов объектов:

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

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

Подход @ dhanushka показал наибольшее обещание, но я хотел поиграть в Python, поэтому продолжил и перевел его в шутку:

import cv2
import numpy as np
from cv2 import boundingRect, countNonZero, cvtColor, drawContours, findContours, getStructuringElement, imread, morphologyEx, pyrDown, rectangle, threshold

large = imread(image_path)
# downsample and use it for processing
rgb = pyrDown(large)
# apply grayscale
small = cvtColor(rgb, cv2.COLOR_BGR2GRAY)
# morphological gradient
morph_kernel = getStructuringElement(cv2.MORPH_ELLIPSE, (3, 3))
grad = morphologyEx(small, cv2.MORPH_GRADIENT, morph_kernel)
# binarize
_, bw = threshold(src=grad, thresh=0, maxval=255, type=cv2.THRESH_BINARY+cv2.THRESH_OTSU)
morph_kernel = getStructuringElement(cv2.MORPH_RECT, (9, 1))
# connect horizontally oriented regions
connected = morphologyEx(bw, cv2.MORPH_CLOSE, morph_kernel)
mask = np.zeros(bw.shape, np.uint8)
# find contours
im2, contours, hierarchy = findContours(connected, cv2.RETR_CCOMP, cv2.CHAIN_APPROX_SIMPLE)
# filter contours
for idx in range(0, len(hierarchy[0])):
rect = x, y, rect_width, rect_height = boundingRect(contours[idx])
# fill the contour
mask = drawContours(mask, contours, idx, (255, 255, 2555), cv2.FILLED)
# ratio of non-zero pixels in the filled region
r = float(countNonZero(mask)) / (rect_width * rect_height)
if r > 0.45 and rect_height > 8 and rect_width > 8:
rgb = rectangle(rgb, (x, y+rect_height), (x+rect_width, y), (0,255,0),3)

Теперь для отображения изображения:

from PIL import Image
Image.fromarray(rgb).show()

Не самый Pythonic из сценариев, но я попытался максимально приблизиться к исходному коду C ++, чтобы читатели могли им следовать.

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

Ты можешь попробовать Этот метод это разработано Chucai Yi и Yingli Tian.

Они также используют программное обеспечение (которое основано на Opencv-1.0 и должно работать на платформе Windows), которое вы можете использовать (хотя исходный код недоступен). Он сгенерирует все текстовые ограничительные рамки (показанные в цветных тенях) на изображении. Применяя свои образцы изображений, вы получите следующие результаты:

Примечание: чтобы сделать результат более надежным, вы можете дополнительно объединить соседние блоки.

Обновить: Если ваша конечная цель заключается в распознавании текстов на изображении, вы можете дополнительно проверить gttext, которая представляет собой бесплатное программное обеспечение для оптического распознавания символов и инструмент Ground Truthing для цветных изображений с текстом. Исходный код также доступен.

С этим вы можете получить признанные тексты, такие как:

Над кодом JAVA версия:
Спасибо @William

public static List<Rect> detectLetters(Mat img){
List<Rect> boundRect=new ArrayList<>();

Mat img_gray =new Mat(), img_sobel=new Mat(), img_threshold=new Mat(), element=new Mat();
Imgproc.cvtColor(img, img_gray, Imgproc.COLOR_RGB2GRAY);
Imgproc.Sobel(img_gray, img_sobel, CvType.CV_8U, 1, 0, 3, 1, 0, Core.BORDER_DEFAULT);
//at src, Mat dst, double thresh, double maxval, int type
Imgproc.threshold(img_sobel, img_threshold, 0, 255, 8);
element=Imgproc.getStructuringElement(Imgproc.MORPH_RECT, new Size(15,5));
Imgproc.morphologyEx(img_threshold, img_threshold, Imgproc.MORPH_CLOSE, element);
List<MatOfPoint> contours = new ArrayList<MatOfPoint>();
Mat hierarchy = new Mat();
Imgproc.findContours(img_threshold, contours,hierarchy, 0, 1);

List<MatOfPoint> contours_poly = new ArrayList<MatOfPoint>(contours.size());

for( int i = 0; i < contours.size(); i++ ){

MatOfPoint2f  mMOP2f1=new MatOfPoint2f();
MatOfPoint2f  mMOP2f2=new MatOfPoint2f();

contours.get(i).convertTo(mMOP2f1, CvType.CV_32FC2);
Imgproc.approxPolyDP(mMOP2f1, mMOP2f2, 2, true);
mMOP2f2.convertTo(contours.get(i), CvType.CV_32S);Rect appRect = Imgproc.boundingRect(contours.get(i));
if (appRect.width>appRect.height) {
boundRect.add(appRect);
}
}

return boundRect;
}

И используйте этот код на практике:

        System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
Mat img1=Imgcodecs.imread("abc.png");
List<Rect> letterBBoxes1=Utils.detectLetters(img1);

for(int i=0; i< letterBBoxes1.size(); i++)
Imgproc.rectangle(img1,letterBBoxes1.get(i).br(), letterBBoxes1.get(i).tl(),new Scalar(0,255,0),3,8,0);
Imgcodecs.imwrite("abc1.png", img1);

Реализация Python для решения @ dhanushka:

def process_rgb(rgb):
hasText = 0
gray = cv2.cvtColor(rgb, cv2.COLOR_BGR2GRAY);
morphKernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (3,3))
grad = cv2.morphologyEx(gray, cv2.MORPH_GRADIENT, morphKernel)
# binarize
_, bw = cv2.threshold(grad, 0.0, 255.0, cv2.THRESH_BINARY | cv2.THRESH_OTSU)
# connect horizontally oriented regions
morphKernel = cv2.getStructuringElement(cv2.MORPH_RECT, (9, 1))
connected = cv2.morphologyEx(bw, cv2.MORPH_CLOSE, morphKernel)
# find contours
mask = np.zeros(bw.shape[:2], dtype="uint8");
_,contours, hierarchy = cv2.findContours(connected, cv2.RETR_CCOMP, cv2.CHAIN_APPROX_SIMPLE)
# filter contours
idx = 0
while idx >= 0:
x,y,w,h = cv2.boundingRect(contours[idx]);
# fill the contour
cv2.drawContours(mask, contours, idx, (255, 255, 255), cv2.FILLED);
# ratio of non-zero pixels in the filled region
r = cv2.contourArea(contours[idx])/(w*h)
if(r > 0.45 and h > 5 and w > 5 and w > h):
cv2.rectangle(rgb, (x,y), (x+w,y+h), (0, 255, 0), 2)
hasText = 1
idx = hierarchy[0][idx][0]
return hasText, rgb