Opencv

Модули камеры для Raspberry Pi

Запись видео в условиях низкой освещённости

Sony Starvis замечательный сенсор для камер

Установка и настройка камеры для Raspberry Pi

$ sudo apt update

$ sudo apt full upgrade

sudo raspi-config

Съёмка фотографий с использованием raspistill

raspistill -v -o test.jpg

Запись видео с помощью raspivid

raspivid -o vid.h264

raspivid -o vid.h264 -t 30000

Настройка потокового вещания

raspivid -o - -t 0 -n | cvlc -vvv stream:///dev/stdin --sout '#rtp{sdp=rtsp://:8554/}' :demux=h264

Итоги

Ни для кого не секрет, что Python прочно занял первенство в ML и Data Science. А что если посмотреть на другие языки и платформы? Насколько в них удобно делать аналогичные решения?

К примеру, распознавание текста на картинке.

Среди текущих решений одним из наиболее распространённым инструментом является tesseract. В Python для него существует удобная библиотека, а для первоначальной обработки изображений, как правило, используется OpenCV. Для обоих этих инструментов есть исходные C++ библиотеки, поэтому их также возможно вызывать и из других экосистем. Попробуем это сделать в jvm и, в частности, на Kotlin.

Несколько слов о Kotlin. У него есть много удобных вещей для Data Science. В совокупности с экосистемой jvm получается статически типизированный Python на jvm. А не так давно ещё появилась возможность использовать Kotlin вместе с Apache Spark.

Первым делом установим tesseract. Его нужно установить отдельно на систему, согласно описанию из wiki. После установки можно проверить, что tesseract работает следующим образом:

tesseract input_file.jpg stdout -l eng --tessdata-dir /usr/local/share/tessdata/

Где --tessdata-dir путь до файлов tesseract (/usr/local/share/tessdata/ в macos). В случае успешной установки в stdout будет выведен распознанные текст.

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

implementation("net.sourceforge.tess4j:tess4j:4.5.3")

Для тех, кто не очень хорошо знаком с экосистемой jvm, есть лёгкий способ быстро себе всё настроить. Понадобится только установленная Java 13+. Её проще всего поставить через sdkman. Далее для удобства можно скачать Intellij IDEA, подойдёт и Community version. Основу проекта можно создать из IDE (new project -> Kotlin, gradle Kotlin) или можно клонировать репозиторий github, в котором перейти на ветку start.

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

 val api = Tesseract() api.setDatapath("/usr/local/share/tessdata/") api.setLanguage("eng") val image = ImageIO.read(File("input_file.jpg")) val result: String = api.doOCR(image)

Как видно, практически все команды совпадают с используемыми в вызове из командной строки. Но, как минимум, на macos нужно ещё дополнительно настроить системную переменную jna.library.path, в которую нужно добавить путь до dylib-библиотеки tesseract.

val libPath = "/usr/local/lib"val libTess = File(libPath, "libtesseract.dylib")if (libTess.exists()) {    val jnaLibPath = System.getProperty("jna.library.path")    if (jnaLibPath == null) {        System.setProperty("jna.library.path", libPath)    } else {        System.setProperty("jna.library.path", libPath + File.pathSeparator + jnaLibPath)    }}

После всех настроек можно попробовать запустить распознавание для того же файла и результат должен полностью соответствовать вызову из командной строки.

Перейдём теперь к обработке изображений с OpenCV. В Python для работы с ней не требуется ставить каких-либо дополнительных инструментов, кроме пакета в pip. В описании OpenCV под java указан порядок установки, когда всё ставится отдельно. Для самой jvm-экосистемы подход, когда требуются установки каких-либо нативных библиотек, не совсем привычен. Чаще всего если зависимости требуется какие-либо дополнительные библиотеки, то либо она сама их скачивает (как, например, djl-pytorch), либо при подключении через систему сборки внутри себя уже содержит библиотеки под различные операционные системы. К счастью, для OpenCV есть такая сборка, которой и воспользуемся:

implementation("org.openpnp:opencv:4.3.0-2")

Перед началом работы с OpenCV потребуется подгрузить нативные библиотеки через:

nu.pattern.OpenCV.loadLocally()

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

 Imgproc.cvtColor(mat, mat, Imgproc.COLOR_BGR2GRAY)

Как вы уже обратили внимание, аргументом для OpenCV выступает Mat, который представляет из себя основной класс-обёртку вокруг изображения в OpenCV в jvm, похожий на привычный BufferedImage.

Сам экземпляр Mat можно получить привычным для Python кода вызовом imread:

val mat = Imgcodecs.imread("input.jpg")

В таком виде экземпляр можно дальше передавать в OpenCV и проделывать с ним различные манипуляции. Но для Java общепринятым является BufferedImage, вокруг которого, как правило, уже может быть выстроен pipeline загрузки и обработки изображения. В связи с чем возникает необходимость конвертации BufferedImage в Mat:

val image: BufferedImage = ...val pixels = (image.raster.dataBuffer as DataBufferByte).dataval mat = Mat(image.height, image.width, CvType.CV_8UC3)            .apply { put(0, 0, pixels) }

И обратной конвертации Mat в BufferedImage:

val mat = ...var type = BufferedImage.TYPE_BYTE_GRAYif (mat.channels() > 1) {    type = BufferedImage.TYPE_3BYTE_BGR}val bufferSize = mat.channels() * mat.cols() * mat.rows()val b = ByteArray(bufferSize)mat[0, 0, b] // get all the pixelsval image = BufferedImage(mat.cols(), mat.rows(), type)val targetPixels = (image.raster.dataBuffer as DataBufferByte).dataSystem.arraycopy(b, 0, targetPixels, 0, b.size)

В частности, тот же tesseract в методе doOCR поддерживает как файл, так и BufferedImage. Используя вышеописанные преобразования, можно вначале обработать изображения с помощью OpenCV, преобразовать Mat в Bufferedimage и передать подготовленное изображение на вход tesseract.

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

Для начала проверим результат нахождения текста на изображении без обработки. И вместо метода doOCR будем использовать getWords, чтобы получить ещё confidence (score в Python-библиотеке) для каждого найденного слова:

val image = ImageIO.read(URL("http://img.ifcdn.com/images/b313c1f095336b6d681f75888f8932fc8a531eacd4bc436e4d4aeff7b599b600_1.jpg"))val result = api.getWords(preparedImage, ITessAPI.TessPageIteratorLevel.RIL_WORD)

В результате будет найден только разный мусор:

[ie, [Confidence: 2.014679 Bounding box: 100 0 13 14], bad [Confidence: 61.585358 Bounding box: 202 0 11 14], oy [Confidence: 24.619446 Bounding box: 21 68 18 22], ' [Confidence: 4.998787 Bounding box: 185 40 11 18], | [Confidence: 60.889648 Bounding box: 315 62 4 14], ae. [Confidence: 27.592728 Bounding box: 0 129 320 126], c [Confidence: 0.000000 Bounding box: 74 301 3 2], ai [Confidence: 24.988930 Bounding box: 133 283 41 11], ee [Confidence: 27.483231 Bounding box: 186 283 126 41]]

Если внимательней посмотреть на изображение, то можно увидеть, что шрифт для текста белый, а значит, можно попробовать использовать threshold вместе с последующей инверсией, чтобы оставить текст только на картинке:

Пробуем следующие преобразования:

// convert to grayImgproc.cvtColor(mat, mat, Imgproc.COLOR_BGR2GRAY)// text -> white, other -> blackImgproc.threshold(mat, mat, 244.0, 255.0, Imgproc.THRESH_BINARY)// inverse Core.bitwise_not(mat, mat)

После них посмотрим на картинку в результате (которую можно сохранить в файл через Imgcodecs.imwrite("output.jpg", mat) )

Теперь если посмотреть на результаты вызова getWords, то получим следующее:

[WHEN [Confidence: 94.933418 Bounding box: 48 251 52 14], SHE [Confidence: 95.249252 Bounding box: 109 251 34 15], CATCHES [Confidence: 95.973259 Bounding box: 151 251 80 15], YOU [Confidence: 96.446579 Bounding box: 238 251 33 15], CHEATING [Confidence: 96.458656 Bounding box: 117 278 86 15]]

Как видно, весь текст успешно распознался.

Итоговый код по обработке изображения будет выглядеть следующим образом:

import net.sourceforge.tess4j.ITessAPIimport net.sourceforge.tess4j.Tesseractimport nu.pattern.OpenCVimport org.opencv.core.Coreimport org.opencv.core.CvTypeimport org.opencv.core.Matimport org.opencv.imgproc.Imgprocimport java.awt.image.BufferedImageimport java.awt.image.DataBufferByteimport java.io.Fileimport java.net.URLimport javax.imageio.ImageIOfun main() {    setupOpenCV()    setupTesseract()    val image = ImageIO.read(URL("http://img.ifcdn.com/images/b313c1f095336b6d681f75888f8932fc8a531eacd4bc436e4d4aeff7b599b600_1.jpg"))    val mat = image.toMat()    Imgproc.cvtColor(mat, mat, Imgproc.COLOR_BGR2GRAY)    Imgproc.threshold(mat, mat, 244.0, 255.0, Imgproc.THRESH_BINARY)    Core.bitwise_not(mat, mat)    val preparedImage = mat.toBufferedImage()    val api = Tesseract()    api.setDatapath("/usr/local/share/tessdata/")    api.setLanguage("eng")    val result = api.getWords(preparedImage, ITessAPI.TessPageIteratorLevel.RIL_WORD)    println(result)}private fun setupTesseract() {    val libPath = "/usr/local/lib"    val libTess = File(libPath, "libtesseract.dylib")    if (libTess.exists()) {        val jnaLibPath = System.getProperty("jna.library.path")        if (jnaLibPath == null) {            System.setProperty("jna.library.path", libPath)        } else {            System.setProperty("jna.library.path", libPath + File.pathSeparator + jnaLibPath)        }    }}private fun setupOpenCV() {    OpenCV.loadLocally()}private fun BufferedImage.toMat(): Mat {    val pixels = (raster.dataBuffer as DataBufferByte).data    return Mat(height, width, CvType.CV_8UC3)        .apply { put(0, 0, pixels) }}private fun Mat.toBufferedImage(): BufferedImage {    var type = BufferedImage.TYPE_BYTE_GRAY    if (channels() > 1) {        type = BufferedImage.TYPE_3BYTE_BGR    }    val bufferSize = channels() * cols() * rows()    val b = ByteArray(bufferSize)    this[0, 0, b] // get all the pixels    val image = BufferedImage(cols(), rows(), type)    val targetPixels = (image.raster.dataBuffer as DataBufferByte).data    System.arraycopy(b, 0, targetPixels, 0, b.size)    return image}

Если сравнить полученный код с Python-версией, то разница будет минимальная. Производительность тоже должна быть практически сравнимой (за исключением, быть может, чуть больших преобразований изображения между Mat и BufferedImage).

Преимущество Python в рамках текущего примера будет только в бесшовной передаче изображений между OpenCV и tesseract. Экосистема Python сама по себе удобна тем, что все библиотеки общаются одними и теми же типами.

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

Python на текущий момент, беcспорно, лидер в ML. И в первую очередь все инструменты и библиотеки появляются на нём. Тем не менее, в других экосистемах можно использовать те же инструменты. Особенно учитывая, что если что-то есть под Python, то должна быть и нативная библиотека, которую можно легко подключить.

Надеюсь, что в этой статье вы нашли для себя что-нибудь полезное и новое. Спасибо за внимание, и напоследок несколько полезных ссылок:

https://djl.ai/ Deep Learning на jvm, где можно подключать модели из pytorch и tensorflow
https://deeplearning4j.org/ аналогичное решение с возможностью обучать модели и импортировать существующие на tensorflow и keras
https://kotlinlang.org/docs/reference/data-science-overview.html разные полезные вещи по Data Science на Kotlin (и Java)

Весь код доступен в репозитории https://github.com/evgzakharov/kotlin_tesseract.

Ищем цель

Подготовка

• opencv-python
• Pillow
• selenium

Управление браузером

wait(self.__driver, 20).until(EC.frame_to_be_available_and_switch_to_it((By.ID, "iframe-game")))self.__canvas = wait(self.__driver, 20).until(EC.visibility_of_element_located((By.XPATH, "/html/body/canvas")))

from selenium import webdriverfrom selenium.webdriver.support import expected_conditions as ECfrom selenium.webdriver.support.ui import WebDriverWait as waitfrom selenium.webdriver.common.by import Byclass Browser:    def __init__(self, game_url):        self.__driver = webdriver.Firefox()        self.__driver.get(game_url)        wait(self.__driver, 20).until(EC.frame_to_be_available_and_switch_to_it((By.ID, "iframe-game")))        self.__canvas = wait(self.__driver, 20).until(EC.visibility_of_element_located((By.XPATH, "/html/body/canvas")))    def screenshot(self):        return self.__canvas.screenshot_as_png    def quit(self):        self.__driver.quit()    def click(self, click_point):        action = webdriver.common.action_chains.ActionChains(self.__driver)        action.move_to_element_with_offset(self.__canvas, click_point[0], click_point[1]).click().perform()

Состояния игры

• Приветственный экран
• Экран выбора уровня
• Выбор цвета на обучающем уровне
• Выбор области на обучающем уровне
• Выбор цвета
• Выбор области
• Результат хода

class Robot:    STATE_START = 0x01    STATE_SELECT_LEVEL = 0x02    STATE_TRAINING_SELECT_COLOR = 0x03    STATE_TRAINING_SELECT_AREA = 0x04    STATE_GAME_SELECT_COLOR = 0x05    STATE_GAME_SELECT_AREA = 0x06    STATE_GAME_RESULT = 0x07    def __init__(self):        self.states = {            self.STATE_START: self.state_start,            self.STATE_SELECT_LEVEL: self.state_select_level,            self.STATE_TRAINING_SELECT_COLOR: self.state_training_select_color,            self.STATE_TRAINING_SELECT_AREA: self.state_training_select_area,            self.STATE_GAME_RESULT: self.state_game_result,            self.STATE_GAME_SELECT_COLOR: self.state_game_select_color,            self.STATE_GAME_SELECT_AREA: self.state_game_select_area,        }

import timeimport cv2import numpyfrom PIL import Imagefrom io import BytesIOclass Robot:    def __init__(self):# self.screenshot = []        self.state_next_success_condition = None          self.state_start_time = 0          self.state_timeout = 0         self.state_current = 0         self.state_next = 0      def run(self, screenshot):        self.screenshot = cv2.cvtColor(numpy.array(Image.open(BytesIO(screenshot))), cv2.COLOR_BGR2RGB)        if self.state_current != self.state_next:            if self.state_next_success_condition():                self.set_state_current()            elif time.time() - self.state_start_time >= self.state_timeout                    self.state_next = self.state_current            return False        else:            try:                return self.states[self.state_current]()            except KeyError:                self.__del__()    def set_state_current(self):        self.state_current = self.state_next    def set_state_next(self, state_next, state_next_success_condition, state_timeout):        self.state_next_success_condition = state_next_success_condition        self.state_start_time = time.time()        self.state_timeout = state_timeout        self.state_next = state_next

# class Robot:   DEFAULT_STATE_TIMEOUT = 10      #     def state_start(self):        # пытаемся получить координату кнопки Play        #         if button_play is False:            return False        self.set_state_next(self.STATE_SELECT_LEVEL, self.state_select_level_condition, self.DEFAULT_STATE_TIMEOUT)        return button_play    def state_select_level_condition(self):        # содержит ли скриншот выбор уровней# 

Зрение бота

Пороговая обработка изображения

    COLOR_BLUE = 0x01      COLOR_ORANGE = 0x02    COLOR_RED = 0x03    COLOR_GREEN = 0x04    COLOR_YELLOW = 0x05    COLOR_WHITE = 0x06    COLOR_ALL = 0x07

image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)_, thresh = cv2.threshold(image, 0, 255, cv2.THRESH_OTSU)

Цветовая сегментация

import cv2import numpy as numpyimage_path = "tests_data/SELECT_LEVEL.png"hsv_max_upper = 0, 0, 0hsv_min_lower = 255, 255, 255def bite_range(value):    value = 255 if value > 255 else value    return 0 if value < 0 else valuedef pick_color(event, x, y, flags, param):    if event == cv2.EVENT_LBUTTONDOWN:        global hsv_max_upper        global hsv_min_lower        global image_hsv        hsv_pixel = image_hsv[y, x]        hsv_max_upper = bite_range(max(hsv_max_upper[0], hsv_pixel[0]) + 1), \                        bite_range(max(hsv_max_upper[1], hsv_pixel[1]) + 1), \                        bite_range(max(hsv_max_upper[2], hsv_pixel[2]) + 1)        hsv_min_lower = bite_range(min(hsv_min_lower[0], hsv_pixel[0]) - 1), \                        bite_range(min(hsv_min_lower[1], hsv_pixel[1]) - 1), \                        bite_range(min(hsv_min_lower[2], hsv_pixel[2]) - 1)        print('HSV range: ', (hsv_min_lower, hsv_max_upper))        hsv_mask = cv2.inRange(image_hsv, numpy.array(hsv_min_lower), numpy.array(hsv_max_upper))        cv2.imshow("HSV Mask", hsv_mask)image = cv2.imread(image_path)cv2.namedWindow('Original')cv2.setMouseCallback('Original', pick_color)image_hsv = cv2.cvtColor(image, cv2.COLOR_BGR2HSV)cv2.imshow("Original", image)cv2.waitKey(0)cv2.destroyAllWindows()

    COLOR_HSV_RANGE = {   COLOR_BLUE: ((112, 151, 216), (128, 167, 255)),   COLOR_ORANGE: ((8, 251, 93), (14, 255, 255)),   COLOR_RED: ((167, 252, 223), (171, 255, 255)),   COLOR_GREEN: ((71, 251, 98), (77, 255, 211)),   COLOR_YELLOW: ((27, 252, 51), (33, 255, 211)),   COLOR_WHITE: ((0, 0, 159), (7, 7, 255)),}

Поиск контуров

thresh = cv2.inRange(image, self.COLOR_HSV_RANGE[self.COLOR_RED][0], self.COLOR_HSV_RANGE[self.COLOR_RED][1])contours, _ = cv2.findContours(thresh, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE

Удаление шума

squares = []        for cnt in contours:            rect = cv2.minAreaRect(cnt)            square = cv2.boxPoints(rect)            square = numpy.int0(square)            (_, _, w, h) = cv2.boundingRect(square)            a = max(w, h)            b = min(w, h)            if numpy.unique(square).shape[0] <= 4 and a <= b * 3:                squares.append(numpy.array([[square[0]], [square[1]], [square[2]], [square[3]]]))

Объединение контуров

        image_zero = numpy.zeros_like(image)        image_zero = cv2.cvtColor(image_zero, cv2.COLOR_BGR2RGB)        cv2.drawContours(image_zero, contours_of_squares, -1, (255, 255, 255), -1)  _, thresh = cv2.threshold(image_zero, 0, 255, cv2.THRESH_OTSU)  kernel = numpy.ones((5, 5), numpy.uint8)        thresh = cv2.dilate(thresh, kernel, iterations=1)        dilate_contours, _ = cv2.findContours(thresh, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)

digit_contours = [cnt for cnt in digit_contours if cv2.contourArea(cnt) > 500]

# ...class Robot:         # ...        def get_dilate_contours(self, image, color_inx, distance):        thresh = self.get_color_thresh(image, color_inx)        if thresh is False:            return []        kernel = numpy.ones((distance, distance), numpy.uint8)        thresh = cv2.dilate(thresh, kernel, iterations=1)        contours, _ = cv2.findContours(thresh, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)        return contours    def get_color_thresh(self, image, color_inx):        if color_inx == self.COLOR_ALL:            image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)            _, thresh = cv2.threshold(image, 0, 255, cv2.THRESH_OTSU)        else:            image = cv2.cvtColor(image, cv2.COLOR_BGR2HSV)            thresh = cv2.inRange(image, self.COLOR_HSV_RANGE[color_inx][0], self.COLOR_HSV_RANGE[color_inx][1])        return threshdef filter_contours_of_rectangles(self, contours):        squares = []        for cnt in contours:            rect = cv2.minAreaRect(cnt)            square = cv2.boxPoints(rect)            square = numpy.int0(square)            (_, _, w, h) = cv2.boundingRect(square)            a = max(w, h)            b = min(w, h)            if numpy.unique(square).shape[0] <= 4 and a <= b * 3:                squares.append(numpy.array([[square[0]], [square[1]], [square[2]], [square[3]]]))        return squares    def get_contours_of_squares(self, image, color_inx, square_inx):        thresh = self.get_color_thresh(image, color_inx)        if thresh is False:            return False        contours, _ = cv2.findContours(thresh, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)        contours_of_squares = self.filter_contours_of_rectangles(contours)        if len(contours_of_squares) < 1:            return False        image_zero = numpy.zeros_like(image)        image_zero = cv2.cvtColor(image_zero, cv2.COLOR_BGR2RGB)        cv2.drawContours(image_zero, contours_of_squares, -1, (255, 255, 255), -1)        dilate_contours = self.get_dilate_contours(image_zero, self.COLOR_ALL, 5)        dilate_contours = [cnt for cnt in dilate_contours if cv2.contourArea(cnt) > 500]        if len(dilate_contours) < 1:            return False        else:            return dilate_contours

Распознание цифр

# class Robot:    # ...    SQUARE_BIG_SYMBOL = 0x01    SQUARE_SIZES = {        SQUARE_BIG_SYMBOL: 9,      }    IMAGE_DATA_PATH = "data/"     def __init__(self):        # ...        self.dilate_contours_bi_data = {}         for image_file in os.listdir(self.IMAGE_DATA_PATH):            image = cv2.imread(self.IMAGE_DATA_PATH + image_file)            contour_inx = os.path.splitext(image_file)[0]            color_inx = self.COLOR_RED            dilate_contours = self.get_dilate_contours_by_square_inx(image, color_inx, self.SQUARE_BIG_SYMBOL)            self.dilate_contours_bi_data[contour_inx] = dilate_contours[0]    def get_dilate_contours_by_square_inx(self, image, color_inx, square_inx):        distance = math.ceil(self.SQUARE_SIZES[square_inx] / 2)        return self.get_dilate_contours(image, color_inx, distance)

cv2.matchShapes(dilate_contour, self.dilate_contours_bi_data['digit_' + str(digit)], cv2.CONTOURS_MATCH_I1, 0)

# class Robot:    #     def scan_digits(self, image, color_inx, square_inx):        result = []        contours_of_squares = self.get_contours_of_squares(image, color_inx, square_inx)        before_digit_x, before_digit_y = (-100, -100)        if contours_of_squares is False:            return result        for contour_of_square in reversed(contours_of_squares):            crop_image = self.crop_image_by_contour(image, contour_of_square)            dilate_contours = self.get_dilate_contours_by_square_inx(crop_image, self.COLOR_ALL, square_inx)            if (len(dilate_contours) < 1):                continue            dilate_contour = dilate_contours[0]            match_shapes = {}            for digit in range(0, 10):                match_shapes[digit] = cv2.matchShapes(dilate_contour, self.dilate_contours_bi_data['digit_' + str(digit)], cv2.CONTOURS_MATCH_I1, 0)            min_match_shape = min(match_shapes.items(), key=lambda x: x[1])            if len(min_match_shape) > 0 and (min_match_shape[1] < self.MAX_MATCH_SHAPES_DIGITS):                digit = min_match_shape[0]                rect = cv2.minAreaRect(contour_of_square)                box = cv2.boxPoints(rect)                box = numpy.int0(box)                (digit_x, digit_y, digit_w, digit_h) = cv2.boundingRect(box)                if abs(digit_y - before_digit_y) < digit_y * 0.3 and abs(                        digit_x - before_digit_x) < digit_w + digit_w * 0.5:                    result[len(result) - 1][0] = int(str(result[len(result) - 1][0]) + str(digit))                else:                    result.append([digit, self.get_contour_centroid(contour_of_square)])                before_digit_x, before_digit_y = digit_x + (digit_w / 2), digit_y        return result

# class Robot:    # def get_contour_centroid(self, contour):        moments = cv2.moments(contour)        return int(moments["m10"] / moments["m00"]), int(moments["m01"] / moments["m00"])

if digit == 6 or digit == 9:    extreme_bottom_point = digit_contour[digit_contour[:, :, 1].argmax()].flatten()    x_points = digit_contour[:, :, 0].flatten()    extreme_right_points_args = numpy.argwhere(x_points == numpy.amax(x_points))    extreme_right_points = digit_contour[extreme_right_points_args]    extreme_top_right_point = extreme_right_points[extreme_right_points[:, :, :, 1].argmin()].flatten()    if extreme_top_right_point[1] > round(extreme_bottom_point[1] / 2):        digit = 6    else:        digit = 9if digit == 2 or digit == 5:    extreme_right_point = digit_contour[digit_contour[:, :, 0].argmax()].flatten()    y_points = digit_contour[:, :, 1].flatten()    extreme_top_points_args = numpy.argwhere(y_points == numpy.amin(y_points))    extreme_top_points = digit_contour[extreme_top_points_args]    extreme_top_right_point = extreme_top_points[extreme_top_points[:, :, :, 0].argmax()].flatten()    if abs(extreme_right_point[0] - extreme_top_right_point[0]) > 0.05 * extreme_right_point[0]:        digit = 2    else:        digit = 5

Анализируем игровое поле

class ColorArea:         def __init__(self, color_inx, click_point, contour):            self.color_inx = color_inx  # индекс цвета            self.click_point = click_point  # клик поинт области            self.contour = contour  # контур области            self.neighbors = []  # индексы соседей

image[pt1[1]:pt2[1], pt1[0]:pt2[0]]

        self.color_areas = []        self.color_areas_color_count = [0] * self.SELECT_COLOR_COUNT        image = self.crop_image_by_rectangle(self.screenshot, numpy.array(self.GAME_MAIN_AREA))        for color_inx in range(1, self.SELECT_COLOR_COUNT + 1):            dilate_contours = self.get_dilate_contours(image, color_inx, 10)            for dilate_contour in dilate_contours:                click_point = tuple(                    dilate_contour[dilate_contour[:, :, 1].argmin()].flatten() + [0, int(self.CLICK_AREA)])                self.color_areas_color_count[color_inx - 1] += 1                color_area = self.ColorArea(color_inx, click_point, dilate_contour)                self.color_areas.append(color_area)

Связываем области

        blank_image = numpy.zeros_like(image)        blank_image = cv2.cvtColor(blank_image, cv2.COLOR_BGR2GRAY)        for color_area_inx_1 in range(0, len(self.color_areas)):            for color_area_inx_2 in range(color_area_inx_1 + 1, len(self.color_areas)):                color_area_1 = self.color_areas[color_area_inx_1]                color_area_2 = self.color_areas[color_area_inx_2]                if color_area_1.color_inx == color_area_2.color_inx:                    continue                common_image = cv2.drawContours(blank_image.copy(), [color_area_1.contour, color_area_2.contour], -1, (255, 255, 255), cv2.FILLED)                kernel = numpy.ones((15, 15), numpy.uint8)                common_image = cv2.dilate(common_image, kernel, iterations=1)                common_contour, _ = cv2.findContours(common_image, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)                if len(common_contour) == 1:self.color_areas[color_area_inx_1].neighbors.append(color_area_inx_2)self.color_areas[color_area_inx_2].neighbors.append(color_area_inx_1)

Ищем оптимальный ход

if self.color_areas_color_count[color_area.color_inx - 1] == 1:   select_color_weight = [x + 10 for x in select_color_weight]

for color_inx in range(0, len(select_color_weight)):   color_count = select_color_weight[color_inx]   if color_count != 0 and self.color_areas_color_count[color_inx] == color_count:      select_color_weight[color_inx] += 10

for select_color_weight_inx in color_area.neighbors:   neighbor_color_area = self.color_areas[select_color_weight_inx]   select_color_weight[neighbor_color_area.color_inx - 1] += 1

max_index = select_color_weights.argmax()self.color_area_inx_next = max_index // self.SELECT_COLOR_COUNTselect_color_next = (max_index % self.SELECT_COLOR_COUNT) + 1self.set_select_color_next(select_color_next)

# class Robot:    # def scan_color_areas(self):        self.color_areas = []        self.color_areas_color_count = [0] * self.SELECT_COLOR_COUNT        image = self.crop_image_by_rectangle(self.screenshot, numpy.array(self.GAME_MAIN_AREA))        for color_inx in range(1, self.SELECT_COLOR_COUNT + 1):            dilate_contours = self.get_dilate_contours(image, color_inx, 10)            for dilate_contour in dilate_contours:                click_point = tuple(                    dilate_contour[dilate_contour[:, :, 1].argmin()].flatten() + [0, int(self.CLICK_AREA)])                self.color_areas_color_count[color_inx - 1] += 1                color_area = self.ColorArea(color_inx, click_point, dilate_contour, [0] * self.SELECT_COLOR_COUNT)                self.color_areas.append(color_area)        blank_image = numpy.zeros_like(image)        blank_image = cv2.cvtColor(blank_image, cv2.COLOR_BGR2GRAY)        for color_area_inx_1 in range(0, len(self.color_areas)):            for color_area_inx_2 in range(color_area_inx_1 + 1, len(self.color_areas)):                color_area_1 = self.color_areas[color_area_inx_1]                color_area_2 = self.color_areas[color_area_inx_2]                if color_area_1.color_inx == color_area_2.color_inx:                    continue                common_image = cv2.drawContours(blank_image.copy(), [color_area_1.contour, color_area_2.contour],                                                -1, (255, 255, 255), cv2.FILLED)                kernel = numpy.ones((15, 15), numpy.uint8)                common_image = cv2.dilate(common_image, kernel, iterations=1)                common_contour, _ = cv2.findContours(common_image, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)                if len(common_contour) == 1:                    self.color_areas[color_area_inx_1].neighbors.append(color_area_inx_2)                    self.color_areas[color_area_inx_2].neighbors.append(color_area_inx_1)    def analysis_color_areas(self):        select_color_weights = []        for color_area_inx in range(0, len(self.color_areas)):            color_area = self.color_areas[color_area_inx]            select_color_weight = numpy.array([0] * self.SELECT_COLOR_COUNT)            for select_color_weight_inx in color_area.neighbors:                neighbor_color_area = self.color_areas[select_color_weight_inx]                select_color_weight[neighbor_color_area.color_inx - 1] += 1            for color_inx in range(0, len(select_color_weight)):                color_count = select_color_weight[color_inx]                if color_count != 0 and self.color_areas_color_count[color_inx] == color_count:                    select_color_weight[color_inx] += 10            if self.color_areas_color_count[color_area.color_inx - 1] == 1:                select_color_weight = [x + 10 for x in select_color_weight]            color_area.set_select_color_weights(select_color_weight)            select_color_weights.append(select_color_weight)        select_color_weights = numpy.array(select_color_weights)        max_index = select_color_weights.argmax()        self.color_area_inx_next = max_index // self.SELECT_COLOR_COUNT        select_color_next = (max_index % self.SELECT_COLOR_COUNT) + 1        self.set_select_color_next(select_color_next)

Вывод

Привет Хабр!

В прошлый раз писал про проект по рентгеновской инспекции печатных плат. Сейчас мы сильно продвинулись, есть рабочий прототип софта плюс потыкали палочкой в Эльбрус. Про этот опыт я и хочу рассказать.

Интро

На старте проекта нам удалось найти дополнительное финансирование, основным условием была работа ПО полная кроссплатформенность, в том числе поддержка отечественных процессоров. На тот момент наиболее производительным вариантом для десктоп машин был Эльбрус 8С (пока он им и остается, 8СВ еще вроде не вышел). Мы купили две станции Эльбрус 801-РС напрямую от МЦСТ. Сейчас их стоимость указана на сайте, год назад были чуть дороже.

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

Операционные системы

По ситуации на начало 2020го года при заказе можно выбрать предустановленную ОС: оригинальную Эльбрус или партнерскую (Альт, Астра). В нашем проекте используется Астра Linux. Она хоть и была доступна официально, но по факту не получилось заказать за адекватное время. Ставили сами с лайв образа отдельной лицензией.

Выбор той или иной ОС дело вкуса, мне понравилось окружение Fly в Астре, субъективно оно шустрее. С другой стороны, пакетная база Альта шире, они теснее сотрудничают с МЦСТ и набор дистрибутивов интереснее.
Пример не существовал USB лайв образ Астры под Эльбрус, а для Альта их было аж несколько штук. Бэкап раздела Астры работал только из-под лайв образа Альта.

Сама ОС Эльбрус изначально разрабатывалась для демо процессора заказчикам. Мы начинали с версии 4.0, сейчас рабочая 5.0rc2 стало лучше, но все же она сыровата для конечного пользователя. Нужна для отладки или получения максимума от VLIW архитектуры. Именно на этой ОС производительность при обработке изображений была максимальной.

UPD: сейчас вышла версия ОС Эльбрус 6.0. Там заявлены C++20 и свежее ядро Linux, но так как мы работаем на Астра обновления еще не добрались.

Архитектура

Пока только С++, 14-ый стандарт, про CUDA и Vulkan лучше не думать, а вот OpenGL на AMD видеокартах работает нормально. Важно OpenGL не старше 3.1, QT 5.11.
По остальным ЯП возможно кто-то поделится свои опытом в комментариях. Знаю, что идет работа в закрытых конторах, в основном по обработке видеопотока и изображений. Понемногу народ осваивает отечественные процессоры.

Теперь слово архитектору проекта, Максиму Титову (titovmaxim, Unicore Solutions)
Наша цель сделать хороший софт для работы с рентгенографическими системами. Поэтому начали с главного подключения железа и тракта обработки изображений. Сильно волновались. TLDR: все прошло гладко.

Главная часть системы детектор рентгеновского излучения. Подключается по Ethernet и забивает канал 1Гбит под завязку, протокол GigE Vision. Коммерческие библиотеки под Эльбрус отсутствуют, библиотеки с открытым исходным кодом (например Aravis) не подходят по скорости и качеству, так что писали свою реализацию.

Столкнулись с тем, что встроенная сетевая карта материнской платы Эльбруса сильно нагружает процессор, и 1ГБит просто так не получить, теряются кадры. Пришлось дописывать дополнительный быстрый промежуточный буфер, чтобы разгрузить поток приема. Обрабатываем все потом в отдельных потоках. Все заработало, канал забивается полностью, потерь кадров нет. При установке на Эльбрус дискретной карты проблем становится заметно меньше.

Предварительная обработка изображений в реальном времени реализована на OpenGL, т.к. это единственное средство, доступное нам на всех платформах. В нее входит применение калибровки и коррекция битых пикселей детектора, обработка гистограммы, гамма коррекция, повышение резкости и подавление шума, раскраска полутонов, геометрические преобразования. Интересно было написать быструю оценку гистограммы изображения на OpenGL, а не CUDA, задача не совсем типичная.
Итого на обработку одного кадра 3000x3000 16 бит на самой слабой видеокарте (AMD R5) на Эльбрусе уходит ~33 мс. Очень даже неплохо, при условии независимости от ОС и полной разгрузки ЦП для задач сложной пост-обработки. Уже доступны более мощные видеокарты, так что здесь мы спокойны. К примеру, на x86 с GeForce RTX 2070 Max-Q мы получаем стабильные ~2мс, ждем подобного на Эльбрус
Подключение прочих компонентов рентгеновских генераторов и мехатроники по RS232, Web камер по UVC, прошло без проблем.

В проекте мы используем Qt 5.11 и QML для интерфейса. Здесь все прошло неожиданно гладко. Работает, заводится "из-коробки", основные пакеты в Астра есть. Ждем, когда будут доступны обновления, поскольку в 5.11 есть шероховатости и баги.
Немного о том, почему мы опасались C++ 14. Активное совместное использование C++ и QML часто вызывает сложности, поэтому мы решили использовать в проекте cвою библиотеку Flow.

Библиотека Flow

Среди плюсов библиотеки декларативность, сокращение boilerplate кода и ошибок. Помогает использовать ФП подход на С++, в частности есть гибкое объединение и композиция функций, ленивость, кеширование, потокобезопасность и фоновое выполнения в других потоках. Последнее, кстати, актуально для OpenGL, который не очень умеет в многопоточность. Все это в динамике с оповещением об изменениях (никаких update) отстыковки/пристыковки веток, действия (эффекты в смысле ФП), интегрированы с контекстами Qt. Из приятного автоматический контроль времени жизни объектов и подписок без ручных subscribe/unsubscribe и беспокойств, кто кого переживёт, все само :) Немного похоже на ReactiveX, но тут больше про состояния, а не про потоки данных.

Там же живет своя мета-система (в C++ рефлексию не завезли), используем вместо QMetaObject. Писать меньше, лучше интегрируется с QML (примерно, как WPF с C#), можно свободно перемещаться по дереву, в частности работать из QML с QVector в середине дерева как с моделью с умным diffом (без написания QAbstractItemModel), автоматическая сериализация/десериализация любого объекта одной командой и пр.
Библиотека изначально была рассчитана минимум на C++ 17. При переходе на C++ 14 мы, естественным образом, потеряли вывод типов и сейчас приходится прописывать большинство шаблонных параметров руками. Однако прогресс МЦСТ впечатляет, ждем новых компиляторов. Была пара особенностей компилятора Эльбрус, не замеченных ранее на GCC и MSVC. Не всегда понимаются auto параметры в лямбдах. Не умеет перезахватывать this во вложенные лямбды. Но это легко правится, в остальном все компилируется и работает без проблем. Да, ошибки компилятора на русском языке немного непривычны
Вследствие особенностей архитектуры на Эльбус не рекомендуется использовать исключения. Поэтому мы сразу отказались от них в нагруженных частях. Однако достаточно широко используем их на верхнем уровне, где операции единичные. Все работает как положено, зря боялись. Да, пока не завезли -fnon-call-exceptions для удобного отлова ошибок уровня системы и их обработки на месте возникновения.
Приятно, что можно большую часть кода писать "дома" на Linux под x86 и потом просто собирать на удаленной машине Эльбруса. При некоторой сноровке проблем с совместимостью кода почти не возникает.

Производительность OpenCV

Наиболее критичные вещи по обработке видеопотока вынесены на видеокарту, для неторопливой пост-обработки изображений используем OpenCV 3.2. Этот пакет портирован на Эльбрус, но есть нюанс производительность сильно зависит от версии пакета для конкретной ОС. См. таблицу по сравнению производительности пакетов OpenCV на Эльбрус 8С (1300 МГц) и Intel core i7 (2600 МГц) под разными ОС/сборками openCV:

Производительность OpenCV на Эльбрусах напрямую завязана на низкоуровневые EML библиотеки (см. руководство по программированию МЦСТ, они оптимизированы под VLIW архитектуру). А пакеты EML зависит уже от дистрибутива ОС. В используемой нами Астре свежая сборка до сих пор не появилась, возможно она есть в Альт Линукс. Кто игрался напишите в комментариях.
Если говорить про рутину свертку изображений, то производительность может быть в 2 раза лучше (16S) по сравнению с i7, а может быть и в 2 раза хуже (32F). На сборке ОС с неоптимизированной библиотекой OpenCV проигрыш в производительности до 20 раз. И да, с 16U у Эльбруса пока все плохо.

Резюме

Жить на Эльбрусе можно. Постепенно МЦСТ и партнеры (Альт, Астра) допиливают ПО, улучшают сервис, снижают цены. Это радует.
С другой стороны их ресурсы ограничены, чего-то нужного именно вам можно ждать полгода.
Возможно правительство станет более активно продвигать отечественные процессоры и стимулировать их коммерческую эксплуатацию, посмотрим. Мы в любом случае к этому готовы.

• Мой обзор будет со стороны ComputerVision. Не стоит забывать что ML это не только CV. Это ещё классические алгоритмы бустинга, это различный NLP (от трансформеров до синтеза речи). И далеко не все задачи ML можно будет исполнять на тех фреймворках про которые я буду говорить.
• Из обозначенных технологий я сам работал где-то с третью. Про остальные читал/минимально щупал/общался с людьми которые интегрировали. Отсюда могут возникнуть какие-то ошибки в статье. Если вы видите что-то что вас покоробило/с чем вы не согласны пишите в комментариях/в личку попробую поправить.
• Мир стремительно меняется. Я пробую верифицировать то что пишу на момент выхода статьи. Но не факт что даже существующая документация соответствует истинному положению дел. Не говоря уже о том, что в ближайшие пару недель любой из указанных фреймворков может катастрофически измениться. Если вдруг такие апдейты вам будут интересны то скорее всего я буду разбирать их в своём блоге CVML (он же в телеге), где я такую мелочь пишу. Тут буду стараться оставлять ссылки на разбор.

Часть 1. Что такое инференс

• обучение
• использование

Часть 2. Железо.

• Серверный инференс. Мы не полезем в него глубоко. Обычно когда вам нужно чтобы сеть выполнялась на сверхпроизводительном сервере редко нужно чтобы данный алгоритм крутился на старой мобилке. Но, тем не менее, тут будет что помянуть
• Десктопный инференс. Это то, что может крутиться у вас на домашнем компе. Обработка фотографий. Анализ видео, компы которые ставятся на предприятия, и прочее и прочее будет именно здесь.
• Мобильный инференс всё что касается телефонов, Android и Ios. Тут огромное поле. Есть GPU, есть специальные ускорители, есть сопроцессоры, и прочее и прочее.
• Embedded. Частично эта часть пересекается с десктопами, а частично с мобильными решениями. Но я вынес её в отдельную ветку, так как часть ускорителей ни на что не похожи.

Специализированное железо: Gyrfalcon, Khadas, Hikvision, и.т.д.

• Не все слои поддерживаются
• Софт часто не выложен в OpenSource. Поставляется вместе с аппаратной частью или требует подписания дополнительного NDA

Специализированное железо но от крупных фирм

Nvidia TensorRT

• Серверные платформы (Tesla)
• Десктопы (видеокарты обычные и полу специализированные)
• Embedded платформы серии Jetson.

Triton Inference Server

Intel OpenVino

• Серверных вычислителей (Intel FPGA, Xe GPU, Xeon)
• Десктопов (с i3 начиная года с 2015 поддерживается почти всё). Intel GPU работает но не сверх круто.
• Embedded платформ (movidius)

Google Edge

• TensorFlow Edge
• TensorFlow lite
• TensorFlow JS
• TensorFlow (чистый, или оптимизированный под какую-то платформу, например Intel TensorFlow)

Универсализация с хорошей аппаратной поддержкой

OpenCV

• Очень мало актуальной документации. Попробуйте найти где-нибудь гайд по всем бекендам модуля DNN в OpenCV и по поддержке их на всех платформах?:) Конечно, можно изучить хедеры, но это не говорит о том что где будет работать. Порог входа и первого прототипа достаточно высок. Не в пример того же OpenVino.
• Нейронные сети под Android поддерживаются ( docs.opencv.org/master/d0/d6c/tutorial_dnn_android.html ). Но я не находил актуального гайда про аппаратную поддержку GPU или других вычислителей.

Tensorflow lite

ONNX runtime

PyTorch

TensorFlow

Китайское вторжение

JS Tensorflow.JS, ONNX.js

Как небольшое резюме

• Если вам нужно максимально широкое использование на всех платформах, то, похоже, наиболее универсален ONNX runtime. Единственное, он может местами сыроват + ios поддержан весьма просто. Не уверен, что все ускорители одинаково хорошо работают. Вариант Tencent-ncnn
• Если вам нужно максимум платформ, без мобильных, то я бы взял OpenCV. Он достаточно удобен и стандартен.
• Если вам не нужны десктопные платформы, тогда я бы использовал TFlite
• Если же вы хотите делать на какой-то стандартной платформе, и чётко понимаете что никуда за её пределы не пойдёте то я бы использовал специализированную платформу под эту платформу. Будь это TensorRT или OpenVino. И на TensorRT и на OpenVino мы разворачивали очень сложные проекты. Непреодолимых проблем не встретили.

P.S.

• пользователь загружает видео с записью волейбольной игры
• один хитрый алгоритм распознает мяч на кадрах
• другой хитрый алгоритм выделяет розыгрыши
• розыгрыши компонуются в отдельные видеофайлы
• файлы с розыгрышами собираются в дайджест всей игры
• все видео заливается в облако
• пользователи смотрят/качают/шарят клипы с самыми классными розыгрышами

Технологии

Альфа

• Front Веб сервис (Django), с которым взаимодействуют конечные пользователи
• Videoproc (Vproc) Ядро алгоритма, python + opencv, которое содержит все алгоритмы треккинга мяча и логику нарезки на розыгрыши
• Clipper Сервис генерации видео на основе выхлопа Vproc, используя ffmpeg

Параллельная обработка

• Кадры из ffmpeg не идентичны кадрам из opencv (это не всегда так, зависит от кодека видеофайла)
• Количество кадров в записи может быть слишком большим например час видео при хорошем fps это порядка 200K файлов, что многовато для одного каталога, даже если это ext4. Городить разбиение на поддиректории и потом склеивать при компоновке видео не хотелось усложнять

Completed file id=73, for game=test, frames=36718, fps=50, duration=600 in 1677 sec

Completed file id=83, for game=test, frames=36718, fps=50, duration=600 in 523 sec + framer time 303

Digital Ocean

• Managed Kubernetes
• Managed Postgres
• S3 хранилище с бесплатным(!) CDN + 1 TB/месяц
• Закрытый docker registry
• Все операции можно делать через API
• Датацентры по всему миру

Логи и метрики

Видео

1. front на котором крутятся веб-сервера
2. vproc где обрабатывается видео

DevOps

Ссылки

• Сервис, про который эта статья
• DigitalOcean Kubernetes
• DigitalOcean API для управления кластером
• New Relic free tier

Базовый синтаксис

Глобальные конструкторы и деструкторы

void cxx_invoke_constructors(void) {    extern const char _ctors_start, _ctors_end;    typedef void (*ctor_func_t)(void);    ctor_func_t *func = (ctor_func_t *) &_ctors_start;    ....    for ( ; func != (ctor_func_t *) &_ctors_end; func++) {        (*func)();    }}

int __cxa_atexit(void (*f)(void *), void *objptr, void *dso) {    if (atexit_func_count >= TABLE_SIZE) {        printf("__cxa_atexit: static destruction table overflow.\n");        return -1;    }    atexit_funcs[atexit_func_count].destructor_func = f;    atexit_funcs[atexit_func_count].obj_ptr = objptr;    atexit_funcs[atexit_func_count].dso_handle = dso;    atexit_func_count++;    return 0;};void __cxa_finalize(void *f) {    int i = atexit_func_count;    if (!f) {        while (i--) {            if (atexit_funcs[i].destructor_func) {                (*atexit_funcs[i].destructor_func)(atexit_funcs[i].obj_ptr);                atexit_funcs[i].destructor_func = 0;            }        }        atexit_func_count = 0;    } else {        for ( ; i >= 0; --i) {            if (atexit_funcs[i].destructor_func == f) {                (*atexit_funcs[i].destructor_func)(atexit_funcs[i].obj_ptr);                atexit_funcs[i].destructor_func = 0;            }        }    }}void cxx_invoke_destructors(void) {    extern const char _dtors_start, _dtors_end;    typedef void (*dtor_func_t)(void);    dtor_func_t *func = ((dtor_func_t *) &_dtors_end) - 1;    /* There are two possible ways for destructors to be calls:     * 1. Through callbacks registered with __cxa_atexit.     * 2. From .fini_array section.  */    /* Handle callbacks registered with __cxa_atexit first, if any.*/    __cxa_finalize(0);    /* Handle .fini_array, if any. Functions are executed in teh reverse order. */    for ( ; func >= (dtor_func_t *) &_dtors_start; func--) {        (*func)();    }}

/** * @brief Register destructor for a global object * * @param destructor the global object destructor function * @param objptr global object pointer * @param dso Dynamic Shared Object handle for shared libraries * * Function does nothing at the moment, assuming the global objects * do not need to be deleted * * @return N/A */int __cxa_atexit(void (*destructor)(void *), void *objptr, void *dso){    ARG_UNUSED(destructor);    ARG_UNUSED(objptr);    ARG_UNUSED(dso);    return 0;}

Операторы new/delete

void* operator new(std::size_t size)  throw() {    void *ptr = NULL;    if ((ptr = std::malloc(size)) == 0) {        if (alloc_failure_handler) {            alloc_failure_handler();        }    }    return ptr;}void operator delete(void* ptr) throw() {    std::free(ptr);}

RTTI & exceptions

void register_eh_frame(void) {    extern const char _eh_frame_begin;    __register_frame((void *)&_eh_frame_begin);}

    .ARM.exidx : {        __exidx_start = .;        KEEP(*(.ARM.exidx*));        __exidx_end = .;    } SECTION_REGION(text)    .ARM.extab : {        KEEP(*(.ARM.extab*));    } SECTION_REGION(text)

extern __EIT_entry __exidx_start;extern __EIT_entry __exidx_end;

Стандартная библиотека языка (libstdc++)

Собственная реализация стандартной библиотеки

Стандартная библиотека из кросс-компилятора

$ arm-none-eabi-gcc -vUsing built-in specs.COLLECT_GCC=arm-none-eabi-gccCOLLECT_LTO_WRAPPER=/home/alexander/apt/gcc-arm-none-eabi-9-2020-q2-update/bin/../lib/gcc/arm-none-eabi/9.3.1/lto-wrapperTarget: arm-none-eabiConfigured with: ***     --with-gnu-as --with-gnu-ld --with-newlib   ***Thread model: singlegcc version 9.3.1 20200408 (release) (GNU Arm Embedded Toolchain 9-2020-q2-update)

struct _reent {    int _errno;           /* local copy of errno */  /* FILE is a big struct and may change over time.  To try to achieve binary     compatibility with future versions, put stdin,stdout,stderr here.     These are pointers into member __sf defined below.  */    FILE *_stdin, *_stdout, *_stderr;};struct _reent global_newlib_reent;void *_impure_ptr = &global_newlib_reent;static int reent_init(void) {    global_newlib_reent._stdin = stdin;    global_newlib_reent._stdout = stdout;    global_newlib_reent._stderr = stderr;    return 0;}

Расширенная поддержка стандартной библиотеки std::thread и std::mutex

$ arm-none-eabi-gcc -v***Thread model: singlegcc version 9.3.1 20200408 (release) (GNU Arm Embedded Toolchain 9-2020-q2-update)

Конфигурация Embox

• embox.lib.libsupcxx определяет какой метод для поддержки базового синтаксиса языка нужно использовать.
• embox.lib.libstdcxx определяет какую реализацию стандартной библиотеки нужно использовать

• embox.lib.cxx.libsupcxx_standalone базовая реализация в составе Embox.
• third_party.lib.libsupcxx_toolchain использовать библиотеку поддержки языка из кросс-компилятора
• third_party.gcc.tlibsupcxx полная сборка библиотеки из исходников

• third_party.STLport.libstlportg стандартная библиотека вслкючающая STL на основе проекта STLport. Не требует пересборки gcc. Но проект давно не поддерживается
• third_party.lib.libstdcxx_toolchain стандартная библиотека из кросс-компилятора
• third_party.gcc.libstdcxx полная сборка библиотеки из исходников

Привет, Хабр! Запускаю цикл статей по библиотеке OpenCV в Python. Кому интересно, добро пожаловать под кат!

Введение

OpenCV это open source библиотека компьютерного зрения, которая предназначена для анализа, классификации и обработки изображений. Широко используется в таких языках как C, C++, Python и Java.

Установка

Будем считать, что Python и библиотека OpenCV у вас уже установлены, если нет, то вот инструкция для установки python на windows и на ubuntu, установка OpenCV на windows и на ubuntu.

Немного про пиксели и цветовые пространства

Перед тем как перейти к практике, нам нужно разобраться немного с теорией. Каждое изображение состоит из набора пикселей. Пиксель это строительный блок изображения. Если представить изображение в виде сетки, то каждый квадрат в сетке содержит один пиксель, где точке с координатой ( 0, 0 ) соответствует верхний левый угол изображения. К примеру, представим, что у нас есть изображение с разрешением 400x300 пикселей. Это означает, что наша сетка состоит из 400 строк и 300 столбцов. В совокупности в нашем изображении есть 400*300 = 120000 пикселей.
В большинстве изображений пиксели представлены двумя способами: в оттенках серого и в цветовом пространстве RGB. В изображениях в оттенках серого каждый пиксель имеет значение между 0 и 255, где 0 соответствует чёрному, а 255 соответствует белому. А значения между 0 и 255 принимают различные оттенки серого, где значения ближе к 0 более тёмные, а значения ближе к 255 более светлые:

Цветные пиксели обычно представлены в цветовом пространстве RGB(red, green, blue красный, зелёный, синий), где одно значение для красной компоненты, одно для зелёной и одно для синей. Каждая из трёх компонент представлена целым числом в диапазоне от 0 до 255 включительно, которое указывает как много цвета содержится. Исходя из того, что каждая компонента представлена в диапазоне [0,255], то для того, чтобы представить насыщенность каждого цвета, нам будет достаточно 8-битного целого беззнакового числа. Затем мы объединяем значения всех трёх компонент в кортеж вида (красный, зеленый, синий). К примеру, чтобы получить белый цвет, каждая из компонент должна равняться 255: (255, 255, 255). Тогда, чтобы получить чёрный цвет, каждая из компонент должна быть равной 0:
(0, 0, 0). Ниже приведены распространённые цвета, представленные в виде RGB кортежей:

Импорт библиотеки OpenCV

Теперь перейдём к практической части. Первое, что нам необходимо сделать это импортировать библиотеку. Есть несколько путей импорта, самый распространённый это использовать выражение:

import cv2

Также можно встретить следующую конструкцию для импорта данной библиотеки:

from cv2 import cv2

Загрузка, отображение и сохранение изображения

def loading_displaying_saving():    img = cv2.imread('girl.jpg', cv2.IMREAD_GRAYSCALE)    cv2.imshow('girl', img)    cv2.waitKey(0)    cv2.imwrite('graygirl.jpg', img)

Для загрузки изображения мы используем функцию cv2.imread(), где первым аргументом указывается путь к изображению, а вторым аргументом, который является необязательным, мы указываем, в каком цветовом пространстве мы хотим считать наше изображение. Чтобы считать изображение в RGB cv2.IMREAD_COLOR, в оттенках серого cv2.IMREAD_GRAYSCALE. По умолчанию данный аргумент принимает значение cv2.IMREAD_COLOR. Данная функция возвращает 2D (для изображения в оттенках серого) либо 3D (для цветного изображения) массив NumPy. Форма массива для цветного изображения: высота x ширина x 3, где 3 это байты, по одному байту на каждую из компонент. В изображениях в оттенках серого всё немного проще: высота x ширина.
С помощью функции cv2.imshow() мы отображаем изображение на нашем экране. В качестве первого аргумента мы передаём функции название нашего окна, а вторым аргументом изображение, которое мы загрузили с диска, однако, если мы далее не укажем функцию cv2.waitKey(), то изображение моментально закроется. Данная функция останавливает выполнение программы до нажатия клавиши, которую нужно передать первым аргументом. Для того, чтобы любая клавиша была засчитана передаётся 0. Слева представлено изображение в оттенках серого, а справа в формате RGB:

И, наконец, с помощью функции cv2.imwrite() записываем изображение в файл в формате jpg(данная библиотека поддерживает все популярные форматы изображений:png, tiff,jpeg,bmp и т.д., поэтому можно было сохранить наше изображение в любом из этих форматов), где первым аргументом передаётся непосредственно само название и расширение, а следующим параметром изображение, которое мы хотим сохранить.

Доступ к пикселям и манипулирование ими

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

print("Высота:"+str(img.shape[0]))print("Ширина:" + str(img.shape[1]))print("Количество каналов:" + str(img.shape[2]))

Важно помнить, что у изображений в оттенках серого img.shape[2] будет недоступно, так как данные изображения представлены в виде 2D массива.
Чтобы получить доступ к значению пикселя, нам просто нужно указать координаты x и y пикселя, который нас интересует. Также важно помнить, что библиотека OpenCV хранит каналы формата RGB в обратном порядке, в то время как мы думаем в терминах красного, зеленого и синего, то OpenCV хранит их в порядке синего, зеленого и красного цветов:

(b, g, r) = img[0, 0]print("Красный: {}, Зелёный: {}, Синий: {}".format(r, g, b))

Cначала мы берём пиксель, который расположен в точке (0,0). Данный пиксель, да и любой другой пиксель, представлены в виде кортежа. Заметьте, что название переменных расположены в порядке b, g и r. В следующей строке выводим значение каждого канала на экран. Как можно увидеть, доступ к значениям пикселей довольно прост, также просто можно и манипулировать значениями пикселей:

img[0, 0] = (255, 0, 0)(b, g, r) = img[0, 0] print("Красный: {}, Зелёный: {}, Синий: {}".format(r, g, b))

В первой строке мы устанавливаем значение пикселя (0, 0) равным (255, 0, 0), затем мы снова берём значение данного пикселя и выводим его на экран, в результате мне на консоль вывелось следующее:

Красный: 251, Зелёный: 43, Синий: 65Красный: 0, Зелёный: 0, Синий: 255

На этом у нас конец первой части. Если вдруг кому-то нужен исходный код и картинка, то вот ссылка на github. Всем спасибо за внимание!

Привет, Хабр! Продолжаем туториал по библиотеке opencv в python. Для тех кто не читал первую часть, сюда: Часть 1, а всем остальным увлекательного чтения!

Введение

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

Изменение размера изображения

Первый метод, который мы изучим это как поменять высоту и ширину у изображения. Для этого в opencv есть такая функция как resize():

def resizing():    res_img = cv2.resize(img, (500, 900), cv2.INTER_NEAREST)

Данная функция первым аргументом принимает изображение, размер которого мы хотим изменить, вторым кортеж, который должен содержать в себе ширину и высоту для нового изображения, третьим метод интерполяции(необязательный). Интерполяция это алгоритм, который находит неизвестные промежуточные значения по имеющемуся набору известных значений. Фактически, это то, как будут заполняться новые пиксели при модификации размера изображения. К примеру, интерполяция методом ближайшего соседа (cv2.INTER_NEAREST) просто берёт для каждого пикселя итогового изображения один пиксель исходного, который наиболее близкий к его положению это самый простой и быстрый способ. Кроме этого метода в opencv существуют следующие: cv2.INTER_AREA, cv2.INTER_LINEAR( используется по умолчанию), cv2.INTER_CUBIC и cv2.INTER_LANCZOS4. Наиболее предпочтительным методом интерполяции для сжатия изображения является cv2.INTER_AREA, для увелечения cv2.INTER_LINEAR. От данного метода зависит качество конечного изображения, но как показывает практика, если мы уменьшаем/увеличиваем изображение меньше, чем в 1.5 раза, то не важно каким методом интерполяции мы воспользовались качество будет схожим. Данное утверждение можно проверить на практике. Напишем следующий код:

res_img_nearest = cv2.resize(img, (int(w / 1.4), int(h / 1.4)),                                  cv2.INTER_NEAREST)res_img_linear = cv2.resize(img, (int(w / 1.4), int(h / 1.4)),                                 cv2.INTER_LINEAR)

Слева изображение с интерполяцией методом ближайшего соседа, справа изображение с билинейной интерполяцией:

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

Поэтому текущую функцию для изменения размера необходимо модифицировать:

def resizing(new_width=None, new_height=None, interp=cv2.INTER_LINEAR):    h, w = img.shape[:2]    if new_width is None and new_height is None:        return img    if new_width is None:        ratio = new_height / h        dimension = (int(w * ratio), new_height)    else:        ratio = new_width / w        dimension = (new_width, int(h * ratio))    res_img = cv2.resize(img, dimension, interpolation=interp)

Соотношение сторон мы вычисляем в переменной ratio. В зависимости от того, какой параметр не равен None, мы берём установленную нами новую высоту/ширину и делим на старую высоту/ширину. Далее, в переменной dimension мы определяем новые размеры изображения и передаём в функцию cv2.resize().

Смещение изображения вдоль осей

С помощью функции cv2.warpAffine() мы можем перемещать изображение влево и вправо, вниз и вверх, а также любую комбинацию из перечисленного:

def shifting():    h, w = img.shape[:2]    translation_matrix = np.float32([[1, 0, 200], [0, 1, 300]])    dst = cv2.warpAffine(img, translation_matrix, (w, h))    cv2.imshow('Изображение, сдвинутое вправо и вниз', dst)    cv2.waitKey(0)

Сначала, в переменной translation_matrix мы создаём матрицу преобразований как показано ниже:

Первая строка матрицы [1, 0, tx ], где tx количество пикселей, на которые мы будем сдвигать изображение влево или вправо. Отрицательное значения tx будет сдвигать изображение влево, положительное вправо.
Вторая строка матрицы [ 0, 1, ty], где ty количество пикселей, на которые мы будем сдвигать изображение вверх или вниз. Отрицательное значения ty будет сдвигать изображение вверх, положительное вниз. Важно помнить, что данная матрица определяется как массив с плавающей точкой.
На следующей строчке и происходит сдвиг изображения вдоль осей, с помощью, как я писал выше, функции cv2.warpAffine(), которая первым аргументом принимает изображение, вторым матрицу, третьим размеры нашего изображения. Если вы запустите данный код, то увидите следующее:

Вырез фрагмента изображения

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

def cropping():    crop_img = img[10:450, 300:750]

В данной строчке мы предоставляем массив numpy для извлечения прямоугольной области изображения, начиная с (300, 10) и заканчивая (750, 450), где 10 это начальная координата по y, 300 начальная координата по x, 450 конечная координата по y и 750 конечная координата по x.Выполнив код выше, мы увидим, что обрезали лицо девочке:

Поворот изображения

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

def rotation():    (h, w) = img.shape[:2]    center = (int(w / 2), int(h / 2))    rotation_matrix = cv2.getRotationMatrix2D(center, -45, 0.6)    rotated = cv2.warpAffine(img, rotation_matrix, (w, h))

Когда мы поворачиваем изображение, нам нужно указать, вокруг какой точки мы будем вращаться, именно это принимает первым аргументом функция cv2.getRotationMatrix2D(). В данном случае я указал центр изображения, однако opencv позволяет указать любую произвольную точку, вокруг которой вы захотите вращаться. Следующим аргументом данная функция принимает угол, на который мы хотим повернуть наше изображение, а последним аргументом коэффициент масштабирования. Мы используем 0.6, то есть уменьшаем изображение на 40%, для того, чтобы оно поместилось в кадр. Данная функция возвращает массив numpy, который мы передаём вторым аргументом в функцию cv2.warpAffine(). В итоге, у вас на экране должно отобразиться следующее изображение:

Вот и вторая часть подошла к концу, исходный код доступен на github. Спасибо за уделённое внимание! До скорой встречи!

$ pkg update -y pkg install curl openssh autossh termux-services screen$ sv-enable sshd$ sv up sshd

$ whoamiu0_a137$ passwd

$ ifconfigwlan0: flags=4163<UP,BROADCAST,RUNNING,MULTICAST>  mtu 1500         inet 192.168.1.88  netmask 255.255.255.0  broadcast 192.168.1.255

$ ssh u0_a137@192.168.1.88 -p 8022 

$ curl https://raw.githubusercontent.com/AndronixApp/AndronixOrigin/master/Installer/Ubuntu/ubuntu.sh | bash

You can now launch Ubuntu with the ./start-ubuntu.sh script

$ ./start-ubuntu.sh 

$ apt update$ apt install curl git net-tools unzip yarn nano nodejs python3-dev python3-pip python3-opencv -y

$ curl -fsSL https://code-server.dev/install.sh | sh

$ nano ~/.config/code-server/config.yamlbind-addr: 127.0.0.1:8080auth: passwordpassword: 4a40bd9973dae545b3b4c037cert: false

$ git clone https://github.com/guinmoon/flask_opencv_sample$ cd flask_opencv_sample && pip3 install flask

Открываем проект в code-server

При первом открытии будет предложено установить расширение Python соглашаемся.
Установим приложение для потоковой передачи с камеры устройства, например IP Webcam. Главное требование к приложению возможность транслировать с камеры поток понятный opencv, например rtsp. Разрешение видео потока настраиваем в зависимости от производительности устройства. На моем самое оптимальное 1280x720.

$ termux-setup-storage

curl -SL -o dotnet-sdk-3.1.403-linux-arm64.tar.gz https://download.visualstudio.microsoft.com/download/pr/7a027d45-b442-4cc5-91e5-e5ea210ffc75/68c891aaae18468a25803ff7c105cf18/dotnet-sdk-3.1.403-linux-arm64.tar

mkdir -p /usr/share/dotnettar -zxf dotnet-sdk-3.1.403-linux-arm64.tar.gz -C /usr/share/dotnetln -s /usr/share/dotnet/dotnet /usr/bin/dotnetdotnet new console -o appcd appdotnet run

apt-get updateapt install sysbenchsysbench --test=cpu --cpu-max-prime=20000 --num-threads=4 run

Привет, Хабр! Это продолжение туториала по библиотеке opencv в python. Для тех кто не читал первую и вторую части, сюда: Часть 1 и Часть 2, а всем остальным приятного чтения!

Введение

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

Арифметика изображений

Надеюсь, что все знают такие арифметические операции как сложение и вычитание, но при работе с изображениями мы не должны забывать о типе данных.
К примеру, у нас есть RGB изображение, пиксели которого попадают в диапазон [0,255]. Итак, что же произойдёт, если мы попытаемся к пикселю с интенсивностью 250 прибавить 30 или от 70 отнять 100? Если бы мы пользовались стандартными арифметическими правилами, то получили бы 280 и -30 соответственно. Однако, если мы работаем с RGB изображениями, где значения пикселей представлены в виде 8-битного целого беззнакового числа, то 280 и -30 не является допустимыми значениями. Для того, чтобы разобраться, что же произойдёт, давайте посмотрим на строчки кода ниже:

print("opencv addition: {}".format(cv2.add(np.uint8([250]),                                                    np.uint8([30]))))print("opencv subtract: {}".format(cv2.subtract(np.uint8([70]),                                                     np.uint8([100]))))print("numpy addition: {}".format(np.uint8([250]) + np.uint8([30])))print("numpy subtract: {}".format(np.uint8([70]) - np.uint8([71])))

Как мы видим, сложение и вычитание можно осуществить с помощью функций opencv add и subtract соответственно, а также с помощью numpy. И результаты будут отличаться:

opencv addition: 255opencv subtract: 0numpy addition: 24numpy subtract: 255

OpenCV выполняет обрезку и гарантирует, что значения пикселей никогда не выйдут за пределы диапазона [0,255]. В numpy же всё происходит немного иначе. Представьте себе обычные настенные часы, где вместо 60 находится 255. Получается, что после достижение 255 следующим числом будет идти 0, а когда мы отнимаем от меньшего числа большее, то после 0 ( против часовой стрелки) будет идти 255.

Разбиение и слияние каналов

Как мы знаем, RGB изображение состоит из красной, зелёной и синих компонент. И что, если мы захотим разделить изображение на соответствующие компоненты? Для этого в opencv есть специальная функция split():

image = cv2.imread('rectangles.png')b, g, r = cv2.split(image)cv2.imshow('blue', b)cv2.imshow('green', g)cv2.imshow('red', r)

Сначала мы загружаем изображение. Для наглядности работы данной функции я взял следующее изображение:

Затем разделяем изображение на три канала и показываем каждый канал по отдельности. В результате выполнения данной функции отобразится три изображения в оттенках серого:

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

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

merge_image = cv2.merge([g,b,r])cv2.imshow('merge_image', merge_image)cv2.imshow('original', image)cv2.waitKey(0)

Таким образом, мы получаем такое же изображение как оригинальное, за исключением того, что я поменял местами синий с зелёным каналом.

Размытие

Размытие это когда более резкие области на изображении теряют свою детализацию, в результате чего изображение становится менее чётким. В opencv имеются следующие основные методы размытия: averaging(усреднённое), gaussian(гауссово) и median(медианное).

Averaging

Данный фильтр делает операцию свёртки на изображении с неким ядром, где свёртка это вычисление нового значения пикселя, при котором учитываются значения соседних пикселей. Ядро свёртки это квадратная матрица, где пиксель в центре этой матрицы затем устанавливается как среднее значение всех других пикселей, окружающих его. Для того, чтобы воспользоваться данным размытием достаточно вызвать метод blur(), который принимает изображение и кортеж, с указанием размера ядра:

def averaging_blurring():    image = cv2.imread('girl.jpg')    img_blur_3 = cv2.blur(image, (3, 3))    img_blur_7 = cv2.blur(image, (7, 7))    img_blur_11 = cv2.blur(image, (11, 11))

Чем больше размер ядра, тем более размытым будет становиться изображение:

Gaussian

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

Это размытие реализуется в opencv с помощью функции GaussianBlur(), которая принимает первые два аргумента такие же как и предыдущая функция, а третьим аргументом указываем стандартное отклонение ядра Гаусса. Установив это значение в 0, мы тем самым говорим opencv автоматически вычислять его, в зависимости от размера нашего ядра:

def gaussian_blurring():    image = cv2.imread('girl.jpg')    img_blur_3 = cv2.GaussianBlur(image, (3, 3), 0)    img_blur_7 = cv2.GaussianBlur(image, (7, 7), 0)    img_blur_11 = cv2.GaussianBlur(image, (11, 11), 0)

Median

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

def median_blurring():    image = cv2.imread('girl.jpg')    img_blur_3 = cv2.medianBlur(image, 3)    img_blur_7 = cv2.medianBlur(image, 7)    img_blur_11 = cv2.medianBlur(image, 11)

В результате у нас получится следующее:

На этом данная часть подошла к концу. Код, как всегда, доступен на github. До скорой встречи:)

import cv2my_photo = cv2.imread('MyPhoto.jpg')cv2.imshow('MyPhoto', my_photo)cv2.waitKey(0)cv2.destroyAllWindows()

import cv2my_photo = cv2.imread('MyPhoto.jpg')cv2.imshow('MyPhoto', my_photo)#Подготовим новые размерыfinal_wide = 200r = float(final_wide) / my_photo.shape[1]dim = (final_wide, int(my_photo.shape[0] * r))# уменьшаем изображение до подготовленных размеровresized = cv2.resize(my_photo, dim, interpolation = cv2.INTER_AREA)cv2.imshow("Resized image", resized)cv2.waitKey(0)cv2.destroyAllWindows()

import cv2img = cv2.imread('MyPhoto.jpg', cv2.IMREAD_GRAYSCALE)cv2.imshow('MyPhoto', img)cv2.waitKey(0)cv2.destroyAllWindows()

import cv2img = cv2.imread('MyPhoto.jpg', cv2.IMREAD_GRAYSCALE)cv2.imshow('MyPhoto', img)cv2.waitKey(0)cv2.destroyAllWindows()

Привет, Хабр! В этой статье я бы хотел рассказать как с помощью только OpenCV распознавать объекты, на примере игральных карт:

Введение

Допустим, у нас имеется следующее изображение с картами:

А также у нас имеются эталонные изображения каждой карты:

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

• находит контуры всех карт;
• находит координаты каждой отдельной карты;
• распознаёт карту с помощью ключевых точек.

Нахождение контуров карт

def find_contours_of_cards(image):    blurred = cv2.GaussianBlur(image, (3, 3), 0)    T, thresh_img = cv2.threshold(blurred, 215, 255,                                   cv2.THRESH_BINARY)    (_, cnts, _) = cv2.findContours(thresh_img,                                 cv2.RETR_EXTERNAL,                                cv2.CHAIN_APPROX_SIMPLE)    return cnts

Первым аргументом в данную функцию мы передаём изображение в оттенках серого, к которому применяем гауссово размытие, для того, чтобы было легче найти контуры карт. После этого с помощью функции threshold() мы преобразуем наше серое изображение в бинарное. Данная функция принимает первым параметром изображение, вторым пороговое значение, третьим это максимальное значение, которое присваивается значениям пикселей, превышающим пороговое значение. Из нашего примера следует, что любое значение пикселя, превышающее 215, устанавливается равным 255, а любое значение, которое меньше 215, устанавливается равным нулю. И последним параметром передаём метод порогового значения. Мы используем THRESH_BINARY(), который указывает на то, что значения пикселей, которые больше 215 устанавливаются в максимальное значение, которое мы передали третьим параметром. Данная функция возвращает два значения, где первое это значение, которое мы передали в данную функцию вторым аргументом, а второе чёрно-белое изображение, которое выглядит подобным образом:

Теперь мы можем найти контуры наших карт, где контур это кривая, соединяющая все непрерывные точки, которые имеют одинаковый цвет. Поиск контуров осуществляется с помощью метода findContours(), где в качестве первого аргумента эта функция принимает изображение, вторым это тип контуров, который мы хотим извлечь. Я использую cv2.RETR_EXTERNAL для извлечения только внешних контуров. К примеру, для того, чтобы извлечь все контуры используют cv2.RETR_LIST, а последний параметром мы указываем метод аппроксимации контура. Мы используем cv2.CHAIN_APPROX_SIMPLE, указывая на то, что все лишние точки будут удалены, тем самым экономя память. Например, если вы нашли контур прямой линии, то разве вам нужны все точки этой линии, чтобы представить эту линию? Нет, нам нужны только две конечные точки этой линии. Это как раз то, что и делает cv2.CHAIN_APPROX_SIMPLE.

Нахождение координат карт

def find_coordinates_of_cards(cnts, image):    cards_coordinates = {}    for i in range(0, len(cnts)):        x, y, w, h = cv2.boundingRect(cnts[i])        if w > 20 and h > 30:            img_crop = image[y - 15:y + h + 15,                             x - 15:x + w + 15]            cards_name = find_features(img_crop)            cards_coordinates[cards_name] = (x - 15,                      y - 15, x + w + 15, y + h + 15)    return cards_coordinates

Данная функция принимает контуры, которые мы нашли в предыдущей функции, а также основное изображение в оттенках серого. Первым делом мы создаём словарь, где в роли ключа будет выступать название карты, а в роли значения координаты каждой карты. Далее мы проходимся в цикле по нашим контурам, где с помощью функции boundingRect() находим ограничительные рамки каждого контура: начальные x и y координаты, за которыми следуют ширина и высота рамки. Так получилось, что функция, которая искала контура, нашла аж 31 контур, хотя карт всего 4. Это могут быть незначительные контуры, которые мы дальше сортируем в условии, исходя из размера контура.

Теперь, зная координаты контура, мы можем вырезать по этим координатам каждую карту, что собственно мы и делаем в следующей строчке кода. Далее вырезанное изображение мы передаём в функцию find_features()(о ней мы поговорим ниже), которая опираясь на ключевые точки, возвращает нам название вырезанной карты. После этого добавляем всё в словарь.

Распознавание карт

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

Теперь закройте глаза и попытайтесь представить это изображение:

И вы увидите, что помните много деталей об этом образе. Причина этого в том, что на изображении много интересных областей. Теперь переходим к практике:

def find_features(img1):    correct_matches_dct = {}    directory = 'images/cards/sample/'    for image in os.listdir(directory):        img2 = cv2.imread(directory+image, 0)        orb = cv2.ORB_create()        kp1, des1 = orb.detectAndCompute(img1, None)        kp2, des2 = orb.detectAndCompute(img2, None)        bf = cv2.BFMatcher()        matches = bf.knnMatch(des1, des2, k=2)        correct_matches = []        for m, n in matches:            if m.distance < 0.75*n.distance:                correct_matches.append([m])                correct_matches_dct[image.split('.')[0]]                    = len(correct_matches)    correct_matches_dct =        dict(sorted(correct_matches_dct.items(),             key=lambda item: item[1], reverse=True))    return list(correct_matches_dct.keys())[0]

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

Затем нам необходимо сопоставить(вычислить расстояние) дискрипторы первого изображения с дискрипторами второго и взять ближайший. Для этого мы создаём BFMatcher объект с помощью вызова метода BFMatcher(). Теперь мы можем с помощью функции knnMatch() найти k лучших совпадений для каждого дескриптора, где k в нашем случае равно 2. Далее нам необходимо выбрать только хорошие совпадения, основываясь на расстоянии. Поэтому мы проходимся в цикле по нашим совпадениям и если оно удовлетворяет условию m.distance < 0.75*n.distance, то мы засчитываем это совпадение как хорошее и добавляем в список. Потом считаем количество хороших совпадений(чем больше, тем лучше) и основываясь на этом делаем вывод, что за карта. Вот какие совпадения были найдены для каждой карты с королём:

И вслед за этим рисуем прямоугольник вокруг карты с помощью функции draw_rectangle_aroud_cards():

def draw_rectangle_aroud_cards(cards_coordinates, image):    for key, value in cards_coordinates.items():        rec = cv2.rectangle(image, (value[0], value[1]),                             (value[2], value[3]),                             (255, 255, 0), 2)        cv2.putText(rec, key, (value[0], value[1] - 10),                     cv2.FONT_HERSHEY_SIMPLEX,                     0.5, (36, 255, 12), 1)    cv2.imshow('Image', image)    cv2.waitKey(0)

На этом всё. Надеюсь, было познавательно) Код и картинки можно найти на github. До новых встреч:)