Adobe Firefly AI 助手深度解读：从生成工具到自主设计协作者的范式跃迁

from dataclasses import dataclass, field
from enum import Enum
from typing import Optional

class LayerType(Enum):
    TEXT = "text"
    IMAGE = "image"
    SHAPE = "shape"
    ADJUSTMENT = "adjustment"
    SMART_OBJECT = "smart_object"
    GROUP = "group"

@dataclass
class LayerInfo:
    """Photoshop 图层的语义化表示"""
    name: str
    layer_type: LayerType
    visible: bool
    locked: bool
    opacity: float  # 0.0 - 1.0
    blend_mode: str  # "normal", "multiply", "screen", etc.
    bounds: tuple  # (left, top, right, bottom)
    children: list["LayerInfo"] = field(default_factory=list)
    
    # AI 生成的语义标注
    semantic_label: Optional[str] = None  # "标题文字", "产品图", "背景层"
    confidence: float = 0.0  # 语义标注的置信度

@dataclass
class DocumentState:
    """当前设计文档的完整状态快照"""
    name: str
    width: int
    height: int
    color_mode: str
    layers: list[LayerInfo]
    active_layer_index: int
    history_states: list[str]  # 最近的操作历史
    selection: Optional[tuple] = None  # 当前选区
    
    def get_layer_by_semantic(self, label: str) -> Optional[LayerInfo]:
        """通过语义标签查找图层"""
        for layer in self.layers:
            if layer.semantic_label == label:
                return layer
        return None
    
    def find_text_layers(self) -> list[LayerInfo]:
        """获取所有文字图层"""
        return [l for l in self.layers if l.layer_type == LayerType.TEXT]

# 示例：AI 解析一个海报文档
doc = DocumentState(
    name="product_poster.psd",
    width=1920,
    height=1080,
    color_mode="RGB",
    layers=[
        LayerInfo("标题", LayerType.TEXT, True, False, 1.0, "normal", 
                  (100, 50, 800, 200), semantic_label="标题文字", confidence=0.95),
        LayerInfo("产品图", LayerType.SMART_OBJECT, True, False, 1.0, "normal",
                  (400, 300, 1500, 900), semantic_label="产品图", confidence=0.92),
        LayerInfo("背景", LayerType.IMAGE, True, False, 1.0, "normal",
                  (0, 0, 1920, 1080), semantic_label="背景层", confidence=0.98),
    ],
    active_layer_index=0,
    history_states=["打开文件", "添加标题", "导入产品图"],
)

import json
from typing import Protocol

class PhotoshopAction(Protocol):
    """Photoshop 操作的抽象接口"""
    def execute(self, doc_state: DocumentState) -> DocumentState:
        ...

class SelectLayerAction:
    """选择指定图层"""
    def __init__(self, layer_name: str):
        self.layer_name = layer_name
    
    def execute(self, doc: DocumentState) -> DocumentState:
        for i, layer in enumerate(doc.layers):
            if layer.name == self.layer_name:
                return DocumentState(
                    {doc.__dict__, "active_layer_index": i}
                )
        raise ValueError(f"未找到图层: {self.layer_name}")

class ReplaceBackgroundAction:
    """替换背景为指定风格"""
    def __init__(self, style: str, source: Optional[str] = None):
        self.style = style  # "sunset", "gradient", "solid"
        self.source = source  # 素材来源路径
    
    def execute(self, doc: DocumentState) -> DocumentState:
        bg_layer = doc.get_layer_by_semantic("背景层")
        if not bg_layer:
            raise ValueError("未找到背景图层")
        
        # 实际操作中会调用 Photoshop API
        # 这里模拟替换过程
        new_layers = [
            LayerInfo(
                name=f"{self.style}_background",
                layer_type=LayerType.IMAGE,
                visible=True,
                locked=False,
                opacity=1.0,
                blend_mode="normal",
                bounds=bg_layer.bounds,
                semantic_label="背景层",
                confidence=0.98,
            ) if l.semantic_label == "背景层" else l
            for l in doc.layers
        ]
        
        return DocumentState(
            {doc.__dict__, "layers": new_layers}
        )

class ExportAction:
    """导出为指定格式和尺寸"""
    def __init__(self, formats: list[str], sizes: list[tuple[int, int]]):
        self.formats = formats
        self.sizes = sizes
    
    def execute(self, doc: DocumentState) -> dict:
        results = []
        for fmt in self.formats:
            for w, h in self.sizes:
                results.append(f"{doc.name}_{w}x{h}.{fmt}")
        return {"exports": results}

# 操作链执行示例
actions = [
    SelectLayerAction("背景"),
    ReplaceBackgroundAction("sunset"),
    ExportAction(["png", "jpg"], [(1920, 1080), (1080, 1080), (1080, 1920)]),
]

for action in actions:
    result = action.execute(doc)
    if isinstance(result, dict):
        print(f"导出完成: {result}")

import re
from typing import Any
from enum import Enum

class ActionStatus(Enum):
    SUCCESS = "success"
    FAILED = "failed"
    NEEDS_HUMAN = "needs_human"

class OperationResult:
    """单次操作的结果"""
    def __init__(self, status: ActionStatus, message: str, 
                 undoable: bool = True, alternatives: list = None):
        self.status = status
        self.message = message
        self.undoable = undoable
        self.alternatives = alternatives or []

class FireflyPipeline:
    """Firefly AI 助手的操作管道模拟"""
    
    def __init__(self, doc_state: DocumentState):
        self.doc = doc_state
        self.action_history: list[dict] = []
        self.error_count = 0
        self.max_retries = 3
    
    def process_natural_language(self, instruction: str) -> list[dict]:
        """将自然语言指令解析为操作序列"""
        # 模拟 NLU + Planner 的过程
        # 实际实现会使用大语言模型
        
        operations = []
        
        # 关键词匹配（简化版，实际使用语义理解）
        if "背景" in instruction and "换" in instruction:
            style = self._extract_style(instruction)
            operations.append({
                "type": "replace_background",
                "params": {"style": style or "default"},
                "description": f"替换背景为 {style} 风格",
            })
        
        if "字体" in instruction and "加粗" in instruction:
            operations.append({
                "type": "bold_text",
                "params": {"target": "title"},
                "description": "标题字体加粗",
            })
        
        if "Logo" in instruction and "移动" in instruction:
            operations.append({
                "type": "move_layer",
                "params": {"layer": "logo", "position": "top-right"},
                "description": "将 Logo 移至右上角",
            })
        
        if "导出" in instruction:
            sizes = self._extract_sizes(instruction)
            operations.append({
                "type": "export",
                "params": {"formats": ["png", "jpg"], "sizes": sizes},
                "description": f"导出 {len(sizes)} 个尺寸",
            })
        
        return operations
    
    def execute_pipeline(self, operations: list[dict]) -> list[OperationResult]:
        """顺序执行操作序列，支持错误恢复"""
        results = []
        
        for i, op in enumerate(operations):
            try:
                result = self._execute_single(op)
                results.append(result)
                
                if result.status == ActionStatus.FAILED:
                    self.error_count += 1
                    # 尝试替代方案
                    if result.alternatives:
                        for alt in result.alternatives:
                            alt_result = self._execute_single(alt)
                            if alt_result.status == ActionStatus.SUCCESS:
                                results.append(alt_result)
                                break
                        else:
                            # 所有替代方案都失败，请求人工介入
                            results.append(OperationResult(
                                ActionStatus.NEEDS_HUMAN,
                                f"操作 {op['description']} 及其替代方案均失败",
                            ))
                    
                    if self.error_count >= self.max_retries:
                        results.append(OperationResult(
                            ActionStatus.NEEDS_HUMAN,
                            f"连续 {self.max_retries} 次失败，需要人工介入",
                        ))
                        break
                
                self.action_history.append({
                    "step": i + 1,
                    "operation": op["description"],
                    "status": result.status.value,
                })
                
            except Exception as e:
                results.append(OperationResult(
                    ActionStatus.FAILED,
                    f"执行异常: {str(e)}",
                ))
        
        return results
    
    def _extract_style(self, text: str) -> str:
        """从指令中提取风格关键词"""
        styles = ["日落", "渐变", "纯色", "模糊", "纹理", "抽象"]
        for style in styles:
            if style in text:
                return style
        return "默认"
    
    def _extract_sizes(self, text: str) -> list[tuple[int, int]]:
        """从指令中提取尺寸"""
        patterns = [
            r"(\d+)\s*[×xX]\s*(\d+)",
            r"(\d+)\s*[-至到~]\s*(\d+)",
        ]
        sizes = []
        for pattern in patterns:
            matches = re.findall(pattern, text)
            for w, h in matches:
                sizes.append((int(w), int(h)))
        
        if "三个" in text or "3个" in text:
            # 默认导出三个常用尺寸
            sizes = [(1920, 1080), (1080, 1080), (1080, 1920)]
        
        return sizes or [(1920, 1080)]
    
    def _execute_single(self, op: dict) -> OperationResult:
        """执行单个操作（模拟）"""
        op_type = op["type"]
        
        if op_type == "replace_background":
            return OperationResult(
                ActionStatus.SUCCESS,
                f"背景已替换为 {op['params']['style']} 风格",
            )
        elif op_type == "bold_text":
            return OperationResult(ActionStatus.SUCCESS, "标题已加粗")
        elif op_type == "move_layer":
            return OperationResult(ActionStatus.SUCCESS, "Logo 已移至右上角")
        elif op_type == "export":
            return OperationResult(
                ActionStatus.SUCCESS,
                f"已导出 {len(op['params']['sizes'])} 个尺寸",
            )
        else:
            return OperationResult(
                ActionStatus.FAILED,
                f"未知操作类型: {op_type}",
                alternatives=[],
            )

# 使用示例
pipeline = FireflyPipeline(doc)
instruction = "把海报背景换成日落风格，标题字体加粗，Logo 移到右上角，然后导出三个尺寸"

operations = pipeline.process_natural_language(instruction)
print(f"解析出 {len(operations)} 个操作:")
for i, op in enumerate(operations):
    print(f"  {i+1}. {op['description']}")

results = pipeline.execute_pipeline(operations)
print(f"\n执行结果:")
for i, r in enumerate(results):
    print(f"  {i+1}. [{r.status.value}] {r.message}")