Pillow: продвинутая обработка изображений
Фильтры изображений и улучшение
Применение встроенного фильтра (filter())
Pillow предоставляет множество встроенных фильтров, используя модуль ImageFilter:
Пример
from PIL import Image, ImageFilter
# Открыть изображение
image = Image.open("input.jpg")
# Применить фильтр размытия
blurred = image.filter(ImageFilter.BLUR)
blurred.save("blurred.jpg")
# Применить контурный фильтр
contour = image.filter(ImageFilter.CONTOUR)
contour.save("contour.jpg")
# Применить фильтр Emboss
emboss = image.filter(ImageFilter.EMBOSS)
emboss.save("emboss.jpg")
# Найти границы
edges = image.filter(ImageFilter.FIND_EDGES)
edges.save("edges.jpg")
# Фильтр повышения резкости
sharpen = image.filter(ImageFilter.SHARPEN)
sharpen.save("sharpen.jpg")
# Фильтр сглаживания
smooth = image.filter(ImageFilter.SMOOTH)
smooth.save("smooth.jpg")
# Повышение детализации
detail = image.filter(ImageFilter.DETAIL)
detail.save("detail.jpg")
# Открыть изображение
image = Image.open("input.jpg")
# Применить фильтр размытия
blurred = image.filter(ImageFilter.BLUR)
blurred.save("blurred.jpg")
# Применить контурный фильтр
contour = image.filter(ImageFilter.CONTOUR)
contour.save("contour.jpg")
# Применить фильтр Emboss
emboss = image.filter(ImageFilter.EMBOSS)
emboss.save("emboss.jpg")
# Найти границы
edges = image.filter(ImageFilter.FIND_EDGES)
edges.save("edges.jpg")
# Фильтр повышения резкости
sharpen = image.filter(ImageFilter.SHARPEN)
sharpen.save("sharpen.jpg")
# Фильтр сглаживания
smooth = image.filter(ImageFilter.SMOOTH)
smooth.save("smooth.jpg")
# Повышение детализации
detail = image.filter(ImageFilter.DETAIL)
detail.save("detail.jpg")
Улучшение изображения (модуль ImageEnhance)
Модуль ImageEnhance предоставляет инструменты для управления яркостью, контрастом, цветом и резкостью:
Пример
from PIL import Image, ImageEnhance
# Открыть изображение
image = Image.open("input.jpg")
# Повысить яркость (коэффициент > 1 увеличивает яркость, < 1 уменьшает яркость)
enhancer = ImageEnhance.Brightness(image)
brightened = enhancer.enhance(1.5) # Увеличить яркость на 50%
brightened.save("brightened.jpg")
# Повысить контраст
enhancer = ImageEnhance.Contrast(image)
contrast = enhancer.enhance(1.8) # Увеличить контраст на 80%
contrast.save("contrast.jpg")
# Повысить насыщенность цвета
enhancer = ImageEnhance.Color(image)
saturated = enhancer.enhance(1.5) # Увеличить насыщенность на 50%
saturated.save("saturated.jpg")
# Повысить резкость
enhancer = ImageEnhance.Sharpness(image)
sharpened = enhancer.enhance(2.0) # Увеличить резкость на 100%
sharpened.save("sharpened.jpg")
Пользовательское ядро свертки
Pillow позволяет использовать пользовательские ядра свертки для создания специальных эффектов:
pythonimport numpy as np
from PIL import Image, ImageFilter
# Открыть изображение
image = Image.open("input.jpg")
# Создание пользовательского ядра свёртки
# Это ядро свёртки для повышения резкости
kernel = ImageFilter.Kernel(
size=(3, 3),
kernel=[-1, -1, -1, -1, 9, -1, -1, -1, -1],
scale=1
)
sharpened = image.filter(kernel)
sharpened.save("custom_sharpen.jpg")
# Ядро свёртки для эффекта тиснения
emboss_kernel = ImageFilter.Kernel(
size=(3, 3),
kernel=[-2, -1, 0, -1, 1, 1, 0, 1, 2],
scale=1,
offset=128
)
embossed = image.filter(emboss_kernel)
embossed.save("custom_emboss.jpg")
# Ядро свёртки для размытия по Гауссу
gaussian_kernel = ImageFilter.Kernel(
size=(5, 5),
kernel=[1, 4, 6, 4, 1, 4, 16, 24, 16, 4, 6, 24, 36, 24, 6, 4, 16, 24, 16, 4, 1, 4, 6, 4, 1],
scale=256
)
gaussian_blur = image.filter(gaussian_kernel)
gaussian_blur.save("custom_gaussian.jpg")
# Открыть изображение
image = Image.open("input.jpg")
# Повысить яркость (коэффициент > 1 увеличивает яркость, < 1 уменьшает яркость)
enhancer = ImageEnhance.Brightness(image)
brightened = enhancer.enhance(1.5) # Увеличить яркость на 50%
brightened.save("brightened.jpg")
# Повысить контраст
enhancer = ImageEnhance.Contrast(image)
contrast = enhancer.enhance(1.8) # Увеличить контраст на 80%
contrast.save("contrast.jpg")
# Повысить насыщенность цвета
enhancer = ImageEnhance.Color(image)
saturated = enhancer.enhance(1.5) # Увеличить насыщенность на 50%
saturated.save("saturated.jpg")
# Повысить резкость
enhancer = ImageEnhance.Sharpness(image)
sharpened = enhancer.enhance(2.0) # Увеличить резкость на 100%
sharpened.save("sharpened.jpg")
Пользовательское ядро свертки
Pillow позволяет использовать пользовательские ядра свертки для создания специальных эффектов:
pythonimport numpy as np
from PIL import Image, ImageFilter
# Открыть изображение
image = Image.open("input.jpg")
# Создание пользовательского ядра свёртки
# Это ядро свёртки для повышения резкости
kernel = ImageFilter.Kernel(
size=(3, 3),
kernel=[-1, -1, -1, -1, 9, -1, -1, -1, -1],
scale=1
)
sharpened = image.filter(kernel)
sharpened.save("custom_sharpen.jpg")
# Ядро свёртки для эффекта тиснения
emboss_kernel = ImageFilter.Kernel(
size=(3, 3),
kernel=[-2, -1, 0, -1, 1, 1, 0, 1, 2],
scale=1,
offset=128
)
embossed = image.filter(emboss_kernel)
embossed.save("custom_emboss.jpg")
# Ядро свёртки для размытия по Гауссу
gaussian_kernel = ImageFilter.Kernel(
size=(5, 5),
kernel=[1, 4, 6, 4, 1, 4, 16, 24, 16, 4, 6, 24, 36, 24, 6, 4, 16, 24, 16, 4, 1, 4, 6, 4, 1],
scale=256
)
gaussian_blur = image.filter(gaussian_kernel)
gaussian_blur.save("custom_gaussian.jpg")
Обнаружение краёв и повышение резкости
Помимо использования встроенных фильтров, вы также можете реализовать более продвинутые эффекты обнаружения краёв и повышения резкости:
Пример
from PIL import Image, ImageFilter, ImageChops, ImageOps
# Открыть изображение
image = Image.open("input.jpg")
# Обнаружение краёв оператором Собеля
# Горизонтальный фильтр Собеля
h_sobel = ImageFilter.Kernel(
size=(3, 3),
kernel=[-1, 0, 1, -2, 0, 2, -1, 0, 1],
scale=1
)
# Вертикальный фильтр Собеля
v_sobel = ImageFilter.Kernel(
size=(3, 3),
kernel=[-1, -2, -1, 0, 0, 0, 1, 2, 1],
scale=1
)
h_edges = image.filter(h_sobel)
v_edges = image.filter(v_sobel)
# Объединить горизонтальные и вертикальные границы
edges = ImageChops.add(
ImageChops.multiply(h_edges, h_edges),
ImageChops.multiply(v_edges, v_edges)
)
edges.save("sobel_edges.jpg")
# Использовать высокочастотное усиление для повышения резкости (USM - Unsharp Masking)
def unsharp_mask(image, radius=2, percent=150, threshold=3):
"""Применить фильтр повышения резкости USM
Параметры:
radius: радиус размытия по Гауссу
percent: процент силы повышения резкости
threshold: минимальный порог изменения яркости для применения повышения резкости
"""
blurred = image.filter(ImageFilter.GaussianBlur(radius=radius))
sharpened = Image.blend(image, ImageChops.subtract(image, blurred), percent/100)
return sharpened
usm_image = unsharp_mask(image, radius=2, percent=200, threshold=5)
usm_image.save("usm_sharpened.jpg")
# Открыть изображение
image = Image.open("input.jpg")
# Обнаружение краёв оператором Собеля
# Горизонтальный фильтр Собеля
h_sobel = ImageFilter.Kernel(
size=(3, 3),
kernel=[-1, 0, 1, -2, 0, 2, -1, 0, 1],
scale=1
)
# Вертикальный фильтр Собеля
v_sobel = ImageFilter.Kernel(
size=(3, 3),
kernel=[-1, -2, -1, 0, 0, 0, 1, 2, 1],
scale=1
)
h_edges = image.filter(h_sobel)
v_edges = image.filter(v_sobel)
# Объединить горизонтальные и вертикальные границы
edges = ImageChops.add(
ImageChops.multiply(h_edges, h_edges),
ImageChops.multiply(v_edges, v_edges)
)
edges.save("sobel_edges.jpg")
# Использовать высокочастотное усиление для повышения резкости (USM - Unsharp Masking)
def unsharp_mask(image, radius=2, percent=150, threshold=3):
"""Применить фильтр повышения резкости USM
Параметры:
radius: радиус размытия по Гауссу
percent: процент силы повышения резкости
threshold: минимальный порог изменения яркости для применения повышения резкости
"""
blurred = image.filter(ImageFilter.GaussianBlur(radius=radius))
sharpened = Image.blend(image, ImageChops.subtract(image, blurred), percent/100)
return sharpened
usm_image = unsharp_mask(image, radius=2, percent=200, threshold=5)
usm_image.save("usm_sharpened.jpg")
Рисование и добавление текста
Рисование базовых фигур (модуль ImageDraw)
Пример
from PIL import Image, ImageDraw
# Создать пустой холст
width, height = 800, 600
image = Image.new("RGB", (width, height), color="white")
draw = ImageDraw.Draw(image)
# Нарисовать линию
draw.line([(100, 100), (700, 500)], fill="black", width=5)
# Нарисовать прямоугольник
draw.rectangle([(200, 200), (600, 400)], outline="red", width=3, fill="yellow")
# Нарисовать эллипс
draw.ellipse([(300, 150), (500, 350)], outline="blue", width=3, fill="lightblue")
# Нарисовать круг
draw.ellipse([(550, 50), (650, 150)], outline="green", width=2, fill="lightgreen")
# Нарисовать многоугольник
draw.polygon([(100, 500), (300, 450), (500, 550), (250, 600)],
outline="purple", fill="lavender")
# Нарисовать дугу
draw.arc([(400, 400), (600, 500)], start=0, end=180, fill="orange", width=3)
# Нарисовать точку
for i in range(50):
import random
x = random.randint(0, width)
y = random.randint(0, height)
draw.point((x, y), fill="black")
image.save("drawings.png")
# Создать пустой холст
width, height = 800, 600
image = Image.new("RGB", (width, height), color="white")
draw = ImageDraw.Draw(image)
# Нарисовать линию
draw.line([(100, 100), (700, 500)], fill="black", width=5)
# Нарисовать прямоугольник
draw.rectangle([(200, 200), (600, 400)], outline="red", width=3, fill="yellow")
# Нарисовать эллипс
draw.ellipse([(300, 150), (500, 350)], outline="blue", width=3, fill="lightblue")
# Нарисовать круг
draw.ellipse([(550, 50), (650, 150)], outline="green", width=2, fill="lightgreen")
# Нарисовать многоугольник
draw.polygon([(100, 500), (300, 450), (500, 550), (250, 600)],
outline="purple", fill="lavender")
# Нарисовать дугу
draw.arc([(400, 400), (600, 500)], start=0, end=180, fill="orange", width=3)
# Нарисовать точку
for i in range(50):
import random
x = random.randint(0, width)
y = random.randint(0, height)
draw.point((x, y), fill="black")
image.save("drawings.png")
Добавление текста (text())
Пример
from PIL import Image, ImageDraw, ImageFont
# Создать пустой холст
image = Image.new("RGB", (800, 600), color="white")
draw = ImageDraw.Draw(image)
# Использовать шрифт по умолчанию
draw.text((100, 100), "Hello, Pillow!", fill="black")
# Загрузить пользовательский шрифт TrueType
try:
# Попробовать загрузить системный шрифт
# Windows: "arial.ttf", "simhei.ttf"
# Mac: "Arial.ttf", "STHeiti Light.ttc"
# Linux: "/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf"
font = ImageFont.truetype("arial.ttf", size=36)
except IOError:
# Если системный шрифт не найден, использовать шрифт по умолчанию
font = ImageFont.load_default()
# Нарисовать текст с помощью пользовательского шрифта
draw.text((100, 200), "Текст с пользовательским шрифтом", font=font, fill="blue")
# Нарисовать текст с обводкой
def draw_text_with_outline(draw, text, position, font, text_color, outline_color):
"""Нарисовать текст с обводкой"""
x, y = position
# Нарисовать обводку
draw.text((x-1, y-1), text, font=font, fill=outline_color)
draw.text((x+1, y-1), text, font=font, fill=outline_color)
draw.text((x-1, y+1), text, font=font, fill=outline_color)
draw.text((x+1, y+1), text, font=font, fill=outline_color)
# Нарисовать основной текст
draw.text((x, y), text, font=font, fill=text_color)
draw_text_with_outline(draw, "Эффект обводки текста", (100, 300), font, "red", "black")
# Получить размер текста и нарисовать по центру
text = "Текст по центру"
text_width, text_height = draw.textsize(text, font=font)
position = ((800 - text_width) // 2, 400)
draw.text(position, text, font=font, fill="purple")
# Нарисовать многострочный текст
multiline_text = """Это
пример многострочного текста
с использованием библиотеки Pillow
для рисования"""
draw.multiline_text((100, 450), multiline_text, font=font, fill="green", spacing=10, align="center")
image.save("text_drawings.png")
# Создать пустой холст
image = Image.new("RGB", (800, 600), color="white")
draw = ImageDraw.Draw(image)
# Использовать шрифт по умолчанию
draw.text((100, 100), "Hello, Pillow!", fill="black")
# Загрузить пользовательский шрифт TrueType
try:
# Попробовать загрузить системный шрифт
# Windows: "arial.ttf", "simhei.ttf"
# Mac: "Arial.ttf", "STHeiti Light.ttc"
# Linux: "/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf"
font = ImageFont.truetype("arial.ttf", size=36)
except IOError:
# Если системный шрифт не найден, использовать шрифт по умолчанию
font = ImageFont.load_default()
# Нарисовать текст с помощью пользовательского шрифта
draw.text((100, 200), "Текст с пользовательским шрифтом", font=font, fill="blue")
# Нарисовать текст с обводкой
def draw_text_with_outline(draw, text, position, font, text_color, outline_color):
"""Нарисовать текст с обводкой"""
x, y = position
# Нарисовать обводку
draw.text((x-1, y-1), text, font=font, fill=outline_color)
draw.text((x+1, y-1), text, font=font, fill=outline_color)
draw.text((x-1, y+1), text, font=font, fill=outline_color)
draw.text((x+1, y+1), text, font=font, fill=outline_color)
# Нарисовать основной текст
draw.text((x, y), text, font=font, fill=text_color)
draw_text_with_outline(draw, "Эффект обводки текста", (100, 300), font, "red", "black")
# Получить размер текста и нарисовать по центру
text = "Текст по центру"
text_width, text_height = draw.textsize(text, font=font)
position = ((800 - text_width) // 2, 400)
draw.text(position, text, font=font, fill="purple")
# Нарисовать многострочный текст
multiline_text = """Это
пример многострочного текста
с использованием библиотеки Pillow
для рисования"""
draw.multiline_text((100, 450), multiline_text, font=font, fill="green", spacing=10, align="center")
image.save("text_drawings.png")
Рисование сложных фигур
Пример
from PIL import Image, ImageDraw
import math
# Создать пустой холст
width, height = 800, 800
image = Image.new("RGB", (width, height), color="white")
draw = ImageDraw.Draw(image)
# Нарисовать звезду
def draw_star(draw, center, points=5, outer_radius=100, inner_radius=50, rotation=0, **kwargs):
"""Нарисовать звезду
Параметры:
center: координатный кортеж центральной точки (x, y)
points: количество точек звезды
outer_radius: радиус внешней окружности
inner_radius: радиус внутренней окружности
rotation: угол поворота (в градусах)
**kwargs: параметры, передаваемые в polygon()
"""
cx, cy = center
angle = math.pi / points
rotation_rad = math.radians(rotation)
vertices = []
for i in range(2 * points):
radius = outer_radius if i % 2 == 0 else inner_radius
theta = i * angle + rotation_rad
x = cx + radius * math.sin(theta)
y = cy - radius * math.cos(theta)
vertices.append((x, y))
draw.polygon(vertices, **kwargs)
# Нарисовать звезду
draw_star(draw, center=(200, 200), fill="gold", outline="orange", width=2)
draw_star(draw, center=(500, 200), points=8, rotation=22.5,
outer_radius=120, inner_radius=40, fill="blue", outline="navy", width=2)
# Нарисовать сердце
def draw_heart(draw, center, size=100, **kwargs):
"""Нарисовать сердце
Параметры:
center: координатный кортеж центральной точки (x, y)
size: размер сердца
**kwargs: параметры, передаваемые в polygon()
"""
cx, cy = center
vertices = []
for t in range(100):
angle = t / 100 * 2 * math.pi
x = 16 * math.sin(angle) ** 3
y = 13 * math.cos(angle) - 5 * math.cos(2*angle) - 2 * math.cos(3*angle) - math.cos(4*angle)
# Масштабирование и перенос
vertices.append((cx + x * size / 16, cy - y * size / 16))
draw.polygon(vertices, **kwargs)
draw_heart(draw, center=(200, 500), size=150, fill="red", outline="darkred", width=3)
# Нарисовать спираль
def draw_spiral(draw, center, loops=3, radius_start=5, radius_end=100, points=500, **kwargs):
"""Нарисовать спираль
Параметры:
center: координатный кортеж центральной точки (x, y)
loops: количество витков в спирали
radius_start: начальный радиус
radius_end: конечный радиус
points: количество точек
**kwargs: параметры, передаваемые в line()
"""
cx, cy = center
vertices = []
for i in range(points + 1):
# Вычислить текущий угол и радиус
angle = i / points * loops * 2 * math.pi
radius = radius_start + (radius_end - radius_start) * i / points
x = cx + radius * math.cos(angle)
y = cy + radius * math.sin(angle)
vertices.append((x, y))
# Нарисовать полилинию
for i in range(len(vertices) - 1):
draw.line([vertices[i], vertices[i+1]], **kwargs)
draw_spiral(draw, center=(500, 500), loops=5, fill="purple", width=2)
image.save("complex_shapes.png")
import math
# Создать пустой холст
width, height = 800, 800
image = Image.new("RGB", (width, height), color="white")
draw = ImageDraw.Draw(image)
# Нарисовать звезду
def draw_star(draw, center, points=5, outer_radius=100, inner_radius=50, rotation=0, **kwargs):
"""Нарисовать звезду
Параметры:
center: координатный кортеж центральной точки (x, y)
points: количество точек звезды
outer_radius: радиус внешней окружности
inner_radius: радиус внутренней окружности
rotation: угол поворота (в градусах)
**kwargs: параметры, передаваемые в polygon()
"""
cx, cy = center
angle = math.pi / points
rotation_rad = math.radians(rotation)
vertices = []
for i in range(2 * points):
radius = outer_radius if i % 2 == 0 else inner_radius
theta = i * angle + rotation_rad
x = cx + radius * math.sin(theta)
y = cy - radius * math.cos(theta)
vertices.append((x, y))
draw.polygon(vertices, **kwargs)
# Нарисовать звезду
draw_star(draw, center=(200, 200), fill="gold", outline="orange", width=2)
draw_star(draw, center=(500, 200), points=8, rotation=22.5,
outer_radius=120, inner_radius=40, fill="blue", outline="navy", width=2)
# Нарисовать сердце
def draw_heart(draw, center, size=100, **kwargs):
"""Нарисовать сердце
Параметры:
center: координатный кортеж центральной точки (x, y)
size: размер сердца
**kwargs: параметры, передаваемые в polygon()
"""
cx, cy = center
vertices = []
for t in range(100):
angle = t / 100 * 2 * math.pi
x = 16 * math.sin(angle) ** 3
y = 13 * math.cos(angle) - 5 * math.cos(2*angle) - 2 * math.cos(3*angle) - math.cos(4*angle)
# Масштабирование и перенос
vertices.append((cx + x * size / 16, cy - y * size / 16))
draw.polygon(vertices, **kwargs)
draw_heart(draw, center=(200, 500), size=150, fill="red", outline="darkred", width=3)
# Нарисовать спираль
def draw_spiral(draw, center, loops=3, radius_start=5, radius_end=100, points=500, **kwargs):
"""Нарисовать спираль
Параметры:
center: координатный кортеж центральной точки (x, y)
loops: количество витков в спирали
radius_start: начальный радиус
radius_end: конечный радиус
points: количество точек
**kwargs: параметры, передаваемые в line()
"""
cx, cy = center
vertices = []
for i in range(points + 1):
# Вычислить текущий угол и радиус
angle = i / points * loops * 2 * math.pi
radius = radius_start + (radius_end - radius_start) * i / points
x = cx + radius * math.cos(angle)
y = cy + radius * math.sin(angle)
vertices.append((x, y))
# Нарисовать полилинию
for i in range(len(vertices) - 1):
draw.line([vertices[i], vertices[i+1]], **kwargs)
draw_spiral(draw, center=(500, 500), loops=5, fill="purple", width=2)
image.save("complex_shapes.png")
Использование различных шрифтов и стилей
Пример
from PIL import Image, ImageDraw, ImageFont
import os
# Создать пустой холст
image = Image.new("RGB", (800, 600), color="white")
draw = ImageDraw.Draw(image)
# Попробуйте загрузить несколько шрифтов
fonts = {
"default": ImageFont.load_default(),
}
# Попробуйте загрузить системные шрифты
try:
fonts["arial"] = ImageFont.truetype("arial.ttf", size=36)
except IOError:
pass
try:
fonts["times"] = ImageFont.truetype("times.ttf", size=36)
except IOError:
pass
try:
fonts["simhei"] = ImageFont.truetype("simhei.ttf", size=36) # Китайский шрифт
except IOError:
pass
# Рисуем разные стили шрифта
y_position = 50
for font_name, font in fonts.items():
draw.text((50, y_position), f"Шрифт: {font_name}", font=font, fill="black")
y_position += 60
# Создаём художественный текстовый эффект
def draw_gradient_text(draw, text, position, font, start_color, end_color, steps=10):
"""Нарисовать градиентный текст
Параметры:
draw: объект ImageDraw
text: текст для отрисовки
position: позиция текста (x, y)
font: объект шрифта
start_color: начальный цвет (r, g, b)
end_color: конечный цвет (r, g, b)
steps: количество шагов градиента
"""
x, y = position
width, height = draw.textsize(text, font=font)
# Вычислить ширину каждого символа
char_width = width / len(text)
for i, char in enumerate(text):
# Вычислить цвет текущего символа
progress = i / (len(text) - 1) if len(text) > 1 else 0
r = int(start_color[0] + (end_color[0] - start_color[0]) * progress)
g = int(start_color[1] + (end_color[1] - start_color[1]) * progress)
b = int(start_color[2] + (end_color[2] - start_color[2]) * progress)
color = (r, g, b)
# Нарисовать текущий символ
draw.text((x + i * char_width, y), char, font=font, fill=color)
# Применить градиент к тексту
if "arial" in fonts:
draw_gradient_text(
draw,
"Эффект градиентного текста",
(50, 300),
fonts["arial"],
start_color=(255, 0, 0), # Красный
end_color=(0, 0, 255) # Синий
)
# Применить тень к тексту
def draw_shadow_text(draw, text, position, font, text_color, shadow_color, offset=(3, 3)):
"""Нарисовать текст с тенью"""
x, y = position
dx, dy = offset
# Нарисовать тень
draw.text((x + dx, y + dy), text, font=font, fill=shadow_color)
# Нарисовать основной текст
draw.text((x, y), text, font=font, fill=text_color)
# Применить эффект тени
if "arial" in fonts:
draw_shadow_text(
draw,
"Текст с эффектом тени",
(50, 400),
fonts["arial"],
text_color=(255, 255, 255), # Белый
shadow_color=(100, 100, 100), # Серый
offset=(3, 3)
)
image.save("font_styles.png")
import os
# Создать пустой холст
image = Image.new("RGB", (800, 600), color="white")
draw = ImageDraw.Draw(image)
# Попробуйте загрузить несколько шрифтов
fonts = {
"default": ImageFont.load_default(),
}
# Попробуйте загрузить системные шрифты
try:
fonts["arial"] = ImageFont.truetype("arial.ttf", size=36)
except IOError:
pass
try:
fonts["times"] = ImageFont.truetype("times.ttf", size=36)
except IOError:
pass
try:
fonts["simhei"] = ImageFont.truetype("simhei.ttf", size=36) # Китайский шрифт
except IOError:
pass
# Рисуем разные стили шрифта
y_position = 50
for font_name, font in fonts.items():
draw.text((50, y_position), f"Шрифт: {font_name}", font=font, fill="black")
y_position += 60
# Создаём художественный текстовый эффект
def draw_gradient_text(draw, text, position, font, start_color, end_color, steps=10):
"""Нарисовать градиентный текст
Параметры:
draw: объект ImageDraw
text: текст для отрисовки
position: позиция текста (x, y)
font: объект шрифта
start_color: начальный цвет (r, g, b)
end_color: конечный цвет (r, g, b)
steps: количество шагов градиента
"""
x, y = position
width, height = draw.textsize(text, font=font)
# Вычислить ширину каждого символа
char_width = width / len(text)
for i, char in enumerate(text):
# Вычислить цвет текущего символа
progress = i / (len(text) - 1) if len(text) > 1 else 0
r = int(start_color[0] + (end_color[0] - start_color[0]) * progress)
g = int(start_color[1] + (end_color[1] - start_color[1]) * progress)
b = int(start_color[2] + (end_color[2] - start_color[2]) * progress)
color = (r, g, b)
# Нарисовать текущий символ
draw.text((x + i * char_width, y), char, font=font, fill=color)
# Применить градиент к тексту
if "arial" in fonts:
draw_gradient_text(
draw,
"Эффект градиентного текста",
(50, 300),
fonts["arial"],
start_color=(255, 0, 0), # Красный
end_color=(0, 0, 255) # Синий
)
# Применить тень к тексту
def draw_shadow_text(draw, text, position, font, text_color, shadow_color, offset=(3, 3)):
"""Нарисовать текст с тенью"""
x, y = position
dx, dy = offset
# Нарисовать тень
draw.text((x + dx, y + dy), text, font=font, fill=shadow_color)
# Нарисовать основной текст
draw.text((x, y), text, font=font, fill=text_color)
# Применить эффект тени
if "arial" in fonts:
draw_shadow_text(
draw,
"Текст с эффектом тени",
(50, 400),
fonts["arial"],
text_color=(255, 255, 255), # Белый
shadow_color=(100, 100, 100), # Серый
offset=(3, 3)
)
image.save("font_styles.png")
Композиция и смешивание изображений
Наложение изображения (paste())
Пример
from PIL import Image
# Открыть фоновое изображение и изображение переднего плана
try:
background = Image.open("background.jpg")
foreground = Image.open("foreground.png")
except IOError:
# Если нет файла изображения, создайте образец изображения
background = Image.new("RGB", (800, 600), color="lightblue")
foreground = Image.new("RGBA", (200, 200), color=(255, 0, 0, 128)) # Полупрозрачный красный квадрат
# Изменить размер изображения переднего плана (необязательно)
foreground = foreground.resize((300, 300))
# Вычислить позицию вставки (по центру)
paste_position = (
(background.width - foreground.width) // 2,
(background.height - foreground.height) // 2
)
# Простая вставка (игнорируя прозрачность)
simple_paste = background.copy()
simple_paste.paste(foreground, paste_position)
simple_paste.save("simple_paste.png")
# Вставка с прозрачностью (если foreground имеет альфа-канал)
if foreground.mode == 'RGBA':
alpha_paste = background.copy()
alpha_paste.paste(foreground, paste_position, foreground)
alpha_paste.save("alpha_paste.png")
# Открыть фоновое изображение и изображение переднего плана
try:
background = Image.open("background.jpg")
foreground = Image.open("foreground.png")
except IOError:
# Если нет файла изображения, создайте образец изображения
background = Image.new("RGB", (800, 600), color="lightblue")
foreground = Image.new("RGBA", (200, 200), color=(255, 0, 0, 128)) # Полупрозрачный красный квадрат
# Изменить размер изображения переднего плана (необязательно)
foreground = foreground.resize((300, 300))
# Вычислить позицию вставки (по центру)
paste_position = (
(background.width - foreground.width) // 2,
(background.height - foreground.height) // 2
)
# Простая вставка (игнорируя прозрачность)
simple_paste = background.copy()
simple_paste.paste(foreground, paste_position)
simple_paste.save("simple_paste.png")
# Вставка с прозрачностью (если foreground имеет альфа-канал)
if foreground.mode == 'RGBA':
alpha_paste = background.copy()
alpha_paste.paste(foreground, paste_position, foreground)
alpha_paste.save("alpha_paste.png")
Обработка прозрачности (альфа-канал)
Пример
from PIL import Image
# Создать изображение с альфа-каналом
width, height = 500, 500
image = Image.new("RGBA", (width, height), color=(0, 0, 0, 0)) # Полностью прозрачный
# Создать эффект градиентной прозрачности
for y in range(height):
for x in range(width):
# Прозрачность уменьшается слева направо (от полностью непрозрачного до полностью прозрачного)
alpha = 255 - int(255 * x / width)
# Цветовой градиент сверху вниз
r = int(255 * y / height)
g = int(255 * (1 - y / height))
b = 128
image.putpixel((x, y), (r, g, b, alpha))
image.save("alpha_gradient.png")
# Преобразовать RGB-изображение в изображение с альфа-каналом
def add_alpha_channel(image, alpha_value=128):
"""Добавить альфа-канал к RGB-изображению
Аргументы:
image: объект PIL Image
alpha_value: значение прозрачности (0-255)
"""
if image.mode != 'RGBA':
# Преобразовать в режим RGBA
rgba_image = image.convert("RGBA")
# Получить данные пикселей
data = rgba_image.getdata()
# Установить прозрачность
new_data = []
for item in data:
# Изменить значение альфа-канала пикселя
if len(item) == 4: # Уже RGBA
new_data.append((item[0], item[1], item[2], alpha_value))
else: # RGB
new_data.append((item[0], item[1], item[2], alpha_value))
rgba_image.putdata(new_data)
return rgba_image
return image
# Создать пример RGB-изображения
rgb_image = Image.new("RGB", (300, 300), color="blue")
# Добавить альфа-канал
rgba_image = add_alpha_channel(rgb_image, alpha_value=128)
rgba_image.save("with_alpha.png")
# Создать круговую маску
def create_circular_mask(image, radius=None):
"""Создать круговую маску
Аргументы:
image: объект PIL Image
radius: радиус круга, по умолчанию равен половине меньшей стороны изображения
"""
width, height = image.width, image.height
center_x, center_y = width // 2, height // 2
if radius is None:
radius = min(center_x, center_y)
# Создать новое прозрачное изображение
mask = Image.new('L', (width, height), 0)
# Создать круговую маску
for y in range(height):
for x in range(width):
# Вычислить расстояние до центра
distance = ((x - center_x) ** 2 + (y - center_y) ** 2) ** 0.5
# Если внутри круга, сделать непрозрачным
if distance <= radius:
mask.putpixel((x, y), 255)
# Применить маску к исходному изображению
if image.mode != 'RGBA':
image = image.convert('RGBA')
result = Image.new('RGBA', (width, height), (0, 0, 0, 0))
result.paste(image, (0, 0), mask)
return result
# Создать пример изображения
square_image = Image.new("RGB", (300, 300), color="green")
# Применить круговую маску
circular_image = create_circular_mask(square_image)
circular_image.save("circular_image.png")
# Создать изображение с альфа-каналом
width, height = 500, 500
image = Image.new("RGBA", (width, height), color=(0, 0, 0, 0)) # Полностью прозрачный
# Создать эффект градиентной прозрачности
for y in range(height):
for x in range(width):
# Прозрачность уменьшается слева направо (от полностью непрозрачного до полностью прозрачного)
alpha = 255 - int(255 * x / width)
# Цветовой градиент сверху вниз
r = int(255 * y / height)
g = int(255 * (1 - y / height))
b = 128
image.putpixel((x, y), (r, g, b, alpha))
image.save("alpha_gradient.png")
# Преобразовать RGB-изображение в изображение с альфа-каналом
def add_alpha_channel(image, alpha_value=128):
"""Добавить альфа-канал к RGB-изображению
Аргументы:
image: объект PIL Image
alpha_value: значение прозрачности (0-255)
"""
if image.mode != 'RGBA':
# Преобразовать в режим RGBA
rgba_image = image.convert("RGBA")
# Получить данные пикселей
data = rgba_image.getdata()
# Установить прозрачность
new_data = []
for item in data:
# Изменить значение альфа-канала пикселя
if len(item) == 4: # Уже RGBA
new_data.append((item[0], item[1], item[2], alpha_value))
else: # RGB
new_data.append((item[0], item[1], item[2], alpha_value))
rgba_image.putdata(new_data)
return rgba_image
return image
# Создать пример RGB-изображения
rgb_image = Image.new("RGB", (300, 300), color="blue")
# Добавить альфа-канал
rgba_image = add_alpha_channel(rgb_image, alpha_value=128)
rgba_image.save("with_alpha.png")
# Создать круговую маску
def create_circular_mask(image, radius=None):
"""Создать круговую маску
Аргументы:
image: объект PIL Image
radius: радиус круга, по умолчанию равен половине меньшей стороны изображения
"""
width, height = image.width, image.height
center_x, center_y = width // 2, height // 2
if radius is None:
radius = min(center_x, center_y)
# Создать новое прозрачное изображение
mask = Image.new('L', (width, height), 0)
# Создать круговую маску
for y in range(height):
for x in range(width):
# Вычислить расстояние до центра
distance = ((x - center_x) ** 2 + (y - center_y) ** 2) ** 0.5
# Если внутри круга, сделать непрозрачным
if distance <= radius:
mask.putpixel((x, y), 255)
# Применить маску к исходному изображению
if image.mode != 'RGBA':
image = image.convert('RGBA')
result = Image.new('RGBA', (width, height), (0, 0, 0, 0))
result.paste(image, (0, 0), mask)
return result
# Создать пример изображения
square_image = Image.new("RGB", (300, 300), color="green")
# Применить круговую маску
circular_image = create_circular_mask(square_image)
circular_image.save("circular_image.png")
Режимы смешивания (blend())
Пример
from PIL import Image, ImageChops
# Создать два примера изображений
width, height = 500, 500
image1 = Image.new("RGB", (width, height), color="blue")
image2 = Image.new("RGB", (width, height), color="yellow")
# Рисуем градиенты на изображениях
for y in range(height):
for x in range(width):
# Изображение 1: от синего к чёрному слева направо
blue_value = max(0, 255 - int(255 * x / width))
image1.putpixel((x, y), (0, 0, blue_value))
# Изображение 2: от жёлтого к красному сверху вниз
red_value = int(255 * y / height)
green_value = max(0, 255 - int(255 * y / height))
image2.putpixel((x, y), (red_value, green_value, 0))
image1.save("gradient1.png")
image2.save("gradient2.png")
# Различные режимы смешивания
# 1. Обычное смешивание (blend)
blend_result = Image.blend(image1, image2, alpha=0.5)
blend_result.save("blend.png")
# 2. Сложение (add)
add_result = ImageChops.add(image1, image2)
add_result.save("add.png")
# 3. Наложение (screen)
screen_result = ImageChops.screen(image1, image2)
screen_result.save("screen.png")
# 4. Умножение (multiply)
multiply_result = ImageChops.multiply(image1, image2)
multiply_result.save("multiply.png")
# 5. Разность (difference)
difference_result = ImageChops.difference(image1, image2)
difference_result.save("difference.png")
# 6. Исключение (invert)
invert_result = ImageChops.invert(image1)
invert_result.save("invert.png")
# 7. Яркость (lighter)
lighter_result = ImageChops.lighter(image1, image2)
lighter_result.save("lighter.png")
# 8. Темнота (darker)
darker_result = ImageChops.darker(image1, image2)
darker_result.save("darker.png")
# Создайте пользовательскую функцию смешивания
def custom_blend(image1, image2, mode="soft_light"):
"""Пользовательский режим смешивания
Аргументы:
image1, image2: два изображения для смешивания
mode: имя режима смешивания
"""
if image1.mode != image2.mode:
raise ValueError("Оба изображения должны иметь одинаковый режим")
width, height = image1.size
result = Image.new(image1.mode, (width, height))
for y in range(height):
for x in range(width):
r1, g1, b1 = image1.getpixel((x, y))
r2, g2, b2 = image2.getpixel((x, y))
if mode == "soft_light":
# Реализовать режим наложения «мягкий свет»
r = (r1 * (255 - r2) + r2 * r2 // 255) // 255
g = (g1 * (255 - g2) + g2 * g2 // 255) // 255
b = (b1 * (255 - b2) + b2 * b2 // 255) // 255
elif mode == "hard_light":
# Реализовать режим наложения «жёсткий свет»
if r2 < 128:
r = (2 * r1 * r2) // 255
else:
r = 255 - (2 * (255 - r1) * (255 - r2)) // 255
if g2 < 128:
g = (2 * g1 * g2) // 255
else:
g = 255 - (2 * (255 - g1) * (255 - g2)) // 255
if b2 < 128:
b = (2 * b1 * b2) // 255
else:
b = 255 - (2 * (255 - b1) * (255 - b2)) // 255
elif mode == "overlay":
# Реализовать режим наложения «перекрытие»
if r1 < 128:
r = (2 * r1 * r2) // 255
else:
r = 255 - (2 * (255 - r1) * (255 - r2)) // 255
if g1 < 128:
g = (2 * g1 * g2) // 255
else:
g = 255 - (2 * (255 - g1) * (255 - g2)) // 255
if b1 < 128:
b = (2 * b1 * b2) // 255
else:
b = 255 - (2 * (255 - b1) * (255 - b2)) // 255
else:
# По умолчанию: использовать обычное наложение
r = (r1 + r2) // 2
g = (g1 + g2) // 2
b = (b1 + b2) // 2
result.putpixel((x, y), (r, g, b))
return result
# Применить пользовательский режим наложения
soft_light = custom_blend(image1, image2, mode="soft_light")
soft_light.save("soft_light.png")
hard_light = custom_blend(image1, image2, mode="hard_light")
hard_light.save("hard_light.png")
overlay = custom_blend(image1, image2, mode="overlay")
overlay.save("overlay.png")
# Создать два примера изображений
width, height = 500, 500
image1 = Image.new("RGB", (width, height), color="blue")
image2 = Image.new("RGB", (width, height), color="yellow")
# Рисуем градиенты на изображениях
for y in range(height):
for x in range(width):
# Изображение 1: от синего к чёрному слева направо
blue_value = max(0, 255 - int(255 * x / width))
image1.putpixel((x, y), (0, 0, blue_value))
# Изображение 2: от жёлтого к красному сверху вниз
red_value = int(255 * y / height)
green_value = max(0, 255 - int(255 * y / height))
image2.putpixel((x, y), (red_value, green_value, 0))
image1.save("gradient1.png")
image2.save("gradient2.png")
# Различные режимы смешивания
# 1. Обычное смешивание (blend)
blend_result = Image.blend(image1, image2, alpha=0.5)
blend_result.save("blend.png")
# 2. Сложение (add)
add_result = ImageChops.add(image1, image2)
add_result.save("add.png")
# 3. Наложение (screen)
screen_result = ImageChops.screen(image1, image2)
screen_result.save("screen.png")
# 4. Умножение (multiply)
multiply_result = ImageChops.multiply(image1, image2)
multiply_result.save("multiply.png")
# 5. Разность (difference)
difference_result = ImageChops.difference(image1, image2)
difference_result.save("difference.png")
# 6. Исключение (invert)
invert_result = ImageChops.invert(image1)
invert_result.save("invert.png")
# 7. Яркость (lighter)
lighter_result = ImageChops.lighter(image1, image2)
lighter_result.save("lighter.png")
# 8. Темнота (darker)
darker_result = ImageChops.darker(image1, image2)
darker_result.save("darker.png")
# Создайте пользовательскую функцию смешивания
def custom_blend(image1, image2, mode="soft_light"):
"""Пользовательский режим смешивания
Аргументы:
image1, image2: два изображения для смешивания
mode: имя режима смешивания
"""
if image1.mode != image2.mode:
raise ValueError("Оба изображения должны иметь одинаковый режим")
width, height = image1.size
result = Image.new(image1.mode, (width, height))
for y in range(height):
for x in range(width):
r1, g1, b1 = image1.getpixel((x, y))
r2, g2, b2 = image2.getpixel((x, y))
if mode == "soft_light":
# Реализовать режим наложения «мягкий свет»
r = (r1 * (255 - r2) + r2 * r2 // 255) // 255
g = (g1 * (255 - g2) + g2 * g2 // 255) // 255
b = (b1 * (255 - b2) + b2 * b2 // 255) // 255
elif mode == "hard_light":
# Реализовать режим наложения «жёсткий свет»
if r2 < 128:
r = (2 * r1 * r2) // 255
else:
r = 255 - (2 * (255 - r1) * (255 - r2)) // 255
if g2 < 128:
g = (2 * g1 * g2) // 255
else:
g = 255 - (2 * (255 - g1) * (255 - g2)) // 255
if b2 < 128:
b = (2 * b1 * b2) // 255
else:
b = 255 - (2 * (255 - b1) * (255 - b2)) // 255
elif mode == "overlay":
# Реализовать режим наложения «перекрытие»
if r1 < 128:
r = (2 * r1 * r2) // 255
else:
r = 255 - (2 * (255 - r1) * (255 - r2)) // 255
if g1 < 128:
g = (2 * g1 * g2) // 255
else:
g = 255 - (2 * (255 - g1) * (255 - g2)) // 255
if b1 < 128:
b = (2 * b1 * b2) // 255
else:
b = 255 - (2 * (255 - b1) * (255 - b2)) // 255
else:
# По умолчанию: использовать обычное наложение
r = (r1 + r2) // 2
g = (g1 + g2) // 2
b = (b1 + b2) // 2
result.putpixel((x, y), (r, g, b))
return result
# Применить пользовательский режим наложения
soft_light = custom_blend(image1, image2, mode="soft_light")
soft_light.save("soft_light.png")
hard_light = custom_blend(image1, image2, mode="hard_light")
hard_light.save("hard_light.png")
overlay = custom_blend(image1, image2, mode="overlay")
overlay.save("overlay.png")
Применение маски и продвинутые техники композитинга
Применение маски
Пример
from PIL import Image, ImageDraw
# Создать пример изображения
width, height = 500, 500
image = Image.new("RGB", (width, height), color="purple")
# Создать градиент
for y in range(height):
for x in range(width):
# Градиент от верхнего левого до нижнего правого угла
r = int(255 * (x + y) / (width + height))
g = int(128 * x / width)
b = int(255 * (1 - y / height))
image.putpixel((x, y), (r, g, b))
# Создать изображение маски (режим L представляет градации серого)
mask = Image.new('L', (width, height), 0)
draw = ImageDraw.Draw(mask)
# Нарисовать фигуры на маске
# Маска с центральным радиальным градиентом
center_x, center_y = width // 2, height // 2
max_distance = (width**2 + height**2)**0.5 / 2
for y in range(height):
for x in range(width):
# Вычислить расстояние от точки до центра
distance = ((x - center_x)**2 + (y - center_y)**2)**0.5
# Задать непрозрачность в зависимости от расстояния (чем дальше, тем прозрачнее)
alpha = max(0, int(255 * (1 - distance / max_distance)))
mask.putpixel((x, y), alpha)
# Сохранить маску для проверки
mask.save("radial_mask.png")
# Создать пустое целевое изображение
result = Image.new("RGBA", (width, height), (0, 0, 0, 0))
# Применить маску к исходному изображению
result.paste(image, (0, 0), mask)
result.save("radial_masked.png")
# Создать пользовательскую маску формы
shape_mask = Image.new('L', (width, height), 0)
draw = ImageDraw.Draw(shape_mask)
# Нарисовать полигональную маску
polygon_points = [
(width//4, height//4),
(3*width//4, height//4),
(width, height//2),
(3*width//4, 3*height//4),
(width//4, 3*height//4),
(0, height//2)
]
draw.polygon(polygon_points, fill=255)
shape_mask.save("polygon_mask.png")
# Применить полигональную маску
poly_result = Image.new("RGBA", (width, height), (0, 0, 0, 0))
poly_result.paste(image, (0, 0), shape_mask)
poly_result.save("polygon_masked.png")
# Создать текстовую маску
text_mask = Image.new('L', (width, height), 0)
draw = ImageDraw.Draw(text_mask)
# Попытаться загрузить пользовательский шрифт, при неудаче вернуться к шрифту по умолчанию
try:
from PIL import ImageFont
font = ImageFont.truetype("arial.ttf", 120)
except IOError:
font = ImageFont.load_default()
# Нарисовать текст на маске
text = "PILLOW"
text_width, text_height = draw.textsize(text, font=font)
position = ((width - text_width) // 2, (height - text_height) // 2)
draw.text(position, text, fill=255, font=font)
text_mask.save("text_mask.png")
# Применить текстовую маску
text_result = Image.new("RGBA", (width, height), (0, 0, 0, 0))
text_result.paste(image, (0, 0), text_mask)
text_result.save("text_masked.png")
# Создать пример изображения
width, height = 500, 500
image = Image.new("RGB", (width, height), color="purple")
# Создать градиент
for y in range(height):
for x in range(width):
# Градиент от верхнего левого до нижнего правого угла
r = int(255 * (x + y) / (width + height))
g = int(128 * x / width)
b = int(255 * (1 - y / height))
image.putpixel((x, y), (r, g, b))
# Создать изображение маски (режим L представляет градации серого)
mask = Image.new('L', (width, height), 0)
draw = ImageDraw.Draw(mask)
# Нарисовать фигуры на маске
# Маска с центральным радиальным градиентом
center_x, center_y = width // 2, height // 2
max_distance = (width**2 + height**2)**0.5 / 2
for y in range(height):
for x in range(width):
# Вычислить расстояние от точки до центра
distance = ((x - center_x)**2 + (y - center_y)**2)**0.5
# Задать непрозрачность в зависимости от расстояния (чем дальше, тем прозрачнее)
alpha = max(0, int(255 * (1 - distance / max_distance)))
mask.putpixel((x, y), alpha)
# Сохранить маску для проверки
mask.save("radial_mask.png")
# Создать пустое целевое изображение
result = Image.new("RGBA", (width, height), (0, 0, 0, 0))
# Применить маску к исходному изображению
result.paste(image, (0, 0), mask)
result.save("radial_masked.png")
# Создать пользовательскую маску формы
shape_mask = Image.new('L', (width, height), 0)
draw = ImageDraw.Draw(shape_mask)
# Нарисовать полигональную маску
polygon_points = [
(width//4, height//4),
(3*width//4, height//4),
(width, height//2),
(3*width//4, 3*height//4),
(width//4, 3*height//4),
(0, height//2)
]
draw.polygon(polygon_points, fill=255)
shape_mask.save("polygon_mask.png")
# Применить полигональную маску
poly_result = Image.new("RGBA", (width, height), (0, 0, 0, 0))
poly_result.paste(image, (0, 0), shape_mask)
poly_result.save("polygon_masked.png")
# Создать текстовую маску
text_mask = Image.new('L', (width, height), 0)
draw = ImageDraw.Draw(text_mask)
# Попытаться загрузить пользовательский шрифт, при неудаче вернуться к шрифту по умолчанию
try:
from PIL import ImageFont
font = ImageFont.truetype("arial.ttf", 120)
except IOError:
font = ImageFont.load_default()
# Нарисовать текст на маске
text = "PILLOW"
text_width, text_height = draw.textsize(text, font=font)
position = ((width - text_width) // 2, (height - text_height) // 2)
draw.text(position, text, fill=255, font=font)
text_mask.save("text_mask.png")
# Применить текстовую маску
text_result = Image.new("RGBA", (width, height), (0, 0, 0, 0))
text_result.paste(image, (0, 0), text_mask)
text_result.save("text_masked.png")
Продвинутые эффекты смешивания и композитинга изображений
Давайте рассмотрим некоторые более продвинутые эффекты смешивания и композитинга изображений:
Пример
from PIL import Image, ImageFilter, ImageChops, ImageOps
import math
# Создать два примера изображений
width, height = 500, 500
image1 = Image.new("RGB", (width, height), color="blue")
image2 = Image.new("RGB", (width, height), color="yellow")
# Рисуем градиенты на изображениях
for y in range(height):
for x in range(width):
# Изображение 1: от синего к чёрному слева направо
blue_value = max(0, 255 - int(255 * x / width))
image1.putpixel((x, y), (0, 0, blue_value))
# Изображение 2: от жёлтого к красному сверху вниз
red_value = int(255 * y / height)
green_value = max(0, 255 - int(255 * y / height))
image2.putpixel((x, y), (red_value, green_value, 0))
# Эффект смешивания переходов
def transition_blend(image1, image2, direction="horizontal", steps=10):
"""Создайте эффект плавного перехода между двумя изображениями
Аргументы:
image1, image2: два изображения для смешивания
direction: направление перехода, "horizontal" или "vertical"
steps: Количество шагов перехода
"""
if image1.size != image2.size:
raise ValueError("Оба изображения должны иметь одинаковый размер")
width, height = image1.size
result = Image.new(image1.mode, (width, height))
for y in range(height):
for x in range(width):
if direction == "horizontal":
# Горизонтальный переход: слева направо
blend_factor = x / width
elif direction == "vertical":
# Вертикальный переход: сверху вниз
blend_factor = y / height
elif direction == "radial":
# Радиальный переход: от центра наружу
center_x, center_y = width // 2, height // 2
distance = ((x - center_x)**2 + (y - center_y)**2)**0.5
max_distance = max((width**2 + height**2)**0.5 / 2, 1)
blend_factor = min(1.0, distance / max_distance)
else:
blend_factor = 0.5 # По умолчанию — равномерное смешивание
# Получаем пиксели обоих изображений
r1, g1, b1 = image1.getpixel((x, y))
r2, g2, b2 = image2.getpixel((x, y))
# Вычисляем смешанный пиксель
r = int(r1 * (1 - blend_factor) + r2 * blend_factor)
g = int(g1 * (1 - blend_factor) + g2 * blend_factor)
b = int(b1 * (1 - blend_factor) + b2 * blend_factor)
result.putpixel((x, y), (r, g, b))
return result
# Создаём горизонтальный переход
horizontal_transition = transition_blend(image1, image2, direction="horizontal")
horizontal_transition.save("horizontal_transition.png")
# Создать вертикальный переход
vertical_transition = transition_blend(image1, image2, direction="vertical")
vertical_transition.save("vertical_transition.png")
# Создать радиальный переход
radial_transition = transition_blend(image1, image2, direction="radial")
radial_transition.save("radial_transition.png")
# Создать эффект шахматного смешивания
def checkerboard_blend(image1, image2, grid_size=50):
"""Создать эффект шахматного смешивания
Аргументы:
image1, image2: два изображения для смешивания
grid_size: Размер шахматной доски
"""
if image1.size != image2.size:
raise ValueError("Оба изображения должны иметь одинаковый размер")
width, height = image1.size
result = Image.new(image1.mode, (width, height))
for y in range(height):
for x in range(width):
# Определить, в какой ячейке сетки находится текущий пиксель
grid_x = x // grid_size
grid_y = y // grid_size
# Выбор изображения на основе шахматного узора
if (grid_x + grid_y) % 2 == 0:
result.putpixel((x, y), image1.getpixel((x, y)))
else:
result.putpixel((x, y), image2.getpixel((x, y)))
return result
# Создание шахматного смешивания
checkerboard = checkerboard_blend(image1, image2, grid_size=50)
checkerboard.save("checkerboard_blend.png")
# Эффект смешивания с шумом
def noise_blend(image1, image2, noise_level=0.5):
"""Смешивание с использованием шума
Аргументы:
image1, image2: два изображения для смешивания
noise_level: Уровень шума (0.0-1.0)
"""
if image1.size != image2.size:
raise ValueError("Оба изображения должны иметь одинаковый размер")
import random
width, height = image1.size
result = Image.new(image1.mode, (width, height))
for y in range(height):
for x in range(width):
# Сгенерировать случайные значения
random_value = random.random()
# Выбрать изображение на основе случайного значения и уровня шума
if random_value < noise_level:
result.putpixel((x, y), image1.getpixel((x, y)))
else:
result.putpixel((x, y), image2.getpixel((x, y)))
return result
# Создать шумовое смешивание
noise_blended = noise_blend(image1, image2, noise_level=0.5)
noise_blended.save("noise_blend.png")
# Создать эффект жидкостного смешивания
def fluid_blend(image1, image2, turbulence=10.0, seed=42):
"""Создать эффект жидкостного смешивания
Аргументы:
image1, image2: два изображения для смешивания
turbulence: Интенсивность турбулентности
seed: случайное зерно
"""
if image1.size != image2.size:
raise ValueError("Оба изображения должны иметь одинаковый размер")
import random
random.seed(seed)
width, height = image1.size
result = Image.new(image1.mode, (width, height))
# Создать упрощённую реализацию шума Перлина
def noise(x, y):
# Упрощённая функция шума
n = x + y * 57
n = (n << 13) ^ n
return (1.0 - ((n * (n * n * 15731 + 789221) + 1376312589) & 0x7fffffff) / 1073741824.0)
for y in range(height):
for x in range(width):
# Использовать искажённые координаты для генерации коэффициента смешивания
noise_value = noise(x / turbulence, y / turbulence)
blend_factor = (noise_value + 1.0) / 2.0 # Нормализовать до диапазона 0-1
# Получаем пиксели обоих изображений
r1, g1, b1 = image1.getpixel((x, y))
r2, g2, b2 = image2.getpixel((x, y))
# Вычисляем смешанный пиксель
r = int(r1 * (1 - blend_factor) + r2 * blend_factor)
g = int(g1 * (1 - blend_factor) + g2 * blend_factor)
b = int(b1 * (1 - blend_factor) + b2 * blend_factor)
result.putpixel((x, y), (r, g, b))
return result
# Создать жидкое смешивание
fluid_blended = fluid_blend(image1, image2, turbulence=20.0)
fluid_blended.save("fluid_blend.png")
import math
# Создать два примера изображений
width, height = 500, 500
image1 = Image.new("RGB", (width, height), color="blue")
image2 = Image.new("RGB", (width, height), color="yellow")
# Рисуем градиенты на изображениях
for y in range(height):
for x in range(width):
# Изображение 1: от синего к чёрному слева направо
blue_value = max(0, 255 - int(255 * x / width))
image1.putpixel((x, y), (0, 0, blue_value))
# Изображение 2: от жёлтого к красному сверху вниз
red_value = int(255 * y / height)
green_value = max(0, 255 - int(255 * y / height))
image2.putpixel((x, y), (red_value, green_value, 0))
# Эффект смешивания переходов
def transition_blend(image1, image2, direction="horizontal", steps=10):
"""Создайте эффект плавного перехода между двумя изображениями
Аргументы:
image1, image2: два изображения для смешивания
direction: направление перехода, "horizontal" или "vertical"
steps: Количество шагов перехода
"""
if image1.size != image2.size:
raise ValueError("Оба изображения должны иметь одинаковый размер")
width, height = image1.size
result = Image.new(image1.mode, (width, height))
for y in range(height):
for x in range(width):
if direction == "horizontal":
# Горизонтальный переход: слева направо
blend_factor = x / width
elif direction == "vertical":
# Вертикальный переход: сверху вниз
blend_factor = y / height
elif direction == "radial":
# Радиальный переход: от центра наружу
center_x, center_y = width // 2, height // 2
distance = ((x - center_x)**2 + (y - center_y)**2)**0.5
max_distance = max((width**2 + height**2)**0.5 / 2, 1)
blend_factor = min(1.0, distance / max_distance)
else:
blend_factor = 0.5 # По умолчанию — равномерное смешивание
# Получаем пиксели обоих изображений
r1, g1, b1 = image1.getpixel((x, y))
r2, g2, b2 = image2.getpixel((x, y))
# Вычисляем смешанный пиксель
r = int(r1 * (1 - blend_factor) + r2 * blend_factor)
g = int(g1 * (1 - blend_factor) + g2 * blend_factor)
b = int(b1 * (1 - blend_factor) + b2 * blend_factor)
result.putpixel((x, y), (r, g, b))
return result
# Создаём горизонтальный переход
horizontal_transition = transition_blend(image1, image2, direction="horizontal")
horizontal_transition.save("horizontal_transition.png")
# Создать вертикальный переход
vertical_transition = transition_blend(image1, image2, direction="vertical")
vertical_transition.save("vertical_transition.png")
# Создать радиальный переход
radial_transition = transition_blend(image1, image2, direction="radial")
radial_transition.save("radial_transition.png")
# Создать эффект шахматного смешивания
def checkerboard_blend(image1, image2, grid_size=50):
"""Создать эффект шахматного смешивания
Аргументы:
image1, image2: два изображения для смешивания
grid_size: Размер шахматной доски
"""
if image1.size != image2.size:
raise ValueError("Оба изображения должны иметь одинаковый размер")
width, height = image1.size
result = Image.new(image1.mode, (width, height))
for y in range(height):
for x in range(width):
# Определить, в какой ячейке сетки находится текущий пиксель
grid_x = x // grid_size
grid_y = y // grid_size
# Выбор изображения на основе шахматного узора
if (grid_x + grid_y) % 2 == 0:
result.putpixel((x, y), image1.getpixel((x, y)))
else:
result.putpixel((x, y), image2.getpixel((x, y)))
return result
# Создание шахматного смешивания
checkerboard = checkerboard_blend(image1, image2, grid_size=50)
checkerboard.save("checkerboard_blend.png")
# Эффект смешивания с шумом
def noise_blend(image1, image2, noise_level=0.5):
"""Смешивание с использованием шума
Аргументы:
image1, image2: два изображения для смешивания
noise_level: Уровень шума (0.0-1.0)
"""
if image1.size != image2.size:
raise ValueError("Оба изображения должны иметь одинаковый размер")
import random
width, height = image1.size
result = Image.new(image1.mode, (width, height))
for y in range(height):
for x in range(width):
# Сгенерировать случайные значения
random_value = random.random()
# Выбрать изображение на основе случайного значения и уровня шума
if random_value < noise_level:
result.putpixel((x, y), image1.getpixel((x, y)))
else:
result.putpixel((x, y), image2.getpixel((x, y)))
return result
# Создать шумовое смешивание
noise_blended = noise_blend(image1, image2, noise_level=0.5)
noise_blended.save("noise_blend.png")
# Создать эффект жидкостного смешивания
def fluid_blend(image1, image2, turbulence=10.0, seed=42):
"""Создать эффект жидкостного смешивания
Аргументы:
image1, image2: два изображения для смешивания
turbulence: Интенсивность турбулентности
seed: случайное зерно
"""
if image1.size != image2.size:
raise ValueError("Оба изображения должны иметь одинаковый размер")
import random
random.seed(seed)
width, height = image1.size
result = Image.new(image1.mode, (width, height))
# Создать упрощённую реализацию шума Перлина
def noise(x, y):
# Упрощённая функция шума
n = x + y * 57
n = (n << 13) ^ n
return (1.0 - ((n * (n * n * 15731 + 789221) + 1376312589) & 0x7fffffff) / 1073741824.0)
for y in range(height):
for x in range(width):
# Использовать искажённые координаты для генерации коэффициента смешивания
noise_value = noise(x / turbulence, y / turbulence)
blend_factor = (noise_value + 1.0) / 2.0 # Нормализовать до диапазона 0-1
# Получаем пиксели обоих изображений
r1, g1, b1 = image1.getpixel((x, y))
r2, g2, b2 = image2.getpixel((x, y))
# Вычисляем смешанный пиксель
r = int(r1 * (1 - blend_factor) + r2 * blend_factor)
g = int(g1 * (1 - blend_factor) + g2 * blend_factor)
b = int(b1 * (1 - blend_factor) + b2 * blend_factor)
result.putpixel((x, y), (r, g, b))
return result
# Создать жидкое смешивание
fluid_blended = fluid_blend(image1, image2, turbulence=20.0)
fluid_blended.save("fluid_blend.png")
Создание градиентных масок и сложных эффектов композитинга
Пример
from PIL import Image, ImageDraw, ImageFilter, ImageOps
import math
# Создать демонстрационное изображение
width, height = 600, 400
original = Image.new("RGB", (width, height), color=(30, 30, 30))
# Нарисовать несколько фигур
draw = ImageDraw.Draw(original)
draw.rectangle([(50, 50), (width-50, height-50)], outline="white", width=2)
draw.ellipse([(100, 100), (width-100, height-100)], outline="blue", width=3)
draw.line([(width//2, 50), (width//2, height-50)], fill="red", width=5)
draw.line([(50, height//2), (width-50, height//2)], fill="green", width=5)
# Сохранить исходное изображение
original.save("original_composite.png")
# Создать градиентную маску
def create_gradient_mask(size, direction="horizontal", start=0, end=255):
"""Создать градиентную маску
Аргументы:
size: Размер маски (width, height)
direction: Направление градиента "horizontal", "vertical", "radial", "diagonal"
start: Начальное значение яркости (0-255)
end: Конечное значение яркости (0-255)
"""
width, height = size
mask = Image.new('L', size, 0)
for y in range(height):
for x in range(width):
if direction == "horizontal":
# Горизонтальный градиент
value = start + int((end - start) * x / width)
elif direction == "vertical":
# Вертикальный градиент
value = start + int((end - start) * y / height)
elif direction == "radial":
# Радиальный градиент
center_x, center_y = width // 2, height // 2
max_dist = math.sqrt((width/2)**2 + (height/2)**2)
dist = math.sqrt((x - center_x)**2 + (y - center_y)**2)
value = start + int((end - start) * (dist / max_dist))
elif direction == "diagonal":
# Диагональный градиент
value = start + int((end - start) * (x + y) / (width + height))
else:
value = 0
# Убедиться, что значения находятся в диапазоне 0-255
value = max(0, min(255, value))
mask.putpixel((x, y), value)
return mask
# Создать градиентные маски в разных направлениях
horizontal_mask = create_gradient_mask((width, height), direction="horizontal")
horizontal_mask.save("horizontal_mask.png")
vertical_mask = create_gradient_mask((width, height), direction="vertical")
vertical_mask.save("vertical_mask.png")
radial_mask = create_gradient_mask((width, height), direction="radial")
radial_mask.save("radial_mask.png")
diagonal_mask = create_gradient_mask((width, height), direction="diagonal")
diagonal_mask.save("diagonal_mask.png")
# Создать новое изображение для смешивания
new_image = Image.new("RGB", (width, height))
for y in range(height):
for x in range(width):
# Создать сложный цветовой узор
r = int(255 * (0.5 + 0.5 * math.sin(x / 30)))
g = int(255 * (0.5 + 0.5 * math.cos(y / 20)))
b = int(255 * (0.5 + 0.5 * math.sin((x + y) / 40)))
new_image.putpixel((x, y), (r, g, b))
new_image.save("pattern_image.png")
# Применить различные эффекты маски
def apply_mask_blend(image1, image2, mask):
"""Смешать два изображения с помощью маски
Аргументы:
image1, image2: два изображения для смешивания
mask: Изображение маски в градациях серого
"""
if image1.size != image2.size or image1.size != mask.size:
raise ValueError("Все изображения должны иметь одинаковый размер")
width, height = image1.size
result = Image.new(image1.mode, (width, height))
for y in range(height):
for x in range(width):
# Получить значение маски (0-255)
mask_value = mask.getpixel((x, y))
blend_factor = mask_value / 255.0
# Получаем пиксели обоих изображений
pixel1 = image1.getpixel((x, y))
pixel2 = image2.getpixel((x, y))
# Смешивание на основе глубины пикселя
if len(pixel1) == 3: # RGB
r1, g1, b1 = pixel1
r2, g2, b2 = pixel2
r = int(r1 * (1 - blend_factor) + r2 * blend_factor)
g = int(g1 * (1 - blend_factor) + g2 * blend_factor)
b = int(b1 * (1 - blend_factor) + b2 * blend_factor)
result.putpixel((x, y), (r, g, b))
elif len(pixel1) == 4: # RGBA
r1, g1, b1, a1 = pixel1
r2, g2, b2, a2 = pixel2
r = int(r1 * (1 - blend_factor) + r2 * blend_factor)
g = int(g1 * (1 - blend_factor) + g2 * blend_factor)
b = int(b1 * (1 - blend_factor) + b2 * blend_factor)
a = int(a1 * (1 - blend_factor) + a2 * blend_factor)
result.putpixel((x, y), (r, g, b, a))
return result
# Применить разные смешивания масок
horizontal_blend = apply_mask_blend(original, new_image, horizontal_mask)
horizontal_blend.save("horizontal_blend.png")
vertical_blend = apply_mask_blend(original, new_image, vertical_mask)
vertical_blend.save("vertical_blend.png")
radial_blend = apply_mask_blend(original, new_image, radial_mask)
radial_blend.save("radial_blend.png")
diagonal_blend = apply_mask_blend(original, new_image, diagonal_mask)
diagonal_blend.save("diagonal_blend.png")
# Создать маску узора
def create_pattern_mask(size, pattern_type="grid", scale=40):
"""Создать маску узора
Аргументы:
size: Размер маски (width, height)
pattern_type: Тип узора "grid", "dots", "stripes", "waves"
scale: Коэффициент масштабирования узора
"""
width, height = size
mask = Image.new('L', size, 0)
for y in range(height):
for x in range(width):
value = 0
if pattern_type == "grid":
# Сетчатый узор
if x % scale < scale // 2 or y % scale < scale // 2:
value = 255
elif pattern_type == "dots":
# Точечно-матричный узор
dist_to_center = math.sqrt(((x % scale) - scale/2)**2 +
((y % scale) - scale/2)**2)
if dist_to_center < scale // 4:
value = 255
elif pattern_type == "stripes":
# Узор в полоску
if (x + y) % scale < scale // 2:
value = 255
elif pattern_type == "waves":
# Волнистый узор
value = int(127.5 + 127.5 * math.sin(x / scale) * math.cos(y / scale))
else:
value = 0
mask.putpixel((x, y), value)
return mask
# Создание разных масок узоров
grid_mask = create_pattern_mask((width, height), pattern_type="grid", scale=30)
grid_mask.save("grid_mask.png")
dots_mask = create_pattern_mask((width, height), pattern_type="dots", scale=30)
dots_mask.save("dots_mask.png")
stripes_mask = create_pattern_mask((width, height), pattern_type="stripes", scale=20)
stripes_mask.save("stripes_mask.png")
waves_mask = create_pattern_mask((width, height), pattern_type="waves", scale=40)
waves_mask.save("waves_mask.png")
# Применить смешивание с маской узора
grid_blend = apply_mask_blend(original, new_image, grid_mask)
grid_blend.save("grid_blend.png")
dots_blend = apply_mask_blend(original, new_image, dots_mask)
dots_blend.save("dots_blend.png")
stripes_blend = apply_mask_blend(original, new_image, stripes_mask)
stripes_blend.save("stripes_blend.png")
waves_blend = apply_mask_blend(original, new_image, waves_mask)
waves_blend.save("waves_blend.png")
import math
# Создать демонстрационное изображение
width, height = 600, 400
original = Image.new("RGB", (width, height), color=(30, 30, 30))
# Нарисовать несколько фигур
draw = ImageDraw.Draw(original)
draw.rectangle([(50, 50), (width-50, height-50)], outline="white", width=2)
draw.ellipse([(100, 100), (width-100, height-100)], outline="blue", width=3)
draw.line([(width//2, 50), (width//2, height-50)], fill="red", width=5)
draw.line([(50, height//2), (width-50, height//2)], fill="green", width=5)
# Сохранить исходное изображение
original.save("original_composite.png")
# Создать градиентную маску
def create_gradient_mask(size, direction="horizontal", start=0, end=255):
"""Создать градиентную маску
Аргументы:
size: Размер маски (width, height)
direction: Направление градиента "horizontal", "vertical", "radial", "diagonal"
start: Начальное значение яркости (0-255)
end: Конечное значение яркости (0-255)
"""
width, height = size
mask = Image.new('L', size, 0)
for y in range(height):
for x in range(width):
if direction == "horizontal":
# Горизонтальный градиент
value = start + int((end - start) * x / width)
elif direction == "vertical":
# Вертикальный градиент
value = start + int((end - start) * y / height)
elif direction == "radial":
# Радиальный градиент
center_x, center_y = width // 2, height // 2
max_dist = math.sqrt((width/2)**2 + (height/2)**2)
dist = math.sqrt((x - center_x)**2 + (y - center_y)**2)
value = start + int((end - start) * (dist / max_dist))
elif direction == "diagonal":
# Диагональный градиент
value = start + int((end - start) * (x + y) / (width + height))
else:
value = 0
# Убедиться, что значения находятся в диапазоне 0-255
value = max(0, min(255, value))
mask.putpixel((x, y), value)
return mask
# Создать градиентные маски в разных направлениях
horizontal_mask = create_gradient_mask((width, height), direction="horizontal")
horizontal_mask.save("horizontal_mask.png")
vertical_mask = create_gradient_mask((width, height), direction="vertical")
vertical_mask.save("vertical_mask.png")
radial_mask = create_gradient_mask((width, height), direction="radial")
radial_mask.save("radial_mask.png")
diagonal_mask = create_gradient_mask((width, height), direction="diagonal")
diagonal_mask.save("diagonal_mask.png")
# Создать новое изображение для смешивания
new_image = Image.new("RGB", (width, height))
for y in range(height):
for x in range(width):
# Создать сложный цветовой узор
r = int(255 * (0.5 + 0.5 * math.sin(x / 30)))
g = int(255 * (0.5 + 0.5 * math.cos(y / 20)))
b = int(255 * (0.5 + 0.5 * math.sin((x + y) / 40)))
new_image.putpixel((x, y), (r, g, b))
new_image.save("pattern_image.png")
# Применить различные эффекты маски
def apply_mask_blend(image1, image2, mask):
"""Смешать два изображения с помощью маски
Аргументы:
image1, image2: два изображения для смешивания
mask: Изображение маски в градациях серого
"""
if image1.size != image2.size or image1.size != mask.size:
raise ValueError("Все изображения должны иметь одинаковый размер")
width, height = image1.size
result = Image.new(image1.mode, (width, height))
for y in range(height):
for x in range(width):
# Получить значение маски (0-255)
mask_value = mask.getpixel((x, y))
blend_factor = mask_value / 255.0
# Получаем пиксели обоих изображений
pixel1 = image1.getpixel((x, y))
pixel2 = image2.getpixel((x, y))
# Смешивание на основе глубины пикселя
if len(pixel1) == 3: # RGB
r1, g1, b1 = pixel1
r2, g2, b2 = pixel2
r = int(r1 * (1 - blend_factor) + r2 * blend_factor)
g = int(g1 * (1 - blend_factor) + g2 * blend_factor)
b = int(b1 * (1 - blend_factor) + b2 * blend_factor)
result.putpixel((x, y), (r, g, b))
elif len(pixel1) == 4: # RGBA
r1, g1, b1, a1 = pixel1
r2, g2, b2, a2 = pixel2
r = int(r1 * (1 - blend_factor) + r2 * blend_factor)
g = int(g1 * (1 - blend_factor) + g2 * blend_factor)
b = int(b1 * (1 - blend_factor) + b2 * blend_factor)
a = int(a1 * (1 - blend_factor) + a2 * blend_factor)
result.putpixel((x, y), (r, g, b, a))
return result
# Применить разные смешивания масок
horizontal_blend = apply_mask_blend(original, new_image, horizontal_mask)
horizontal_blend.save("horizontal_blend.png")
vertical_blend = apply_mask_blend(original, new_image, vertical_mask)
vertical_blend.save("vertical_blend.png")
radial_blend = apply_mask_blend(original, new_image, radial_mask)
radial_blend.save("radial_blend.png")
diagonal_blend = apply_mask_blend(original, new_image, diagonal_mask)
diagonal_blend.save("diagonal_blend.png")
# Создать маску узора
def create_pattern_mask(size, pattern_type="grid", scale=40):
"""Создать маску узора
Аргументы:
size: Размер маски (width, height)
pattern_type: Тип узора "grid", "dots", "stripes", "waves"
scale: Коэффициент масштабирования узора
"""
width, height = size
mask = Image.new('L', size, 0)
for y in range(height):
for x in range(width):
value = 0
if pattern_type == "grid":
# Сетчатый узор
if x % scale < scale // 2 or y % scale < scale // 2:
value = 255
elif pattern_type == "dots":
# Точечно-матричный узор
dist_to_center = math.sqrt(((x % scale) - scale/2)**2 +
((y % scale) - scale/2)**2)
if dist_to_center < scale // 4:
value = 255
elif pattern_type == "stripes":
# Узор в полоску
if (x + y) % scale < scale // 2:
value = 255
elif pattern_type == "waves":
# Волнистый узор
value = int(127.5 + 127.5 * math.sin(x / scale) * math.cos(y / scale))
else:
value = 0
mask.putpixel((x, y), value)
return mask
# Создание разных масок узоров
grid_mask = create_pattern_mask((width, height), pattern_type="grid", scale=30)
grid_mask.save("grid_mask.png")
dots_mask = create_pattern_mask((width, height), pattern_type="dots", scale=30)
dots_mask.save("dots_mask.png")
stripes_mask = create_pattern_mask((width, height), pattern_type="stripes", scale=20)
stripes_mask.save("stripes_mask.png")
waves_mask = create_pattern_mask((width, height), pattern_type="waves", scale=40)
waves_mask.save("waves_mask.png")
# Применить смешивание с маской узора
grid_blend = apply_mask_blend(original, new_image, grid_mask)
grid_blend.save("grid_blend.png")
dots_blend = apply_mask_blend(original, new_image, dots_mask)
dots_blend.save("dots_blend.png")
stripes_blend = apply_mask_blend(original, new_image, stripes_mask)
stripes_blend.save("stripes_blend.png")
waves_blend = apply_mask_blend(original, new_image, waves_mask)
waves_blend.save("waves_blend.png")