Установка

Opencv python установка: Установка OpenCV-Python на виртуальной среде для суперчайников / Хабр

Содержание

Установка OpenCV-Python на виртуальной среде для суперчайников / Хабр

Здесь вы найдете пошаговый пример установки библиотеки OpenCV на Python.

  • Установка Python
  • Установка виртуальной среды
  • Установка OpenCV + jupiterlab, numpy, matplotlib
  • Тестирование

Все тестировала на планшете Microsoft Surface, Windows 10 Pro, c 64-битной операционной системой.

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

  1. Сначала установим Python.

    Скачиваем нужную версию и запускаем .exe файл. Не забываем установить галочку add path. Я установила Python 3.7.3 от 25 марта 2019 г., потому что новая на данный момент версия Python 3.7.4 от 8го июля 2019 г. работала некорректно, а именно в терминале некоторые команды зависали. Открываем командную строку.
  2. Устанавливаем virtualenv.

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

    Пакеты будем устанавливать с помощью pip. Он в последнее время сразу идет с Python, но обычно требуется его обновить командой:
    python -m pip install --upgrade pip

    Обновили pip, теперь установим виртуальную среду:
    pip install virtualenv

    Командой cd перейдите в папку, в которой хотите создать среду и введите команду:
    mkdir opencvtutorial_env — так мы создали среду с названием opencvtutorial_env.

    Далее вводим команду virtualenv opencvtutorial_env и для активации перейдите в папку среды и далее с помощью Tab до activate.
    .\opencvtutorial_env\Scripts\activate
  3. Установим библиотеки OpenCV-Python, Numpy и Matplotlib, которые понадобятся для тестирования функций opencv.

    Самый легкий и быстрый вариант установки у меня получился с неофициальной версии. Устанавливаем его командой:
    pip install opencv-python

    Вместе с opencv-python в подарок с этим пакетом идет numpy. Дополнительно установим matplotlib: pip install matplotlib.
  4. Установим pip install jupyterlab и запустим его командой jupyter notebook.

    Теперь осталось проверить все ли у нас работает. В открывшемся окне создаем новый Python 3 файл, и запускаем команду:
    import cv2 as cv
    print( cv.__version__ )

    Если выходит версия opencv, то поздравляю, можно тестировать туториалы c официального сайта. Мои примеры работ по туториалам можно найти здесь.

Введение в OpenCV — библиотеку компьютерного зрения на Python

Введение

В этом руководстве мы изучим, как использовать библиотеку OpenCV в Python.

OpenCV — это библиотека с открытым кодом, поддерживающая множество платформ, включая Windows, MacOs и Linux. Также эта библиотека существует и для многих языков программирования. Но наиболее часто она используется для написания приложений машинного обучения на языке Python, особенно в сфере компьютерного зрения.

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

В этой статье мы научим вас устанавливать библиотеку OpenСV на платформы Windows, MacOS и Linux. Также мы расскажем про операции с изображениями, арифметику изображений, сглаживание изображений и геометрические трансформации изображений при помощи библиотеки OpenCV. Приступим!

Установка библиотеки

Замечание: так как мы рассматриваем использование библиотеки OpenСV для языка Python, то неявно подразумевается, что сам Python ( версии 3) у вас уже установлен. Для установки библиотеки OpenCV выполните одну из следующих команд, в зависимости от вашей операционной системы.

Windows

$ pip install opencv-python

MacOS

$ brew install opencv3 --with-contrib --with-python3

Linux

$ sudo apt-get install libopencv-dev python-opencv

Для проверки результата установки просто введите в терминале Python следующую команду:

import cv2

Если не появилось сообщение об ошибке, значит библиотека была установлена успешно.

Основные операции с изображениями

Установив OpenCV, давайте теперь, так сказать, пощупаем основные функциональные возможности данной библиотеки.

Вывод изображения на экран

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

Для вывода изображения на экран нам необходимо задать две вещи:

  1. Путь к файлу, в котором содержится изображение (подойдет как относительный, так и абсолютный путь).
  2. Режим чтения файла (только чтение, запись, и т.д.).

Функция, при помощи которой мы считываем изображение, называется cv2.imread(). У нее есть три режима работы. Первый — это IMREAD_GRAYSCALE. Как видно из названия, он преобразует изображение в черно-белое с оттенками серого. Второй — IMREAD_UNCHANGED, он загружает изображение без обрезания альфа-канала. И третий, используемый по умолчанию, — IMREAD_COLOR. Он просто загружает цветное изображение, используя RGB-каналы.

Вот пример кода:

import cv2

my_bike = cv2.imread('bike.png')

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

Замечание: если в результате выполнения данного кода возникла ошибка, есть только три возможных причины для этого. Первая — вы неправильно задали путь к файлу. Вторая — такого файла просто не существует, и третья — тип изображения (jpg/jpeg/png) задан неверно.

Теперь давайте выведем на экран только что загруженное изображение. Для этого используется функция cv2.imshow(). Если вы пользовались Matlab, ее работа должны быть вам знакома.

cv2.imshow('my_bike', my_bike)

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

Сохранение изображений

Для сохранения результатов нашей работы с изображениями в библиотеке OpenCV существует функция cv2.imwrite().

Вот пример ее использования:

cv2.imwrite('bike.png', my_bike)

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

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

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

Из всего множества возможных операций мы рассмотрим только два примера, которые помогут нам понять концепцию арифметических операций в библиотеке OpenСV. В качестве первого примера мы возьмем сложение двух изображений, а в качестве второго — их смешение (blending).

Давайте рассмотрим код этих примеров.

Сложение изображений

import cv2

# Считываем два изображения
image_1 = cv2.imread('bike.jpg')
image_2 = cv2.imread('car.jpg')

# Суммируем массивы двух изображений по всем каналам
result = cv2.add(image_1, image_2)

cv2.imshow('result', result)
cv2.waitKey(0)
cv2.destroyAllWindows()

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

Смешение изображений

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

Чтобы прояснить это, давайте рассмотрим код:

import cv2

# Считываем два изображения
image_1 = cv2.imread('bike.jpg')
image_2 = cv2.imread('car.jpg')

result = cv2.addWeighted(image_1, 0.9, image_2, 0.1)

cv2.imshow('result', result)
cv2.waitKey(0) # Программа останавливается до нажатия любой клавиши
cv2.destroyAllWindows() 

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

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

Сглаживание изображений

Сглаживание изображений является крайне полезной операцией и очень часто используется перед тем как передать картинку для обработки в модель машинного обучения. В основном это нужно делать для фильтрации высокочастотных шумов, применяя для этого низкочастотный фильтр. Существует множество различных фильтров, например усредняющий фильтр (box filter), медианный фильтр (median filter), фильтр типов волн (модовый фильтр, mode filter), фильтр Гаусса (Gaussian filter) и многие другие. Но для понимания сглаживания изображений и его применения в библиотеке OpenCV, мы рассмотрим только первый, усредняющий фильтр (box filter).

Допустим, у вас есть изображение размером 10X10 и вы хотите его пропустить через усредняющий фильтр размером 3Х3. Как вы будете действовать?

Мы начнем с крайнего левого угла нашего изображения, поместим туда фильтр размером 3Х3 и заменим центральный элемент на среднее по всем девяти элементам (сумма элементов, попавших в фильтр, деленная на 9). Это будет только первым этапом. Далее мы сдвинем фильтр на один шаг вправо и повторим эту процедуру. Ниже этот пример наглядно проиллюстрирован.

Фильтр или маска:

Применение фильтра к изображению размером 10Х10:

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

import cv2

# Загрузка первоначального изображения
original_image = cv2.imread('my_bike.png')

# Фильтрация изображения усредняющим фильтром 3Х3
average_image = cv2.blur(original_image,(3,3))

# Применение фильтра Гаусса к первоначальному изображению
gaussian_image = cv2.GaussianBlur((original_image,(3,3),0))

# Применение медианного фильтра к первоначальному изображению
median_image = cv2.medianBlur(original_image,3)

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

import matplotlib.pyplot as plt

plt.imshow(average_image)
plt.show()

Преобразование изображений

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

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

Масштабирование

Попросту говоря, масштабирование — это не что иное как изменение размеров изображения, его увеличение либо уменьшение. В библиотеке OpenCV для этого существует функция resize. У этой функции, в свою очередь, есть три метода: INTER_CUBICINTER_LINEAR и INTER_AREA. Давайте на примере конкретного кода разберем, как это все работает. Пожалуйста, внимательно изучите код, комментарии к нему и описание ниже.

import cv2
import numpy as np
import matplotlib.pyplot as plt

image = cv2.imread('my_bike.jpg')

# Увеличиваем масштаб/расширяем в 2 раза по ширине и высоте
result_1 = cv2.resize(image, None, fx=2, fy=2, interpolation=cv2.INTER_CUBIC)

# Уменьшаем масштаб/сжимаем в 2 раза по ширине и высоте
result_2 = cv2.resize(image, None, fx=2, fy=2, interpolation=cv2.INTER_AREA)

# Выводим на экран получившиеся изображения
plt.imshow(result_1)
plt.imshow(result_2)
plt.show()

Здесь в функции resize параметр fx определяет масштаб изменений по ширине, fy — по высоте, а параметр interpolation отвечает за сам способ изменений (то есть расширение или сжатие).

Вращение

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

Перед тем как мы научимся вращать наши изображения при помощи библиотеки OpenСV, давайте вспомним, что существует линейный оператор под названием матрица поворота, который как раз и осуществляет преобразования такого рода. Мы не будем вдаваться в математические детали, так как в библиотеке OpenCV эта матрица вычисляется при помощи одного вызова функции. Вы это увидите в следующем коде:

import cv2
import matplotlib.pyplot as plt

# Загружаем изображение велосипеда
image = cv2.imread('my_bike.jpg',0)

# ряды и колонки
r, c = image.shape

matrix = cv2.getRotationMatrix2D((cols/2,rows/2), 180, 1)
result = cv2.warpAffine(image,matrix,(c,r))

# Выводим на экран повернутое изображение
plt.imshow(result)
plt.show()

В функции getRotationMatrix2D 180 — это угол, на который наше изображение должно быть повернуто, 1 — это масштабный коэффициент. Данная функция возвращает матрицу поворота, которая записывается в переменную matrix.

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

Выводы

Подводя итоги, давайте еще раз пройдемся по наиболее важным местам в нашей статье. Библиотека OpenCV доступна на многих языках и часто используется вместе с библиотеками NumPy, SciPy и Matplotlib, как мы могли заметить в приведенных примерах. Некоторые функции библиотеки взяты из Matlab и также поддерживают векторные вычисления, что сильно повышает вычислительную эффективность.

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

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

OpenCV в Python. Часть 1 / Хабр

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

Введение

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

Установка

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

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

Перед тем как перейти к практике, нам нужно разобраться немного с теорией. Каждое изображение состоит из набора пикселей. Пиксель — это строительный блок изображения. Если представить изображение в виде сетки, то каждый квадрат в сетке содержит один пиксель, где точке с координатой ( 0, 0 ) соответствует верхний левый угол изображения. К примеру, представим, что у нас есть изображение с разрешением 400×300 пикселей. Это означает, что наша сетка состоит из 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

Вы здесь:
Главная — Python — Основы Python — Работа с OpenCV в Python



Компьютерное зрение — это одно из самых популярных направлений в программировании. Оно сегодня присутствует в том или ином виде практически
везде, так, что легче сказать где оно есть, чем где его нет. Из примеров, это например, популярное, до своего исчезновения из открытого доступа, приложение FindFace, которое помогало найти людей в социальной сети по их фотографии.

В общем областей применения распознавание изображений превеликое множество. И в Python как раз есть возможность начать работать с этим направлением
посредством библиотеки opencv.


Opencv библиотека с открытым исходным кодом, содержащей более 2500 алгоритмов обработки изображений и работы с видеопотоком. Простейшие действия доступные в Opencv — это: открытие изображений, и видеопотоков, наложение текста и других объектов, наложение на изображение фильтров, искажение. Из сложных создание программ по распознаванию различных объектов реального мира и человеческих лиц в том числе. Т.е. Opencv — это библиотека для создания современных приложений. В качестве интерфейсов доступа к библиотеке, используются такие языки программирования как Java, Python, C#, C++ другие.

Прежде всего устанавливаем саму библиотеку: в командной строке вводим команду




pip install opencv

Далее импортируем модуль командой




import cv2

#Смотрим версию пакета так:

print(cv2.__version__)


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




# img будет содержать данные в ввиде массива или матрицы пикселей, 

img = cv2.imread("image1.jpeg", 1) # аргумент 1 - есть вывод в цветном формате, другой вариант 0 - для черно-белого.

# Для отображения данного массива в визуальной форме и используется метод imshow() oбъекта cv2

cv2.imshow("image", img)

print(img)

# ну и чтобы увидеть само изображение на экране добавим

k = cv2.waitKey(0) со значением 0, или же 5000 - исчезнет через 5000 миллисекунд. 

# И в конце 

cv2.destroyAllWindows().


Вот просто можно начать работать с opencv в Python.


  • Создано 10.03.2020 09:27:11



  • Михаил Русаков

Предыдущая статья Следующая статья

Копирование материалов разрешается только с указанием автора (Михаил Русаков) и индексируемой прямой ссылкой на сайт (http://myrusakov.ru)!

Добавляйтесь ко мне в друзья ВКонтакте: http://vk.com/myrusakov.
Если Вы хотите дать оценку мне и моей работе, то напишите её в моей группе: http://vk.com/rusakovmy.

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

Если у Вас остались какие-либо вопросы, либо у Вас есть желание высказаться по поводу этой статьи, то Вы можете оставить свой комментарий внизу страницы.

Порекомендуйте эту статью друзьям:

Если Вам понравился сайт, то разместите ссылку на него (у себя на сайте, на форуме, в контакте):


  1. Кнопка:

    <a href=»https://myrusakov.ru» target=»_blank»><img src=»https://myrusakov.ru/images/button.gif» alt=»Как создать свой сайт» /></a>

    Она выглядит вот так:


  2. Текстовая ссылка:
    <a href=»https://myrusakov.ru» target=»_blank»>Как создать свой сайт</a>

    Она выглядит вот так: Как создать свой сайт

  3. BB-код ссылки для форумов (например, можете поставить её в подписи):

    [URL=»https://myrusakov.ru»]Как создать свой сайт[/URL]

Введение в обработку изображений в Python с OpenCV 

В этом уроке мы узнаем, как мы можем выполнять обработку изображений с использованием языка Python. Мы не собираемся ограничиваться одной библиотекой или структурой; однако есть одна, которую мы будем использовать чаще всего, — библиотека Open CV. Мы начнем с небольшого разговора об обработке изображений, а затем перейдем к рассмотрению различных приложений / сценариев, где обработка изображений может оказаться полезной. Итак, начнем!

Что такое обработка изображений?

Важно знать, что именно представляет собой обработка изображений и какова ее роль в общей картине, прежде чем углубляться в ее принципы. Обработка изображений чаще всего называется «Цифровая обработка изображений», а область, в которой она часто используется, — «Компьютерное зрение». Не смущайтесь — мы поговорим об этих терминах и о том, как они связаны. Оба алгоритма обработки изображений и алгоритмы Computer Vision (CV) принимают изображение в качестве входных данных; однако при обработке изображения вывод также является изображением, тогда как в компьютерном зрении выводом могут быть некоторые особенности / информация об изображении.

Зачем нам это нужно?

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

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

Это только одна из многих причин, по которым обработка изображений необходима для любого приложения компьютерного зрения.

Предпосылки

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

Чтобы следовать этому уроку, вы должны определенно знать, как именно изображение представляется в памяти. Каждое изображение представлено набором пикселей, то есть матрицей значений пикселей. Для изображения в градациях серого значения пикселей варьируются от 0 до 255, и они представляют интенсивность этого пикселя. Например, если у вас есть изображение размером 20 x 20, оно будет представлено матрицей 20 x 20 (всего 400-пиксельных значений).

Если вы имеете дело с цветным изображением, вы должны знать, что оно будет иметь три канала — Красный, Зеленый и Синий (RGB). Следовательно, было бы три таких матрицы для одного изображения.

Установка

Примечание. Поскольку мы собираемся использовать OpenCV через Python, подразумевается, что на вашей рабочей станции уже установлен Python (версии 3).

Windows
pip install opencv-python
MacOS
brew install opencv3 --with-contrib --with-python3
Linux
sudo apt-get install libopencv-dev python-opencv

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

Некоторые основы, которые вы должны знать

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

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

Примечание. Исходный размер, который мы используем, составляет около 1180×786.

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

Поиск деталей изображения

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

import cv2

img = cv2.imread('rose.jpg')

print("Image Properties")
print("- Number of Pixels: " + str(img.size))
print("- Shape/Dimensions: " + str(img.shape))

Выход:

Image Properties
- Number of Pixels: 2782440
- Shape/Dimensions: (1180, 786, 3)
Разделение изображения на отдельные каналы

Теперь мы разделим изображение на его красные, зеленые и синие компоненты с помощью OpenCV и отобразим их:

from google.colab.patches import cv2_imshow

blue, green, red = cv2.split(img) # Split the image into its channels
img_gs = cv2.imread('rose.jpg', cv2.IMREAD_GRAYSCALE) # Convert image to grayscale

cv2_imshow(red) # Display the red channel in the image
cv2_imshow(blue) # Display the red channel in the image
cv2_imshow(green) # Display the red channel in the image
cv2_imshow(img_gs) # Display the grayscale version of image

Для краткости мы просто покажем изображение в градациях серого.

Изображение в градациях серого:

Thresholding изображения (сегментация)

Концепция сегментации довольно проста. Как обсуждалось выше в представлении изображения, значениями пикселей могут быть любые значения от 0 до 255. Допустим, мы хотим преобразовать изображение в двоичное изображение, то есть назначить пикселю значение 0 или 1. Для этого мы можем выполнить сегментацию. Например, если значение Threshold(T) равно 125, тогда всем пикселям со значениями больше 125 будет присвоено значение 1, а всем пикселям со значениями, меньшими или равными этому, будет присвоено значение 0. Давайте сделаем это через код, чтобы получить лучшее понимание.

Изображение, используемое для Thresholding:

import cv2

# Read image
img = cv2.imread('image.png', 0)

# Perform binary thresholding on the image with T = 125
r, threshold = cv2.threshold(img, 125, 255, cv2.THRESH_BINARY)
cv2_imshow(threshold)

Выход:

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

Приложения

1: удаление шума с изображения

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

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

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

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

import numpy as np

# Adding salt & pepper noise to an image
def salt_pepper(prob):
      # Extract image dimensions
      row, col = img_gs.shape

      # Declare salt & pepper noise ratio
      s_vs_p = 0.5
      output = np.copy(img_gs)

      # Apply salt noise on each pixel individually
      num_salt = np.ceil(prob * img_gs.size * s_vs_p)
      coords = [np.random.randint(0, i - 1, int(num_salt))
            for i in img_gs.shape]
      output[coords] = 1

      # Apply pepper noise on each pixel individually
      num_pepper = np.ceil(prob * img_gs.size * (1. - s_vs_p))
      coords = [np.random.randint(0, i - 1, int(num_pepper))
            for i in img_gs.shape]
      output[coords] = 0
      cv2_imshow(output)

      return output

# Call salt & pepper function with probability = 0.5
# on the grayscale image of rose
sp_05 = salt_pepper(0.5)

# Store the resultant image as 'sp_05.jpg'
cv2.imwrite('sp_05.jpg', sp_05)

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

Шумное изображение:

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

Арифметический фильтр с Sharpening Kernel
# Create our sharpening kernel, the sum of all values must equal to one for uniformity
kernel_sharpening = np.array([[-1,-1,-1],
                              [-1, 9,-1],
                              [-1,-1,-1]])

# Applying the sharpening kernel to the grayscale image & displaying it.
print("\n\n--- Effects on S&P Noise Image with Probability 0.5 ---\n\n")

# Applying filter on image with salt & pepper noise
sharpened_img = cv2.filter2D(sp_05, -1, kernel_sharpening)
cv2_imshow(sharpened_img)

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

Выход арифметического фильтра:

Фильтр средней точки
from scipy.ndimage import maximum_filter, minimum_filter

def midpoint(img):
    maxf = maximum_filter(img, (3, 3))
    minf = minimum_filter(img, (3, 3))
    midpoint = (maxf + minf) / 2
    cv2_imshow(midpoint)

print("\n\n---Effects on S&P Noise Image with Probability 0.5---\n\n")
midpoint(sp_05)

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

Выход фильтра средней точки:

Контрагармонический средний фильтр

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

def contraharmonic_mean(img, size, Q):
    num = np.power(img, Q + 1)
    denom = np.power(img, Q)
    kernel = np.full(size, 1.0)
    result = cv2.filter2D(num, -1, kernel) / cv2.filter2D(denom, -1, kernel)
    return result

print("\n\n--- Effects on S&P Noise Image with Probability 0.5 ---\n\n")
cv2_imshow(contraharmonic_mean(sp_05, (3,3), 0.5))

Результирующее изображение от применения фильтра Contraharmonic Mean к изображению с шумом соли и перца показано ниже. При сравнении с исходным изображением в градациях серого мы видим, что оно воспроизводило почти то же самое изображение, что и исходное. Его уровень интенсивности / яркости одинаков, и он также выделяет яркие пятна на розе. Следовательно, мы можем сделать вывод, что фильтр с контрастным антигармоническим эффектом очень эффективен для борьбы с шумом соли и перца.

Результат работы контрагармонического среднего фильтра:

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

2: Обнаружение края с помощью Canny Edge Detector

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

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

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

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

import cv2
import numpy as np
from matplotlib import pyplot as plt

# Declaring the output graph's size
plt.figure(figsize=(16, 16))

# Convert image to grayscale
img_gs = cv2.imread('cat.jpg', cv2.IMREAD_GRAYSCALE)
cv2.imwrite('gs.jpg', img_gs)

# Apply canny edge detector algorithm on the image to find edges
edges = cv2.Canny(img_gs, 100,200)

# Plot the original image against the edges
plt.subplot(121), plt.imshow(img_gs)
plt.title('Original Gray Scale Image')
plt.subplot(122), plt.imshow(edges)
plt.title('Edge Image')

# Display the two images
plt.show()

Результат обнаружения края:

Как вы можете видеть, часть изображения, которая содержит объект, который в данном случае является кошкой, была расставлена ​​точками / отделена посредством обнаружения края. Теперь вам должно быть интересно, что такое Canny Edge Detector и как он это сделал; так что давайте обсудим это сейчас.

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

В конце он выполняет гистерезисный порог; мы сказали выше, что есть скачок в значении первой производной на ребре, но мы не указали, «насколько высоким» должен быть скачок, чтобы его можно было классифицировать как ребро — это называется порогом! Ранее в этом уроке мы обсуждали, что такое простой порог. Гистерезисный порог является улучшением в том, что он использует два пороговых значения вместо одного. Причина этого заключается в том, что если пороговое значение слишком высокое, мы можем пропустить некоторые фактические ребра (истинные негативы), а если значение слишком низкое, мы получим множество точек, классифицированных как ребра, которые на самом деле не являются ребрами (ложные срабатывания). Одно пороговое значение установлено высоким, а другое низким. Все точки, которые находятся выше «верхнего порогового значения», обозначены как ребра, затем оцениваются все точки, которые находятся выше нижнего порогового значения, но ниже верхнего порогового значения; точки, которые близки или являются соседями точек, которые были определены как ребра, также идентифицируются как ребра, а остальные отбрасываются.

Это базовые концепции / методы, которые алгоритм Canny Edge Detector использует для идентификации краев на изображении.

Установка python3-opencv в Ubuntu / Linux Mint

Установка:

Для установки python3-opencv в Ubuntu / Linux Mint, введите в Терминал:

sudo apt update

sudo apt install python3-opencv

Подробная информация о пакете:

Связи Python 3 для библиотеки компьютерного зрения



Источник: https://packages.ubuntu.com

Навигация по записям

  • Зависимости:

  • libc6

    Библиотека GNU C: общие библиотеки

  • libgcc1

    Библиотека поддержки GCC

  • libopencv-calib3d3.2

    Компьютерная камера

  • libopencv-contrib3.2

    Библиотека компьютерного зрения contrlib

  • libopencv-core3.2

    Компьютерная система видеонаблюдения

  • libopencv-features2d3.2

    Компьютерное зрение Библиотека детектирования функций и дескрипторов

  • libopencv-flann3.2

    Компьютерное видение Кластеризация и поиск в библиотеке многомерных пространств

  • libopencv-highgui3.2

    Компьютерное зрение Высокоуровневый графический интерфейс и медиа-библиотека ввода-вывода

  • libopencv-imgcodecs3.2

    Компьютерное изображение Image Codecs library

  • libopencv-imgproc3.2

    Компьютерная библиотека обработки изображений

  • libopencv-ml3.2

    Компьютерное зрение

  • libopencv-objdetect3.2

    Компьютерное зрение Библиотека обнаружения объектов

  • libopencv-photo3.2

    Библиотека вычислительной фотографии компьютерного зрения

  • libopencv-shape3.2

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

  • libopencv-stitching3.2

    Библиотека сшивки изображений компьютерного зрения

  • libopencv-superres3.2

    Компьютерное видение Библиотека супер разрешений

  • libopencv-video3.2

    Компьютерное зрение Библиотека видеоанализа

  • libopencv-videoio3.2

    Библиотека видеообъявлений

  • libopencv-videostab3.2

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

  • libopencv-viz3.2

    Компьютерная визуализация 3D-библиотека визуализации данных

  • libstdc++6

    Стандартная библиотека GNU GNU v3

  • python3

    Интерактивный высокоуровневый объектно-ориентированный язык (версия python3 по умолчанию)

  • python3-numpy

    Быстрое создание массива на языке Python 3

  • python3-numpy-abi9

OpenCV python — сегментируем рыбок, разбираемся в цветовых пространствах

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

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

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

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

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

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

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

Цвет Значение RGB
Красный 255, 0, 0
Оранжевый 255, 128, 0
Розовый 255, 153, 255

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

В издательском деле используется CMYK, потому что оно описывает комбинации, которые необходимы для получения цвета на белом фоне. Если в RGB кортеж 0 — это черный, то в CMYK — это белый. Таким образом принтеры содержат картриджи с голубым, пурпурным, желтым и черным цветами.

Подписывайтесь на телеграм каналы

В определенных областях медицины сканируются стеклянные слайды с образцами окрашенной ткани. Они сохраняются в виде изображений. Такие анализируются в пространстве HED — представлении насыщенности типов краски — гематоксилина, эозина и 3,3’-Диаминобензидина.

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

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

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

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

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

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

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

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

import cv2

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

flags = [i for i in dir(cv2) if i.startswith('COLOR_')]

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

>>> len(flags)
258
>>> flags[40]
'COLOR_BGR2RGB'

Первые символы после COLOR обозначают оригинальное цветовое пространство, а символы после 2 — целевое. Этот флаг представляет преобразование из BGR (Blue, Green, Red) в RGB. Эти пространства очень похожи. У них лишь отличаются значения первого и последнего каналов.

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

Архив с изображениями

import matplotlib.pyplot as plt
import numpy as np

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

nemo = cv2.imread('./images/nemo0.jpg')
plt.imshow(nemo)
plt.show()

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

nemo = cv2.cvtColor(nemo, cv2.COLOR_BGR2RGB)
plt.imshow(nemo)
plt.show()

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

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

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

Вот график цветового рассеивания изображения Немо в RGB:

Здесь можно видеть, что оранжевые элементы изображения распределены по всем значениям красного, зеленого и синего. Таким образом сегментировать Немо в пространстве RGB на основе значений RGB — совсем не простая задача.

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

Теперь посмотрим, как будет выглядеть Немо в пространстве HSV и сравним результаты.

Как уже упоминалось, HSV — это Hue, Saturation и Value (оттенок, насыщенность и яркость). Это цилиндрическое цветовое пространство. Цвета, или оттенки, меняются при движении по кругу цилиндра. Вертикальная ось отвечает за яркость: от темного (0 в нижней части) до светлого сверху. Третья ось, насыщенность, определяет тени оттенков при движении от центра к краю вдоль радиуса цилиндра (от менее к более насыщенному)

Для конвертации из RGB в HSV можно использовать cvtColor():

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

Сейчас hsv_nemo хранит представление Немо в HSV. С помощью уже знакомой техники можно посмотреть на график изображения в HSV:

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

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

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

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

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

mask = cv2.inRange(hsv_nemo, light_orange, dark_orange)

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

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

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

plt.subplot(1, 2, 1)
plt.imshow(mask, cmap="gray")
plt.subplot(1, 2, 2)
plt.imshow(result)
plt.show()

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

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

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

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

mask_white = cv2.inRange(hsv_nemo, light_white, dark_white)
result_white = cv2.bitwise_and(nemo, nemo, mask=mask_white)

plt.subplot(1, 2, 1)
plt.imshow(mask_white, cmap="gray")
plt.subplot(1, 2, 2)
plt.imshow(result_white)
plt.show()

Неплохо. Теперь можно объединить маски. В таком случае единицы будут в тех местах, где значения — белый или оранжевый, что и требуется для получения результата. Соединим маски и посмотрим на результат:

final_mask = mask + mask_white

final_result = cv2.bitwise_and(nemo, nemo, mask=final_mask)
plt.subplot(1, 2, 1)
plt.imshow(final_mask, cmap="gray")
plt.subplot(1, 2, 2)
plt.imshow(final_result)
plt.show()

По сути, грубая сегментация Немо в пространстве HSV уже готова. Все еще есть «блуждающие» пиксели вдоль границы сегментации, но их можно исправить с помощью гауссовского размытия.

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

blur = cv2.GaussianBlur(final_result, (7, 7), 0)
plt.imshow(blur)
plt.show()

Обобщает ли эта сегментация родственников Немо?

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

В первую очередь загрузим их все в список:

path = "./images/nemo"

nemos_friends = []
for i in range(6):
   friend = cv2.cvtColor(cv2.imread(path + str(i) + ".jpg"), cv2.COLOR_BGR2RGB)
   nemos_friends.append(friend)

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

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

    
    hsv_image = cv2.cvtColor(image, cv2.COLOR_RGB2HSV)

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

    
    mask = cv2.inRange(hsv_image, light_orange, dark_orange)

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

    
    mask_white = cv2.inRange(hsv_image, light_white, dark_white)

    
    final_mask = mask + mask_white
    result = cv2.bitwise_and(image, image, mask=final_mask)

    
    blur = cv2.GaussianBlur(result, (7, 7), 0)
    return blur

Таким образом сегментация превращается в одну строку:

results = [segment_fish(friend) for friend in nemos_friends]

Посмотрим на результаты в цикле:

for i in range(1, 6):
    plt.subplot(1, 2, 1)
    plt.imshow(nemos_friends[i])
    plt.subplot(1, 2, 2)
    plt.imshow(results[i])
    plt.show()

У рыбы на переднем плане оранжевые оттенки темнее выбранного диапазона.

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

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

Выводы

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

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

OpenCV: установить OpenCV-Python в Windows

Goals

В этом руководстве

  • Мы научимся настраивать OpenCV-Python в вашей системе Windows.

Следующие шаги протестированы на машине с Windows 7-64 бит с Visual Studio 2010 и Visual Studio 2012. На снимках экрана показан VS2012.

Установка OpenCV из готовых двоичных файлов

  1. Нижеуказанные пакеты Python должны быть загружены и установлены в места по умолчанию.
    1. Python 3.x (3.4+) или Python 2.7.x отсюда.
    2. Пакет Numpy (например, с помощью команды pip install numpy ).
    3. Matplotlib ( pip install matplotlib ) ( Matplotlib не является обязательным, но рекомендуется, поскольку мы часто используем его в наших учебных пособиях ).
  2. Установите все пакеты в их расположение по умолчанию. Python будет установлен на C: / Python27 / в случае Python 2.7.
  3. После установки откройте Python IDLE. Введите import numpy и убедитесь, что Numpy работает нормально.
  4. Загрузите последний выпуск OpenCV с сайта GitHub или SourceForge и дважды щелкните его, чтобы извлечь.
  5. Перейти к папке opencv / build / python / 2.7 .
  6. Скопируйте cv2.pyd в C: / Python27 / lib / site-packages .
  7. Откройте Python IDLE и введите следующие коды в терминале Python.

    >>> импортировать cv2 как cv

    >>> print (cv .__ version__)

Если результаты распечатываются без ошибок, поздравляем !!! Вы успешно установили OpenCV-Python.

Сборка OpenCV из исходников

  1. Загрузите и установите Visual Studio и CMake.
    1. Visual Studio 2012
    2. CMake
  2. Загрузите и установите необходимые пакеты Python в места по умолчанию

    1. Python
    2. Numpy
    Примечание
    В этом случае мы используем 32-битные двоичные файлы пакетов Python. Но если вы хотите использовать OpenCV для x64, необходимо установить 64-битные двоичные файлы пакетов Python.Проблема в том, что официальных 64-битных двоичных файлов Numpy нет. Вы должны построить это самостоятельно. Для этого вы должны использовать тот же компилятор, который использовался для сборки Python. Когда вы запускаете Python IDLE, он показывает детали компилятора. Вы можете получить больше информации здесь. Таким образом, ваша система должна иметь ту же версию Visual Studio и собирать Numpy из исходного кода.
    Другой способ получить 64-битные пакеты Python — это использовать готовые дистрибутивы Python от сторонних производителей, таких как Anaconda, Enthought и т. Д. Он будет больше по размеру, но в нем будет все, что вам нужно.Все в одной оболочке. Вы также можете скачать 32-битные версии.
  3. Убедитесь, что Python и Numpy работают нормально.
  4. Загрузите исходный код OpenCV. Это может быть Sourceforge (для официальной версии выпуска) или из Github (для последней версии).
  5. Распакуйте его в папку opencv и создайте в ней новую папку build.
  6. Откройте CMake-gui ( Пуск> Все программы> CMake-gui )
  7. Заполните поля следующим образом (см. Изображение ниже):
    1. Щелкните Browse Source… и найдите папку opencv.
    2. Щелкните Browse Build … и найдите созданную нами папку сборки.
    3. Щелкните Настроить .

      изображение

    4. Откроется новое окно для выбора компилятора. Выберите соответствующий компилятор (здесь Visual Studio 11) и нажмите Готово .

      изображение

    5. Дождитесь завершения анализа.
  8. Вы увидите, что все поля отмечены красным.Щелкните поле С , чтобы развернуть его. Он решает, какие дополнительные функции вам нужны. Так что отметьте соответствующие поля. См. Изображение ниже:

    изображение

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

    изображение

  10. В остальных полях указывается, какие модули должны быть построены. Поскольку модули графического процессора еще не поддерживаются OpenCV-Python, вы можете полностью избежать этого, чтобы сэкономить время (но если вы работаете с ними, оставьте их там).Смотрите изображение ниже:

    изображение

  11. Теперь щелкните поле ВКЛЮЧИТЬ , чтобы развернуть его. Убедитесь, что для ENABLE_SOLUTION_FOLDERS не установлен флажок (папки решений не поддерживаются выпуском Visual Studio Express). Смотрите изображение ниже:

    изображение

  12. Также убедитесь, что в поле PYTHON все заполнено. (Игнорировать PYTHON_DEBUG_LIBRARY). Смотрите изображение ниже:

    изображение

  13. Наконец, нажмите кнопку Создать .
  14. Теперь перейдите в нашу папку opencv / build . Там вы найдете файл OpenCV.sln . Откройте его с помощью Visual Studio.
  15. Проверьте режим сборки как Release вместо Debug .
  16. В обозревателе решений щелкните правой кнопкой мыши решение Solution (или ALL_BUILD ) и создайте его. Это займет некоторое время.
  17. Снова щелкните правой кнопкой мыши УСТАНОВИТЬ и создайте его. Теперь OpenCV-Python будет установлен.

    изображение

  18. Откройте Python IDLE и введите «import cv2 as cv». Если ошибок нет, значит, он установлен правильно.
Примечание
Мы установили без какой-либо другой поддержки, такой как TBB, Eigen, Qt, Documentation и т. Д. Было бы трудно объяснить это здесь. Скоро будет добавлено более подробное видео или можно просто пошарить.

Дополнительные ресурсы

Упражнения

Если у вас есть машина с Windows, скомпилируйте OpenCV из исходного кода.Делайте всевозможные хаки. Если вы столкнетесь с какой-либо проблемой, посетите форум OpenCV и объясните свою проблему.

.

OpenCV: установить OpenCV-Python в Ubuntu

Goals

В этом руководстве мы научимся настраивать OpenCV-Python в системе Ubuntu. Ниже приведены шаги, протестированные для Ubuntu 16.04 и 18.04 (оба 64-битных).

OpenCV-Python можно установить в Ubuntu двумя способами:

  • Установить из готовых двоичных файлов, доступных в репозиториях Ubuntu
  • Скомпилировать из исходников. В этом разделе мы увидим и то, и другое.

Еще один важный момент — требуются дополнительные библиотеки.OpenCV-Python требует только Numpy (в дополнение к другим зависимостям, которые мы увидим позже). Но в этом руководстве мы также используем Matplotlib для некоторых простых и приятных целей построения графиков (что мне кажется намного лучше по сравнению с OpenCV). Matplotlib не является обязательным, но настоятельно рекомендуется. Точно так же мы также увидим IPython , интерактивный терминал Python, который также настоятельно рекомендуется.

Установка OpenCV-Python из готовых двоичных файлов

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

Установите пакет python-opencv с помощью следующей команды в терминале (как пользователь root).

$ sudo apt-get install python-opencv

Откройте Python IDLE (или IPython) и введите следующие коды в терминале Python.

import cv2 as cv

print (cv .__ version__)

Если результаты распечатываются без ошибок, поздравляем !!! Вы успешно установили OpenCV-Python.

Это довольно просто. Но с этим есть проблема. Репозитории Apt могут не всегда содержать последнюю версию OpenCV.Например, на момент написания этого руководства репозиторий apt содержал 2.4.8, а последняя версия OpenCV — 3.x. Что касается Python API, последняя версия всегда будет содержать гораздо лучшую поддержку и последние исправления ошибок.

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

Сборка OpenCV из исходников

Компиляция из исходных текстов поначалу может показаться немного сложной, но как только вам это удастся, в этом нет ничего сложного.

Сначала мы установим некоторые зависимости. Некоторые из них являются обязательными, некоторые — необязательными. Вы можете пропустить необязательные зависимости, если не хотите.

Обязательные зависимости сборки

Нам нужны CMake для настройки установки, GCC для компиляции, Python-devel и Numpy для создания привязок Python и т. Д.

sudo apt-get install cmake

sudo apt-get install gcc g ++

для поддержки python2:

sudo apt-get install python-dev python-numpy

для поддержки python3:

sudo apt-get install python3-dev python3-numpy

Далее нам понадобится поддержка GTK для функций графического интерфейса, поддержка камеры (v4l), поддержка мультимедиа (ffmpeg, gstreamer) и т. Д.

sudo apt-get install libavcodec-dev libavformat-dev libswscale-dev

sudo apt-get install libgstreamer-plugins-base1.0-dev libgstreamer1.0-dev

для поддержки gtk2:

sudo apt-get install libgtk2 .0-dev

для поддержки gtk3:

sudo apt-get install libgtk-3-dev

Дополнительные зависимости

Вышеуказанных зависимостей достаточно для установки OpenCV на вашем компьютере с Ubuntu. Но в зависимости от ваших требований вам могут потребоваться дополнительные зависимости.Список таких необязательных зависимостей приведен ниже. Можете оставить или установить, ваш звонок 🙂

OpenCV поставляется с поддерживающими файлами для форматов изображений, таких как PNG, JPEG, JPEG2000, TIFF, WebP и т. Д. Но он может быть немного устаревшим. Если вы хотите получить последние библиотеки, вы можете установить файлы разработки для системных библиотек этих форматов.

sudo apt-get install libpng-dev

sudo apt-get install libjpeg-dev

sudo apt-get install libopenexr-dev

sudo apt-get install libtiff-dev

sudo apt-get install libwebp-dev

Примечание
Если вы используете Ubuntu 16.04 вы также можете установить libjasper-dev , чтобы добавить поддержку системного уровня для формата JPEG2000.

Загрузка OpenCV

Чтобы загрузить последний исходный код из репозитория OpenCV GitHub. (Если вы хотите внести свой вклад в OpenCV, выберите это. Для этого вам необходимо сначала установить Git )

$ sudo apt-get install git

$ git clone https://github.com/opencv/opencv.git

Будет создана папка «opencv» в текущем каталоге. Клонирование может занять некоторое время в зависимости от вашего интернет-соединения.

Теперь откройте окно терминала и перейдите в загруженную папку «opencv». Создайте новую папку «build» и перейдите к ней.

Настройка и установка

Теперь у нас есть все необходимые зависимости, давайте установим OpenCV. Установка должна быть настроена с помощью CMake. Он определяет, какие модули должны быть установлены, путь установки, какие дополнительные библиотеки будут использоваться, будет ли скомпилирована документация и примеры и т. Д. Большая часть этой работы выполняется автоматически с хорошо настроенными параметрами по умолчанию.

Команда ниже обычно используется для настройки сборки библиотеки OpenCV (выполняется из папки сборки):

OpenCV по умолчанию предполагает тип сборки «Release» и путь установки «/ usr / local». Дополнительные сведения о параметрах CMake см. В руководстве по компиляции OpenCV C ++:

Вы должны увидеть эти строки в выводе CMake (они означают, что Python найден правильно):

— Python 2:

— Интерпретатор: / usr / bin / python2.7 (версия 2.7.6)

— Библиотеки: /usr/lib/x86_64-linux-gnu/libpython2.7.so (версия 2.7.6)

— numpy: /usr/lib/python2.7/ dist-packages / numpy / core / include (ver 1.8.2)

— путь пакетов: lib / python2.7 / dist-packages

— Python 3:

— Интерпретатор: / usr /bin/python3.4 (версия 3.4.3)

— Библиотеки: / usr / lib / x86_64-linux-gnu / libpython3.4m.so (версия 3.4.3)

— numpy: / usr / lib / python3 / dist-packages / numpy / core / include (ver 1.8.2)

— путь пакетов: lib / python3.4 / dist-packages

Теперь вы собираете файлы с помощью команды «make» и устанавливаете их с помощью команды «make install».

$ make

# sudo make install

Установка завершена. Все файлы устанавливаются в папку «/ usr / local /». Откройте терминал и попробуйте импортировать «cv2».

импортировать cv2 как cv

print (cv.__версия__)

.

pip install opencv — PyImageSearch

Получите мгновенный доступ к коду для этого руководства и всех других 400+ руководств по PyImageSearch.

Внутри вы найдете …

  • Доступ к централизованным репозиториям кода для все 400 руководств в блоге PyImageSearch
  • Предварительно настроенные блокноты Jupyter в Google Colab для всех новых руководств
  • Углубленные видеоуроки для всех новых сообщений в блогах — эти видео включают дополнительные комментарии, методы и советы, которые я не включаю в текстовые версии моих руководств

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

Я использовал часть одного из ваших руководств для решения возникшей у меня проблемы с Python и OpenCV.Боролся с этим две недели, но от других экспертов не ответили. Прочтите вашу статью я нашел …. Исправил за два часа. И это тоже было критически важно. Ваши вещи качественные!

Исмаил Томас-Бенге Старший консультант по обеспечению качества и архитектор

PyImageSearch Plus — получите мгновенный доступ к коду для этого руководства и всех других 400 руководств по PyImageSearch!

Выберите свой тарифный план ниже …

$ 4.95 / мес

49,50 $ / год (экономия 15%)

  • Доступ к централизованным репозиториям кода для все 400 руководств на PyImageSearch
  • Простой код доступа для Все новых руководств , которые публикуются каждый понедельник
  • Простая загрузка в один клик для кода, моделей, наборов данных и т. Д.

$ 14.95 / мес

149,50 $ / год (экономия 15%)

  • Предварительно настроенные блокноты Jupyter в Google Colab для всех новых учебников
  • Запускайте все примеры кода в своем веб-браузере. — работает в Windows, macOS и Linux.
  • Доступ к централизованным репозиториям кода для все 400 руководств на PyImageSearch
  • Простой код доступа для Все новых руководств , которые публикуются каждый понедельник
  • Простая загрузка в один клик для кода, моделей, наборов данных и т. Д.

$ 74.95 / мес

749,50 $ / год (экономия 15%)

  • Видеоуроки для всех новых сообщений в блоге
  • Предварительно настроенные блокноты Jupyter в Google Colab для всех новых учебников
  • Запускайте все примеры кода в своем веб-браузере. — работает в Windows, macOS и Linux.
  • Доступ к централизованным репозиториям кода для все 400 руководств на PyImageSearch
  • Простой код доступа для Все новых руководств , которые публикуются каждый понедельник
  • Простая загрузка в один клик для кода, моделей, наборов данных и т. Д.

.

Установите OpenCV 3 и Python 2.7+ на Ubuntu

На прошлой неделе мы запустили фестиваль установки OpenCV 3.0, подробно описав, как установить OpenCV 3.0 и Python 2.7+ на платформу OSX.

Сегодня мы продолжим серию инструкций по установке OpenCV 3.0, перейдя на операционную систему Ubuntu.

В оставшейся части поста я предоставлю инструкции по настройке и установке OpenCV 3.0 и Python 2.7+ в Ubuntu. У меня лично протестировал эти инструкции на Ubuntu 14.04, но они должны работать в любой операционной системе на основе Debian.

Небольшая заметка, прежде чем мы начнем: Да, OpenCV 3.0 действительно совместим с Python 3+. Однако инструкции по установке для Python 2.7+ и Python 3+ немного отличаются. Стремясь сделать каждую статью автономной и простой для понимания, я создаю отдельные руководства по установке OpenCV 3.0 для Python 2.7 и Python 3+. Если вы хотите использовать OpenCV 3.0 и Python 3+ в своей системе Ubuntu, следите за этим блогом — я опубликую OpenCV 3.0 и Python 3+ инструкции по установке позже в этом месяце. Но пока остановимся на Python 2.7.

ОБНОВЛЕНИЕ: В руководстве, которое вы сейчас читаете, рассказывается, как установить OpenCV 3.0 с привязками Python 2.7+ на Ubuntu 14.04 . Этот учебник по-прежнему отлично работает , но если вы хотите установить OpenCV на более новый Ubuntu 16.04 с привязками OpenCV 3.1 и Python 2.7 (или Python 3.5), используйте это недавно обновленное руководство:

https: // pyimagesearch.com / 2016/10/24 / ubuntu-16-04-как-установить-opencv /


Это вторая статья из серии установочных фестивалей OpenCV 3.0. На прошлой неделе мы рассказали, как установить OpenCV 3.0 и Python 2.7+ на OSX. Сегодня мы собираемся выполнить ту же установку OpenCV 3.0 и Python 2.7, только в операционной системе Ubuntu. В общем, установка OpenCV 3.0 и Python 2.7+ на Ubuntu должна быть намного проще, чем установка на OSX.

Шаг 1:

Откройте терминал и обновите менеджер пакетов apt-get с последующим обновлением всех предустановленных пакетов:

 $ sudo apt-get update
$ sudo apt-get upgrade
 

Шаг 2:

Теперь нам нужно установить наши инструменты разработчика:

 $ sudo apt-get install build-essential cmake git pkg-config
 

pkg-config , скорее всего, уже установлен, но обязательно включите его на всякий случай.Мы будем использовать git , чтобы загрузить репозитории OpenCV с GitHub. Пакет cmake используется для настройки нашей сборки.

Шаг 3:

OpenCV должен иметь возможность загружать файлы изображений различных форматов с диска, включая JPEG, PNG, TIFF и т. Д. Для загрузки этих форматов изображений с диска нам потребуются наши пакеты ввода-вывода изображений:

 $ sudo apt-get install libjpeg8-dev libtiff4-dev libjasper-dev libpng12-dev
 

Шаг 4:

На этом этапе у нас есть возможность загрузить заданный образ с диска.Но как вывести на экран реальное изображение? Ответ — библиотека разработки GTK, от которой модуль highgui OpenCV зависит от графических интерфейсов пользователя (GUI) гильдии:

 $ sudo apt-get install libgtk2.0-dev
 

Шаг 5:

Мы можем загружать изображения с помощью OpenCV, но как насчет обработки видеопотоков и доступа к отдельным кадрам? У нас есть это здесь:

 $ sudo apt-get установить libavcodec-dev libavformat-dev libswscale-dev libv4l-dev
 

Шаг 6:

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

 $ sudo apt-get install libatlas-base-dev gfortran
 

Шаг 7:

Установите pip , менеджер пакетов Python:

 $ wget https: // bootstrap.pypa.io/get-pip.py
$ sudo python get-pip.py
 

Шаг 8:

Установите virtualenv и virtualenvwrapper. Эти два пакета позволяют нам создавать отдельных сред Python для каждого проекта, над которым мы работаем. При установке virtualenv и virtualenvwrapper — это , а не требование для запуска OpenCV 3.0 и Python 2.7+ в вашей системе Ubuntu, Я настоятельно рекомендую и остальную часть этого учебника предполагает, что они у вас установлены!

 $ sudo pip install virtualenv virtualenvwrapper
$ sudo rm -rf ~ /.кеш / пункт
 

Теперь, когда у нас установлены virtualenv и virtualenvwrapper , нам нужно обновить наш файл ~ / .bashrc :

 # virtualenv и virtualenvwrapper
экспорт WORKON_HOME = $ HOME / .virtualenvs
источник /usr/local/bin/virtualenvwrapper.sh
 

Это быстрое обновление гарантирует, что и virtualenv , и virtualenvwrapper загружаются каждый раз при входе в систему.

Чтобы внести изменения в наш ~ /.bashrc вступит в силу, вы можете (1) выйти из системы и снова войти в систему, (2) закрыть текущее окно терминала и открыть новое или, желательно, (3) перезагрузить содержимое файла ~ / .bashrc :

 $ источник ~ / .bashrc
 

Наконец, мы можем создать виртуальную среду cv , где мы будем заниматься разработкой компьютерного зрения и установкой OpenCV 3.0 + Python 2.7+:

 $ mkvirtualenv cv
 

Шаг 9:

Как я упоминал выше, в этом руководстве рассказывается, как установить OpenCV 3.0 и Python 2.7+ (в конце этого месяца у меня будет учебник по OpenCV 3.0 + Python 3), поэтому нам нужно будет установить наши инструменты разработки Python 2.7:

 $ sudo apt-get install python2.7-dev
 

Поскольку OpenCV представляет изображения как многомерные массивы NumPy, нам лучше установить NumPy в нашу виртуальную среду cv . Также устанавливаем imutils — мой пакет удобных функций:

 $ pip install numpy
$ pip install imutils
 

Шаг 10:

Наша среда теперь полностью настроена — мы можем перейти к нашему домашнему каталогу, загрузить OpenCV с GitHub и проверить файл 3.0.0 версия:

 $ cd ~
$ git clone https://github.com/Itseez/opencv.git
$ cd opencv
$ git checkout 3.0.0
 

Обновление (3 января 2016 г.): Вы можете заменить версию 3.0.0 любой текущей версией (на данный момент это 3.1.0 ). Не забудьте проверить OpenCV.org для получения информации о последней версии.

Как я упоминал на прошлой неделе, нам также понадобится репозиторий opencv_contrib. Без этого репозитория у нас не будет доступа к стандартным детекторам ключевых точек и локальным инвариантным дескрипторам (таким как SIFT, SURF и т. Д.), которые были доступны в версии OpenCV 2.4.X. Мы также упустим некоторые новые функции OpenCV 3.0, такие как обнаружение текста в естественных изображениях:

 $ cd ~
$ git clone https://github.com/Itseez/opencv_contrib.git
$ cd opencv_contrib
$ git checkout 3.0.0
 

Опять же, убедитесь, что вы проверяете той же версии для opencv_contrib , которую вы делали для opencv выше, иначе вы можете столкнуться с ошибками компиляции.

Время на настройку сборки:

 $ cd ~ / opencv
сборка $ mkdir
$ cd build
$ cmake -D CMAKE_BUILD_TYPE = RELEASE \
-D CMAKE_INSTALL_PREFIX = / usr / local \
-D INSTALL_C_EXAMPLES = ON \
-D INSTALL_PYTHON_EXAMPLES = ON \
-D OPENCV_EXTRA_MODULES_PATH = ~ / opencv_contrib / modules \
-D BUILD_EXAMPLES = ON ..
 

Обновление (3 января 2016 г.): Чтобы построить OpenCV 3.1.0 , вам необходимо установить -D INSTALL_C_EXAMPLES = OFF (а не ON ) в команде cmake .В скрипте сборки CMake OpenCV v3.1.0 есть ошибка, которая может вызвать ошибки, если вы оставите этот переключатель включенным. После того, как вы выключите этот переключатель, CMake должен работать без проблем.

Обратите внимание, что по сравнению с прошлой неделей наша команда CMake значительно менее подробна и требует меньше ручной настройки — это потому, что CMake может лучше автоматически настраивать наши параметры установки (по крайней мере, по сравнению с OSX).

Теперь мы наконец можем скомпилировать OpenCV:

 $ make -j4
 

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

Вот пример компиляции OpenCV 3.0 в моей системе:

Рисунок 1: OpenCV 3.0 с поддержкой Python 2.7+, компиляция в моей системе Ubuntu 14.04.

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

 $ sudo make install
$ sudo ldconfig
 

Шаг 11:

Если вы прошли этот шаг без ошибок, OpenCV теперь должен быть установлен в /usr/local/lib/python2.7/site-packages

Однако наша виртуальная среда cv находится в нашем домашнем каталоге — таким образом, чтобы использовать OpenCV в нашей среде cv , нам сначала нужно символьно связать OpenCV с каталогом site-packages виртуальной среды cv :

 $ cd ~ /.virtualenvs / CV / Библиотека / python2.7 / сайты-пакеты /
$ ln -s /usr/local/lib/python2.7/site-packages/cv2.so cv2.so
 

Шаг 12:

Поздравляем! Вы успешно установили OpenCV 3.0 с привязками Python 2.7+ в вашей системе Ubuntu!

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

 $ workon cv
$ питон
>>> импортировать cv2
>>> cv2.__версия__
"3.0.0"
 

Вот пример демонстрации установки OpenCV 3.0 и Python 2.7+ на моем компьютере с Ubuntu:

Рисунок 2: OpenCV 3.0 с привязками Python 2.7+ успешно установлен на Ubuntu!

Шаг 13:

Теперь, когда OpenCV настроен и установлен, давайте создадим быстрый скрипт Python для обнаружения игрового картриджа красный в изображении с именем games.jpg ниже:

Рисунок 3: Наша цель — обнаружить красный картридж с игрой ( справа, ) на этом изображении.

Откройте свой любимый редактор, создайте новый файл, назовите его find_game.py и вставьте следующий код:

 # импортируем необходимые пакеты
импортировать numpy как np
импорт imutils
импорт cv2

# загрузить изображение игры
image = cv2.imread ("games.jpg")

# найти игру красного цвета на изображении
верхний = np.array ([65, 65, 255])
нижний = np.array ([0, 0, 200])
маска = cv2.inRange (изображение, нижнее, верхнее)

# найти контуры на изображении с маской и оставить самый большой
cnts = cv2.findContours (маска.copy (), cv2.RETR_EXTERNAL,
cv2.CHAIN_APPROX_SIMPLE)
cnts = imutils.grab_contours (cnts)
c = max (cnts, key = cv2.contourArea)

# приблизить контур
пери = cv2.arcLength (c, Истина)
прибл. = cv2.approxPolyDP (c, 0,05 * пери, True)

# рисуем зеленую ограничивающую рамку вокруг красной игры
cv2.drawContours (изображение, [приблизительное], -1, (0, 255, 0), 4)
cv2.imshow ("Изображение", изображение)
cv2.waitKey (0)
 

Вам также необходимо загрузить изображение games.jpg и поместить его в тот же каталог, что и ваш find_game .py файл. После загрузки файла games.jpg вы можете запустить скрипт через:

 $ python find_game.py
 

Предполагая, что вы загрузили изображение games.jpg и поместили его в тот же каталог, что и наш сценарий find_game.py , вы должны увидеть следующий результат:

Рисунок 4: Мы успешно обнаружили красный картридж с игрой на изображении!

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

Очевидно, что это не самый захватывающий пример в мире, но он продемонстрировал, что у нас есть OpenCV 3.0 с привязками Python 2.7+ и работает в нашей системе Ubuntu!

Поздравляю! У вас есть совершенно новая, свежая установка OpenCV в вашей системе Ubuntu — и я уверен, что вам просто не терпится использовать новую установку для создания замечательных приложений для компьютерного зрения.

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

Лично я большой поклонник , обучающего на примере , поэтому первым делом было бы прочитать это сообщение в блоге о доступе к вашей веб-камере с помощью OpenCV. В этом руководстве подробно описаны точных шагов , которые необходимо предпринять, чтобы (1) сделать снимок с веб-камеры и (2) получить доступ к необработанному видеопотоку.

И если вас действительно интересует в повышении уровня ваших навыков компьютерного зрения, вам обязательно стоит почитать мою книгу Practical Python и OpenCV + Case Studies .Моя книга не только охватывает основы компьютерного зрения и обработки изображений , но и учит, как решать реальные проблемы компьютерного зрения, включая обнаружение лиц в изображениях и видеопотоках , отслеживание объектов в видео , и , распознавание рукописного ввода.

Итак, давайте применим вашу новую установку OpenCV в вашей системе Ubuntu — просто нажмите здесь , чтобы узнать больше о реальных проектах, которые вы можете решить, используя новую установку OpenCV + Практический Python и OpenCV.

Чтобы отпраздновать выпуск OpenCV 3.0, я прорабатываю инструкции по установке OpenCV 3.0 и Python 2.7 / Python 3.4 на OSX , Ubuntu, и Raspberry Pi .

На прошлой неделе я рассказал, как установить OpenCV 3.0 и Python 2.7+ на OSX.

И сегодня мы рассмотрели, как установить OpenCV 3.0 с привязками Python 2.7 в Ubuntu. У меня лично. тестировал эти инструкции на моем собственном Ubuntu 14.04, но они должны работать в любой системе на основе Debian.

На следующей неделе мы продолжим установку и вернемся к OSX — на этот раз установим OpenCV 3.0 и Python 3!

Мы впервые используем Python 3 в блоге PyImageSearch, так что вы не захотите его пропустить!

И, пожалуйста, рассмотрите возможность подписки на информационный бюллетень PyImageSearch, указав свой адрес электронной почты в форме ниже. По мере того, как мы работаем в рамках установочного фестиваля OpenCV, я буду рассылать обновления для каждого нового OpenCV 3.0 + Выпущено руководство по установке Python!

Подпишитесь на информационный бюллетень PyImageSearch и получите БЕСПЛАТНОЕ 17-страничное руководство по ресурсам PDF

Введите свой адрес электронной почты ниже, чтобы присоединиться к информационному бюллетеню PyImageSearch и загрузите БЕСПЛАТНОЕ 17-страничное руководство по ресурсам PDF по компьютерному зрению, OpenCV и глубокому обучению.

.

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *