Обрезать фото по контуру: Как вырезать картинку по контуру

Введение

Музей искусств Индианаполиса (IMA) недавно поделился с Арчи тысячами изображений высокого разрешения из своей постоянной коллекции, включая 5000 изображений, которые были в необрезанном состоянии. Эти изображения содержат образцы цветов, рамки и разнообразный фон, как показано ниже. Беспорядок в этих изображениях сделал их неприемлемыми для отображения конечным пользователям, и предложил подход для автоматической обрезки изображений.Этот пост исследует некоторые полностью автоматизированные методы, чтобы найти произведение искусства на каждой фотографии. Если вы хотите сразу перейти к коду, который работал лучше всего, вы найдете здесь реализацию раздела «Поиск прямоугольного контура».

Некоторые образцы из набора данных изображений IMA. Жирная зеленая форма указывает на лучший выбор для обрезки, а тонкие желтые формы — на альтернативные.

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

Варианты обрезки в картине Джозефа Альберса.Copyright Фонд Джозефа и Анни Альберс / Общество прав художников (ARS), Нью-Йорк

Фон

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

Blur Преобразования

Gaussian Blur

Гауссово сглаживание — это метод снижения шума на изображении путем усреднения каждого пикселя с окружающими его пикселями.Чтобы выполнить сглаживание по Гауссу, изображение является свернутым с квадратной матрицей фильтра (с нечетным числом измерений для обеспечения симметрии), чьи значения ( весов ) определяются распределением Гаусса с некоторым стандартным отклонением \ (\ sigma \). Матрица фильтра также называется ядром в контексте свертки. Ниже показано ядро ​​\ (3 \ times3 \) с \ (\ sigma \) 0:

$$ \ frac {1} {16} \ begin {bmatrix} 1 & 2 & 1 \\\ 2 и 4 и 2 \\\ 1 & 2 & 1 \ end {bmatrix} $$

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

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

 1
2
3
 

  размытие = cv2.GaussianBlur (src = bw, ksize = (3,3), сигма = 0)
# чтобы увидеть матрицу фильтра 3 на 3, с которой свернуто изображение bw:
cv2.getGaussianKernel (ksize = 3, sigma = 0) * cv2.getGaussianKernel (3, 0) .T
  

Median Blur Filter

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

 1
2
 

  # использует медиану в окрестности 7 на 7 для переназначения каждого пикселя
cv2.medianBlur (img, ksize = 7)
  

Края

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

Sobel Filter

Фильтр Собель является приближением к градиенту первого порядка изображения. Используя две ортогональные \ (3 \ times3 \) матрицы свертки, каждая из которых аппроксимирует частную производную изображения (в направлениях x и y), можно объединить результаты двух сверток для аппроксимации градиента изображения. Два соответствующих ядра для аппроксимации величин градиента направления x и y:

$$ \ begin {bmatrix} 1 & 2 & 1 \\\ 0 & 0 & 0 \\\ -1 & -2 & -1 \ end {bmatrix} \ и\ \ begin {bmatrix} 1 & 0 & 1 \\\ 2 & 0 & 2 \\\ 1 & 0 & 1 \ end {bmatrix} $$

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

 1
2
3
4
5
6
7
 

  # использует два вышеуказанных частных производных
sobelx = cv2.Sobel (bw, cv2.CV_16S, 1, 0, ksize = 3)
sobely = cv2.Sobel (bw, cv2.CV_16S, 0, 1, ksize = 3)
abs_gradientx = cv2.convertScaleAbs (sobelx)
abs_gradienty = cv2.convertScaleAbs (sobely)
# объединить два в равных пропорциях
total_gradient = cv2.addWeighted (abs_gradientx, 0,5, abs_gradienty, 0,5, 0)
  

Canny Edges

Детектор края Canny — это многоступенчатый процесс, который объединяет градиенты первого и второго порядка таким образом, чтобы оптимизировать:

1. Обнаружение — пропущено несколько ребер (благодаря чувствительности градиента 2-го порядка)
2. Локализация — точность обнаруженных ребер (благодаря точности градиента 2-го порядка)
3. Отдельных ответов — 1 ребро обнаружено на реальном ребре (благодаря подавлению не максимальных значений)

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

 1
2
 

  # аргумент apertureSize - размер фильтра для аппроксимации производной
CV2.Canny (bw, threshold1 = 0, threshold2 = 50, apertureSize = 3)
  

Hough Lines

Преобразование Хафа пытается найти линии на изображении, которые можно объяснить линейным уравнением \ (y = mx + b \). Более удобный способ выражения этого уравнения на плоскости изображения — с помощью: \ (d = xcos (\ theta) + ysin (\ theta) \), где точка \ ((x, y) \) объясняется нормальным расстоянием от начала координат до линии (\ (d \)) и угла между этой нормальной линией и осью x (\ (\ theta \)).{n} \) норма.

Поворот изображений (правильно) с OpenCV и Python

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

Это был конец моего второго семестра курсовой работы.

Я сдал все свои экзамены рано, и все мои проекты на семестр были представлены.

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

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

После первой недели я добился фантастических успехов.

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

… однако возникла проблема:

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

Как это могло быть?

Я ломал голову для объяснения.

Был ли недостаток в логике моего алгоритма извлечения признаков?

Я не соответствовал функциям правильно?

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

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

Я обманываю.

Оказывается, что на этапе предварительной обработки изображений я неправильно вращал свои изображения.

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

Но для продолговатых таблеток они будут «обрезаны» в процессе вращения, например:

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

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

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

Как я справился с этим и навсегда исправил ошибку?

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

Поворот изображений (правильно) с помощью OpenCV и Python

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

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

Чтобы убедиться, что мы все понимаем эту проблему ротации с OpenCV и Python, я сделаю следующее:

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

Простая проблема вращения с OpenCV

Давайте начнем этот пост с примера сценария.

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

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

# построить аргумент parse и разобрать аргументы
ap = argparse.ArgumentParser ()
ap.add_argument ("- i", "--image", обязательный = True,
help = "путь к файлу изображения")
args = vars (ap.parse_args ())
 

Строки 2-5 начинаются с импорта необходимых пакетов Python.

Если у вас еще нет imutils, моя серия удобных функций OpenCV установлена, вам нужно сделать это сейчас:

 $ pip install imutils
 

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

 $ pip install --upgrade imutils
 

Оттуда строк 8-10 анализируют аргументы нашей командной строки.Здесь нам нужен только один переключатель, - изображение , это путь к тому месту, где находится наш образ на диске.

Давайте перейдем к фактическому повороту нашего изображения:

 # загрузить изображение с диска
image = cv2.imread (args ["image"])

# цикл по углам поворота
для угла в np.arange (0, 360, 15):
rotated = imutils.rotate (изображение, угол)
cv2.imshow ("Повернуто (проблемно)", повернуто)
cv2.waitKey (0)

# снова обведите углы поворота, на этот раз
# ни одна часть изображения не обрезана
для угла в нп.arange (0, 360, 15):
rotated = imutils.rotate_bound (изображение, угол)
cv2.imshow ("Повернуто (правильно)", повернуто)
cv2.waitKey (0)
 

Строка 14 загружает изображение, которое мы хотим повернуть с диска.

Затем мы зациклимся под различными углами в диапазоне [0, 360] с шагом 15 градусов (, строка 17, ).

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

Строки 24-27 выполняют идентичный процесс, но на этот раз мы вызываем imutils.rotate_bound (о реализации этой функции я расскажу в следующем разделе).

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

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

 $ python rotate_simple.py --image images / saratoga.jpg
 

Результат использования функции imutils.rotate для неквадратного изображения можно увидеть ниже:

Рисунок 3: Пример обрезания углов при повороте изображения с использованием OpenCV и Python.

Как вы видите, изображение «обрезается» при повороте — все изображение не сохраняется в поле зрения.

Но если мы используем imutils.rotate_bound , мы можем решить эту проблему:

Рисунок 4: Мы можем обеспечить сохранение всего изображения в поле зрения, изменив матрицу, возвращаемую cv2.getRotationMatrix2D .

Отлично, мы исправили проблему!

Значит ли это, что всегда должны использовать .rotate_bound вместо метода .rotate ?

Что делает его таким особенным?

А что происходит под капотом?

Я отвечу на эти вопросы в следующем разделе.

Реализация функции поворота, которая не обрезает ваши изображения

Позвольте мне начать с того, что ничего не значит с cv2.Функции getRotationMatrix2D и cv2.warpAffine , которые используются для поворота изображений внутри OpenCV.

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

Функция cv2.getRotationMatrix2D не заботится о , если мы хотим сохранить все повернутое изображение.

не заботит , если изображение обрезано.

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

Вместо этого вам нужно понять, что такое матрица вращения, а — как построить .

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

Рисунок 5: Структура матрицы M , возвращенная cv2.getRotationMatrix2D .

Эта матрица выглядит страшно, но я обещаю вам: это не так.

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

Затем мы можем вставить значения для и :

и

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

Ответ находится внутри функции rotate_bound для удобства. Imutils:

 def rotate_bound (изображение, угол):
    # захватить размеры изображения, а затем определить
    # центр
    (h, w) = image.shape [: 2]
    (cX, cY) = (w // 2, h // 2)

    # захватить матрицу вращения (применяя минус
    # угол поворота по часовой стрелке), затем захватите синус и косинус
    # (то есть, компоненты вращения матрицы)
    M = cv2.getRotationMatrix2D ((cX, cY), -angle, 1.0)
    cos = np.abs (M [0, 0])
    sin = np.abs (M [0, 1])

    # вычислить новые ограничивающие размеры изображения
    nW = int ((h * sin) + (w * cos))
    nH = int ((h * cos) + (w * sin))

    # настроить матрицу вращения, чтобы учесть перевод
    M [0, 2] + = (nW / 2) - cX
    M [1, 2] + = (нН / 2) - сГ

    # выполнить фактическое вращение и вернуть изображение
    return cv2.warpAffine (изображение, M, (nW, nH))
 

В строке 410009 мы определяем нашу функцию rotate_bound .

Этот метод принимает входное изображение и угол для его поворота.

Мы предполагаем, что будем вращать изображение вокруг его центра с координатами (x, y) , поэтому мы определяем эти значения в строках 44 и 45 .

Учитывая эти координаты, мы можем вызвать cv2.getRotationMatrix2D , чтобы получить нашу матрицу вращения M ( Line 50 ).

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

Мы начинаем с получения значений косинуса и синуса из нашей матрицы вращения M (, строки 51 и 52 ).

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

Как только мы узнаем новые ширину и высоту, мы можем отрегулировать перевод по строкам 59 и 60 , изменив нашу матрицу вращения еще раз.

Наконец, cv2.warpAffine вызывается по Line 63 , чтобы повернуть реальное изображение с помощью OpenCV, гарантируя, что ни одно из изображений не будет обрезано.

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

Исправление проблемы с обрезкой повернутого изображения в OpenCV и Python

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

Мы будем использовать следующую таблетку в качестве примера:

Рисунок 6: Пример продолговатой таблетки, которую мы будем вращать с помощью OpenCV.

Для начала откройте новый файл и назовите его rotate_pills.py . Затем введите следующий код:

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

# построить аргумент parse и разобрать аргументы
ap = argparse.ArgumentParser ()
ap.add_argument ("- i", "--image", обязательный = True,
help = "путь к файлу изображения")
args = vars (ap.parse_args ())
 

Строки 2-5 импортируют наши необходимые пакеты Python. Снова убедитесь, что вы установили и / или обновили пакет Python imutils, прежде чем продолжить.

Затем мы анализируем наши аргументы командной строки на Строки 8-11 . Как и в примере в начале поста в блоге, нам нужен только один переключатель: - изображение , путь к нашему входному изображению.

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

 # загрузить изображение с диска, преобразовать его в оттенки серого, смазать его,
# и применить обнаружение края, чтобы показать контур таблетки
изображение = cv2.imread (арг [ "образ"])
серый = cv2.cvtColor (изображение, cv2.COLOR_BGR2GRAY)
серый = cv2.GaussianBlur (серый, (3, 3), 0)
edged = cv2.Canny (серый, 20, 100)
 

После выполнения этих функций предварительной обработки наше изображение таблетки теперь выглядит так:

Рисунок 7: Обнаружение краев в таблетке.

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

 # найти контуры на карте ребер
cnts = cv2.findContours (обрезной.copy (), cv2.RETR_EXTERNAL,
cv2.CHAIN_APPROX_SIMPLE)
cnts = imutils.grab_contours (cnts)
 

Теперь мы готовы извлечь ROI для таблеток из изображения:

 # убедитесь, что был найден хотя бы один контур
если len (cnts)> 0:
# возьмите самый большой контур, затем нарисуйте маску для таблетки
c = max (cnts, key = cv2.contourArea)
mask = np.zeros (gray.shape, dtype = "uint8")
cv2.drawContours (маска, [c], -1, 255, -1)

# вычислить ограничивающую рамку таблетки, затем извлечь ROI,
# и применить маску
(x, y, w, h) = cv2.boundingRect (с)
imageROI = изображение [y: y + h, x: x + w]
maskROI = маска [y: y + h, x: x + w]
imageROI = cv2.bitwise_and (imageROI, imageROI,
Маска = maskROI)
 

Во-первых, мы гарантируем, что по крайней мере один контур был найден на карте ребер ( Строка 26 ).

При условии, что у нас есть хотя бы один контур, мы строим маску для самой большой области контура в строках 29 и 30 .

Наша маска выглядит так:

Рисунок 8: Маска, представляющая всю область таблеток на изображении.

Учитывая область контура, мы можем вычислить (x, y) -координат ограничительной рамки области ( Линия 34 ).

Используя ограничивающую рамку и маску , мы можем извлечь фактическую рентабельность инвестиций в области таблеток ( Линии 35-38 ).

Теперь давайте продолжим и применим функции imutils.rotate и imutils.rotate_bound к imageROI , как мы это делали в простых примерах выше:

 # петля по углам поворота
для угла в нп.arange (0, 360, 15):
rotated = imutils.rotate (imageROI, угол)
cv2.imshow ("Повернуто (проблемно)", повернуто)
cv2.waitKey (0)

# снова обведите угол поворота, на этот раз убедитесь, что
# вся таблетка все еще находится в ROI после ротации
для угла в np.arange (0, 360, 15):
rotated = imutils.rotate_bound (imageROI, угол)
cv2.imshow ("Повернуто (правильно)", повернуто)
cv2.waitKey (0)
 

После загрузки исходного кода в этот учебник с использованием раздела «Загрузки» , приведенного ниже, вы можете выполнить следующую команду, чтобы просмотреть вывод:

 $ python rotate_pills.py --image images / pill_01.png
 

Выход imutils.rotate будет выглядеть так:

Рисунок 9: Неправильный поворот изображения с помощью OpenCV приводит к обрезанию частей изображения.

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

Используя imutils.rotate_bound , мы можем гарантировать, что ни одна часть изображения не будет обрезана при использовании OpenCV:

Рисунок 10: Изменяя матрицу вращения OpenCV, мы можем решить эту проблему и убедиться, что все изображение видно.

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

Резюме

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

Тот факт, что границы изображения могут быть обрезаны, это , а не , ошибка в OpenCV — фактически, это как cv2.getRotationMatrix2D и cv2.WarpAffine разработаны.

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

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

Конечно, это требует от нас знать, как формируется наша матрица вращения M и что представляет каждый из ее компонентов (обсуждалось ранее в этом уроке).Если мы понимаем это, математика выпадает естественно.

Чтобы узнать больше об обработке изображений и компьютерном зрении, обязательно ознакомьтесь с курсом PyImageSearch Gurus, где я обсуждаю эти темы более подробно.

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

Загрузите исходный код и БЕСПЛАТНОЕ 17-страничное руководство по ресурсам

Введите адрес электронной почты ниже, чтобы получить.почтовый индекс и бесплатное 17-страничное руководство по ресурсам по Computer Vision, OpenCV и Deep Learning. Внутри вы найдете мои отобранные учебники, книги, курсы и библиотеки, которые помогут вам освоить CV и DL!

,