AI 一键图片优化

when {
    faceCount >= 2 && faceRatio > 0.1 -> "group_portrait"
    faceCount == 1 && faceRatio > 0.3 -> "selfie"
    faceCount == 1 && faceRatio < 0.3 -> "portrait"
    labels.containsAny("Food", "Meal", "Dish") -> "food"
    labels.containsAny("Sky", "Mountain", "Sea", "Tree") -> "landscape"
    labels.containsAny("Document", "Text") -> "document"
    brightness < 40 -> "low_light"
    else -> "general"
}

{
  "beauty": { "smoothing": 35, "whitening": 25, "slimFace": 10, "bigEyes": 15, "lipColor": 25, "blush": 10, "eyebrow": 10 },
  "filter": { "colorFilter": "NONE", "styleFilter": "NONE" },
  "adjustment": { "brightness": 5, "exposure": 0, "contrast": 52, "saturation": 102, "temperature": 5200, "tint": 2 }
}

{
  "beauty": { "smoothing": 25, "whitening": 20, "slimFace": 5, "bigEyes": 10, "lipColor": 20, "blush": 8, "eyebrow": 8 },
  "filter": { "colorFilter": "FILM_GOLD", "styleFilter": "NONE" },
  "adjustment": { "brightness": 3, "exposure": 0, "contrast": 53, "saturation": 103, "temperature": 5300, "tint": 2 }
}

{
  "beauty": { "smoothing": 20, "whitening": 15, "slimFace": 0, "bigEyes": 0, "lipColor": 10, "blush": 5, "eyebrow": 5 },
  "filter": { "colorFilter": "NONE", "styleFilter": "NONE" },
  "adjustment": { "brightness": 3, "exposure": 0, "contrast": 52, "saturation": 102, "temperature": 5200, "tint": 1 }
}

{
  "beauty": { "enabled": false },
  "filter": { "colorFilter": "LEICA_VIBRANT", "styleFilter": "NONE" },
  "adjustment": { "brightness": 2, "exposure": 0, "contrast": 55, "saturation": 110, "temperature": 5400, "tint": 3 }
}

{
  "beauty": { "enabled": false },
  "filter": { "colorFilter": "LEICA_VIBRANT", "styleFilter": "NONE" },
  "adjustment": { "brightness": 0, "exposure": 0, "contrast": 58, "saturation": 110, "temperature": 5000, "tint": 0 }
}

{
  "beauty": { "smoothing": 15, "whitening": 10 },
  "filter": { "colorFilter": "WARM", "styleFilter": "NONE" },
  "adjustment": { "brightness": 12, "exposure": 5, "contrast": 55, "saturation": 100, "temperature": 5600, "tint": 3 }
}

{
  "beauty": { "enabled": false },
  "filter": { "colorFilter": "NONE", "styleFilter": "NONE" },
  "adjustment": { "brightness": 8, "exposure": 0, "contrast": 60, "saturation": 95, "temperature": 5000, "tint": 0 }
}

{
  "beauty": { "smoothing": 15, "whitening": 10 },
  "filter": { "colorFilter": "NONE", "styleFilter": "NONE" },
  "adjustment": { "brightness": 2, "exposure": 0, "contrast": 52, "saturation": 100, "temperature": 5000, "tint": 0 }
}

Capability(
    name = "ai_optimize",
    description = "分析照片场景并自动推荐美颜/滤镜/调节参数，支持一键优化",
    schema = AiOptimizeCapabilitySchema
)

data class AiOptimizeRequest(
    val imageUri: String,
    val mode: OptimizeMode = OptimizeMode.FAST,
    val source: OptimizeSource = OptimizeSource.GALLERY_VIEWER,
    val allowCloud: Boolean = false
)

enum class OptimizeMode { FAST, SMART }
enum class OptimizeSource { GALLERY_VIEWER, EDITOR, CHAT, BATCH, IM_REMOTE }

data class AiOptimizeResult(
    val scene: Scene,
    val confidence: Float,
    val preset: OptimizePreset,
    val explanation: String,
    val usedCloud: Boolean,
    val processingTimeMs: Long
)

class AiOptimizeCapability(
    private val sceneAnalyzer: SceneAnalyzer,
    private val presetRepository: PresetRepository,
    private val smartEngine: SmartOptimizeEngine? = null,
    private val consentManager: CloudOptimizeConsentManager
) : Capability {

    override val name: String = "ai_optimize"
    override val description: String = "分析照片场景并自动推荐美颜/滤镜/调节参数"

    override suspend fun execute(request: CapabilityRequest): CapabilityResponse {
        val optimizeRequest = request.parseAs<AiOptimizeRequest>()

        return try {
            when (optimizeRequest.mode) {
                OptimizeMode.FAST -> fastOptimize(optimizeRequest)
                OptimizeMode.SMART -> smartOptimize(optimizeRequest)
            }
        } catch (e: Exception) {
            Logger.e("AiOptimize", "Optimization failed", e)
            fallbackFastOptimize(optimizeRequest)
        }
    }

    private suspend fun fastOptimize(request: AiOptimizeRequest): CapabilityResponse {
        val startTime = SystemClock.elapsedRealtime()
        val analysis = sceneAnalyzer.analyze(request.imageUri)
        val preset = presetRepository.getPreset(analysis.scene)
        val elapsed = SystemClock.elapsedRealtime() - startTime

        val result = AiOptimizeResult(
            scene = analysis.scene,
            confidence = analysis.confidence,
            preset = preset,
            explanation = buildExplanation(analysis.scene),
            usedCloud = false,
            processingTimeMs = elapsed
        )

        return CapabilityResponse.Success(result)
    }

    private suspend fun smartOptimize(request: AiOptimizeRequest): CapabilityResponse {
        if (!consentManager.isCloudOptimizeAllowed()) {
            return CapabilityResponse.NeedConsent("cloud_optimize")
        }
        if (smartEngine == null) {
            return fastOptimize(request)
        }
        return smartEngine.optimize(request)
    }

    private fun fallbackFastOptimize(request: AiOptimizeRequest): CapabilityResponse {
        val preset = presetRepository.getPreset(Scene.GENERAL)
        return CapabilityResponse.Success(
            AiOptimizeResult(
                scene = Scene.GENERAL,
                confidence = 0.5f,
                preset = preset,
                explanation = context.getString(R.string.ai_optimize_fallback_explanation),
                usedCloud = false,
                processingTimeMs = 0
            )
        )
    }
}

class PhotoEditorViewModel(
    private val aiOptimizeCapability: AiOptimizeCapability,
    private val recipeApplier: RecipeApplier,
    private val history: EditHistory
) : ViewModel() {

    fun onAiOptimizeClick() {
        viewModelScope.launch {
            _uiState.value = _uiState.value.copy(isAiOptimizing = true)

            val request = AiOptimizeRequest(
                imageUri = currentImageUri,
                mode = OptimizeMode.FAST,
                source = OptimizeSource.EDITOR
            )

            when (val response = aiOptimizeCapability.execute(CapabilityRequest(request))) {
                is CapabilityResponse.Success -> {
                    val result = response.data as AiOptimizeResult
                    val newRecipe = OptimizeRecipeMapper.toEditRecipe(
                        preset = result.preset,
                        baseRecipe = history.current
                    )
                    history.push(newRecipe)
                    renderPreview()
                }
                is CapabilityResponse.NeedConsent -> {
                    _events.emit(EditorEvent.ShowCloudConsentDialog)
                }
                is CapabilityResponse.Error -> {
                    _events.emit(EditorEvent.ShowError(response.message))
                }
            }

            _uiState.value = _uiState.value.copy(isAiOptimizing = false)
        }
    }
}

{
  "type": "function",
  "function": {
    "name": "ai_optimize",
    "description": "分析照片场景并自动推荐美颜、滤镜、调节参数，一键优化图片。",
    "parameters": {
      "type": "object",
      "properties": {
        "image_uri": {
          "type": "string",
          "description": "待优化图片的本地文件 URI"
        },
        "mode": {
          "type": "string",
          "enum": ["fast", "smart"],
          "description": "优化模式：fast 为本地快速优化（默认），smart 为云端智能推荐"
        }
      },
      "required": ["image_uri"],
      "additionalProperties": false
    }
  }
}