Flutter AI稳定性分析插件stability_ai_dart的使用

Flutter AI稳定性分析插件stability_ai_dart的使用

简介

stability_ai_dart 是一个用于与Stability AI REST API交互的Dart库。通过这个库，你可以在Flutter应用中实现文本到图像生成、核心图像生成、超分辨率图像生成等多种功能。

目录

特性 ✨

  • 文本到图像生成
  • 核心图像生成
  • 超分辨率图像生成
  • 背景移除
  • 图像放大
  • 引擎管理
  • 稳定扩散3.0和3.5图像生成
  • 完整的类型安全

安装 📦

在你的项目的 pubspec.yaml 文件中添加以下依赖：

dependencies:
  stability_ai_dart: ^0.0.1

使用 🚀

初始化客户端 🔑

import 'package:stability_ai_dart/stability_ai_dart.dart';

// 创建一个客户端实例
final client = StabilityAiFactory.create(
  apiKey: 'your-api-key-here',
  // 可选参数：自定义基础URL或HTTP客户端
  // baseUrl: 'https://api.stability.ai',
  // httpClient: customHttpClient,
);

// 客户端实现了StabilityAiInterface接口，定义了所有可以使用的操作

列出可用引擎 🔍

final engines = await client.listEngines();
for (final engine in engines) {
  print('${engine.id}: ${engine.name}');
  print('Description: ${engine.description}');
  print('Type: ${engine.type}');
  print('Status: ${engine.ready ? 'Ready' : 'Not Ready'}');
}

从文本生成图像 ✍️

final request = TextToImageRequest(
  textPrompts: [
    TextPrompt(text: 'A serene mountain lake at sunset'),
    TextPrompt(text: 'vibrant colors', weight: 0.5),
  ],
  height: 512,
  width: 512,
  numberOfSamples: 1,
  numberOfSteps: 50,
  cfgScale: 7.0,
);

final response = await client.generateImage(
  engineId: 'stable-diffusion-v1-5',
  request: request,
);

for (final artifact in response.artifacts) {
  print('Generated image: ${artifact.base64}');
  print('Seed used: ${artifact.seed}');
  print('MIME type: ${artifact.mimeType}');
}

生成核心图像 🖼️

final request = CoreImageRequest(
  prompt: 'A lighthouse on a cliff overlooking the ocean',
  negativePrompt: 'blur, haze, fog',
  aspectRatio: AspectRatio.ratio16x9,
  outputFormat: OutputFormat.png,
  stylePreset: StylePreset.photographic,
);

// 获取原始字节
final result = await client.generateCoreImage(
  request: request,
  returnJson: false,
);

if (result is CoreImageBytes) {
  // 使用原始字节
  await File('lighthouse.png').writeAsBytes(result.bytes);
}

// 或获取包含base64和元数据的JSON响应
final jsonResult = await client.generateCoreImage(
  request: request,
  returnJson: true,
);

if (jsonResult is CoreImageResponse) {
  print('Generated image: ${jsonResult.image}');
  print('Finish reason: ${jsonResult.finishReason}');
  print('Seed used: ${jsonResult.seed}');
}

可用风格预设 🎨

  • enhance - 通用增强
  • anime - 动漫风格
  • photographic - 摄影风格
  • digital-art - 数字艺术风格
  • comic-book - 漫画书风格
  • fantasy-art - 幻想艺术风格
  • line-art - 线条艺术风格
  • analog-film - 模拟电影风格
  • neon-punk - 电子朋克风格
  • isometric - 等距风格
  • low-poly - 低多边形风格
  • origami - 折纸风格
  • modeling-compound - 塑料模型风格
  • cinematic - 电影风格
  • 3d-model - 3D模型风格
  • pixel-art - 像素艺术风格
  • tile-texture - 瓷砖纹理风格

生成超分辨率图像 🌟

final request = UltraImageRequest(
  prompt: 'A majestic mountain landscape',
  negativePrompt: 'blur, haze, people',
  aspectRatio: AspectRatio.ratio16x9,
  outputFormat: OutputFormat.png,
);

// 获取原始字节
final result = await client.generateUltraImage(
  request: request,
  returnJson: false,
);

if (result is UltraImageBytes) {
  // 使用原始字节
  final bytes = result.bytes;
}

// 或获取包含base64和元数据的JSON响应
final jsonResult = await client.generateUltraImage(
  request: request,
  returnJson: true,
);

if (jsonResult is UltraImageResponse) {
  print('Generated image: ${jsonResult.image}');
  print('Finish reason: ${jsonResult.finishReason}');
  print('Seed used: ${jsonResult.seed}');
}

生成图像变化 🔄

final request = UltraImageRequest(
  prompt: 'Similar to this, but more vibrant',
  image: imageBytes, // 源图像的Uint8List
  strength: 0.7, // 与源图像变化的程度 (0.0 到 1.0)
  outputFormat: OutputFormat.png,
);

final result = await client.generateUltraImage(
  request: request,
  returnJson: false,
);

去除图像背景 ✂️

final request = RemoveBackgroundRequest(
  image: imageBytes, // 源图像的Uint8List
  outputFormat: OutputFormat.png,
);

// 获取原始字节
final result = await client.removeBackground(
  request: request,
  returnJson: false,
);

if (result is UltraImageBytes) {
  // 使用原始字节
  final bytes = result.bytes;
}

// 或获取包含base64和元数据的JSON响应
final jsonResult = await client.removeBackground(
  request: request,
  returnJson: true,
);

if (jsonResult is RemoveBackgroundResponse) {
  print('Processed image: ${jsonResult.image}');
  print('Finish reason: ${jsonResult.finishReason}');
}

放大图像 📐

有四种上采样选项可用：

  1. 标准上采样器：增强质量的同时放大图像。
  2. 创意上采样器：适用于高度退化的图像，进行大量重绘。
  3. 保守上采样器：最小化改变的同时放大图像。
  4. 快速上采样器：快速4倍放大，质量良好，适合社交媒体。
标准上采样器
使用方便方法
final request = UpscaleRequest(
  image: imageBytes, // 图像的Uint8List (64x64 到 1兆像素)
  prompt: 'A high resolution landscape photo',
  negativePrompt: 'blur, noise', // 可选：不包括的内容
  outputFormat: OutputFormat.png,
  seed: 123, // 可选：可重复结果
  creativity: 0.3, // 可选：控制创意增强 (0.0 到 0.35)
);

// 放大并等待结果
final result = await client.upscaleImageAndWaitForResult(
  request: request,
  returnJson: false, // true 为带元数据的JSON响应
  pollInterval: Duration(seconds: 10), // 可选：自定义轮询间隔
);

if (result is UpscaleResultBytes) {
  // 处理原始字节
  await File('upscaled.png').writeAsBytes(result.bytes);
} else if (result is UpscaleResultResponse) {
  // 处理JSON响应
  print('Finish reason: ${result.finishReason}');
  final bytes = base64.decode(result.image);
  await File('upscaled.png').writeAsBytes(bytes);
}
创意上采样器
final request = UpscaleRequest(
  image: imageBytes, // 图像的Uint8List (64x64 到 1兆像素)
  prompt: 'A high resolution landscape photo',
  negativePrompt: 'blur, noise', // 可选：不包括的内容
  outputFormat: OutputFormat.png,
  seed: 123, // 可选：可重复结果
  creativity: 0.3, // 可选：控制创意增强 (0.0 到 0.35)
);

// 获取结果，自动处理轮询
final result = await client.upscaleImageCreativeAndWaitForResult(
  request: request,
  returnJson: false,
  pollInterval: Duration(seconds: 10), // 可选：自定义轮询间隔
);

if (result is UpscaleResultBytes) {
  // 处理原始字节
  await File('upscaled.png').writeAsBytes(result.bytes);
} else if (result is UpscaleResultResponse) {
  // 处理JSON响应
  print('Finish reason: ${result.finishReason}');
  final bytes = base64.decode(result.image);
  await File('upscaled.png').writeAsBytes(bytes);
}

// 或者开始上采样并手动处理轮询
final response = await client.upscaleImageCreative(request: request);
print('Generation ID: ${response.id}');

// 轮询结果
while (true) {
  final result = await client.getCreativeUpscaleResult(
    id: response.id,
    returnJson: false,
  );

  if (result is UpscaleInProgressResponse) {
    // 仍在处理中，等待后重试
    await Future.delayed(Duration(seconds: 10));
    continue;
  }

  // 生成完成
  if (result is UpscaleResultBytes) {
    await File('upscaled.png').writeAsBytes(result.bytes);
    break;
  } else if (result is UpscaleResultResponse) {
    print('Finish reason: ${result.finishReason}');
    final bytes = base64.decode(result.image);
    await File('upscaled.png').writeAsBytes(bytes);
    break;
  }
}
保守上采样器
final request = UpscaleRequest(
  image: imageBytes, // 图像的Uint8List (64x64 到 1兆像素)
  prompt: 'A high resolution landscape photo',
  negativePrompt: 'blur, noise', // 可选：不包括的内容
  outputFormat: OutputFormat.png,
  seed: 123, // 可选：可重复结果
  creativity: 0.3, // 可选：控制创意增强 (0.0 到 0.35)
);

// 直接获取结果
final result = await client.upscaleImageConservative(
  request: request,
  returnJson: false, // true 为带元数据的JSON响应
);

if (result is UltraImageBytes) {
  // 处理原始字节
  await File('upscaled.png').writeAsBytes(result.bytes);
} else if (result is UltraImageResponse) {
  // 处理JSON响应
  print('Finish reason: ${result.finishReason}');
  final bytes = base64.decode(result.image);
  await File('upscaled.png').writeAsBytes(bytes);
}

// 或使用方便方法
final result = await client.upscaleImageConservativeAndWaitForResult(
  request: request,
  returnJson: false,
  pollInterval: Duration(seconds: 10), // 可选：自定义轮询间隔
);
手动轮询（标准上采样器）
final request = UpscaleRequest(
  image: imageBytes,
  prompt: 'A high resolution landscape photo',
  outputFormat: OutputFormat.png,
);

// 开始上采样
final response = await client.upscaleImage(request: request);
print('Generation ID: ${response.id}');

// 轮询结果
while (true) {
  final result = await client.getUpscaleResult(
    id: response.id,
    returnJson: false,
  );

  if (result is UpscaleInProgressResponse) {
    // 仍在处理中，等待后重试
    await Future.delayed(Duration(seconds: 10));
    continue;
  }

  // 生成完成
  if (result is UpscaleResultBytes) {
    await File('upscaled.png').writeAsBytes(result.bytes);
    break;
  } else if (result is UpscaleResultResponse) {
    print('Finish reason: ${result.finishReason}');
    final bytes = base64.decode(result.image);
    await File('upscaled.png').writeAsBytes(bytes);
    break;
  }
}

错误处理 ⚠️

try {
  final response = await client.generateImage(
    engineId: 'invalid-engine',
    request: request,
  );
} on StabilityAiException catch (e) {
  print('API error: ${e.statusCode} - ${e.message}');
  if (e.id != null) print('Error ID: ${e.id}');
  if (e.name != null) print('Error name: ${e.name}');
}

可用的宽高比 📏

  • 16:9 (AspectRatio.ratio16x9)
  • 1:1 (AspectRatio.ratio1x1)
  • 21:9 (AspectRatio.ratio21x9)
  • 2:3 (AspectRatio.ratio2x3)
  • 3:2 (AspectRatio.ratio3x2)
  • 4:5 (AspectRatio.ratio4x5)
  • 5:4 (AspectRatio.ratio5x4)
  • 9:16 (AspectRatio.ratio9x16)
  • 9:21 (AspectRatio.ratio9x21)

输出格式 💾

  • JPEG (OutputFormat.jpeg)
  • PNG (OutputFormat.png)
  • WebP (OutputFormat.webp)

使用SD3生成图像 🎯

final request = SD3ImageRequest(
  prompt: 'A lighthouse on a cliff overlooking the ocean',
  model: SD3Model.sd35Large, // 或 sd35LargeTurbo, sd35Medium, sd3Large, sd3Medium 等
  aspectRatio: AspectRatio.ratio16x9,
  cfgScale: 7.0, // 可选：控制图像如何贴近提示
  seed: 42, // 可选：可重复结果
  outputFormat: OutputFormat.png,
);

// 获取原始字节
final result = await client.generateSD3Image(
  request: request,
  returnJson: false,
);

if (result is SD3ImageBytes) {
  // 使用原始字节
  await File('lighthouse.png').writeAsBytes(result.bytes);
}

// 或获取包含base64和元数据的JSON响应
final jsonResult = await client.generateSD3Image(
  request: request,
  returnJson: true,
);

if (jsonResult is SD3ImageResponse) {
  print('Generated image: ${jsonResult.image}');
  print('Finish reason: ${jsonResult.finishReason}');
  print('Seed used: ${jsonResult.seed}');
}

SD3模型和信用成本 💰

  • SD 3.5 Large (6.5 credits)
    • 最高质量模型
    • 适用于详细的、高保真的图像
  • SD 3.5 Large Turbo (4 credits)
    • 更快的生成速度
    • 速度和质量的良好平衡
  • SD 3.5 Medium (3.5 credits)
    • 较轻的模型，具有良好的质量
    • 经济实惠的选择
  • SD 3.0 Large (6.5 credits)
    • 原始的高质量模型
  • SD 3.0 Large Turbo (4 credits)
    • SD3 Large 的更快版本
  • SD 3.0 Medium (3.5 credits)
    • 平衡的SD3模型

清理 🧹

client.close();

更多关于Flutter AI稳定性分析插件stability_ai_dart的使用的实战教程也可以访问 https://www.itying.com/category-92-b0.html

1 回复

更多关于Flutter AI稳定性分析插件stability_ai_dart的使用的实战系列教程也可以访问 https://www.itying.com/category-92-b0.html


当然，以下是如何在Flutter项目中使用stability_ai_dart插件进行AI稳定性分析的一个简要代码示例。请注意，由于stability_ai_dart并非一个广为人知的库（截至我最后的知识更新），我将提供一个假设性的实现框架，并假设该库提供了类似的功能接口。如果stability_ai_dart库确实存在并且具有不同的API，请根据实际情况调整代码。

首先，确保你已经在pubspec.yaml文件中添加了stability_ai_dart依赖项（假设它存在于pub.dev上）：

dependencies:
  flutter:
    sdk: flutter
  stability_ai_dart: ^x.y.z  # 替换为实际的版本号

然后，运行flutter pub get来安装依赖项。

接下来，在你的Flutter项目中，你可以按照以下方式使用stability_ai_dart插件进行AI稳定性分析。以下是一个假设的示例，展示了如何初始化插件，输入数据，并获取稳定性分析结果。

import 'package:flutter/material.dart';
import 'package:stability_ai_dart/stability_ai_dart.dart';  // 假设库提供了这样的导入路径

void main() {
  runApp(MyApp());
}

class MyApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      home: Scaffold(
        appBar: AppBar(
          title: Text('AI Stability Analysis'),
        ),
        body: Center(
          child: StabilityAnalysisScreen(),
        ),
      ),
    );
  }
}

class StabilityAnalysisScreen extends StatefulWidget {
  @override
  _StabilityAnalysisScreenState createState() => _StabilityAnalysisScreenState();
}

class _StabilityAnalysisScreenState extends State<StabilityAnalysisScreen> {
  String result = "";

  void performStabilityAnalysis() async {
    // 假设StabilityAnalyzer是插件提供的一个类
    final StabilityAnalyzer analyzer = StabilityAnalyzer();

    // 输入数据，这里假设数据是一个List<double>类型
    List<double> inputData = [0.1, 0.2, 0.3, ..., 1.0];  // 替换为实际数据

    try {
      // 调用分析函数，这里假设是analyze方法
      final StabilityResult result = await analyzer.analyze(inputData);

      // 更新UI显示结果
      setState(() {
        this.result = "Stability Score: ${result.score}\nStability Details: ${result.details}";
      });
    } catch (e) {
      setState(() {
        this.result = "Error during analysis: $e";
      });
    }
  }

  @override
  Widget build(BuildContext context) {
    return Column(
      mainAxisAlignment: MainAxisAlignment.center,
      children: <Widget>[
        Text('AI Stability Analysis Result:'),
        Text(result),
        ElevatedButton(
          onPressed: performStabilityAnalysis,
          child: Text('Analyze'),
        ),
      ],
    );
  }
}

// 假设的StabilityAnalyzer类和StabilityResult类
class StabilityAnalyzer {
  Future<StabilityResult> analyze(List<double> data) async {
    // 这里应该是插件实现的AI稳定性分析逻辑
    // 由于是假设，这里直接返回一个模拟的结果
    double score = calculateStabilityScore(data);  // 假设的方法
    String details = "Some detailed stability analysis information.";
    return StabilityResult(score, details);
  }

  double calculateStabilityScore(List<double> data) {
    // 简单的平均值作为稳定性评分（仅为示例）
    double sum = data.reduce((a, b) => a + b);
    return sum / data.length;
  }
}

class StabilityResult {
  final double score;
  final String details;

  StabilityResult(this.score, this.details);
}

请注意，上面的代码完全是基于假设的，因为stability_ai_dart库的具体API和功能未知。如果库确实存在，你应该参考其官方文档和API参考来正确实现功能。如果库不存在，你可能需要寻找其他适合的Flutter插件或自己实现AI稳定性分析逻辑。

回到顶部