Как я могу определить разницу между двумя изображениями?
Вот что я хотел бы сделать:
Я снимаю с веб-камеры через равные промежутки времени. Вроде как промежуток времени. Однако, если ничего не изменилось, то есть картинка выглядит примерно так же, я не хочу сохранять последний снимок.
Я полагаю, что есть какой-то способ количественной оценки разницы, и мне придется эмпирически определять порог.
Я ищу простоту, а не совершенство. Я использую Python.
25 ответов
Главная идея
Вариант 1. Загрузите оба изображения в виде массивов (scipy.misc.imread) и рассчитать поэлементную (попиксельную) разницу. Рассчитайте норму разницы.
Вариант 2. Загрузите оба изображения. Рассчитайте некоторый вектор признаков для каждого из них (например, гистограмму). Рассчитайте расстояние между векторами объектов, а не изображениями.
Однако, есть некоторые решения, которые нужно принять в первую очередь.
Вопросы
Сначала вы должны ответить на эти вопросы:
Являются ли изображения одинаковой формы и размера?
Если нет, вам может понадобиться изменить их размер или обрезать. Библиотека PIL поможет сделать это на Python.
Если они взяты с одинаковыми настройками и тем же устройством, они, вероятно, одинаковы.
Хорошо ли выровнены изображения?
Если нет, вы можете сначала запустить взаимную корреляцию, чтобы сначала найти лучшее выравнивание. SciPy имеет функции, чтобы сделать это.
Если камера и сцена неподвижны, изображения, вероятно, будут хорошо выровнены.
Экспозиция изображений всегда одинакова? (Легкость и контрастность одинаковы?)
Если нет, вы можете нормализовать изображения.
Но будьте осторожны, в некоторых ситуациях это может принести больше вреда, чем пользы. Например, один яркий пиксель на темном фоне сделает нормализованное изображение совершенно другим.
Важна ли информация о цвете?
Если вы хотите заметить изменение цвета, у вас будет вектор значений цвета на точку, а не скалярное значение, как на изображении в оттенках серого. Вам нужно больше внимания при написании такого кода.
Есть ли четкие края на изображении? Они могут двигаться?
Если да, вы можете сначала применить алгоритм обнаружения ребер (например, рассчитать градиент с помощью преобразования Собеля или Превитта, применить некоторый порог), затем сравнить ребра в первом изображении с ребрами во втором.
Есть ли шум на изображении?
Все датчики загрязняют изображение некоторым количеством шума. Недорогие датчики имеют больше шума. Вы можете применить некоторое шумоподавление, прежде чем сравнивать изображения. Blur - самый простой (но не самый лучший) подход.
Какие изменения вы хотите заметить?
Это может повлиять на выбор нормы для разницы между изображениями.
Подумайте об использовании нормы Манхэттена (сумма абсолютных значений) или нулевой нормы (количество элементов, не равное нулю), чтобы измерить, насколько изменилось изображение. Первый скажет вам, сколько изображение выключено, последний скажет только, сколько пикселей отличается.
пример
Я предполагаю, что ваши изображения хорошо выровнены, одинакового размера и формы, возможно, с разной экспозицией. Для простоты я конвертирую их в оттенки серого, даже если они являются цветными (RGB) изображениями.
Вам понадобится этот импорт:
import sys
from scipy.misc import imread
from scipy.linalg import norm
from scipy import sum, average
Основная функция, чтение двух изображений, преобразование в оттенки серого, сравнение и печать результатов:
def main():
file1, file2 = sys.argv[1:1+2]
# read images as 2D arrays (convert to grayscale for simplicity)
img1 = to_grayscale(imread(file1).astype(float))
img2 = to_grayscale(imread(file2).astype(float))
# compare
n_m, n_0 = compare_images(img1, img2)
print "Manhattan norm:", n_m, "/ per pixel:", n_m/img1.size
print "Zero norm:", n_0, "/ per pixel:", n_0*1.0/img1.size
Как сравнить. img1 а также img2 здесь 2D SciPy массивы:
def compare_images(img1, img2):
# normalize to compensate for exposure difference, this may be unnecessary
# consider disabling it
img1 = normalize(img1)
img2 = normalize(img2)
# calculate the difference and its norms
diff = img1 - img2 # elementwise for scipy arrays
m_norm = sum(abs(diff)) # Manhattan norm
z_norm = norm(diff.ravel(), 0) # Zero norm
return (m_norm, z_norm)
Если файл является цветным изображением, imread возвращает трехмерный массив, средние каналы RGB (последнюю ось массива) для получения интенсивности. Нет необходимости делать это для изображений в оттенках серого (например, .pgm):
def to_grayscale(arr):
"If arr is a color image (3D array), convert it to grayscale (2D array)."
if len(arr.shape) == 3:
return average(arr, -1) # average over the last axis (color channels)
else:
return arr
Нормализация тривиальна, вы можете выбрать нормализацию до [0,1] вместо [0,255]. arr здесь массив SciPy, поэтому все операции поэлементны:
def normalize(arr):
rng = arr.max()-arr.min()
amin = arr.min()
return (arr-amin)*255/rng
Запустить main функция:
if __name__ == "__main__":
main()
Теперь вы можете поместить все это в сценарий и запустить два изображения. Если мы сравним изображение с самим собой, нет никакой разницы:
$ python compare.py one.jpg one.jpg
Manhattan norm: 0.0 / per pixel: 0.0
Zero norm: 0 / per pixel: 0.0
Если мы размываем изображение и сравниваем его с оригиналом, есть некоторая разница:
$ python compare.py one.jpg one-blurred.jpg
Manhattan norm: 92605183.67 / per pixel: 13.4210411116
Zero norm: 6900000 / per pixel: 1.0
PS Весь скрипт Compare.py.
Обновление: соответствующие методы
Поскольку вопрос касается видеопоследовательности, где кадры, вероятно, будут почти одинаковыми, а вы ищете что-то необычное, я хотел бы упомянуть некоторые альтернативные подходы, которые могут быть актуальны:
- вычитание и сегментация фона (для обнаружения объектов переднего плана)
- разреженный оптический поток (для обнаружения движения)
- сравнивая гистограммы или другую статистику вместо изображений
Я настоятельно рекомендую взглянуть на книгу "Обучение OpenCV", главы 9 (Части изображения и сегментация) и 10 (Отслеживание и движение). Первый учит использовать метод вычитания фона, второй дает некоторую информацию о методах оптического потока. Все методы реализованы в библиотеке OpenCV. Если вы используете Python, я предлагаю использовать OpenCV ≥ 2.3, и его cv2 Модуль Python.
Самый простой вариант вычитания фона:
- узнать среднее значение μ и стандартное отклонение σ для каждого пикселя фона
- сравнить текущие значения пикселей с диапазоном (μ-2σ,μ+2σ) или (μ-σ,μ+σ)
Более продвинутые версии учитывают временные ряды для каждого пикселя и обрабатывают нестатические сцены (например, движущиеся деревья или траву).
Идея оптического потока состоит в том, чтобы взять два или более кадров и назначить вектор скорости каждому пикселю (плотный оптический поток) или некоторым из них (разреженный оптический поток). Для оценки разреженного оптического потока вы можете использовать метод Лукаса-Канаде (он также реализован в OpenCV). Очевидно, что если поток большой (среднее среднее по максимальным значениям поля скорости), то в кадре что-то движется, и последующие изображения более различны.
Сравнение гистограмм может помочь обнаружить внезапные изменения между последовательными кадрами. Этот подход был использован в Курбоне и др., 2010:
Сходство последовательных кадров. Расстояние между двумя последовательными кадрами измеряется. Если оно слишком высокое, это означает, что второй кадр поврежден и, следовательно, изображение устранено. Расстояние Кульбака – Лейблера, или взаимная энтропия, на гистограммах двух систем отсчета:
где p и q - гистограммы фреймов. Порог фиксируется на 0,2.
Простое решение:
Закодируйте изображение в формате JPEG и найдите существенное изменение в размере файла.
Я реализовал нечто подобное с миниатюрами видео, и добился большого успеха и масштабируемости.
Вы можете сравнить два изображения, используя функции из PIL.
import Image
import ImageChops
im1 = Image.open("splash.png")
im2 = Image.open("splash2.png")
diff = ImageChops.difference(im2, im1)
Объект diff - это изображение, в котором каждый пиксель является результатом вычитания значений цвета этого пикселя во втором изображении из первого изображения. Используя разностное изображение, вы можете сделать несколько вещей. Самый простой из них diff.getbbox() функция. Он скажет вам минимальный прямоугольник, который содержит все изменения между вашими двумя изображениями.
Вероятно, вы можете реализовать аппроксимации других вещей, упомянутых здесь, используя функции из PIL.
Два популярных и относительно простых метода: (а) евклидово расстояние уже предложено, или (б) нормализованная взаимная корреляция. Нормализованная взаимная корреляция имеет тенденцию быть заметно более устойчивой к изменениям освещения, чем простая взаимная корреляция. Википедия дает формулу для нормализованной взаимной корреляции. Существуют и более сложные методы, но они требуют немного больше работы.
Используя похожий на numpy синтаксис,
dist_euclidean = sqrt (sum ((i1 - i2) ^ 2)) / i1.size dist_manhattan = сумма (абс (i1 - i2)) / i1.size dist_ncc = сумма ((i1 - среднее (i1)) * (i2 - среднее (i2))) / ( (i1.size - 1) * stdev(i1) * stdev(i2))
при условии, что i1 а также i2 двухмерные массивы изображений в градациях серого.
Тривиальная вещь, чтобы попробовать:
Измените оба изображения на маленькие миниатюры (например, 64 x 64) и сравните пиксели за пикселем с определенным порогом. Если исходные изображения почти одинаковы, уменьшенные эскизы будут очень похожими или даже точно такими же. Этот метод заботится о шуме, который может возникнуть, особенно в условиях низкой освещенности. Это может быть даже лучше, если вы перейдете в оттенках серого.
Еще один приятный, простой способ измерить сходство между двумя изображениями:
import sys
from skimage.measure import compare_ssim
from skimage.transform import resize
from scipy.ndimage import imread
# get two images - resize both to 1024 x 1024
img_a = resize(imread(sys.argv[1]), (2**10, 2**10))
img_b = resize(imread(sys.argv[2]), (2**10, 2**10))
# score: {-1:1} measure of the structural similarity between the images
score, diff = compare_ssim(img_a, img_b, full=True)
print(score)
Если другие заинтересованы в более эффективном способе сравнения сходства изображений, я собрал учебник и веб- приложение для измерения и визуализации похожих изображений с помощью Tensorflow.
У меня была похожая проблема на работе, я переписывал нашу конечную точку преобразования изображений и хотел убедиться, что новая версия выдает тот же или почти такой же вывод, что и старая версия. Итак, я написал это:
https://github.com/nicolashahn/diffimg
Он работает с изображениями одинакового размера и на уровне пикселей, измеряет разницу значений в каждом канале: R, G, B(, A), берет среднюю разницу этих каналов и затем усредняет разницу по все пиксели и возвращает соотношение.
Например, для 10х10 изображений с белыми пикселями и того же изображения, но с одним пикселем, он стал красным, разница в этом пикселе составляет 1/3 или 0,33... (RGB 0,0,0 против 255,0,0) и для всех остальных пикселей равен 0. При 100 пикселях всего 0,33.../100 = разность изображения ~0,33%.
Я считаю, что это отлично подойдет для проекта OP (я понимаю, что это очень старая статья, но она публикуется для будущих Stackruers, которые также хотят сравнивать изображения в python).
Я обращаюсь конкретно к вопросу о том, как вычислить, достаточно ли они различны. Я предполагаю, что вы можете понять, как вычитать пиксели один за другим.
Во-первых, я взял бы несколько изображений без изменений и выяснил, какую максимальную величину может изменить любой пиксель только из-за различий в захвате, шума в системе обработки изображений, артефактов сжатия JPEG и мгновенных изменений освещения, Возможно, вы обнаружите, что следует ожидать разницы в 1 или 2 бита, даже когда ничего не происходит.
Тогда для "настоящего" теста вам нужен такой критерий:
- то же самое, если до P пикселей отличаются не более чем на E.
Так что, возможно, если E = 0,02, P = 1000, это будет означать (приблизительно), что он будет "другим", если какой-либо один пиксель изменится более чем на ~5 единиц (при условии 8-битных изображений), или если более 1000 у пикселей были какие-либо ошибки вообще.
Это предназначено главным образом как хороший метод "сортировки", чтобы быстро идентифицировать изображения, которые достаточно близки, чтобы не нуждаться в дальнейшем рассмотрении. Изображения, которые "терпят неудачу", могут затем быть более сложным / дорогостоящим методом, который не имел бы ложных срабатываний, если камера, например, немного дрожала, или была более устойчивой к изменениям освещения.
Я запускаю проект с открытым исходным кодом, OpenImageIO, который содержит утилиту под названием "idiff", которая сравнивает различия с такими пороговыми значениями (на самом деле, даже более сложными). Даже если вы не хотите использовать это программное обеспечение, вы можете посмотреть на источник, чтобы увидеть, как мы это сделали. Он широко используется в коммерческих целях, и этот метод пороговой разработки был разработан для того, чтобы у нас мог быть набор тестов для программного обеспечения рендеринга и обработки изображений с "опорными изображениями", которые могут иметь небольшие отличия от платформы к платформе или поскольку мы внесли небольшие изменения в алгоритмы, поэтому мы хотели, чтобы операция "соответствовала в пределах допуска".
Большинство ответов не будут касаться уровней освещения.
Я бы сначала нормализовал изображение до стандартного уровня освещения, прежде чем делать сравнение.
Вы видели Алгоритм для поиска похожих изображений вопрос? Проверьте это, чтобы увидеть предложения.
Я бы предложил вейвлет-преобразование ваших фреймов (для этого я написал расширение C с использованием преобразования Хаара); затем, сравнивая индексы наибольших (пропорционально) вейвлет-факторов между двумя изображениями, вы должны получить числовое приближение подобия.
Я прошу прощения, если уже слишком поздно, чтобы ответить, но так как я делал что-то подобное, я думал, что мог бы как-то помочь.
Может быть, с OpenCV вы могли бы использовать сопоставление шаблонов Предполагая, что вы используете веб-камеру, как вы сказали:
- Упростить изображения (возможно, пороговое значение?)
- Примените сопоставление шаблона и проверьте max_val с помощью minMaxLoc.
Совет: max_val (или min_val в зависимости от используемого метода) даст вам числа, большие числа. Чтобы получить разницу в процентах, используйте сопоставление шаблонов с тем же изображением - результат будет вашим 100%.
Псевдокод для примера:
previous_screenshot = ...
current_screenshot = ...
# simplify both images somehow
# get the 100% corresponding value
res = matchTemplate(previous_screenshot, previous_screenshot, TM_CCOEFF)
_, hundred_p_val, _, _ = minMaxLoc(res)
# hundred_p_val is now the 100%
res = matchTemplate(previous_screenshot, current_screenshot, TM_CCOEFF)
_, max_val, _, _ = minMaxLoc(res)
difference_percentage = max_val / hundred_p_val
# the tolerance is now up to you
Надеюсь, поможет.
У меня была та же проблема, и я написал простой модуль Python, который сравнивает два изображения одинакового размера, используя ImageChops подушки, для создания черно-белого разностного изображения и суммирует значения гистограммы.
Вы можете получить либо этот счет напрямую, либо процентное значение по сравнению с полным черным или белым различием.
Он также содержит простую функцию is_equal, с возможностью задавать нечеткий порог при (и включающем) прохождении изображения как равном.
Подход не очень сложен, но, возможно, полезен для тех, кто борется с той же проблемой.
Вы можете вычислить гистограмму обоих изображений, а затем рассчитать коэффициент Бхаттачарьи, это очень быстрый алгоритм, и я использовал его для обнаружения изменений в кадре в видео по крикету (в C с использованием openCV)
import os
from PIL import Image
from PIL import ImageFile
import imagehash
#just use to the size diferent picture
def compare_image(img_file1, img_file2):
if img_file1 == img_file2:
return True
fp1 = open(img_file1, 'rb')
fp2 = open(img_file2, 'rb')
img1 = Image.open(fp1)
img2 = Image.open(fp2)
ImageFile.LOAD_TRUNCATED_IMAGES = True
b = img1 == img2
fp1.close()
fp2.close()
return b
#through picturu hash to compare
def get_hash_dict(dir):
hash_dict = {}
image_quantity = 0
for _, _, files in os.walk(dir):
for i, fileName in enumerate(files):
with open(dir + fileName, 'rb') as fp:
hash_dict[dir + fileName] = imagehash.average_hash(Image.open(fp))
image_quantity += 1
return hash_dict, image_quantity
def compare_image_with_hash(image_file_name_1, image_file_name_2, max_dif=0):
"""
max_dif: The maximum hash difference is allowed, the smaller and more accurate, the minimum is 0.
recommend to use
"""
ImageFile.LOAD_TRUNCATED_IMAGES = True
hash_1 = None
hash_2 = None
with open(image_file_name_1, 'rb') as fp:
hash_1 = imagehash.average_hash(Image.open(fp))
with open(image_file_name_2, 'rb') as fp:
hash_2 = imagehash.average_hash(Image.open(fp))
dif = hash_1 - hash_2
if dif < 0:
dif = -dif
if dif <= max_dif:
return True
else:
return False
def compare_image_dir_with_hash(dir_1, dir_2, max_dif=0):
"""
max_dif: The maximum hash difference is allowed, the smaller and more accurate, the minimum is 0.
"""
ImageFile.LOAD_TRUNCATED_IMAGES = True
hash_dict_1, image_quantity_1 = get_hash_dict(dir_1)
hash_dict_2, image_quantity_2 = get_hash_dict(dir_2)
if image_quantity_1 > image_quantity_2:
tmp = image_quantity_1
image_quantity_1 = image_quantity_2
image_quantity_2 = tmp
tmp = hash_dict_1
hash_dict_1 = hash_dict_2
hash_dict_2 = tmp
result_dict = {}
for k in hash_dict_1.keys():
result_dict[k] = None
for dif_i in range(0, max_dif + 1):
have_none = False
for k_1 in result_dict.keys():
if result_dict.get(k_1) is None:
have_none = True
if not have_none:
return result_dict
for k_1, v_1 in hash_dict_1.items():
for k_2, v_2 in hash_dict_2.items():
sub = (v_1 - v_2)
if sub < 0:
sub = -sub
if sub == dif_i and result_dict.get(k_1) is None:
result_dict[k_1] = k_2
break
return result_dict
def main():
print(compare_image('image1\\815.jpg', 'image2\\5.jpg'))
print(compare_image_with_hash('image1\\815.jpg', 'image2\\5.jpg', 6))
r = compare_image_dir_with_hash('image1\\', image2\\', 10)
for k in r.keys():
print(k, r.get(k))
if __name__ == '__main__':
main()
выход:
Ложь
Правда
image2 \ 5.jpg image1 \ 815.jpg
image2 \ 6.jpg image1 \ 819.jpg
image2 \ 7.jpg image1 \ 900.jpg
image2 \ 8.jpg image1 \ 998.jpg
image2 \ 9.jpg image1 \ 1012.jpgпримеры фотографий:
815.jpg
5.jpg
Несколько более принципиальный подход заключается в использовании глобального дескриптора для сравнения изображений, такого как GIST или CENTRIST. Хеш-функция, как описано здесь, также предоставляет аналогичное решение.
Я думаю, что вы могли бы просто вычислить евклидово расстояние (т. Е. Sqrt (сумма квадратов разностей, пиксель за пикселем)) между яркостью двух изображений и считать их равными, если оно падает ниже некоторого эмпирического порога. И вам лучше сделать это, оборачивая функцию C.
Расстояние от землеройных машин может быть именно тем, что вам нужно. Это может быть довольно сложно реализовать в режиме реального времени.
Существует простое и быстрое решение с использованием numpy путем вычисления среднеквадратичной ошибки:
before = np.array(get_picture())
while True:
now = np.array(get_picture())
MSE = np.mean((now - before)**2)
if MSE > threshold:
break
before = now
Узнайте, как вейвлеты Haar реализованы в isk-daemon. Вы можете использовать его код C++ imgdb для вычисления различий между изображениями на лету:
isk-daemon - это сервер базы данных с открытым исходным кодом, способный добавлять контентный (визуальный) поиск изображений к любому веб-сайту или программному обеспечению, связанному с изображениями.
Эта технология позволяет пользователям любого веб-сайта или программного обеспечения, относящегося к изображениям, делать наброски на виджете, какое изображение они хотят найти, и веб-сайт отвечает им наиболее похожими изображениями или просто запрашивает больше похожих фотографий на каждой странице сведений об изображении.
Вот функция, которую я написал, которая принимает 2 изображения (пути к файлам) в качестве аргументов и возвращает среднюю разницу между компонентами пикселей двух изображений. Это очень хорошо помогло мне определить визуально "одинаковые" изображения (когда они не
== равный).
(Я обнаружил, что 8 - хороший предел, чтобы определить, одинаковы ли изображения по сути.)
(Если вы не добавляете предварительную обработку, изображения должны иметь одинаковые размеры.)
from PIL import Image
def imagesDifference( imageA, imageB ):
A = list(Image.open(imageA, r'r').convert(r'RGB').getdata())
B = list(Image.open(imageB, r'r').convert(r'RGB').getdata())
if (len(A) != len(B)): return -1
diff = []
for i in range(0, len(A)):
diff += [abs(A[i][0] - B[i][0]), abs(A[i][1] - B[i][1]), abs(A[i][2] - B[i][2])]
return (sum(diff) / len(diff))
Как насчет расчета Манхэттенского расстояния двух изображений. Это дает вам n*n значений. Затем вы могли бы сделать что-то вроде среднего по строке, чтобы уменьшить до n значений, и выполнить функцию для получения одного единственного значения.
Мне очень повезло с изображениями jpg, снятыми одной и той же камерой на штатив, благодаря (1) значительному упрощению (например, переходу от 3000 пикселей в ширину до 100 пикселей или даже меньше) (2) сведению каждого массива jpg в один вектор (3) попарно коррелирует последовательные изображения с помощью простого алгоритма корреляции, чтобы получить коэффициент корреляции (4) квадратный коэффициент корреляции для получения r-квадрата (то есть доли изменчивости в одном изображении, объясняемой изменением в следующем) (5), как правило, в моем приложении если r-квадрат < 0,9, я говорю, что два изображения разные, и что-то произошло между ними.
Это надежно и быстро в моей реализации (Mathematica 7)
Стоит поиграть с той частью изображения, которая вас интересует, и сфокусироваться на ней, подрезая все изображения в этой маленькой области, в противном случае удаленное от камеры, но важное изменение будет пропущено.
Я не знаю, как использовать Python, но уверен, что он тоже делает корреляции, нет?
Ознакомьтесь с этим довольно полезным пакетом Python, если кому-то может понадобиться проверить показатель качества изображения. проект
Существует множество метрик для оценки того, как выглядят два изображения / как они выглядят.
Я не буду вдаваться в какой-либо код здесь, потому что я думаю, что это должна быть научная проблема, а не техническая проблема.
Как правило, этот вопрос связан с восприятием человека на изображениях, поэтому каждый алгоритм имеет свою поддержку черт зрительной системы человека.
Классические подходы:
Предиктор видимых различий: алгоритм оценки точности изображения (https://www.spiedigitallibrary.org/conference-proceedings-of-spie/1666/0000/Visible-differences-predictor--an-algorithm-for-the-assessment-of/10.1117/12.135952.short?SSO=1)
Оценка качества изображения: от видимости ошибок до структурного сходства (http://www.cns.nyu.edu/pub/lcv/wang03-reprint.pdf)
FSIM: индекс сходства функций для оценки качества изображения (https://www4.comp.polyu.edu.hk/~cslzhang/IQA/TIP_IQA_FSIM.pdf)
Среди них SSIM (оценка качества изображения: от видимости ошибки до структурного сходства) является самым простым для вычисления, и его издержки также невелики, как сообщается в другой статье "Оценка качества изображения на основе градиентного сходства" (https://www.semanticscholar.org/paper/Image-Quality-Assessment-Based-on-Gradient-Liu-Lin/2b819bef80c02d5d4cb56f27b202535e119df988).
Есть много других подходов. Взгляните на Google Scholar и найдите что-то вроде "визуальной разницы", "оценки качества изображения" и т. Д., Если вы заинтересованы / действительно заботитесь об искусстве.
Используйте SSIM для измерения показателя индекса структурного сходства между двумя изображениями.