Определения цвета программа: что лучше Zx Color Spy?

У нас есть значения r, g и b. Теперь нам нужна другая функция, которая вернет нам название цвета из значений RGB. Чтобы получить название цвета, мы вычисляем расстояние (d), которое говорит нам, насколько мы близки к цвету, и выбираем тот, который имеет минимальное расстояние.

Наше расстояние рассчитывается по следующей формуле:

d = abs (Red - ithRedColor) + (Green - ithGreenColor) + (Blue - ithBlueColor)

 def getColorName (R, G, B):
    минимум = 10000
    для i в диапазоне (len (csv)):
        d = abs (R- int (csv.loc [i, «R»])) + abs (G- int (csv.loc [i, «G»])) + abs (B- int (csv.loc [ i, "B"]))
        если (d <= минимум):
            минимум = d
            cname = csv.loc [я, "имя_цвета"]
    return cname 

7. Отображение изображения в окне

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

Используя функцию cv2.imshow () , мы рисуем изображение в окне. Когда пользователь дважды щелкает по окну, мы рисуем прямоугольник и получаем имя цвета для рисования текста в окне с помощью функций cv2.rectangle и cv2.putText () .

, а (1):
    cv2.imshow ("изображение", img)
    если (нажал):
        # cv2.rectangle (изображение, начальная точка, конечная точка, цвет, толщина) -1 толщина заполняет прямоугольник полностью
        cv2.rectangle (img, (20,20), (750,60), (b, g, r), -1)

        # Создание текстовой строки для отображения (название цвета и значения RGB)
        текст = getColorName (r, g, b) + 'R =' + str (r) + 'G ​​=' + str (g) + 'B =' + str (b)

        # cv2.putText (img, текст, начало, шрифт (0-7), fontScale, цвет, толщина, lineType, (необязательно bottomLeft bool))
        cv2.putText (img, текст, (50,50), 2,0,8, (255,255,255), 2, cv2.LINE_AA)
  # Для очень светлых цветов текст будет отображаться черным цветом
        если (r + g + b> = 600):
            cv2. putText (img, текст, (50,50), 2,0.8, (0,0,0), 2, cv2.LINE_AA)

        clicked = Ложь

    # Разрыв цикла, когда пользователь нажимает клавишу "esc"
    если cv2.waitKey (20) & 0xFF == 27:
        перерыв

cv2.destroyAllWindows () 

8. Запустите файл Python

Теперь проект Python для начинающих завершен, вы можете запустить файл Python из командной строки.Не забудьте указать путь к изображению с помощью аргумента «-i». Если изображение находится в другом каталоге, вам необходимо указать полный путь к нему:

 python color_detection.py -i <добавьте сюда путь к изображению> 

Снимки экрана:

Вывод:

Дважды щелкните по окну, чтобы узнать название цвета пикселя

Сводка

В этом проекте Python с исходным кодом мы узнали о цветах и ​​о том, как мы можем извлечь цветовые значения RGB и название цвета пикселя.Мы узнали, как обрабатывать такие события, как двойной щелчок по окну, и увидели, как читать файлы CSV с помощью pandas и выполнять операции с данными. Это используется во многих приложениях для редактирования изображений и рисования.

Хотите подготовиться к собеседованию по Python?

Практикуйте 150+ вопросов на собеседовании по Python и получите работу в качестве эксперта по Python

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

Если вы довольны DataFlair, не забудьте порадовать нас своим положительным отзывом в Google | Facebook

Новейшие вопросы об обнаружении цвета - Stack overflow на русском

Получить основные цвета пикселей изображения

Я пытаюсь получить все цвета моего изображения. Я делаю это с unique_rgbs = np.unique (resized_img.reshape (-1, resized_img.shape [2]), axis = 0) Я ожидал получить 6 цветов, но я получаю ...

задан 18 фев в 21:59

Как читать цветные ячейки отсканированного документа?

Мне нужно извлечь таблицы из отсканированных документов (без проблем), но таблицы не содержат данных / данных в текстовом формате.Скорее клетки по-разному окрашены. Мне нужно извлечь таблицу с помощью ...

задан 18 фев в 15:07

Распознавание цвета с камерой в реальном времени во флаттере

Кто-нибудь знает, как реализовать распознавание цвета с живой камерой на флаттере? Я реализовал обнаружение объекта, но также хочу распознавать цвет объекта, но понятия не имею, как это сделать....

задан 6 янв в 9:33

Какой самый простой способ определить цвет в Python?

Я пытаюсь написать программу Python, которая определяет цвет части экрана и помещает его в условное обозначение. Думаю, самый простой способ - определить цвет под курсором (...

Создан 03 авг.

Как получить ползунки определения цвета OpenCV RGB?

Я новичок в использовании OpenCV.Я использую его, чтобы найти разные цвета на изображениях, особенно для трафика в Google Maps. Я немного поработал с этим кодом: импортировать numpy как np import argparse импорт ...

Создан 28 июл.

Ваша конфиденциальность

Нажимая «Принять все файлы cookie», вы соглашаетесь с тем, что Stack Exchange может хранить файлы cookie на вашем устройстве и раскрывать информацию в соответствии с нашей Политикой в ​​отношении файлов cookie.

Принимать все файлы cookie Настроить параметры

🎈 Общественная лаборатория: определение цвета компьютерного зрения

Введение:

Некоторые приложения цифровых камер, такие как спектроскопия или измерения нормированного разностного индекса растительности (NDVI), выигрывают от возможности автоматического определения цветовых узоров изображения.В этой исследовательской заметке описывается программное обеспечение компьютерного зрения (OpenCV / python), которое может измерять цветовые характеристики изображения. Два разных примера показывают, как можно использовать определение цвета. Первое приложение - это спектр, генерируемый светодиодом с перекрещенной решеткой и белым светом. Второе приложение использует изображение NDVI, полученное с https://publiclab.org/wiki/ndvi.

Обнаружение цвета компьютерным зрением: Обнаружение цвета с использованием методов компьютерного зрения описано в https: //docs.opencv.org / 3.0-beta / doc / py_tutorials / py_imgproc / py_colorspaces / py_colorspaces.html и в https://www.pyimagesearch.com/2014/08/04/opencv-python-color-detection/

Видеопрогулка доступна по адресу: https://www.youtube.com/watch?v=ggBCx4nVQ4I

Python / OpenCV (https://opencv.org/), разработанное для реализации этих методов, описано ниже:

--1: Цветное входное изображение загружается в программу

- 2а. Изображение масштабируется и преобразуется в цветовое пространство оттенка, насыщенности, значения (HSV).См. Https://en.wikipedia.org/wiki/HSL_and_HSV для получения дополнительной информации о HSV.

- 2б. Трекбары создаются с опциями нижнего / верхнего цветового пространства,

- 2с. Отображаются изображение, маска изображения и полосы прокрутки.

--2д. На маску накладывается изображение, показывающее выбор цвета. Пользователь выбирает цветовой диапазон с помощью трекбаров H, S, V.

- 3а. Значения H, S, V указывают выбранный цвет. Примечание. Диапазон цветового пространства OpenCV HSV: H: 0 - 180, S: 0 - 255, V: 0 - 255.

Видео-демонстрация сортировки красного цвета размещена по адресу: https: // www.youtube.com/watch?v=ggBCx4nVQ4I

!

Пример спектроскопии:

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

На рисунке ниже показано обнаружение красного / зеленого / желтого / синего цвета для спектра белого светодиода / скрещенной решетки.

Рисунок ниже - это крупный план красного цвета, описанного выше.Обратите внимание на цветные контуры вокруг насыщенных пикселей, которые трудно заметить на многоцветном входном изображении.

Пример NDVI:

На рисунке ниже показано определение цвета, примененное к изображению NDVI. Красный цвет указывает на здоровую жизнь растений.

Резюме:

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

размещен по адресу: https://github.com/MargaretAN9/Peggy/blob/master/Image%20Processing/HSVcolortrackbar.py

@warren, @icarito, @amirberAgain

с использованием цветовых пространств в OpenCV + Python - Real Python

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

В этой статье вы узнаете, как просто сегментировать объект из изображения на основе цвета в Python с помощью OpenCV. OpenCV - популярная библиотека компьютерного зрения, написанная на C / C ++ с привязками к Python. Она предоставляет простые способы управления цветовыми пространствами.

Хотя вам не обязательно быть знакомым с OpenCV или другими вспомогательными пакетами, используемыми в этой статье, предполагается, что у вас есть хотя бы базовое понимание кодирования на Python.

Что такое цветовые пространства?

В наиболее распространенном цветовом пространстве RGB (красный, зеленый, синий) цвета представлены в виде их красных, зеленых и синих компонентов. Говоря техническим языком, RGB описывает цвет как набор из трех компонентов. Каждый компонент может принимать значение от 0 до 255, где кортеж (0, 0, 0) представляет черный цвет, а (255, 255, 255) представляет белый цвет.

RGB считается «аддитивным» цветовым пространством , и цвета можно представить как получаемые из ярких количеств красного, синего и зеленого света на черном фоне.

Вот еще несколько примеров цветов в RGB:

RGB - одна из пяти основных моделей цветового пространства, каждая из которых имеет множество ответвлений. Существует так много цветовых пространств, потому что разные цветовые пространства используются для разных целей .

В мире печати CMYK полезен, потому что он описывает цветовые комбинации, необходимые для получения цвета на белом фоне. В то время как кортеж 0 в RGB является черным, в CMYK кортеж 0 является белым. Наши принтеры содержат канистры с чернилами голубого, пурпурного, желтого и черного цветов.

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

HSV и HSL - это описания оттенка, насыщенности и яркости / яркости, которые особенно полезны для определения контраста в изображениях. Эти цветовые пространства часто используются в инструментах выбора цвета в программном обеспечении и для веб-дизайна.

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

Теперь, когда мы понимаем концепцию цветовых пространств, мы можем перейти к их использованию в OpenCV.

Простая сегментация с использованием цветовых пространств

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

Ключевые пакеты Python, которым вы должны следовать, - это NumPy, самый передовой пакет для научных вычислений на Python, Matplotlib, библиотека для построения графиков и, конечно же, OpenCV. В этой статье используются OpenCV 3.2.0, NumPy 1.12.1 и Matplotlib 2.0.2. Немного разные версии не будут иметь большого значения с точки зрения понимания концепций.

Если вы не знакомы с NumPy или Matplotlib, вы можете прочитать о них в официальном руководстве по NumPy и в отличной статье Брэда Соломона о Matplotlib.

Цветовые пространства и чтение изображений в OpenCV

Во-первых, вам нужно настроить вашу среду. В этой статье предполагается, что в вашей системе установлен Python 3.x. Обратите внимание, что хотя текущая версия OpenCV - 3.x, имя импортируемого пакета по-прежнему cv2 :

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

  >>> flags = [i вместо i в каталоге (cv2), если i. startswith ('COLOR_')]
  

Список и количество флагов могут незначительно отличаться в зависимости от вашей версии OpenCV, но в любом случае их будет много! Посмотрите, сколько у вас флагов:

  >>> len (флаги)
258
>>> флаги [40]
'COLOR_BGR2RGB'
  

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

Вам понадобится matplotlib.pyplot для просмотра изображений и NumPy для некоторых манипуляций с изображениями. Если у вас еще не установлен Matplotlib или NumPy, вам нужно будет установить pip3 install matplotlib и pip3 install numpy перед попыткой импорта:

  >>> import matplotlib.pyplot как plt
>>> импортировать numpy как np
  

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

  >>> nemo = cv2.imread ('./ images / nemo0.jpg ')
>>> plt.imshow (немо)
>>> plt.show ()
  

Эй, Немо… или Дори? Вы заметите, что похоже, что синий и красный каналы перепутались. Фактически, OpenCV по умолчанию считывает изображения в формате BGR. Вы можете использовать cvtColor (изображение, флаг) и флаг, который мы рассмотрели выше, чтобы исправить это:

  >>> nemo = cv2.cvtColor (nemo, cv2.COLOR_BGR2RGB)
>>> plt.imshow (немо)
>>> plt.show ()
  

Теперь Немо больше похож на себя.

Визуализация Немо в цветовом пространстве RGB

HSV - хороший выбор цветового пространства для сегментирования по цвету, но чтобы понять, почему, давайте сравним изображение в цветовом пространстве RGB и HSV, визуализировав цветовое распределение его пикселей. Трехмерный график показывает это довольно хорошо, каждая ось представляет один из каналов в цветовом пространстве. Если вы хотите узнать, как сделать 3D-график, просмотрите свернутый раздел:

Для построения сюжета вам понадобится еще несколько библиотек Matplotlib:

  >>> из mpl_toolkits.mplot3d импорт Axes3D
>>> из matplotlib import cm
>>> из matplotlib import colors
  

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

  >>> r, g, b = cv2.сплит (немо)
>>> fig = plt.figure ()
>>> axis = fig.add_subplot (1, 1, 1, projection = "3d")
  

Теперь, когда вы настроили график, вам нужно настроить цвета пикселей. Чтобы окрасить каждый пиксель в его истинный цвет, необходимо немного изменить форму и нормализовать. Это выглядит неаккуратно, но, по сути, вам нужно, чтобы цвета, соответствующие каждому пикселю изображения, были сведены в список и нормализованы, чтобы их можно было передать параметру facecolors функции Matplotlib scatter () .

Нормализация означает просто сжатие диапазона цветов от 0-255 до 0-1 , как требуется для параметра facecolors . Наконец, facecolors хочет список, а не массив NumPy:

  >>> pixel_colors = nemo.reshape ((np.shape (nemo) [0] * np.shape (nemo) [1], 3))
>>> norm = colors. Normalize (vmin = -1., vmax = 1.)
>>> norm.autoscale (pixel_colors)
>>> pixel_colors = norm (pixel_colors) .tolist ()
  

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

  >>> axis.scatter (r.flatten (), g.flatten (), b.flatten (), facecolors = pixel_colors, marker = ".")
>>> axis.set_xlabel ("Красный")
>>> axis.set_ylabel ("Зеленый")
>>> axis.set_zlabel ("Синий")
>>> plt.show ()
  

Вот цветной график рассеяния для изображения Nemo в RGB:

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

Визуализация Немо в цветовом пространстве HSV

Мы видели Немо в пространстве RGB, теперь давайте рассмотрим его в пространстве HSV и сравним.

Как вкратце упоминалось выше, HSV обозначает оттенок, насыщенность и значение (или яркость) и представляет собой цилиндрическое цветовое пространство. Цвета или оттенки моделируются как угловой размер, вращающийся вокруг центральной вертикальной оси, которая представляет канал значений.Значения изменяются от темного (0 внизу) к светлому вверху. Третья ось, насыщенность, определяет оттенки оттенка от наименее насыщенных на вертикальной оси до наиболее насыщенных, наиболее удаленных от центра:

Чтобы преобразовать изображение из RGB в HSV, вы можете использовать cvtColor () :

  >>> hsv_nemo = cv2.cvtColor (nemo, cv2.COLOR_RGB2HSV)
  

Теперь hsv_nemo хранит представление Nemo в HSV. Используя ту же технику, что и выше, мы можем посмотреть на график изображения в HSV, созданный свернутой секцией ниже:

Код для отображения изображения в формате HSV такой же, как и для RGB. Обратите внимание, что вы используете ту же переменную pixel_colors для раскраски пикселей, поскольку Matplotlib ожидает, что значения будут в RGB:

  >>> h, s, v = cv2.split (hsv_nemo)
>>> fig = plt.figure ()
>>> axis = fig.add_subplot (1, 1, 1, projection = "3d")

>>> axis.scatter (h.flatten (), s.flatten (), v.flatten (), facecolors = pixel_colors, marker = ".")
>>> axis.set_xlabel ("Оттенок")
>>> axis.set_ylabel ("Насыщенность")
>>> ось.set_zlabel ("Значение")
>>> plt.show ()
  

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

Выбор диапазона

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

  >>> light_orange = (1, 190, 200)
>>> dark_orange = (18, 255, 255)
  

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

Простым способом отображения цветов в Python является создание небольших квадратных изображений желаемого цвета и нанесение их на график в Matplotlib. Matplotlib интерпретирует цвета только в RGB, но для основных цветовых пространств предусмотрены удобные функции преобразования, так что мы можем отображать изображения в других цветовых пространствах:

  >>> из matplotlib.цвета импорт hsv_to_rgb
  

Затем постройте маленькие квадраты размером 10x10x3 , залитые соответствующим цветом. Вы можете использовать NumPy, чтобы легко заполнить квадраты цветом:

  >>> lo_square = np. full ((10, 10, 3), light_orange, dtype = np.uint8) / 255.0
>>> do_square = np.full ((10, 10, 3), dark_orange, dtype = np.uint8) / 255.0
  

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

  >>> plt.подзаговор (1, 2, 1)
>>> plt.imshow (hsv_to_rgb (do_square))
>>> plt.subplot (1, 2, 2)
>>> plt.imshow (hsv_to_rgb (lo_square))
>>> plt.show ()
  

Создает эти изображения, заполненные выбранными цветами:

Как только вы получите приличный цветовой диапазон, вы можете использовать cv2.inRange () , чтобы попытаться установить порог Nemo. inRange () принимает три параметра: изображение, нижний диапазон и верхний диапазон . Он возвращает двоичную маску ( ndarray единиц и нулей) размера изображения, где значения 1 указывают значения в пределах диапазона, а нулевые значения указывают значения за пределами:

  >>> маска = cv2.inRange (hsv_nemo, light_orange, dark_orange)
  

Чтобы наложить маску поверх исходного изображения, вы можете использовать cv2.bitwise_and () , которая сохраняет каждый пиксель в данном изображении, если соответствующее значение в маске равно 1 :

  >>> result = cv2.bitwise_and (nemo, nemo, mask = mask)
  

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

  >>> plt.подзаговор (1, 2, 1)
>>> plt.imshow (маска, cmap = "серый")
>>> plt.subplot (1, 2, 2)
>>> plt.imshow (результат)
>>> plt.show ()
  

Вот и все! Это уже проделало достойную работу по отлову оранжевых частей рыбы. Единственная проблема в том, что у Немо также есть белые полосы ... К счастью, добавление второй маски, которая ищет белые, очень похоже на то, что вы уже делали с апельсинами:

  >>> light_white = (0, 0, 200)
>>> dark_white = (145, 60, 255)
  

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

Чтобы отобразить белые, вы можете использовать тот же подход, что и мы ранее с апельсинами:

  >>> lw_square = np. полный ((10, 10, 3), light_white, dtype = np.uint8) / 255.0
>>> dw_square = np.full ((10, 10, 3), dark_white, dtype = np.uint8) / 255.0

>>> plt.subplot (1, 2, 1)
>>> plt.imshow (hsv_to_rgb (lw_square))
>>> plt.subplot (1, 2, 2)
>>> plt.imshow (hsv_to_rgb (dw_square))
>>> plt.show ()
  

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

  >>> mask_white = cv2.inRange (hsv_nemo, light_white, dark_white)
>>> result_white = cv2.bitwise_and (немо, немо, маска = маска_белая)

>>> plt.subplot (1, 2, 1)
>>> plt.imshow (mask_white, cmap = "серый")
>>> plt.subplot (1, 2, 2)
>>> plt.imshow (result_white)
>>> plt.show ()
  

Неплохо! Теперь вы можете комбинировать маски. Сложение двух масок вместе дает 1 значений везде, где есть оранжевый или белый, что как раз и нужно.Давайте сложим маски и нанесем на график результат:

  >>> final_mask = маска + маска_белая

>>> final_result = cv2.bitwise_and (nemo, nemo, mask = final_mask)
>>> plt.subplot (1, 2, 1)
>>> plt.imshow (final_mask, cmap = "серый")
>>> plt.subplot (1, 2, 2)
>>> plt.imshow (final_result)
>>> plt.show ()
  

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

Размытие по Гауссу - это фильтр изображения, который использует вид функции, называемой гауссовым, для преобразования каждого пикселя в изображении. Это приводит к сглаживанию шума на изображении и уменьшению детализации. Вот как выглядит размытие для нашего изображения:

  >>> blur = cv2.GaussianBlur (final_result, (7, 7), 0)
>>> plt. imshow (размытие)
>>> plt.show ()
  

Распространяется ли эта сегментация на родственников Немо?

Ради удовольствия, давайте посмотрим, насколько хорошо этот метод сегментации применим к другим изображениям рыб-клоунов.В репозитории есть выбор из шести изображений рыбы-клоуна от Google, лицензированных для публичного использования. Изображения находятся в подкаталоге и проиндексированы nemo i .jpg, где i - это индекс от 0-5 .

Сначала загрузите всех родственников Немо в список:

  путь = "./images/nemo"

nemos_friends = []
для i в диапазоне (6):
   friend = cv2.cvtColor (cv2.imread (путь + str (i) + ".jpg"), cv2.COLOR_BGR2RGB)
   nemos_friends.append (друг)
  

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

Вот функция segment_fish () :

  def segment_fish (изображение):
    '' 'Попытки отделить рыбу-клоуна от предоставленного изображения' ''

    # Конвертировать изображение в HSV
    hsv_image = cv2.cvtColor (изображение, cv2.COLOR_RGB2HSV)

    # Установите оранжевый диапазон
    light_orange = (1, 190, 200)
    dark_orange = (18, 255, 255)

    # Нанесите оранжевую маску
    маска = cv2.inRange (hsv_image, light_orange, dark_orange)

    # Установить белый диапазон
    light_white = (0, 0, 200)
    dark_white = (145, 60, 255)

    # Применяем белую маску
    маска_белая = cv2.inRange (hsv_image, светлый_белый, темный_белый)

    # Объедините две маски
    final_mask = маска + маска_белая
    результат = cv2.bitwise_and (изображение, изображение, маска = final_mask)

    # Очистить сегментацию с помощью размытия
    blur = cv2.GaussianBlur (результат, (7, 7), 0)
    возвратное размытие
  

С помощью этой полезной функции вы можете сегментировать всю рыбу:

  результатов = [segment_fish (друг) для друга в nemos_friends]
  

Давайте рассмотрим все результаты, построив их в виде цикла:

  для i в диапазоне (1, 6):
    plt. подзаговор (1, 2, 1)
    plt.imshow (nemos_friends [i])
    plt.subplot (1, 2, 2)
    plt.imshow (результаты [i])
    plt.show ()
  

Рыба-клоун на переднем плане имеет более темные оранжевые оттенки, чем наш ассортимент.

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

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

Заключение

В этом руководстве вы увидели, что такое несколько разных цветовых пространств, как изображение распределяется по цветовым пространствам RGB и HSV и как использовать OpenCV для преобразования между цветовыми пространствами и сегментации диапазонов.

В целом, вы узнали, как базовые знания о том, как цветовые пространства в OpenCV могут использоваться для выполнения сегментации объектов в изображениях, и, надеюсь, увидели его потенциал для решения других задач. Если освещение и фон контролируются, например, в экспериментальных условиях или с более однородным набором данных, этот метод сегментации прост, быстр и надежен.

Обнаружение и фильтрация цветов OpenCV с помощью Python

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

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

2018 Pi Wars 4.0

Я интересовался OpenCV уже несколько лет, но до сих пор не использовал его. Моя последняя мотивация работать с OpenCV - это последнее соревнование Pi Wars.Одна из задач турнира называется «Где-то над радугой». Эта задача требует, чтобы соревнующийся робот обнаружил четыре шара четырех разных цветов (красный, синий, желтый и зеленый). Робот должен подъехать к каждому мячу определенного цвета, чтобы выполнить задание и набрать наибольшее количество очков.

Итак, чтобы поработать над тем, чтобы иметь возможность участвовать в испытании Somewhere Over The Rainbow, я собираюсь посмотреть, что нужно, чтобы определить четыре разных цвета.Следовательно, определение цвета OpenCV является хорошей отправной точкой для распознавания четырех интересующих цветов - красного, синего, желтого и зеленого.

OpenCV Color Detection

OpenCV Color Detection - это только отправная точка. Конечная цель - в конечном итоге найти положение цветного элемента в кадре видеопотока с помощью кода Python 3. Итак, если я могу изолировать и отслеживать элемент в видеопотоке, я могу, например, установить путевую точку для робота.

Установка OpenCV

Чтобы запустить пример программы Python для определения цвета OpenCV, вам необходимо установить OpenCV либо на Raspberry Pi, либо на ОС Windows.

Raspberry Pi

Чтобы быстро установить OpenCV на Raspberry Pi, вы можете следовать этой статье, чтобы установить OpenCV из файла сценария оболочки. Вы можете загрузить и запустить сценарий оболочки, чтобы установить OpenCV и все зависимости за один раз.

Установите OpenCV на Raspberry Pi из сценария оболочки - Ссылка.

Windows 10

Если вы хотите запустить OpenCV в Windows 10, вам необходимо установить Python. Затем, используя диспетчер пакетов Python pip, установите библиотеки Numpy и OpenCV. Я считаю, что Python включает диспетчер пакетов pip с установкой Windows Python.

• Загрузите и установите последнюю версию программного обеспечения Python 3 для Windows.
• Затем установите следующие пакеты в командной строке Windows:

 pip3 install numpy pip3 install opencv-python 

Теперь приложение Idle должно быть доступно для запуска и редактирования кода Python в Windows.

Код примера определения цвета OpenCV

Две версии кода Python 3 для определения цвета OpenCV доступны на моем GitHub.Единственная разница между ними - это тип средств массовой информации, которые они открывают. Итак, один пример кода Python открывает файл изображения, а другой - видеопоток. Однако, если вы используете Linux или Raspberry Pi в среде виртуальной машины, такой как та, которая представлена ​​в этом посте, вы можете открывать только файлы изображений или видео.

Камера Raspberry Pi

Для моей цели и совместимости с примером кода я использую дешевую веб-камеру, совместимую с USB Raspberry Pi, от Banggood (идентификатор продукта: 1023048).Веб-камера стоимостью 5,10 британских фунтов (6,67 долларов США) намного надежнее с более длинным кабелем по сравнению с камерой Raspberry Pi.

Однако, если вы хотите использовать камеру Raspberry Pi с приведенными ниже примерами кода, проверьте ресурсы ниже, чтобы найти ссылку на руководство. Руководство объяснит, как использовать камеру Raspberry Pi в OpenCV.

Как работает пример программы на Python

Запустите приведенный ниже код с приложением Python Idle на Raspberry Pi или на рабочем столе Windows.Окна должны появиться на рабочем столе, как на изображении выше. Вы можете использовать ползунки HSV (оттенок, насыщенность, значение), чтобы выделить цвет, который вы хотите обнаружить в изображении.

При использовании ползунков графического интерфейса для определения нового цвета сначала сбросьте ползунки. Следовательно, три верхних ползунка обнуляются; нижние три идут к 255. Сначала нужно изменить низкие и высокие значения оттенка, чтобы зафиксировать желаемый цвет. Затем отрегулируйте низкую насыщенность и значение для точной настройки.

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

Проверьте в разделе Ресурсы ниже ссылки GitHub на обе версии этого кода и тестовое изображение.

Код определения цвета OpenCV

OpenCV хорошо документирован, просто погуглите метод OpenCV, с которым вы не знакомы, чтобы узнать о нем больше.

Код определения цвета OpenCV выполняет следующие шаги:

1. Загрузить образец изображения.
2. Получите значения HSV с помощью ползунков графического интерфейса.
3. Показать исходный образец изображения на рабочем столе ОС.
4. Размытие образца изображения и отображение на рабочем столе.
5. Преобразует размытое изображение в цветовую модель HSV.
6. Создайте маску из значений в диапазоне, выбранном с помощью ползунков. Затем покажите получившуюся маску.
7. Очистите маску с помощью функций преобразования морфологии. Затем покажите получившуюся маску.
8. Примените последнюю маску к исходному изображению, чтобы оставить интересующий цвет нетронутым.
9. Наконец, отобразите получившееся изображение.

Эксперимент

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

 frameBGR = cv2.GaussianBlur (кадр, (15, 15), 0) frameBGR = cv2.medianBlur (кадр, 7) frameBGR = cv2.двустороннийFilter (frame, 15, 75, 75) kernal = np.ones ((15, 15), np.float32) / 255 frameBGR = cv2.filter2D (frame, -1, kernal) 

Морфологические преобразования

Морфологические Операции преобразования, использованные в примере кода, помогли заполнить дыры в круглых цветных шарах, которые я пытался отфильтровать. Темные тени и пятна лампы могут привести к неидеальной маске изображения при использовании только цветовой фильтрации. Чтобы узнать больше о морфологических преобразованиях, посетите документацию OpenCV здесь.

 kernal = cv2.getStructuringElement (cv2.MORPH_ELLIPSE, (30, 30)) mask = cv2.morphologyEx (mask, cv2.MORPH_CLOSE, kernal) mask = cv2.morphologyEx (mask, cv2.MORPH_OPEN, kernal) 

What Next

Если у вас есть совместимая веб-камера, попробуйте версию кода Python для захвата видео. Найдите ссылку на код в разделе "Ресурсы" ниже.

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

В примере кода OpenCV, описанном в этой статье, код еще не может отслеживать AOI (интересующую область) в изображении. Об этом я и расскажу в следующей статье OpenCV.

Обнаружение и отслеживание объектов с помощью OpenCV и Python - Link.

Захват видео с камеры Pi с многопоточностью OpenCV и Python - Ссылка.

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