Как получить цвет пикселя python

Обновлено: 21.11.2024

Чтобы понять, как работать с изображениями, сначала нужно понять, как изображения представлены на компьютере. Изображения представляют собой двумерные массивы пикселей. Приходилось ли вам когда-либо увеличивать изображение так близко, что вы видите отдельные прямоугольники? Один из этих «боксов» представляет собой пиксель (сокращение от «элемент изображения»). И этот пиксель имеет цвет. Таким образом, изображения состоят из (на самом деле) крошечных «коробочек» цвета. В следующих разделах мы более подробно рассмотрим изображения с использованием JES/Python, а затем рассмотрим пиксели и цветовую модель RGB.

1.1 Код JES для просмотра изображений и свойств

  • pickAFile , который открывает диалоговое окно выбора файла и возвращает строку для выбранного файла
  • makePicture , создающий объект изображения
  • getHeight, который возвращает количество пикселей сверху вниз.
  • getWidth, который возвращает количество пикселей слева направо
  • getPixels , который возвращает список всех пикселей (объектов Pixel) на изображении
  • getPixel , который возвращает один объект Pixel с координатами x и y

Если вы не уверены, какие функции являются частью Python, а какие частью JES, вы можете посмотреть в меню JES в разделе Справка > Понимание изображений . Нажмите «Функции изображения в JES». Там вы можете найти кое-что интересное.

Следующая функция является компиляцией всех упомянутых выше функций JES.

Обратите внимание, что когда вы запускаете его и выбираете " caterpillarSmall.jpg ", выводится следующее:

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

1.2 Исследование пикселей

После того, как вы запустите приведенный выше код, вы заметите, что появилось дополнительное окно. Это инструмент «Проводник», который поставляется вместе с JES как часть приложения MediaTools. Вот как это должно выглядеть для вас:

Давайте попробуем следующее:

  • щелкните в любом месте изображения и обратите внимание на изменение значений X , Y и R:, G:, B:
  • попробуйте нажать в правом верхнем углу. Обратите внимание, что значение X близко к ширине.
  • попробуйте нажать на нижний левый угол. Обратите внимание, что значение Y близко к высоте.
  • Что вы замечаете в координатах X и Y, когда нажимаете в правом нижнем углу?
  • увеличение до 500 % (из пункта меню «Масштаб»). Вы видите цветные квадраты? Вы можете нажать на отдельные квадраты и увидеть значения цветов RGB.

Исследуя это изображение, вы можете получить интуитивное представление о пикселях. Чтобы дать вам немного больше информации, пиксели хранятся в двумерном массиве. Значения x представляют столбцы, а значения y представляют строки. Когда мы хотим получить доступ к отдельному пикселю (в определенном столбце и строке), мы можем использовать функцию getPixel(picture, x, y) .

На приведенной ниже диаграмме показано небольшое изображение (16 x 16 пикселей) и представление строк и столбцов с координатами углов, выделенными красным цветом. Обратите внимание на диапазон значений x от 0 до (width-1) и значений y от 0 до (height-1).

Обратите также внимание на порядок координат (столбец, строка) . Будьте осторожны: это отличается от двумерных массивов в C++.

1.3 Изучение цветов

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

Когда мы используем цветовую модель RGB, есть три значения: красный (R), зеленый (G) и синий (B). Если каждый из них хранится в одном байте (или 8 битах) памяти, то 0 означает отсутствие интенсивности, а 255 — полную интенсивность.

  • чистый красный: R: 255, G: 0, B: 0
  • чистый синий – R: 0, G: 0, B: 255.
  • чистый белый: R: 255, G: 255, B: 255
  • чистый черный — это R: 0, G: 0, B: 0
  • оттенок серого: R: 100, G: 100, B: 100

Запомните, что оттенки серого имеют одинаковую интенсивность красного, зеленого и синего компонентов.

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

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

2. «Отвержение» изображения

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

Итак, возникает вопрос: "Как нам перемещаться по изображению по одному пикселю за раз?" Итак, мы будем использовать циклы for. Как оказалось, при использовании JES существует два подхода к перемещению по пикселям: первый подход генерирует список всех объектов Pixel, а второй подход получает по одному пикселю за раз на основе значения строки и столбца. Почему вы изучаете оба подхода? Что ж, если вы хотите работать с частью изображения или «перевернуть» изображение, проще получить доступ к отдельным пикселям в определенных строках и столбцах. Напротив, если вы вносите глобальные изменения в цвет всего изображения, вы можете захватить все пиксели (в списке). Достаточно теории, давайте посмотрим на код!

2.1 Просмотр списка пикселей

Инструкция for выполняет итерацию по списку по одному объекту Pixel ( px ) за раз. Используя этот объект Pixel ( px ), мы можем:

  • получить красный, зеленый и синий компоненты (используя getRed() , getGreen() и getBlue() )
  • создать новый цвет (используя makeColor() )
  • изменить цвет текущего пикселя (используя setColor() )

Вуаля, новый образ! Как вы думаете, что делает makeColor(255-красный, 255-зеленый, 255-синий)? Ну а если у вас черный (0, 0, 0), то он станет белым (255, 255, 255). Если у вас красный (255, 0, 0), какой цвет он приобретет?

Вы можете попробовать запустить код, введя в JES следующее:

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

2.2 Использование вложенного цикла For

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

Возможно, вы заметили функцию диапазона. Например, range(0, getWidth(picture)) создает список, начинающийся с 0 (первый аргумент) и заканчивающийся на единицу меньше ширины изображения (второй аргумент). Внутренний цикл (связанный с y ) изменит строку. Внешний цикл (связанный с x ) изменит столбец. По сути, этот код будет перемещаться по изображению по столбцам по одному.

Обратите внимание на разницу в этом коде: мы должны получить отдельные пиксели по их координатам x и y, используя getPixel(picture, x, y) . Как только у нас появится отдельный пиксель, код будет таким же, как и в предыдущем подразделе, и создаст такое же изображение.

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

2.3 Использование функции

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

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

С точки зрения синтаксиса обратите внимание на определение функции:

  • используйте ключевое слово def, за которым следует имя функции и любые аргументы в квадратных скобках
  • не забудьте поставить полное двоеточие ( : ) после аргументов

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

3. Изменение значений цвета

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

Обратите внимание на синтаксис операторов if/elif/else в коде. Условия не заключены в квадратные скобки, а после каждого условия стоит полное двоеточие ( : ).

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

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

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

1. Отменить 2. Осветлить 3. Уменьшить красный цвет 4. Оттенки серого 5. Смешать с белым

Вы можете сравнить эти результаты с оригиналом:

Вы уже знаете о функции инвертирования изображения, но вам могут быть интересны другие функции. В следующих подразделах обсуждаются дополнительные функции изменения пикселей: lightenPixel() , reduceRedPixel() , grayScalePixel() и blendWhite() .

3.1 Освещение

Функция осветления показана ниже:

Код можно обобщить следующим образом:

  • получить объект Color для текущего пикселя (используя функцию JES getColor() )
  • возвратить более светлую версию исходного цвета (используя функцию JES makeLighter() )
  • изменить текущий пиксель на более светлый (используя setColor() )

3.2 Уменьшение красного

Функция для уменьшения интенсивности красного на 50 % приведена ниже:

Код можно обобщить следующим образом:

  • получить красный компонент для текущего пикселя (используя функцию JES getRed() )
  • изменить значение красного цвета текущего пикселя на 50 % (используя функцию JES setRed() )

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

Что бы мы изменили, если бы захотели уменьшить красный цвет на 25 %?

3.3 Применение оттенков серого

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

  • яркость=(красный+зеленый+синий)/3
  • яркость=(красный*0,3333)+(зеленый*0,3333)+(синий*0,3333)

Однако глаз воспринимает синий цвет как более темный, чем красный, поэтому в формуле яркости синий имеет меньший вес. Обратите внимание, что 0,299+0,587+0,114 равняется 1,0 (хорошая весовая функция). Получив значение яркости из этих взвешенных значений RGB, мы можем создать новый серый цвет.

3.4 Смешение с белым

Функция для смешивания цветов с количеством белого приведена ниже:

Да, я знаю; это больше математика. Давайте рассмотрим, как вычисляется значение newRed. Во-первых, помните, что белый цвет имеет значения RGB 255, 255, 255. Если мы хотим смешать 20% белого, то мы должны использовать 80% (1-0,20) текущей интенсивности красного. Первая часть формулы ( 255*amount ) предназначена для управления «белизной», а вторая часть (getRed(pixel)*(1-amount)) — для управления тем, сколько исходного цвета проходит.

  • Если количество равно 0,5, сколько используется белого и исходного цвета?
  • Если количество равно 0,95, сколько используется белого и исходного цвета?
  • Если количество равно 1, сколько белого и сколько исходного цвета используется?

В этом лабораторном упражнении мы будем использовать смешивание с белым цветом!

4. Копирование пикселей

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

4.1 Дублирование изображения

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

Есть несколько дополнительных функций:

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

Обобщая приведенный выше код

  • создать объект Picture из изображения гусеницы; используйте функции JES getMediaPath() и makePicture()
  • создать пустой "холст" (второй объект Picture) для копирования изображения; используйте функцию JES makeEmptyPicture()
  • цикл для всех столбцов и всех строк
    • получить текущий цвет пикселя изображения гусеницы; используйте функцию JES getColor()
    • скопируйте этот цвет на холст (скопированное изображение); используйте функцию JES setColor()

    4.2 Зеркальное отображение изображения

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

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

    • создать объект Picture из гусеницы
    • создайте холст (второй объект Picture) той же ширины и высоты, что и изображение гусеницы
    • зациклить

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

    • одна копия цвета находится в том же пикселе, что и исходное изображение.
    • вторая копия создается, начиная с правого края изображения ( ширина - x - 1 )

    Полученное изображение выглядит следующим образом:

    Что бы вы изменили, чтобы изображение выглядело так?

    5. Ссылки

    6. Упражнение

    Общая идея

    Модно создать зеркальное отражение изображения, а затем сделать его белым с помощью какого-нибудь прикладного программного обеспечения. Вы можете создать такой же эффект в JES. Идея состоит в том, что вы будете дублировать и зеркально отображать изображение внизу. Когда вы дублируете «перевернутое» изображение, вы рассчитаете, сколько белого цвета вам нужно сделать. Да, это требует некоторой математики. Вы можете выбрать линейное смешение или S-образное смешение. Оба результата показаны ниже.

    Линейное смешение

    Наложение S-образной кривой

    Подробнее

    Шаг 1

    Создайте функцию, которая будет:

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

    • одна копия существующего изображения
    • одну копию, чтобы "отражать" изображение (подсказка: значение y будет начинаться с нижнего края холста)

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

    Шаг 2

    Создайте вторую функцию (которая будет вызываться первой), которая будет вычислять и возвращать значение "затухания":

      Передать два аргумента: текущий y ( y ), высоту изображения ( h )

      Для линейного затухания используется следующая формула:
      fadeAmount=(h-y)/float(h)+0,15 Идея этой формулы заключается в том, что у будет отображаться значение от 0 до 1 (идеально подходит для процентов смешивания). Значение +0,15 должно придать мгновенный «выцветший» вид. В противном случае изменение будет слишком постепенным.

    Используйте эту функцию с функцией "Шаг 1":

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

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

    Этот код позволяет сохранить изображение под указанным именем (по текущему пути к медиафайлу). Имя, строка, должна заканчиваться на .jpg, .jpg или .bmp, чтобы JES знала, какой формат применять.

    Если я открываю изображение с помощью open("image.jpg") , как я могу получить значения RGB для пикселя, если у меня есть координаты пикселя?

    Тогда, как я могу сделать обратное? Начиная с пустого изображения, «записать» пиксель с определенным значением RGB?

    Я бы предпочел, чтобы мне не нужно было загружать какие-либо дополнительные библиотеки.

    13 ответов 13

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

    Самый простой способ сделать то, что вы хотите, — использовать метод load() объекта Image, который возвращает объект доступа к пикселю, которым вы можете манипулировать как массивом:

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

    Для будущих читателей: подушка установки pip успешно и довольно быстро установит PIL (может потребоваться sudo, если не в virtualenv).

    pillow.readthedocs.io/en/latest/… показывает команды bash на этапах установки Windows. Не знаю, что делать дальше.

    Используя Pillow (который работает как с Python 3.X, так и с Python 2.7+), вы можете делать следующее:

    Теперь у вас есть все значения пикселей. Если это RGB или другой режим, его можно прочитать с помощью im.mode. Затем вы можете получить пиксель (x, y) с помощью:

    Кроме того, вы можете использовать Numpy и изменить форму массива:

    Полное и простое в использовании решение

    Проверить код дымом

    Возможно, вы не уверены в порядке ширины/высоты/канала. По этой причине я создал этот градиент:

    • Форма (ширина, высота, каналы)
    • Изображение[0] , то есть первая строка, содержит 26 троек одного цвета.

    Будьте осторожны, список параметров «изменить форму» должен быть (высота, ширина, каналы). а для изображений rgba вы можете включить image.mode = RGBA с каналами = 4

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

    PyPNG – облегченный декодер/кодировщик PNG

    Хотя вопрос намекает на JPG, я надеюсь, что мой ответ будет полезен для некоторых людей.

    Вот как читать и записывать пиксели PNG с помощью модуля PyPNG:

    PyPNG – это отдельный модуль Python длиной менее 4 000 строк, включая тесты и комментарии.

    PIL — это более полная библиотека изображений, но она также значительно тяжелее.

    Как сказал Дэйв Уэбб:

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

    Почему при запуске кода Лаклана Филлипса я получаю четыре значения? Я даю это: print(pix[10,200]) и получаю это: (156, 158, 157, 255) Почему?

    Вероятно, это связано с тем, что ваше изображение поддерживает альфа-прозрачность и имеет формат rgba, а это означает, что четвертое значение указывает, насколько прозрачен этот пиксель.

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

    Кто-нибудь знает, почему за это проголосовали? Есть ли известная проблема с libgd или что-то в этом роде? (Я никогда не смотрел на это, но всегда приятно знать, что есть альтернатива PiL)

    Вы можете использовать модуль Surfarray от pygame. Этот модуль имеет метод возврата трехмерного массива пикселей, называемый пикселями3d(поверхность). Я показал использование ниже:

    Надеюсь, был полезен. Последнее слово: экран заблокирован на время жизни screenpix.

    Используя библиотеку под названием Pillow, вы можете превратить это в функцию для простоты использования позже в вашей программе, а также если вам придется использовать ее несколько раз. Функция просто принимает путь к изображению и координаты пикселя, который вы хотите «захватить». Он открывает изображение, преобразует его в цветовое пространство RGB и возвращает R, G и B запрошенного пикселя.

    *Примечание: я не был первоначальным автором этого кода; это было оставлено без объяснения причин. Поскольку это довольно легко объяснить, я просто даю пояснение на тот случай, если кто-то в будущем его не поймет.

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

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

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

    Содержание

    Изобретатель приложений [ изменить ]

    App Inventor имеет два блока Canvas для определения цвета под пикселем.
    GetBackgroundPixelColor возвращает цвет из Canvas, но игнорирует спрайты Ball и ImageSprites.
    GetPixelColor возвращает цвет спрайта Canvas, Ball или ImageSprite.
    На приведенном ниже экране приложения фиолетовый спрайт с мячом коснулся левого холста, но возвращенный цвет пикселя (зеленый) был из области под ним.

    8086 Сборка [ изменить ]

    С прерываниями [ изменить ]

    В MS-DOS есть встроенный способ расчета цвета пикселя на экране.

    Цвет возвращается в формате AL.

    Действовать! [править]

    Автогорячая клавиша [ изменить ]

    AutoIt [ изменить ]

    Топор [ изменить ]

    Бекон [ изменить ]

    BaCon может использовать включение High Performance Canvas. За пределами этого холста ему требуется доступ к функциям API XLib.

    ОСНОВНЫЕ [изменить]

    AmigaBASIC [править]

    (Индекс цвета равен -1, если указатель мыши находится за пределами основного окна.)

    Applesoft BASIC [ изменить ]

    В Applesoft нет функции HSCRN(X,Y). Далее следует сложная подпрограмма, определяющая цвет высокого разрешения в месте, заданном переменными X и Y на текущей странице высокого разрешения.Значение цвета в диапазоне от 0 до 7 возвращается в переменной C. Цвет определяется просмотром соседних пикселей и старшим битом старшего разряда. Процедура VTAB используется в качестве вспомогательного средства для вычисления адреса пикселей. Другие цвета помимо 6 цветов высокого разрешения могут отображаться путем позиционирования пикселей на границах байтов с использованием MSB. Эта процедура ограничена восемью цветами высокого разрешения.

    BBC BASIC [ изменить ]

    В BBC BASIC для Windows вы можете прочитать либо «логический цвет» (индекс палитры), либо «истинный цвет» (24-битное значение RGB).

    Commodore BASIC [править]

    Пример 1: Commodore 64

    В Commodore 64 BASIC нет графических команд. Графика высокого разрешения (аренда) программируется путем прямого манипулирования аппаратными регистрами и памятью.

    Растровое изображение найма Commodore 64 имеет размер 320 x 200, разделенное на ячейки 8 x 8, начиная с верхнего левого угла и двигаясь вправо. Каждая ячейка адресуется сверху вниз по 8 байтам. Каждый байт управляет горизонтальной строкой из 8 бит. Это требует вычислений со стороны программиста для преобразования координат X, Y в определенную комбинацию адрес/значение памяти (строки 1210–1220).

    Пример 2: Commodore Plus 4 и 128

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

    FreeBASIC [править]

    Это очень простой пример из документации FreeBASIC. Для получения цвета произвольного пикселя экрана (т. е. вне графического экрана, управляемого FB) необходимо использовать функции API.

    QuickBASIC [ изменить ]

    В графическом режиме (например, ЭКРАН 13 или ЭКРАН 12)

    Целочисленный БАЗОВЫЙ [ редактировать ]

    Свобода БАЗОВЫЙ [ изменить ]

    Основной локомотив [ изменить ]

    PureBasic [править]

    Возвращает цвет, используемый в позиции x,y в текущем выводе. Если текущий вывод имеет альфа-канал, результатом будет 32-битное значение RGBA, в противном случае это будет 24-битное значение RGB. Цвет можно разделить на значения RGB и альфа-канала с помощью функций Red(), Green(), Blue() и Alpha().

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

    QBasic [править]

    BASIC256 [править]

    SmileBASIC [ изменить ]

    TI-89 БАЗОВЫЙ [править]

    Можно прочитать только экран графика.

    VBA [править]

    В "чистом" Visual Basic for Application невозможно определить цвет пикселя экрана. Мы должны использовать функции API. Этот код следует адаптировать для 64-битных версий.

    Ябасич [ изменить ]

    Базовый ZX Spectrum [править]

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

    Произошла ошибка сервера. Обновите страницу или повторите попытку через некоторое время.

    Произошла ошибка. Обновите страницу или повторите попытку через некоторое время.

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

    Наша политика конфиденциальности и Условия предоставления услуг помогут вам понять, как вы нашли данные на HackerEarth.

    Зарегистрируйтесь и получите бесплатный доступ к более чем 100 руководствам и практическим задачам Начать

    Я хотел извлечь значения каждого пикселя, чтобы использовать их для поиска простых объектов на изображении. Каждое изображение состоит из пикселей, и когда эти значения извлекаются с помощью Python, для каждого пикселя получается четыре значения (R, G, B, A). Это называется цветовым пространством RGBA, имеющим красный, зеленый, синий цвета и значение альфа-канала соответственно.

    В Python мы используем библиотеку под названием PIL (библиотека изображений Python). Модули в этой библиотеке используются для обработки изображений и поддерживают многие форматы файлов, такие как png, jpg, bmp, gif и т. д. Он поставляется с большим количеством функций, которые можно использовать для открытия, извлечения данных, изменения свойств, создания новых изображений. и многое другое…

    PIL предустанавливается вместе с python2.7 в Ubuntu, но для Windows его нужно устанавливать вручную. Но для операционных систем с python2.7 или выше можно скачать отсюда. а для python3 его можно скачать отсюда.

      импортируйте модуль изображения PIL в оболочку:

    >>>из изображения импорта PIL

    >>>im = Image.open('myfile.jpg', ' r')

    >>>pix_val = список(im.getdata())

    pix_val — это список, содержащий все значения пикселей, которые можно распечатать, чтобы увидеть эти значения. Но полученный список представляет собой список наборов, и иногда его необходимо сгладить, например, если список выглядит так: ), (345,453,234,124),……] и необходимый список — [123, 124, 145, 120, 345, 453, 234, 124….], тогда команда для выравнивания списка:

    >>> pix_val_flat = [x для наборов в pix_val для x в наборах]

    Это понимание списка извлекает каждый элемент каждого набора из списка pix_val, и все элементы сохраняются в pix_val_flat. Таким образом, это можно скомпилировать в скрипт или превратить в функцию, которую можно использовать в любых проектах обработки изображений позже. PIL — один из многих методов обработки изображений. pygames или numpy также можно использовать с соответствующими модулями для обработки изображений.

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

    Вы также узнаете:

    • Что такое пиксели
    • Как работает система координат изображения в OpenCV
    • Как получить доступ к значениям отдельных пикселей изображения
    • Как установить/обновить пиксели изображения
    • Как использовать нарезку массива для захвата областей изображения

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

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

    Ищете исходный код этого сообщения?

    Получение и настройка пикселей OpenCV

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

    Оттуда мы настроим нашу среду разработки и просмотрим структуру каталогов нашего проекта.

    Изучив структуру каталогов нашего проекта, мы реализуем скрипт Python, opencv_getting_setting.py . Как следует из названия, это позволяет нам получать доступ к пикселям и управлять ими с помощью OpenCV.

    Мы завершим это руководство обсуждением наших результатов.

    Начнем!

    Что такое пиксели?

    Пиксели — это необработанные строительные блоки изображения. Каждое изображение состоит из набора пикселей. Нет более точной детализации, чем пиксель.

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

    Если рассматривать изображение как сетку, каждый квадрат сетки содержит один пиксель. Давайте посмотрим на пример изображения на рисунке 1:

    Большинство пикселей представлены двумя способами:

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

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

    Однако цветные пиксели обычно представлены в цветовом пространстве RGB — одно значение для красного компонента, одно для зеленого и одно для синего, что в сумме дает 3 значения на пиксель:< бр />

    Существуют и другие цветовые пространства (HSV (оттенок, насыщенность, яркость), L*a*b* и т. д.), но давайте начнем с основ и будем двигаться дальше.

    Затем мы объединяем эти значения в кортеж RGB в форме (красный, зеленый, синий) . Этот кортеж представляет наш цвет.

    Чтобы построить белый цвет, мы должны полностью заполнить каждую из красных, зеленых и синих корзин, например: (255, 255, 255) — поскольку белый — это присутствие всех цветов.

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

    Чтобы создать чистый красный цвет, мы должны полностью заполнить красное ведро (и только красное ведро): (255, 0, 0) .

    Вы начинаете замечать закономерность?

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

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

    И в вверху справа у нас есть черный цвет — красные, зеленые и синие ведра теперь полностью пусты.

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

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

    Для справки, вот некоторые распространенные цвета, представленные в виде кортежей RGB:

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

    Обзор системы координат изображения в OpenCV

    Как я уже упоминал на рис. 1, изображение представлено в виде сетки пикселей. Представьте нашу сетку в виде листа миллиметровой бумаги. На этой миллиметровке точка (0, 0) соответствует верхнему левому углу изображения (т. е. началу). По мере перемещения вниз и вправо значения x и y увеличиваются.

    Давайте посмотрим на изображение на рис. 5, чтобы прояснить этот момент:

    Здесь у нас есть буква «I» на листе миллиметровой бумаги. Мы видим, что у нас есть сетка 8 x 8 с общим количеством пикселей 64.

    Точка (0, 0) соответствует верхнему левому пикселю нашего изображения, тогда как точка (7, 7) соответствует правому нижнему углу.

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

    Наконец, 4 столбца пикселя вправо и 5 строк вниз индексируются точкой (3, 4), сохраняя помните, что мы считаем с нуля, а не с единицы.

    Настройка среды разработки

    Чтобы следовать этому руководству, в вашей системе должна быть установлена ​​библиотека OpenCV.

    К счастью, OpenCV можно установить с помощью pip:

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

    Возникли проблемы с настройкой среды разработки?

    Все, что сказано, вы:

    • Нет времени?
    • Изучаете административно заблокированную систему вашего работодателя?
    • Хотите избавиться от проблем с командной строкой, менеджерами пакетов и виртуальными средами?
    • Готовы запустить кодпрямо сейчасв вашей системе Windows, macOS или Linux?

    Получите доступ к Jupyter Notebooks для этого руководства и других руководств по PyImageSearch, которые предварительно настроены для работы в экосистеме Google Colab прямо в вашем веб-браузере! Установка не требуется.

    И самое главное, эти ноутбуки Jupyter Notebook будут работать в Windows, macOS и Linux!

    Структура проекта

    Сегодня мы рассмотрим один скрипт Python, opencv_getting_setting.py , который позволит нам получать доступ и управлять пикселями изображения из изображения adrian.jpg .

    Получение и установка пикселей с помощью OpenCV

    Давайте узнаем, как получать и устанавливать пиксели с помощью OpenCV.

    Откройте файл opencv_getting_setting.py в структуре каталогов вашего проекта и приступайте к работе:

    Строки 2 и 3 импортируют необходимые пакеты Python. Нам нужен только argparse для наших аргументов командной строки cv2 для наших привязок OpenCV.

    Аргумент командной строки --image указывает на изображение, которым мы хотим управлять, находящееся на диске. По умолчанию аргумент командной строки --image имеет значение adrian.jpg .

    Далее загрузим это изображение и начнем обращаться к значениям пикселей:

    Строки 13–15 загружают входное изображение с диска, захватывают его ширину и высоту и отображают изображение на экране:

    Изображения в OpenCV представлены массивами NumPy. Чтобы получить доступ к определенному пикселю изображения, все, что нам нужно сделать, это передать координаты (x, y) как image[y, x] :

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

    Большой вопрос:

    Почему OpenCV представляет изображения в порядке каналов BGR, а не в стандартном RGB?

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

    Строка 23 затем обращается к пикселю, расположенному по адресу x = 50, y = 20, используя индексацию массива image[20, 50] .

    Но подождите. . . это не отсталость? Разве это не должно быть image[50, 20], поскольку x = 50 и y = 20?

    Давайте вернемся на шаг назад и рассмотрим, что изображение — это просто матрица с шириной (количество столбцов) и высотой (количество строк). Если бы нам нужно было получить доступ к отдельному местоположению в этой матрице, мы бы обозначили его как значение x (номер столбца) и значение y (номер строки).

    Поэтому, чтобы получить доступ к пикселю, расположенному по адресу x = 50, y = 20, вы сначала передаете значение y (строка число), за которым следует x-значение (номер столбца), в результате получается image[y, x] .

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

    Строки 27 и 28 обновляют пиксель, расположенный в точках x = 50, y = 20, устанавливая для него красный цвет (0, 0, 255) в BGR. заказ. Затем строка 29 выводит обновленное значение пикселя на наш терминал, тем самым демонстрируя, что оно было обновлено.

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

    В строке 33 мы вычисляем координаты (x, y) центра изображения. Это достигается путем простого деления ширины и высоты на два, что обеспечивает целочисленное преобразование (поскольку мы не можем получить доступ к «дробным пикселям»).

    Затем в строке 38 мы используем простое нарезку массива NumPy для извлечения областей [0, cX) и [0, cY) изображения. На самом деле эта область соответствует верхнему левому углу изображения! Чтобы получить фрагменты изображения, NumPy ожидает, что мы предоставим четыре индекса:

    • Начальная координата y. Первое значение — это начальная координата y. Здесь наш срез массива будет начинаться вдоль оси y. В нашем примере выше наш срез начинается с y = 0.
    • Конец y: так же, как мы указали начальное значение y, мы должны указать конечное значение y. Наш срез останавливается вдоль оси y, когда y = cY.
    • Начальная x. Третье значение, которое мы должны указать, — это начальная координата x для среза. Чтобы захватить верхнюю левую область изображения, мы начинаем с x = 0.
    • Конец x: Наконец, нам нужно указать значение оси x для остановки нашего среза. Мы останавливаемся, когда x = cX.

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

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

    Как и в приведенном выше примере, строка 44 извлекает правый верхний угол изображения, строка 45 извлекает правый нижний угол, а строка 46 нижний левый.

    Наконец, все четыре угла изображения отображаются на экране в строках 47-49, вот так:

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

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

    В строке 52 вы можете видеть, что мы снова обращаемся к верхнему левому углу изображения; однако на этот раз мы устанавливаем для этой области значение (0, 255, 0) (зеленый цвет).

    Строки 55 и 56 показывают результаты нашей работы:

    Получение и настройка результатов пикселя OpenCV

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

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

    Оттуда вы можете выполнить следующую команду:

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

    Первая строка вывода сообщает нам, что пиксель, расположенный в точке (0, 0), имеет значение R = 233, G = 240 и B = 246. Сегменты для всех трех каналов почти белые, что указывает на то, что пиксель очень яркий.

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

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

    Что дальше? Я рекомендую университет PyImageSearch.

    Информация о курсе:
    всего 35 классов • 39 ч. 44 м. видео • Последнее обновление: февраль 2022 г.
    ★★★★★ 4,84 (128 оценок) • Зачислено более 3000 студентов

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

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

    Это не дело.

    Все, что вам нужно, чтобы освоить компьютерное зрение и глубокое обучение, — это чтобы кто-то объяснил вам все в простых, интуитивно понятных терминах. И это именно то, чем я занимаюсь. Моя миссия — изменить образование и то, как преподаются сложные темы, связанные с искусственным интеллектом.

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

    В Университете PyImageSearch вы найдете:

    • &проверить; Более 35 курсов по основным темам компьютерного зрения, глубокого обучения и OpenCV.
    • &проверить; 35+ сертификатов об окончании
    • &проверить; Видео по запросу 39 ч. 44 мин.
    • &проверить; Каждый месяц выпускаются новые курсы, благодаря которым вы сможете овладеть самыми современными технологиями
      • .
    • &проверить; Предварительно настроенные ноутбуки Jupyter в Google Colab
    • &проверить; Запускайте все примеры кода в своем веб-браузере — работает в Windows, macOS и Linux (настройка среды разработки не требуется!)
    • &проверить; Доступ к централизованным репозиториям кода для всех 500+ руководств по PyImageSearch
    • &проверить; Простая загрузка кода, наборов данных, предварительно обученных моделей и т. д. одним щелчком мыши.
    • &проверить; Доступ на мобильных устройствах, ноутбуках, компьютерах и т. д.

    Обзор

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

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

    В отличие от системы координат, которую вы изучали в основах алгебры, где начало координат, обозначаемое как (0, 0), находится в нижнем левом углу, начало координат для изображений на самом деле находится в верхнем левом изображении.

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

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

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

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

    Об авторе

    Здравствуйте, я Адриан Роузброк, доктор философии. Слишком часто я вижу, как разработчики, студенты и исследователи тратят свое время впустую, изучая неправильные вещи и вообще пытаясь начать работу с Computer Vision, Deep Learning и OpenCV. Я создал этот веб-сайт, чтобы показать вам, как, по моему мнению, лучше всего начать работу.

    Читайте также: