Python для графических редакторов: инструмент автоматизации рутины

from PIL import Image, ImageEnhance

# Открыть изображение
img = Image.open('исходное.jpg')

# Изменить размер
resized_img = img.resize((800, 600))

# Регулировка яркости
enhancer = ImageEnhance.Brightness(resized_img)
brightened_img = enhancer.enhance(1.2)

# Повышение резкости
enhancer = ImageEnhance.Sharpness(brightened_img)
final_img = enhancer.enhance(1.5)

# Сохранить результат
final_img.save('обработанное.jpg', quality=95)

import subprocess
import os
import tempfile

def run_photoshop_action(image_path, action_name, action_set):
"""Запускает указанное действие Photoshop для обработки изображения"""

jsx_script = f'''
var fileRef = new File("{image_path.replace('\\', '\\\\')}");
app.open(fileRef);

try {{
app.doAction("{action_name}", "{action_set}");
app.activeDocument.saveAs(new File(app.activeDocument.path + "/" + 
"processed_" + app.activeDocument.name), 
new JPEGSaveOptions() {{ quality: 10 }});
app.activeDocument.close(SaveOptions.DONOTSAVECHANGES);
}} catch (e) {{
alert(e);
}}
'''

# Создаем временный jsx-файл
jsx_file = tempfile.NamedTemporaryFile(suffix='.jsx', delete=False)
jsx_file.write(jsx_script.encode('utf-8'))
jsx_file.close()

# Запускаем Photoshop и выполняем скрипт
photoshop_path = "C:/Program Files/Adobe/Adobe Photoshop 2022/Photoshop.exe"
subprocess.call([photoshop_path, jsx_file.name])

# Удаляем временный файл
os.unlink(jsx_file.name)

# Пример использования
image_folder = "C:/Projects/Images"
for filename in os.listdir(image_folder):
if filename.endswith(('.jpg', '.jpeg', '.png')):
image_path = os.path.join(image_folder, filename)
run_photoshop_action(image_path, "HighContrastEffect", "MyPhotoActions")

import os
import subprocess

def process_image_with_gimp(image_path):
"""Обрабатывает изображение с помощью скрипта Python-Fu в GIMP"""

# Создаем Python-Fu скрипт
script_content = f'''
import os
from gimpfu import *

def enhance_image(image_path):
# Открываем изображение
image = pdb.file_jpeg_load(image_path, image_path)
drawable = pdb.gimp_image_get_active_layer(image)

# Применяем улучшение контраста
pdb.gimp_levels_stretch(drawable)

# Повышаем резкость
pdb.plug_in_sharpen(image, drawable, 20)

# Сохраняем результат
base_name = os.path.basename(image_path)
save_path = os.path.join(os.path.dirname(image_path), 
"processed_" + base_name)
pdb.file_jpeg_save(image, drawable, save_path, save_path, 
0.9, 0, 0, 0, "", 0, 0, 0, 0)

# Закрываем изображение
pdb.gimp_image_delete(image)

enhance_image("{image_path.replace('\\', '/')}")
'''

# Записываем скрипт во временный файл
script_path = os.path.join(os.path.dirname(image_path), "temp_script.py")
with open(script_path, 'w') as f:
f.write(script_content)

# Запускаем GIMP с нашим скриптом
gimp_path = "C:/Program Files/GIMP 2/bin/gimp-2.10.exe"
subprocess.call([gimp_path, "-i", "-b", f"(python-fu-eval RUN-NONINTERACTIVE \\"execfile('{script_path}')\\") (gimp-quit 0)"])

# Удаляем временный скрипт
os.remove(script_path)

# Пример использования
process_image_with_gimp("C:/Projects/Images/example.jpg")

from PIL import Image, ImageEnhance, ImageFilter
import os
from concurrent.futures import ThreadPoolExecutor
import time

def process_image(input_path, output_folder, quality=85, max_size=(1200, 1200), 
sharpen=1.3, contrast=1.2, saturation=1.1, watermark_path=None):
"""
Комплексная обработка изображения:
- изменение размера с сохранением пропорций
- повышение резкости
- регулировка контраста и насыщенности
- добавление водяного знака (если указан)
"""
try:
# Открываем изображение
img = Image.open(input_path)

# Конвертируем в RGB (для случаев с CMYK или индексированными цветами)
if img.mode != 'RGB':
img = img.convert('RGB')

# Изменяем размер с сохранением пропорций
img.thumbnail(max_size, Image.LANCZOS)

# Увеличиваем резкость
enhancer = ImageEnhance.Sharpness(img)
img = enhancer.enhance(sharpen)

# Улучшаем контраст
enhancer = ImageEnhance.Contrast(img)
img = enhancer.enhance(contrast)

# Усиливаем насыщенность
enhancer = ImageEnhance.Color(img)
img = enhancer.enhance(saturation)

# Добавляем водяной знак, если указан
if watermark_path and os.path.exists(watermark_path):
watermark = Image.open(watermark_path).convert('RGBA')

# Изменяем размер водяного знака относительно размера изображения
wm_width = int(img.width * 0.25)
wm_ratio = watermark.width / watermark.height
wm_height = int(wm_width / wm_ratio)
watermark = watermark.resize((wm_width, wm_height), Image.LANCZOS)

# Создаем новое изображение с альфа-каналом
watermarked = Image.new('RGBA', img.size, (0, 0, 0, 0))

# Вставляем основное изображение
watermarked.paste(img, (0, 0))

# Вставляем водяной знак в правый нижний угол
position = (img.width – watermark.width – 10, 
img.height – watermark.height – 10)
watermarked.paste(watermark, position, watermark)

# Конвертируем обратно в RGB для сохранения в JPEG
img = watermarked.convert('RGB')

# Создаем выходную папку, если её нет
if not os.path.exists(output_folder):
os.makedirs(output_folder)

# Формируем имя выходного файла
filename = os.path.basename(input_path)
output_path = os.path.join(output_folder, f"processed_{filename}")
if not output_path.lower().endswith('.jpg'):
output_path = os.path.splitext(output_path)[0] + '.jpg'

# Сохраняем результат
img.save(output_path, 'JPEG', quality=quality, optimize=True)

return True, output_path
except Exception as e:
return False, str(e)

# Пример использования в многопоточном режиме
def batch_process_images(input_folder, output_folder, watermark_path=None):
"""Обрабатывает все изображения в указанной папке"""

# Получаем список всех изображений
image_files = []
for root, _, files in os.walk(input_folder):
for file in files:
if file.lower().endswith(('.jpg', '.jpeg', '.png', '.tiff', '.bmp')):
image_files.append(os.path.join(root, file))

total_files = len(image_files)
print(f"Найдено {total_files} изображений для обработки")

start_time = time.time()
successful = 0
failed = 0

# Используем многопоточную обработку
with ThreadPoolExecutor(max_workers=os.cpu_count()) as executor:
futures = {executor.submit(process_image, 
image_path, 
output_folder,
watermark_path=watermark_path): image_path 
for image_path in image_files}

for i, future in enumerate(futures, 1):
success, result = future.result()
if success:
successful += 1
print(f"[{i}/{total_files}] Успешно обработано: {result}")
else:
failed += 1
print(f"[{i}/{total_files}] Ошибка обработки: {futures[future]} – {result}")

elapsed_time = time.time() – start_time
print(f"\nОбработка завершена за {elapsed_time:.2f} секунд")
print(f"Успешно: {successful}, С ошибками: {failed}")

# batch_process_images("C:/Input_Images", "C:/Processed_Images", "C:/watermark.png")

import cv2
import numpy as np
from PIL import Image

def smart_crop(image_path, target_width, target_height):
"""
Интеллектуальное кадрирование изображения с использованием 
алгоритма поиска значимой области
"""
# Загружаем изображение через OpenCV
img = cv2.imread(image_path)
height, width = img.shape[:2]

# Конвертируем в оттенки серого для анализа
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

# Применяем фильтр Собеля для выделения границ
sobel_x = cv2.Sobel(gray, cv2.CV_64F, 1, 0, ksize=3)
sobel_y = cv2.Sobel(gray, cv2.CV_64F, 0, 1, ksize=3)
abs_sobel_x = cv2.convertScaleAbs(sobel_x)
abs_sobel_y = cv2.convertScaleAbs(sobel_y)
edges = cv2.addWeighted(abs_sobel_x, 0.5, abs_sobel_y, 0.5, 0)

# Определяем карту значимости
saliency = cv2.saliency.StaticSaliencySpectralResidual_create()
_, saliency_map = saliency.computeSaliency(img)
saliency_map = (saliency_map * 255).astype('uint8')

# Комбинируем края и карту значимости
importance_map = cv2.addWeighted(edges, 0.3, saliency_map, 0.7, 0)

# Ищем оптимальную область для кадрирования
aspect_ratio = target_width / target_height

best_score = -1
best_crop = None

# Перебираем возможные области кадрирования
step_size = max(width, height) // 20 # Шаг для ускорения поиска

for y in range(0, height – int(width/aspect_ratio) + 1, step_size):
for x in range(0, width – int(height*aspect_ratio) + 1, step_size):
# Вычисляем размеры кадра с сохранением пропорций
crop_height = min(int(width/aspect_ratio), height – y)
crop_width = int(crop_height * aspect_ratio)

if x + crop_width > width:
continue

# Вычисляем "важность" данной области
crop_importance = np.sum(importance_map[y:y+crop_height, x:x+crop_width])
normalized_importance = crop_importance / (crop_width * crop_height)

if normalized_importance > best_score:
best_score = normalized_importance
best_crop = (x, y, crop_width, crop_height)

# Если не найдена оптимальная область, используем центральное кадрирование
if best_crop is None:
if width / height > aspect_ratio: # Изображение шире, чем нужно
crop_height = height
crop_width = int(height * aspect_ratio)
x = (width – crop_width) // 2
y = 0
else: # Изображение выше, чем нужно
crop_width = width
crop_height = int(width / aspect_ratio)
x = 0
y = (height – crop_height) // 2
best_crop = (x, y, crop_width, crop_height)

# Применяем кадрирование с помощью PIL для лучшего качества
pil_img = Image.open(image_path)
x, y, w, h = best_crop
cropped_img = pil_img.crop((x, y, x+w, y+h))

# Изменяем размер до целевых значений
resized_img = cropped_img.resize((target_width, target_height), Image.LANCZOS)

return resized_img

# Пример использования:
# smart_crop("image.jpg", 800, 600).save("cropped.jpg", quality=95)

import sys
from PyQt5.QtWidgets import (QApplication, QMainWindow, QWidget, QVBoxLayout, 
QHBoxLayout, QPushButton, QLabel, QFileDialog, 
QSpinBox, QDoubleSpinBox, QCheckBox, QProgressBar, 
QComboBox, QGroupBox, QLineEdit)
from PyQt5.QtCore import Qt, QThread, pyqtSignal
import os
from PIL import Image, ImageEnhance

class ImageProcessorThread(QThread):
"""Фоновый поток для обработки изображений без блокировки UI"""
progress_updated = pyqtSignal(int)
processing_finished = pyqtSignal(int, int) # success_count, error_count

def __init__(self, input_files, output_dir, options):
super().__init__()
self.input_files = input_files
self.output_dir = output_dir
self.options = options

def run(self):
success_count = 0
error_count = 0

for i, file_path in enumerate(self.input_files):
try:
# Открываем изображение
img = Image.open(file_path)

# Применяем настройки
if self.options.get('resize', False):
width = self.options.get('width', 800)
height = self.options.get('height', 600)
img = img.resize((width, height), Image.LANCZOS)

if self.options.get('enhance_contrast', False):
factor = self.options.get('contrast_factor', 1.2)
enhancer = ImageEnhance.Contrast(img)
img = enhancer.enhance(factor)

if self.options.get('enhance_brightness', False):
factor = self.options.get('brightness_factor', 1.1)
enhancer = ImageEnhance.Brightness(img)
img = enhancer.enhance(factor)

if self.options.get('sharpen', False):
factor = self.options.get('sharpen_factor', 1.3)
enhancer = ImageEnhance.Sharpness(img)
img = enhancer.enhance(factor)

# Создаем выходную директорию, если не существует
if not os.path.exists(self.output_dir):
os.makedirs(self.output_dir)

# Формируем имя выходного файла
base_name = os.path.basename(file_path)
name, ext = os.path.splitext(base_name)

# Определяем формат сохранения
save_format = self.options.get('format', 'JPEG')
if save_format == 'JPEG':
ext = '.jpg'
elif save_format == 'PNG':
ext = '.png'
elif save_format == 'WEBP':
ext = '.webp'

output_path = os.path.join(self.output_dir, name + ext)

# Сохраняем результат
if save_format == 'JPEG':
img.save(output_path, 'JPEG', 
quality=self.options.get('quality', 85))
elif save_format == 'PNG':
img.save(output_path, 'PNG')
elif save_format == 'WEBP':
img.save(output_path, 'WEBP', 
quality=self.options.get('quality', 85))

success_count += 1
except Exception as e:
print(f"Error processing {file_path}: {str(e)}")
error_count += 1

# Обновляем прогресс
self.progress_updated.emit(int((i + 1) / len(self.input_files) * 100))

# Сигнализируем о завершении
self.processing_finished.emit(success_count, error_count)

class ImageProcessorApp(QMainWindow):
"""Основное окно приложения для обработки изображений"""
def __init__(self):
super().__init__()
self.input_files = []
self.output_dir = ""
self.initUI()

def initUI(self):
self.setWindowTitle('Python Image Processor')
self.setGeometry(100, 100, 800, 600)

central_widget = QWidget()
self.setCentralWidget(central_widget)

main_layout = QVBoxLayout(central_widget)

# Выбор файлов
file_group = QGroupBox("Входные файлы")
file_layout = QHBoxLayout()

self.files_label = QLabel("Не выбрано")
file_layout.addWidget(self.files_label)

select_files_btn = QPushButton("Выбрать файлы")
select_files_btn.clicked.connect(self.select_input_files)
file_layout.addWidget(select_files_btn)

file_group.setLayout(file_layout)
main_layout.addWidget(file_group)

# Выбор выходной директории
output_group = QGroupBox("Выходная директория")
output_layout = QHBoxLayout()

self.output_label = QLabel("Не выбрано")
output_layout.addWidget(self.output_label)

select_output_btn = QPushButton("Выбрать директорию")
select_output_btn.clicked.connect(self.select_output_dir)
output_layout.addWidget(select_output_btn)

output_group.setLayout(output_layout)
main_layout.addWidget(output_group)

# Настройки изменения размера
resize_group = QGroupBox("Изменение размера")
resize_group.setCheckable(True)
resize_group.setChecked(False)
resize_layout = QHBoxLayout()

resize_layout.addWidget(QLabel("Ширина:"))
self.width_spin = QSpinBox()
self.width_spin.setRange(1, 10000)
self.width_spin.setValue(800)
resize_layout.addWidget(self.width_spin)

resize_layout.addWidget(QLabel("Высота:"))
self.height_spin = QSpinBox()
self.height_spin.setRange(1, 10000)
self.height_spin.setValue(600)
resize_layout.addWidget(self.height_spin)

resize_group.setLayout(resize_layout)
main_layout.addWidget(resize_group)

# Улучшение изображения
enhance_group = QGroupBox("Улучшение изображения")
enhance_layout = QVBoxLayout()

# Контраст
contrast_layout = QHBoxLayout()
self.contrast_check = QCheckBox("Улучшить контраст")
contrast_layout.addWidget(self.contrast_check)

contrast_layout.addWidget(QLabel("Фактор:"))
self.contrast_factor = QDoubleSpinBox()
self.contrast_factor.setRange(0.1, 3.0)
self.contrast_factor.setValue(1.2)
self.contrast_factor.setSingleStep(0.1)
contrast_layout.addWidget(self.contrast_factor)

enhance_layout.addLayout(contrast_layout)

# Яркость
brightness_layout = QHBoxLayout()
self.brightness_check = QCheckBox("Улучшить яркость")
brightness_layout.addWidget(self.brightness_check)

brightness_layout.addWidget(QLabel("Фактор:"))
self.brightness_factor = QDoubleSpinBox()
self.brightness_factor.setRange(0.1, 3.0)
self.brightness_factor.setValue(1.1)
self.brightness_factor.setSingleStep(0.1)
brightness_layout.addWidget(self.brightness_factor)

enhance_layout.addLayout(brightness_layout)

# Резкость
sharpen_layout = QHBoxLayout()
self.sharpen_check = QCheckBox("Повысить резкость")
sharpen_layout.addWidget(self.sharpen_check)

sharpen_layout.addWidget(QLabel("Фактор:"))
self.sharpen_factor = QDoubleSpinBox()
self.sharpen_factor.setRange(0.1, 3.0)
self.sharpen_factor.setValue(1.3)
self.sharpen_factor.setSingleStep(0.1)
sharpen_layout.addWidget(self.sharpen_factor)

enhance_layout.addLayout(sharpen_layout)

enhance_group.setLayout(enhance_layout)
main_layout.addWidget(enhance_group)

# Настройки сохранения
save_group = QGroupBox("Настройки сохранения")
save_layout = QHBoxLayout()

save_layout.addWidget(QLabel("Формат:"))
self.format_combo = QComboBox()
self.format_combo.addItems(["JPEG", "PNG", "WEBP"])
save_layout.addWidget(self.format_combo)

save_layout.addWidget(QLabel("Качество:"))
self.quality_spin = QSpinBox()
self.quality_spin.setRange(1, 100)
self.quality_spin.setValue(85)
save_layout.addWidget(self.quality_spin)

save_group.setLayout(save_layout)
main_layout.addWidget(save_group)

# Прогресс
self.progress_bar = QProgressBar()
self.progress_bar.setValue(0)
main_layout.addWidget(self.progress_bar)

# Кнопка запуска
self.process_btn = QPushButton("Начать обработку")
self.process_btn.clicked.connect(self.process_images)
main_layout.addWidget(self.process_btn)

# Статус
self.status_label = QLabel("")
main_layout.addWidget(self.status_label)

def select_input_files(self):
"""Выбор входных файлов"""
files, _ = QFileDialog.getOpenFileNames(
self, "Выберите изображения", "", 
"Image Files (*.png *.jpg *.jpeg *.bmp *.tiff *.webp)"
)
if files:
self.input_files = files
self.files_label.setText(f"Выбрано {len(files)} файлов")

def select_output_dir(self):
"""Выбор выходной директории"""
directory = QFileDialog.getExistingDirectory(
self, "Выберите директорию для сохранения"
)
if directory:
self.output_dir = directory
self.output_label.setText(directory)

def process_images(self):
"""Запуск обработки изображений"""
if not self.input_files:
self.status_label.setText("Ошибка: не выбраны входные файлы")
return

if not self.output_dir:
self.status_label.setText("Ошибка: не выбрана выходная директория")
return

# Собираем настройки
options = {
'resize': self.findChild(QGroupBox, "").isChecked(),
'width': self.width_spin.value(),
'height': self.height_spin.value(),
'enhance_contrast': self.contrast_check.isChecked(),
'contrast_factor': self.contrast_factor.value(),
'enhance_brightness': self.brightness_check.isChecked(),
'brightness_factor': self.brightness_factor.value(),
'sharpen': self.sharpen_check.isChecked(),
'sharpen_factor': self.sharpen_factor.value(),
'format': self.format_combo.currentText(),
'quality': self.quality_spin.value()
}

# Отключаем кнопку процесса во время обработки
self.process_btn.setEnabled(False)
self.status_label.setText("Обработка...")

# Запускаем обработку в отдельном потоке
self.processor_thread = ImageProcessorThread(
self.input_files, self.output_dir, options
)
self.processor_thread.progress_updated.connect(self.update_progress)
self.processor_thread.processing_finished.connect(self.on_processing_finished)
self.processor_thread.start()

def update_progress(self, value):
"""Обновление прогресс-бара"""
self.progress_bar.setValue(value)

def on_processing_finished(self, success_count, error_count):
"""Обработчик завершения процесса"""
self.process_btn.setEnabled(True)
self.status_label.setText(
f"Обработка завершена. Успешно: {success_count}, Ошибок: {error_count}"
)

# Запуск приложения
if __name__ == '__main__':
app = QApplication(sys.argv)
ex = ImageProcessorApp()
ex.show()
sys.exit(app.exec_())