Требования к фото товаров на маркетплейсах: чек-лист для продавцов

Рекомендуемая последовательность фото:

1. Главное фото — товар на белом фоне, анфас
2. Товар под углом 45° (объем и форма)
3. Детали и текстуры крупным планом
4. Размерная сетка или линейка
5. Товар в использовании/на модели
6. Упаковка товара
7. Сертификаты и документы
8. Инфографика с характеристиками

## Размеры превью на Wildberries
image_sizes = {
    'thumbnail': '120x160',  # Карточки в поиске
    'small': '240x320',      # Мини-карточки
    'medium': '450x600',     # Просмотр товара
    'big': '900x1200',       # Основное изображение
    'original': 'max'        # Оригинальный размер
}
## URL-структура для доступа к разным размерам
base_url = "https://basket-{server}.wbbasket.ru/vol{vol}/part{part}/{id}/images"
sizes_mapping = {
    'tm': 'thumbnail',
    'c246x328': 'small', 
    'c516x688': 'medium',
    'big': 'big'
}

class WildberriesImageOptimizer:
    def optimize_main_photo(self, image_path):
        """Оптимизация главного фото для WB."""
        from PIL import Image, ImageEnhance
## Открываем изображение
        img = Image.open(image_path)
## Приводим к нужному соотношению 3:4
        target_ratio = 3/4
        current_ratio = img.width / img.height

        if current_ratio != target_ratio:
## Кропим по центру
            if current_ratio > target_ratio:
## Изображение слишком широкое
                new_width = int(img.height * target_ratio)
                left = (img.width - new_width) // 2
                img = img.crop((left, 0, left + new_width, img.height))
            else:
## Изображение слишком высокое
                new_height = int(img.width / target_ratio)
                top = (img.height - new_height) // 2
                img = img.crop((0, top, img.width, top + new_height))
## Изменяем размер до 1200x1600
        img = img.resize((1200, 1600), Image.Resampling.LANCZOS)
## Увеличиваем резкость
        enhancer = ImageEnhance.Sharpness(img)
        img = enhancer.enhance(1.2)
## Сохраняем в WEBP с оптимизацией
        output_path = image_path.replace('.jpg', '_optimized.webp')
        img.save(output_path, 'WEBP', quality=85, optimize=True)

        return output_path

## Размеры изображений в системе Ozon
class OzonImageProcessor:
    SIZES = {
        'wc50': (50, 50),      # Супер-мини
        'wc150': (150, 150),   # Мини-превью  
        'wc250': (250, 250),   # Стандартные превью
        'wc400': (400, 400),   # Средние карточки
        'wc600': (600, 600),   # Большие карточки
        'wc1000': (1000, 1000), # Детальный просмотр
        'wc1200': (1200, 1200)  # Максимальное качество
    }

    @staticmethod 
    def get_image_url(image_id, size='wc1200'):
        """Получение URL изображения нужного размера."""
        return f"https://cdn1.ozone.ru/s3/multimedia-{image_id[:1]}/{image_id}/{size}.jpg"

<!-- Пример A+ контента для Ozon -->
<div class="enhanced-content">
    <section class="hero-banner">
        <img src="brand-story.jpg" alt="История бренда">
        <h2>Наша миссия</h2>
    </section>

    <section class="feature-comparison">
        <table class="comparison-table">
            <tr>
                <th>Характеристика</th>
                <th>Наш товар</th>
                <th>Конкурент</th>
            </tr>
        </table>
    </section>

    <section class="lifestyle-images">
        <!-- 3-5 изображений товара в использовании -->
    </section>
</div>

## Структура URL изображений Яндекс Маркет
def yandex_image_url_generator(image_id, size='orig'):
    """
    Размеры на Яндекс Маркет:
    - 50x50, 100x100, 150x150 — превью
    - 200x200, 300x300 — карточки товаров
    - 600x600, 900x900 — детальный просмотр  
    - orig — оригинальный размер
    """
    base_urls = [
        'https://avatars.mds.yandex.net/get-mpic/',
        'https://avatars.mds.yandex.net/get-marketpic/'
    ]

    return f"{base_urls[0]}{image_id}/{size}"
## Пример использования
product_image = yandex_image_url_generator("1234567", "orig")
thumbnail = yandex_image_url_generator("1234567", "300x300")

def optimize_for_yandex_seo(image_path, product_name, category):
    """SEO-оптимизация изображений для Яндекс Маркет."""
    from PIL import Image
    from PIL.ExifTags import TAGS
    import piexif
## Оптимизируем размер и качество
    img = Image.open(image_path)
## Приводим к оптимальному размеру
    if max(img.size) > 1500:
        ratio = 1500 / max(img.size)
        new_size = tuple(int(dim * ratio) for dim in img.size)
        img = img.resize(new_size, Image.Resampling.LANCZOS)
## Создаем SEO-friendly имя файла
    safe_name = product_name.lower()
    safe_name = re.sub(r'[^а-яa-z0-9\s]', '', safe_name)
    safe_name = re.sub(r'\s+', '-', safe_name)[:50]
## Добавляем EXIF-данные для SEO
    exif_dict = {
        "0th": {
            piexif.ImageIFD.Artist: "Интернет-магазин",
            piexif.ImageIFD.ImageDescription: f"{product_name} - {category}",
        }
    }
    exif_bytes = piexif.dump(exif_dict)
## Сохраняем оптимизированное изображение
    output_path = f"{safe_name}-yandex-market.jpg"
    img.save(output_path, "JPEG", quality=90, exif=exif_bytes, optimize=True)

    return output_path

def mobile_image_optimization(image_path):
    """Создание мобильно-оптимизированных изображений."""
    from PIL import Image
    import io

    img = Image.open(image_path)
## Создаем несколько версий для разных экранов
    versions = {
        'mobile_1x': (400, 533),   # Обычные экраны
        'mobile_2x': (800, 1067),  # Retina экраны  
        'tablet': (600, 800),      # Планшеты
        'desktop': (1200, 1600)    # Десктоп
    }

    optimized_images = {}

    for version_name, size in versions.items():
## Изменяем размер с сохранением пропорций
        resized_img = img.copy()
        resized_img.thumbnail(size, Image.Resampling.LANCZOS)
## Оптимизируем для быстрой загрузки
        buffer = io.BytesIO()
## Используем прогрессивный JPEG для мобильных
        if version_name.startswith('mobile'):
            resized_img.save(buffer, 'JPEG', quality=75, 
                           optimize=True, progressive=True)
        else:
            resized_img.save(buffer, 'WEBP', quality=80, optimize=True)

        optimized_images[version_name] = buffer.getvalue()

    return optimized_images

def analyze_image_composition(image_path):
    """Анализ композиции изображения для максимальной конверсии."""
    import cv2
    import numpy as np
## Загружаем изображение
    img = cv2.imread(image_path)
    height, width = img.shape[:2]
## Правило третей - оптимальное размещение объекта
    rule_of_thirds = {
        'top_left': (width//3, height//3),
        'top_right': (2*width//3, height//3),
        'bottom_left': (width//3, 2*height//3),
        'bottom_right': (2*width//3, 2*height//3),
        'center': (width//2, height//2)
    }
## Анализ контраста (важно для мобильных экранов)
    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    contrast = gray.std()

    recommendations = []

    if contrast < 40:
        recommendations.append("Увеличить контраст изображения")
## Проверяем центрированность объекта
    edges = cv2.Canny(gray, 50, 150)
    contours, _ = cv2.findContours(edges, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)

    if contours:
## Находим самый большой контур (предположительно, товар)
        largest_contour = max(contours, key=cv2.contourArea)
        x, y, w, h = cv2.boundingRect(largest_contour)
        object_center = (x + w//2, y + h//2)
## Проверяем, насколько центр объекта близок к идеальным точкам
        distances = {point: np.sqrt((object_center[0] - coords[0])**2 + 
                                  (object_center[1] - coords[1])**2) 
                    for point, coords in rule_of_thirds.items()}

        closest_point = min(distances, key=distances.get)

        if distances[closest_point] > width * 0.1:  # Больше 10% от ширины
            recommendations.append(f"Сдвинуть объект ближе к точке: {closest_point}")

    return {
        'contrast_score': contrast,
        'composition_recommendations': recommendations,
        'optimal_points': rule_of_thirds
    }

class ImageABTester:
    """Класс для A/B тестирования изображений на маркетплейсах."""

    def __init__(self, product_id, marketplace='wildberries'):
        self.product_id = product_id
        self.marketplace = marketplace
        self.results = {}

    def test_variations(self, image_variants, test_duration_days=14):
        """Тестирование различных вариантов изображений."""

        test_metrics = {
            'click_through_rate': [],
            'conversion_rate': [],
            'time_on_page': [],
            'bounce_rate': []
        }

        for i, image_variant in enumerate(image_variants):
## Загружаем вариант изображения
            variant_name = f"variant_{i+1}"
## Имитация метрик (в реальности - интеграция с API маркетплейса)
            variant_metrics = self._simulate_metrics(image_variant)

            self.results[variant_name] = variant_metrics

        return self._analyze_results()

    def _simulate_metrics(self, image_path):
        """Симуляция метрик на основе характеристик изображения."""
## Анализируем качество изображения
        quality_score = self._calculate_image_quality(image_path)
## Базовые метрики в зависимости от качества
        base_ctr = 2.5
        base_conversion = 3.2
## Качество влияет на метрики
        ctr_modifier = quality_score / 100
        conversion_modifier = quality_score / 120

        return {
            'ctr': base_ctr * ctr_modifier,
            'conversion': base_conversion * conversion_modifier,
            'quality_score': quality_score
        }

    def _calculate_image_quality(self, image_path):
        """Расчет качества изображения по различным параметрам."""
        from PIL import Image, ImageStat
        import math

        img = Image.open(image_path)
## Проверяем разрешение
        resolution_score = min(100, (min(img.size) / 900) * 50)
## Проверяем резкость (вариация яркости)
        if img.mode == 'RGB':
            stat = ImageStat.Stat(img.convert('L'))
            sharpness_score = min(100, stat.stddev[0] / 2)
        else:
            sharpness_score = 50
## Проверяем композицию (центрированность)
        composition_score = 75  # Упрощенная оценка
## Общий балл качества
        total_score = (resolution_score + sharpness_score + composition_score) / 3

        return total_score

import os
from concurrent.futures import ThreadPoolExecutor, as_completed
from PIL import Image, ImageEnhance
import logging

class MarketplaceBatchProcessor:
    """Массовая обработка изображений для маркетплейсов."""

    def __init__(self, marketplace='wildberries'):
        self.marketplace = marketplace
        self.requirements = self._get_requirements()
## Настройка логирования
        logging.basicConfig(level=logging.INFO)
        self.logger = logging.getLogger(__name__)

    def _get_requirements(self):
        """Получение требований для конкретного маркетплейса."""
        requirements = {
            'wildberries': {
                'min_resolution': (900, 1200),
                'max_size_mb': 10,
                'aspect_ratio': 3/4,
                'formats': ['JPG', 'PNG', 'WEBP']
            },
            'ozon': {
                'min_resolution': (900, 1200),
                'max_size_mb': 10,
                'aspect_ratio': None,  # Любое соотношение
                'formats': ['JPEG', 'PNG', 'WEBP']
            },
            'yandex': {
                'min_resolution': (600, 600),
                'max_size_mb': 20,
                'aspect_ratio': 1/1,  # Предпочтение квадратным
                'formats': ['JPG', 'PNG']
            }
        }
        return requirements.get(self.marketplace, requirements['wildberries'])

    def process_directory(self, input_dir, output_dir, max_workers=4):
        """Обработка всех изображений в директории."""

        if not os.path.exists(output_dir):
            os.makedirs(output_dir)
## Получаем список всех изображений
        image_files = []
        for ext in ['jpg', 'jpeg', 'png', 'webp']:
            pattern = os.path.join(input_dir, f"*.{ext}")
            image_files.extend(glob.glob(pattern, recursive=True))

        self.logger.info(f"Найдено {len(image_files)} изображений для обработки")
## Обрабатываем параллельно
        with ThreadPoolExecutor(max_workers=max_workers) as executor:
## Запускаем задачи
            future_to_file = {
                executor.submit(self.process_single_image, img_path, output_dir): img_path 
                for img_path in image_files
            }
## Собираем результаты
            results = {'success': 0, 'errors': 0, 'skipped': 0}

            for future in as_completed(future_to_file):
                img_path = future_to_file[future]
                try:
                    result = future.result()
                    results[result] += 1

                    if result == 'success':
                        self.logger.info(f"✅ Обработано: {os.path.basename(img_path)}")
                    elif result == 'error':
                        self.logger.error(f"❌ Ошибка: {os.path.basename(img_path)}")

                except Exception as e:
                    self.logger.error(f"💥 Критическая ошибка {img_path}: {e}")
                    results['errors'] += 1
## Итоговая статистика
        self.logger.info(f"""
        Обработка завершена:
        ✅ Успешно: {results['success']}
        ❌ Ошибок: {results['errors']} 
        ⏭️ Пропущено: {results['skipped']}
        """)

        return results

    def process_single_image(self, img_path, output_dir):
        """Обработка одного изображения."""
        try:
            img = Image.open(img_path)
## Проверяем, нужна ли обработка
            if self._meets_requirements(img, img_path):
                return 'skipped'
## Приводим к нужному формату и размеру
            processed_img = self._optimize_image(img)
## Сохраняем
            filename = os.path.basename(img_path)
            name, _ = os.path.splitext(filename)
            output_path = os.path.join(output_dir, f"{name}_optimized.webp")

            processed_img.save(output_path, 'WEBP', quality=85, optimize=True)

            return 'success'

        except Exception as e:
            self.logger.error(f"Ошибка обработки {img_path}: {e}")
            return 'error'

    def _meets_requirements(self, img, img_path):
        """Проверка соответствия требованиям."""
## Проверяем размер
        if min(img.size) < min(self.requirements['min_resolution']):
            return False
## Проверяем размер файла
        file_size_mb = os.path.getsize(img_path) / (1024 * 1024)
        if file_size_mb > self.requirements['max_size_mb']:
            return False
## Проверяем соотношение сторон (если задано)
        if self.requirements['aspect_ratio']:
            current_ratio = img.width / img.height
            target_ratio = self.requirements['aspect_ratio']
            if abs(current_ratio - target_ratio) > 0.05:  # Допуск 5%
                return False

        return True

    def _optimize_image(self, img):
        """Оптимизация изображения под требования маркетплейса."""
## Конвертируем в RGB если нужно
        if img.mode in ('RGBA', 'LA', 'P'):
            background = Image.new('RGB', img.size, (255, 255, 255))
            background.paste(img, mask=img.split()[-1] if 'A' in img.mode else None)
            img = background
## Приводим к нужному соотношению сторон
        if self.requirements['aspect_ratio']:
            img = self._crop_to_aspect_ratio(img, self.requirements['aspect_ratio'])
## Изменяем размер если нужно
        min_res = self.requirements['min_resolution']
        if min(img.size) < min(min_res):
## Увеличиваем с сохранением пропорций
            scale = max(min_res[0] / img.width, min_res[1] / img.height)
            new_size = (int(img.width * scale), int(img.height * scale))
            img = img.resize(new_size, Image.Resampling.LANCZOS)
## Улучшаем резкость
        enhancer = ImageEnhance.Sharpness(img)
        img = enhancer.enhance(1.1)

        return img

    def _crop_to_aspect_ratio(self, img, target_ratio):
        """Обрезка изображения до нужного соотношения сторон."""
        current_ratio = img.width / img.height

        if abs(current_ratio - target_ratio) < 0.01:
            return img

        if current_ratio > target_ratio:
## Изображение слишком широкое
            new_width = int(img.height * target_ratio)
            left = (img.width - new_width) // 2
            img = img.crop((left, 0, left + new_width, img.height))
        else:
## Изображение слишком высокое  
            new_height = int(img.width / target_ratio)
            top = (img.height - new_height) // 2
            img = img.crop((0, top, img.width, top + new_height))

        return img
## Пример использования
if __name__ == "__main__":
## Обработка изображений для Wildberries
    processor = MarketplaceBatchProcessor('wildberries')

    results = processor.process_directory(
        input_dir='./raw_images',
        output_dir='./optimized_wildberries',
        max_workers=8
    )

    print(f"Обработано изображений: {results}")

class ImagePerformanceTracker:
    """Отслеживание эффективности изображений товаров."""

    def __init__(self):
        self.metrics_history = {}

    def track_image_performance(self, product_id, image_version, metrics):
        """Отслеживание метрик конкретного изображения."""

        if product_id not in self.metrics_history:
            self.metrics_history[product_id] = {}

        self.metrics_history[product_id][image_version] = {
            'timestamp': datetime.now(),
            'ctr': metrics.get('click_through_rate', 0),
            'conversion': metrics.get('conversion_rate', 0),
            'views': metrics.get('views', 0),
            'sales': metrics.get('sales', 0),
            'returns': metrics.get('return_rate', 0)
        }

    def get_best_performing_images(self, limit=10):
        """Получение изображений с лучшими показателями."""

        all_performances = []

        for product_id, versions in self.metrics_history.items():
            for version, metrics in versions.items():
## Вычисляем комплексный показатель эффективности
                efficiency_score = (
                    metrics['ctr'] * 0.3 +
                    metrics['conversion'] * 0.4 +
                    (100 - metrics['returns']) * 0.2 +
                    min(100, metrics['views'] / 100) * 0.1
                )

                all_performances.append({
                    'product_id': product_id,
                    'version': version,
                    'efficiency_score': efficiency_score,
                    'metrics': metrics
                })
## Сортируем по эффективности
        all_performances.sort(key=lambda x: x['efficiency_score'], reverse=True)

        return all_performances[:limit]

    def generate_insights(self, product_id):
        """Генерация рекомендаций по улучшению изображений."""

        if product_id not in self.metrics_history:
            return "Недостаточно данных для анализа"

        versions = self.metrics_history[product_id]
        insights = []
## Анализируем тренды
        best_version = max(versions.items(), 
                          key=lambda x: x[1]['conversion'])

        worst_version = min(versions.items(),
                           key=lambda x: x[1]['conversion'])

        if len(versions) > 1:
            insights.append(f"""
            📊 Лучший вариант изображения: {best_version[0]}
            - Конверсия: {best_version[1]['conversion']:.2f}%
            - CTR: {best_version[1]['ctr']:.2f}%

            📉 Худший вариант: {worst_version[0]}  
            - Конверсия: {worst_version[1]['conversion']:.2f}%
            - Разница: {(best_version[1]['conversion'] - worst_version[1]['conversion']):.2f}%
            """)
## Рекомендации на основе данных
        avg_ctr = sum(v['ctr'] for v in versions.values()) / len(versions)
        avg_conversion = sum(v['conversion'] for v in versions.values()) / len(versions)

        if avg_ctr < 2.0:
            insights.append("🎯 Рекомендация: Улучшить привлекательность главного изображения")

        if avg_conversion < 3.0:
            insights.append("📸 Рекомендация: Добавить больше детальных фото товара")

        return "\n".join(insights)

🔍 Техническое качество:
[ ] Разрешение соответствует минимальным требованиям
[ ] Размер файла оптимизирован для быстрой загрузки  
[ ] Формат файла поддерживается площадкой
[ ] Изображение четкое, без размытости

📐 Композиция:
[ ] Товар занимает 70-80% площади изображения
[ ] Фон не отвлекает от товара
[ ] Освещение равномерное, без резких теней
[ ] Товар расположен по правилу третей

🛍️ Коммерческая привлекательность:
[ ] Все важные детали видны четко
[ ] Цвета передаются естественно
[ ] Масштаб товара понятен (есть размерные ориентиры)
[ ] Товар показан в контексте использования

📊 SEO-оптимизация:
[ ] Имя файла содержит ключевые слова
[ ] Alt-теги заполнены (где возможно)
[ ] EXIF-данные содержат описание товара
[ ] Размер оптимизирован для мобильных устройств

## Пример автоматической генерации вариаций изображений
class ImageVariationGenerator:
    """Генератор вариаций изображений для A/B тестирования."""

    def generate_variations(self, original_image_path):
        """Создание различных вариаций исходного изображения."""

        from PIL import Image, ImageFilter, ImageEnhance

        img = Image.open(original_image_path)
        variations = {}
## Вариация 1: Увеличенная резкость
        sharp_enhancer = ImageEnhance.Sharpness(img)
        variations['sharp'] = sharp_enhancer.enhance(1.3)
## Вариация 2: Увеличенная контрастность  
        contrast_enhancer = ImageEnhance.Contrast(img)
        variations['high_contrast'] = contrast_enhancer.enhance(1.2)
## Вариация 3: Теплые тона
        color_enhancer = ImageEnhance.Color(img)
        variations['warm_tones'] = color_enhancer.enhance(1.1)
## Вариация 4: Мягкий фокус на фоне
        variations['soft_background'] = img.filter(
            ImageFilter.GaussianBlur(radius=0.5)
        )

        return variations