Обработка изображений: Pillow и OpenCV

Изображение — массив пикселей NumPy: координаты, каналы и формула серого; открытие, изменение размера, обрезка, рисование и сохранение в Pillow; BGR, цветовые пространства, размытие, порог, границы и контуры в OpenCV — с проектом подсчёта монет.

  • Университет
  • 22 мин
  • 12 вопросов
  • Урок 59 из 66

В этом уроке ты узнаешь

  • Понимать изображение как массив (H, W, C), различать координаты (x, y) и [y, x] и вычислять яркость
  • Открывать, уменьшать с сохранением пропорций, обрезать, поворачивать, рисовать и сохранять изображения в Pillow
  • Переводить цветовые пространства в OpenCV и объяснять шаги размытия, порога, границ и контуров
  • Находить, считать и измерять объекты на изображении

Для компьютера изображение — таблица чисел: каждая точка — пиксель — это несколько чисел. Уменьшить сотню фотографий для сайта, поставить водяной знак, посчитать монеты на снимке — всё это операции над этими числами. Pillow (PIL) нужен, чтобы открывать, изменять размер, рисовать и сохранять файлы, а OpenCV — библиотека компьютерного зрения: фильтры, границы, контуры, поиск объектов. Обе умеют превращать изображение в массив NumPy, поэтому знания из урока «Основы NumPy: массивы» работают здесь напрямую.

Изображение — это массив чисел

Пиксель и каналОпределение

Пиксель — наименьшая точка изображения. У цветного пикселя три канала — красный, зелёный, синий (RGB), каждый типа uint8 от 0 до 255. У серого изображения канал один: 0 — чёрный, 255 — белый. Форма массива — (H, W, C): высота, ширина, каналы.

x — столбцы (ширина)xy(0; 0)[1, 4]y — строки (высота), растёт внизimg[1, 4]: строка y = 1, столбец x = 4shape = (4, 6, 3): высота, ширина, каналы
Pillow записывает координаты как (x, y), а массивы NumPy и OpenCV индексируются как [строка, столбец] = [y, x].
L = 0,299 · R + 0,587 · G + 0,114 · B

Где

R, G, B
красное, зелёное и синее значения пикселя (0–255)
L
яркость в оттенках серого (0–255)

Преобразования convert('L') в Pillow и COLOR_BGR2GRAY в OpenCV используют эту формулу (ITU-R 601). Глаз чувствительнее всего к зелёному, поэтому у него наибольший вес.

Python
import numpy as np
import matplotlib.pyplot as plt

img = np.zeros((4, 6, 3), dtype=np.uint8)
img[:, :3] = [255, 0, 0]
img[:, 3:] = [0, 0, 255]
img[1, 4] = [255, 255, 255]
print(img.shape, img.dtype, img.size)
print(img[1, 4], img[0, 0])

r, g, b = img[..., 0], img[..., 1], img[..., 2]
gray = (0.299 * r + 0.587 * g + 0.114 * b).round().astype(np.uint8)
print(gray)

plt.imshow(img)
plt.title('6 × 4 pixels')
Ожидаемый результат
(4, 6, 3) uint8 72
[255 255 255] [255   0   0]
[[ 76  76  76  29  29  29]
 [ 76  76  76  29 255  29]
 [ 76  76  76  29  29  29]
 [ 76  76  76  29  29  29]]
Этот код работает в браузере: изображение — просто массив uint8, а matplotlib его показывает. img[1, 4] — строка 1, столбец 4; в сером варианте красный становится 76, синий — 29, белый — 255.

Пример 1: яркость вручную

Задача

Найди яркость в сером: 1) красный (255, 0, 0); 2) зелёный (0, 255, 0); 3) оранжевый (200, 120, 40).

Показать решениеСкрыть решение

Решение

1) 0,299 · 255 ≈ 76,2 → 76.
2) 0,587 · 255 ≈ 149,7 → 150 — из цветов одинаковой интенсивности зелёный выглядит самым светлым.
3) 59,8 + 70,44 + 4,56 = 134,8 → 135 (код Pillow ниже тоже даёт 135).

Чтобы читать дальше, зарегистрируйся бесплатно

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

Pillow: открыть, изменить, нарисовать, сохранить

Image.open(path) открывает файл, Image.new(mode, size, color) создаёт пустое изображение; размер всегда задаётся как (ширина, высота). ImageDraw.Draw(img) рисует на нём прямоугольники, эллипсы, линии и текст. save выбирает формат по расширению: .png — без потерь, .jpg сжимается с качеством quality. Pillow и OpenCV в браузере не работают: pip install pillow opencv-python.

Python
from PIL import Image, ImageDraw

img = Image.new('RGB', (400, 300), color=(240, 240, 255))
draw = ImageDraw.Draw(img)
draw.rectangle((40, 40, 200, 140), fill=(255, 159, 28), outline='black', width=3)
draw.ellipse((220, 60, 360, 200), fill=(31, 182, 255))
draw.line((0, 299, 399, 0), fill='red', width=2)
draw.text((40, 250), 'Educora', fill='black')
img.save('scene.png')

loaded = Image.open('scene.png')
print(loaded.format, loaded.size, loaded.mode)
print(loaded.getpixel((100, 100)), loaded.getpixel((290, 130)), loaded.getpixel((5, 5)))

Ожидаемый результат

PNG (400, 300) RGB
(255, 159, 28) (31, 182, 255) (240, 240, 255)
Прямоугольник задаётся рамкой (левый, верхний, правый, нижний край). Точка (100, 100) внутри оранжевого прямоугольника, (290, 130) — внутри синего круга; угол (5, 5) — цвета фона.
h′ = h · w′/wk = min(Wmax/w; Hmax/h)h′ = h · w′/wk = min(Wmax/w; Hmax/h)

Где

w, h
исходные ширина и высота (пиксели)
w′, h′
новые размеры
k
масштаб для thumbnail((W_max, H_max)): изображение должно уместиться в оба предела

Изменение размера с сохранением пропорций: resize принимает любой размер (пропорцию считаешь ты), а thumbnail сохраняет пропорцию сам и уменьшает изображение на месте.

Python
from PIL import Image, ImageFilter

photo = Image.new('RGB', (1600, 1200), (200, 120, 40))
w, h = photo.size
small = photo.resize((800, h * 800 // w))
print(small.size)

thumb = photo.copy()
thumb.thumbnail((300, 300))
print(thumb.size)
print(photo.crop((100, 100, 500, 400)).size)
print(photo.rotate(90, expand=True).size, photo.rotate(30).size)

gray = photo.convert('L')
print(gray.mode, gray.getpixel((0, 0)))
soft = small.filter(ImageFilter.GaussianBlur(radius=2))
soft.save('small.jpg', quality=85)
print(Image.open('small.jpg').format, Image.open('small.jpg').size)

Ожидаемый результат

(800, 600)
(300, 225)
(400, 300)
(1200, 1600) (1600, 1200)
L 135
JPEG (800, 600)
crop возвращает новое изображение (400 × 300). rotate(90, expand=True) расширяет холст, и размеры меняются местами; без expand углы обрезаются. GaussianBlur смягчает картинку, JPEG сохраняется с quality=85.

Пример 2: новые размеры

Задача

1) Фото 4000 × 3000 уменьшают до ширины 800. 2) Изображение 1600 × 1200 и thumbnail((300, 300)). 3) Вертикальное изображение 1200 × 1600 и thumbnail((300, 300)).

Показать решениеСкрыть решение

Решение

1) h′ = 3000 · 800 / 4000 = 600 → 800 × 600.
2) k = min(300/1600; 300/1200) = min(0,1875; 0,25) = 0,1875 → 300 × 225 (как и вывел код).
3) k = min(0,25; 0,1875) = 0,1875 → 225 × 300.

OpenCV: цветовые пространства, фильтры, границы

В OpenCV изображение — тоже массив NumPy, но порядок каналов BGR (синий, зелёный, красный). cv2.cvtColor меняет цветовое пространство: серое (GRAY), RGB, HSV (тон, насыщенность, яркость — удобно для поиска объектов по цвету). Функции рисования меняют массив на месте, точки задаются как (x, y), а цвета — в BGR.

Python
import cv2
import numpy as np

img = np.full((300, 400, 3), 255, dtype=np.uint8)
cv2.rectangle(img, (40, 40), (160, 140), (0, 0, 255), -1)
cv2.circle(img, (280, 150), 60, (255, 0, 0), -1)
cv2.putText(img, 'OpenCV', (40, 260), cv2.FONT_HERSHEY_SIMPLEX, 1.2, (0, 0, 0), 2)
print(img.shape, img.dtype)
print(img[90, 100], img[150, 280])

rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
hsv = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)
print(rgb[90, 100], gray.shape, gray[90, 100], hsv[90, 100])
cv2.imwrite('shapes.png', img)
print(cv2.imread('missing.png'))

Ожидаемый результат

(300, 400, 3) uint8
[  0   0 255] [255   0   0]
[255   0   0] (300, 400) 76 [  0 255 255]
None
(0, 0, 255) в OpenCV — красный: в массиве [0 0 255], а после перевода в RGB — [255 0 0]. В HSV у красного тон 0. Если файла нет, cv2.imread не выбрасывает исключение — печатает предупреждение и возвращает None.
Python
import cv2
import numpy as np

a = np.array([[200, 250]], dtype=np.uint8)
b = np.array([[100, 10]], dtype=np.uint8)
print(a + b)
print(cv2.add(a, b))
print(np.clip(a.astype(np.int16) + b, 0, 255).astype(np.uint8))

Ожидаемый результат

[[44  4]]
[[255 255]]
[[255 255]]
200 + 100 = 300 = 256 + 44, поэтому NumPy хранит 44, а 250 + 10 = 260 превращается в 4. cv2.add складывает с насыщением; чтобы получить то же в NumPy, сначала перейди к более широкому типу и примени np.clip.

Ядро (kernel) и фильтрОпределение

Фильтр заменяет каждый пиксель взвешенной суммой его соседей; таблица весов — это ядро. cv2.GaussianBlur(img, (5, 5), 0) сглаживает шум гауссовым ядром 5 × 5 (размер должен быть нечётным). Алгоритм Кэнни (cv2.Canny) находит места резкого изменения яркости — границы, а cv2.threshold превращает изображение в чёрно-белую маску.

Чтобы увидеть, что делают эти шаги, выполним те же операции с scipy.ndimage, который работает в браузере: шумное изображение → размытие → границы (Собель) → маска и подсчёт объектов.

Python
import numpy as np
import matplotlib.pyplot as plt
from scipy import ndimage

yy, xx = np.mgrid[0:120, 0:160]
img = np.where((xx - 60)**2 + (yy - 60)**2 < 35**2, 220.0, 60.0)
img[20:50, 110:150] = 220.0
noisy = img + np.random.default_rng(0).normal(0, 25, img.shape)
blurred = ndimage.gaussian_filter(noisy, sigma=2)
edges = np.hypot(ndimage.sobel(blurred, axis=0), ndimage.sobel(blurred, axis=1))
mask = blurred > 140
labels, n = ndimage.label(mask)
print('objects:', n)
print('sizes:', [int(s) for s in ndimage.sum(mask, labels, range(1, n + 1))])

fig, axes = plt.subplots(1, 4, figsize=(10, 2.6))
for ax, im, title in zip(axes, [noisy, blurred, edges, mask], ['noisy', 'blurred', 'edges', 'mask']):
    ax.imshow(im, cmap='gray')
    ax.set_title(title)
    ax.axis('off')
Ожидаемый результат
objects: 2
sizes: [1190, 3830]
После размытия порог (140) убирает шум, и остаются два объекта: прямоугольник (30 × 40 = 1200 пикселей, найдено 1190) и круг (π · 35² ≈ 3848, найдено 3830).

Мини-проект: считаем монеты

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

  1. Серое и гладкое

    cvtColor(…, COLOR_BGR2GRAY), затем GaussianBlur — крапинки шума исчезают.

  2. Маска

    threshold с THRESH_OTSU — порог выбирается автоматически по гистограмме.

  3. Контуры

    findContours(…, RETR_EXTERNAL, …) — внешняя граница каждого белого пятна.

  4. Измерь и нарисуй

    contourArea, minEnclosingCircle, boundingRect; отметь результат через rectangle.

Python
import cv2
import numpy as np

rng = np.random.default_rng(7)
img = np.full((300, 400, 3), 90, dtype=np.uint8)
for (x, y), r in zip([(80, 80), (220, 90), (320, 210), (130, 220)], [30, 45, 25, 38]):
    cv2.circle(img, (x, y), r, (200, 210, 220), -1)
img = np.clip(img + rng.normal(0, 12, img.shape), 0, 255).astype(np.uint8)

gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
blur = cv2.GaussianBlur(gray, (5, 5), 0)
t, mask = cv2.threshold(blur, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
print('threshold:', t, 'objects:', len(contours))
for c in sorted(contours, key=cv2.contourArea, reverse=True):
    x, y, w, h = cv2.boundingRect(c)
    (cx, cy), radius = cv2.minEnclosingCircle(c)
    print(f'center ({cx:.0f}, {cy:.0f})  r = {radius:.0f}  area {cv2.contourArea(c):.0f}  box {w}x{h}')
    cv2.rectangle(img, (x, y), (x + w, y + h), (0, 255, 0), 2)
edges = cv2.Canny(blur, 50, 150)
print('edge pixels:', int((edges > 0).sum()))
cv2.imwrite('result.png', img)

Ожидаемый результат

threshold: 148.0 objects: 4
center (220, 90)  r = 45  area 6230  box 89x89
center (130, 220)  r = 38  area 4402  box 75x75
center (80, 80)  r = 30  area 2732  box 59x59
center (320, 210)  r = 25  area 1886  box 49x49
edge pixels: 1024
Метод Оцу выбрал порог 148, и все четыре монеты найдены; радиусы совпадают с нарисованными (45, 38, 30, 25). Площадь контура немного меньше πr² (π · 45² ≈ 6362), потому что контур проходит через центры пикселей.
ЗадачаPillowOpenCV
Открыть / сохранитьImage.open, img.savecv2.imread, cv2.imwrite
Размерimg.size → (W, H)img.shape → (H, W, C)
Изменить размерresize, thumbnailcv2.resize(img, (W, H))
Оттенки серогоconvert('L')cvtColor(…, COLOR_BGR2GRAY)
РисоватьImageDraw.Drawcv2.rectangle, cv2.circle, cv2.putText
Перевести друг в другаnp.array(img), Image.fromarray(arr)cvtColor(arr, COLOR_RGB2BGR)

Задание

Преобразуй цветное изображение 2 × 2 в серое по формуле L = 0,299 · R + 0,587 · G + 0,114 · B, округли и выведи как массив uint8.

Задание · Python
import numpy as np

img = np.array([[[255, 0, 0], [0, 255, 0]],
                [[0, 0, 255], [128, 128, 128]]], dtype=np.uint8)
# take the channels with img[..., 0], img[..., 1], img[..., 2]
Ожидаемый результат
[[ 76 150]
 [ 29 128]]

Задание

Сделай с помощью NumPy то, что делает cv2.boundingRect: найди пиксели ярче 128, выведи их количество и охватывающий прямоугольник в виде (x, y, w, h).

Задание · Python
import numpy as np

img = np.zeros((8, 8), dtype=np.uint8)
img[3:6, 2:6] = 200
img[4, 3] = 90
mask = img > 128
# np.nonzero(mask) returns (rows, columns) = (ys, xs)
Ожидаемый результат
pixels: 11
box: (2, 3, 4, 3)

Запомни

  • Изображение — массив uint8: форма (H, W, C), значения 0–255; массив индексируется img[y, x], а Pillow пишет (x, y).
  • Серый: L = 0,299 R + 0,587 G + 0,114 B; Pillow convert('L'), OpenCV COLOR_BGR2GRAY.
  • Pillow: open, resize, thumbnail (сохраняет пропорции), crop((левый, верхний, правый, нижний)), rotate, ImageDraw, save(quality=…).
  • OpenCV использует порядок BGR; imread при ошибке возвращает None; uint8 в NumPy переполняется по кругу, а cv2.add останавливается на 255.
  • Цепочка поиска объектов: серое → GaussianBlur (нечётное ядро) → threshold (Оцу) → findContours → contourArea, boundingRect.
Заметил ошибку или неточность в уроке?

Проверь себя

Вопросов: 12. Каждый правильный ответ приносит XP.

Вопрос 1 / 12

Вопрос 1 / 12. Цветное фото 640 × 480 прочитано через cv2.imread. Чему равно img.shape?