ssjsjdjj/visual-detail-image-processor

Generación de Plantillas de Páginas de Detalle Visuales

Entrega predeterminada: Imagen larga editable por producto

• La generación de páginas de detalle utiliza por defecto la Regla de PSD de imagen larga editable. Para cada producto en el rango de entrada se genera una imagen larga independiente con su contenido reemplazado, archivada por producto.
• El formato predeterminado actual utiliza temporalmente xiaoshanxingfenggandongku-zhong.psb (790 × 40000 px), entregando PSB cuando se conserva el lienzo completo. Se puede especificar explícitamente una plantilla maestra antigua en la tarea. El código de producto, material, rango de tallas y tablas siguen las reglas de fuente carácter por carácter originales.
• Las imágenes de producto y las imágenes de modelos/escenas utilizan objetos inteligentes incrustados reemplazables por separado. El texto del producto, nombres de color y celdas de tabla utilizan capas de texto nativas de Photoshop. Las nuevas plantillas maestras ajustan las cuadrículas de S3 (Seleccionar talla), S4 (Selección rápida de talla) y S5 (Informe de prueba) según el número real de filas y columnas, conservando los títulos de cada sección, la combinación de colores, la posición de los módulos y el diseño fijo de la plantilla maestra.
• Cuando el usuario solicite explícitamente módulos JPG, se utiliza el flujo JPG siguiente. Si el usuario también solicita JPG, se exporta adicionalmente según sea necesario.

Generación por producto

1. Inventariar todos los productos en el directorio raíz de entrada, verificar la plantilla maestra PSD/PSB y las capas reales. Distinguir entre diseño fijo y contenido que varía por producto.
2. Preparar un JSON de tarea y una ruta de salida independiente para cada producto. Vincular el texto del producto, tabla de tallas, selección rápida de tallas, informe de prueba existente, imágenes de producto, imágenes de modelos/escenas y otros módulos que varían por producto. El JSON de producto existente se puede reutilizar como fuente de datos.
3. Utilizar scripts/build_editable_long_psd.py para generar JSX por producto y luego ejecutarlo a través de Photoshop. Si las ranuras de la plantilla maestra no coinciden o faltan materiales para ese producto, listar el código de producto, el módulo y los elementos faltantes. El contenido dinámico de productos antiguos, JPG combinados o copias incompletas de la plantilla maestra no deben entregarse como producto final.
4. Reabrir cada PSD de salida, verificar el código de producto, el contenido visible, la editabilidad del texto y las tablas, y comprobar que las imágenes de producto y de escena se puedan abrir como contenido de objeto inteligente de forma independiente sin dependencias de enlaces externos. Listar las rutas de los archivos finales por producto y los elementos incompletos.

Preparación del entorno

Antes del primer uso, inicializar el entorno de Python en el directorio scripts/ de la habilidad:

cd scripts
uv sync

Si uv no está instalado, ejecutar primero:

• macOS/Linux: curl -LsSf https://astral.sh/uv/install.sh | sh
• Windows: powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"

Después de la inicialización, asegúrese de usar el Python de .venv para ejecutar los scripts de herramientas.

Estructura de entrada

La estructura de las carpetas de materiales de producto suele ser:

<input-root>/
  <product-folder>/
    product_data.json
    Información_producto.jpg|png
    Seleccionar_talla.png|jpg|jpeg
    Selección_rápida_talla.png|jpg|jpeg
    Imágenes_transparentes/
      <nombre_color>.png
    Imágenes_modelos/
      1.jpg
      2.jpg
      3.jpg

El directorio de plantillas incorporado es:

template/

La estructura de la plantilla suele ser:

template/
  01Información_producto.jpg
  02Imagen_transparente.jpg
  03Seleccionar_talla.jpg
  04Talla_recomendada.jpg
  05Selección_rápida_talla.jpg
  Imagen_modelo1.jpg
  Imagen_modelo2.jpg
  Imagen_modelo2_superposición.png
  Imagen_modelo3.jpg

Flujo de ejecución

1. Primero confirmar el directorio raíz de entrada y el directorio raíz de salida; por defecto se usan template/ y assets/ incorporados en la habilidad.
2. Si el producto aún no tiene datos estructurados, utilizar la capacidad de reconocimiento de imágenes de GPT para leer las tres imágenes Información_producto, Seleccionar_talla y Selección_rápida_talla, generar un JSON combinado por producto y guardarlo en scripts/output/product_data/<nombre_carpeta_producto>-product_data-<marca_tiempo>.json.
3. Leer la Regla de conversión de datos de tablas de imágenes, validar el JSON del producto, escribir contenido incierto en warnings, no inventar.
4. Antes de ejecutar el script de renderizado, escanear si el producto tiene imágenes de modelo; mientras existan imágenes de modelo legibles, primero se debe utilizar la selección estética de imagen/recorte con IA, generando coordenadas de píxeles de la imagen fuente para cada imagen de modelo utilizable, y guardarlas en scripts/output/visual_model_selection/visual_model_selection-<marca_tiempo>.json.
5. Ejecutar el script de procesamiento por lotes general, no permitir escribir el nombre del producto o los datos del producto de forma fija; si se ha generado un JSON de coordenadas de IA en esta ronda, se debe pasar explícitamente --visual-model-selection "<ruta_json_coordenadas>", no confiar en la reversión automática o espera automática de datos del script.
6. Generar subcarpetas de salida para cada producto, manteniendo el nombre original de la carpeta del producto.
7. Las imágenes finales solo se emiten en --output-root/<nombre_carpeta_producto>/; el informe de procesamiento por lotes se emite de manera unificada en scripts/output/report/render_report-<marca_tiempo>.json.
8. Si el usuario solicita "archivos en capas", "PSD", "ajuste secundario en Photoshop" o entrega para revisión del diseñador, cambiar a usar scripts/create_layered_psd_package.py; este genera simultáneamente un manifiesto JPG, lista de PSD y script de ensamblaje JSX de Photoshop.
9. Después de la salida, realizar una verificación visual y de tamaño, especialmente revisando marcos blancos, residuos de líneas verdes, sombras de tablas, texto desalineado, cambios de tamaño en imágenes transparentes y recortes de imágenes de modelos.
10. Leer el informe para confirmar que todas las imágenes de modelo con coordenadas tienen mode como visual_model_selection; si se revierte a cover_crop, se debe explicar elemento por elemento si es por falta de coordenadas, coordenadas inválidas, archivo fuente inexistente, o porque el entorno actual no puede realizar un juicio visual confiable.

Flujo de archivos en capas de Photoshop

Cuando el usuario necesita archivos ajustables secundariamente por el diseñador, usar el flujo de capas de Photoshop:

cd scripts
uv run python create_layered_psd_package.py `
  --input-root "<input-root>" `
  --output-root "<output-root>"

El script genera en <output-root>/_photoshop_layered/:

layered_psd_manifest.json
build_layered_psd.jsx

Luego llamar a Photoshop para generar los PSD:

powershell -ExecutionPolicy Bypass -File run_photoshop_jsx.ps1 `
  -JsxPath "<output-root>/_photoshop_layered/build_layered_psd.jsx"

Los PSD se emiten en:

<output-root>/<nombre_carpeta_producto>/_psd/

Convenciones de capas:

• El fondo de la plantilla es una capa independiente 00 Fondo plantilla.
• El contenido dinámico reemplazado se convierte en capas activables/desactivables, como imágenes transparentes del producto, fotos de modelo, capas de tabla, color de fondo del área de datos.
• Cada PSD incluye por defecto una capa oculta 99 Referencia final (oculta) para que el diseñador pueda comparar.
• Las tablas y textos de composición compleja se conservan como capas de píxeles para mantener la consistencia visual; la información del producto y los nombres de color se convierten en capas de texto de Photoshop siempre que sea posible, para facilitar ajustes secundarios.
• Si solo se desea reconstruir el PSD basado en JPG/materiales existentes sin re-renderizar JPG, se puede agregar --skip-jpg-render.

Reglas detalladas obligatorias

Leer la referencia correspondiente según la tarea:

• Antes de procesar cualquier tarea por lotes, leer la Regla de ejecución por lotes.
• Cuando sea necesario conocer los recursos de fuente fija, leer la Regla de recursos incorporados.
• Cuando sea necesario conocer o reemplazar recursos de plantilla, leer la Regla de recursos de plantilla incorporados.
• Cuando se necesiten obtener datos de materiales de imagen/tabla, leer la Regla de conversión de datos de tablas de imágenes.
• Al dibujar texto o encontrar problemas de fuentes, leer la Regla de fuentes y texto.
• Al procesar 01Información_producto.jpg, leer la Regla de información del producto.
• Al procesar 02Imagen_transparente.jpg, leer la Regla de imágenes transparentes.
• Al procesar 03Seleccionar_talla.jpg o 05Selección_rápida_talla.jpg, leer la Regla de tablas.
• Al procesar Imagen_modelo1.jpg, Imagen_modelo2.jpg, Imagen_modelo3.jpg, leer la Regla de imágenes de modelo.
• Cuando sea necesario utilizar coordenadas de recorte con criterio estético de IA, leer la Regla de selección de recuadro de imagen de modelo inteligente.
• Al usar o mantener scripts, leer la Descripción de scripts.
• Cuando sea necesario generar archivos PSD en capas o controlar Photoshop, leer la Regla de archivos PSD en capas de Photoshop.

Scripts actuales

scripts/detail_template_replacer_2000.py
scripts/main.py
scripts/create_layered_psd_package.py
scripts/run_photoshop_jsx.ps1
scripts/create_product_data_template.py
scripts/validate_product_data.py

Ejecución

Ejemplo de comando:

cd scripts
uv run python main.py `
  --input-root "<input-root>" `
  --output-root "<output-root>"

Si existen materiales de imagen de modelo en esta ronda, primero generar visual_model_selection-<marca_tiempo>.json y luego pasar explícitamente el archivo de coordenadas:

cd scripts
uv run python main.py `
  --input-root "<input-root>" `
  --output-root "<output-root>" `
  --visual-model-selection "output/visual_model_selection/visual_model_selection-<marca_tiempo>.json"

Si se utiliza un directorio de datos externo o un directorio de plantillas externo:

cd scripts
uv run python main.py `
  --input-root "<input-root>" `
  --output-root "<output-root>" `
  --data-dir "<data-dir>" `
  --template-dir "<custom-template-dir>" `
  --visual-model-selection "<visual_model_selection-json>"

Criterios de aceptación

• Cada carpeta de producto de entrada debe ser procesada o se debe informar el motivo.
• El ancho de todas las imágenes de salida debe ser de 790 px.
• El texto fijo de la plantilla, fondos, bloques verdes, logotipos, líneas decorativas y capas de superposición no deben ser dañados por la representación dinámica.
• Los datos del producto deben provenir de product_data.json o un archivo estructurado equivalente, no pueden estar escritos fijamente en Python.
• Los valores vacíos se dejan vacíos, no se rellenan con valores predeterminados, no se deducen.
• No deben aparecer marcos blancos, residuos de líneas verdes, sombras de tablas, líneas verticales blancas en encabezados verdes.
• El tamaño de fuente y el grosor del mismo tipo de texto deben ser consistentes; los números de composición mixta no deben saltar arriba y abajo.
• El tamaño visual de las imágenes transparentes del mismo producto debe ser consistente; los nombres de color deben estar cerca del producto y en la misma línea base.
• El sujeto de la imagen del modelo no debe deformarse; se debe priorizar la integridad de la cabeza y del sujeto.
• Los procesos por lotes que incluyan imágenes de modelo deben producir primero un JSON de coordenadas de IA antes de ejecutar el script; en el informe, las imágenes de modelo correspondientes deben mostrar visual_model_selection, a menos que se haya explicado claramente por qué no se pueden usar coordenadas de IA.