xdedmi/aisee
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

first commit

Browse Source
This commit is contained in:
unknown
2026-03-02 21:26:32 +08:00
commit e68bb3ac42
8 changed files with 3076 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

450
技术文档/Flutter开发环境搭建.md Normal file
View File

@@ -0,0 +1,450 @@
# AISee Flutter 开发环境搭建指南
## 系统要求
- **操作系统**：Windows 10/11（64位）
- **内存**：至少 8GB RAM（推荐 16GB）
- **硬盘**：至少 10GB 可用空间
- **处理器**：Intel/AMD 处理器
## 一、安装 Flutter SDK
### 1. 下载 Flutter SDK
```bash
# 官网下载（可能较慢）
https://flutter.dev/docs/get-started/install/windows
# 推荐：使用国内镜像
https://flutter.cn/docs/get-started/install/windows
# 下载稳定版
flutter_windows_3.16.9-stable.zip
```
### 2. 解压 Flutter SDK
```bash
# 解压到：
C:\src\flutter
# 注意：不要放在需要管理员权限的目录（如 Program Files）
```
### 3. 配置环境变量
```bash
# 1. 右键"此电脑" -> 属性 -> 高级系统设置 -> 环境变量
# 2. 在"用户变量"中新建：
变量名：FLUTTER_HOME
变量值：C:\src\flutter
# 3. 编辑 Path 变量，添加：
%FLUTTER_HOME%\bin
C:\src\flutter\bin\cache\dart-sdk\bin
# 4. 配置国内镜像（重要！）
变量名：PUB_HOSTED_URL
变量值：https://pub.flutter-io.cn
变量名：FLUTTER_STORAGE_BASE_URL
变量值：https://storage.flutter-io.cn
# 5. 验证
flutter --version
dart --version
```
### 4. 运行 Flutter Doctor
```bash
# 检查环境
flutter doctor
# 输出示例：
Doctor summary (to see all details, run flutter doctor -v):
[√] Flutter (Channel stable, 3.16.9, on Microsoft Windows)
[!] Android toolchain - develop for Android devices
[!] Chrome - develop for the web
[!] Visual Studio - develop for Windows
[!] Android Studio (not installed)
[√] VS Code (version 1.85.0)
[√] Connected device (1 available)
```
## 二、安装 Android 开发环境
### 1. 安装 Android Studio
```bash
# 下载地址
https://developer.android.com/studio
# 安装步骤（参考之前的 Android 环境文档）
1. 安装 Android Studio
2. 安装 Android SDK (API 26-34)
3. 配置 ANDROID_HOME 环境变量
```
### 2. 安装 Android SDK 命令行工具
```bash
# 在 Android Studio 中
# Tools -> SDK Manager -> SDK Tools
勾选：
☑ Android SDK Command-line Tools
☑ Android SDK Build-Tools
☑ Android SDK Platform-Tools
☑ Android Emulator
```
### 3. 接受 Android 许可
```bash
flutter doctor --android-licenses
# 输入 y 接受所有许可
```
## 三、安装 Visual Studio Code
### 1. 下载安装 VS Code
```bash
# 官网
https://code.visualstudio.com/
# 下载 Windows 64-bit 版本
VSCodeUserSetup-x64-1.85.0.exe
```
### 2. 安装 Flutter 插件
```bash
# 打开 VS Code
# 按 Ctrl+Shift+X 打开扩展面板
搜索并安装：
1. Flutter（自动安装 Dart 插件）
2. Dart
3. Flutter Widget Snippets（可选）
4. Awesome Flutter Snippets（可选）
5. Pubspec Assist（可选）
```
### 3. 配置 VS Code
```bash
# 按 Ctrl+Shift+P 打开命令面板
# 输入：Flutter: New Project
# 如果能看到选项，说明配置成功
```
## 四、创建和运行测试项目
### 1. 创建测试项目
```bash
# 打开命令行
cd C:\Users\xdedmi\Desktop\aisee
# 创建 Flutter 项目
flutter create hello_flutter
# 进入项目目录
cd hello_flutter
# 查看项目结构
dir
```
### 2. 启动 Android 模拟器
```bash
# 查看可用设备
flutter devices
# 如果没有设备，创建模拟器
# 打开 Android Studio -> Device Manager -> Create Device
# 或使用命令行创建
flutter emulators
flutter emulators --launch <emulator_id>
```
### 3. 运行项目
```bash
# 确保模拟器已启动
flutter devices
# 运行项目
flutter run
# 或在 VS Code 中按 F5
```
### 4. 热重载测试
```bash
# 修改 lib/main.dart 中的文本
# 保存文件（Ctrl+S）
# 应该看到模拟器自动更新
# 或在终端按：
r - 热重载
R - 热重启
q - 退出
```
## 五、安装必要的工具
### 1. Git（如果还没安装）
```bash
# 下载
https://git-scm.com/download/win
# 安装并配置
git config --global user.name "你的名字"
git config --global user.email "你的邮箱"
```
### 2. Chrome（用于 Web 调试）
```bash
# Flutter 支持 Web 开发
# 安装 Chrome 浏览器用于调试
# 启用 Web 支持
flutter config --enable-web
# 运行 Web 版本
flutter run -d chrome
```
## 六、Flutter 常用命令
### 项目管理
```bash
# 创建新项目
flutter create project_name
# 创建指定平台项目
flutter create --platforms=android,ios project_name
# 获取依赖
flutter pub get
# 更新依赖
flutter pub upgrade
# 清理项目
flutter clean
```
### 运行和调试
```bash
# 运行项目
flutter run
# 指定设备运行
flutter run -d <device_id>
# Release 模式运行
flutter run --release
# 查看日志
flutter logs
```
### 构建
```bash
# 构建 APK
flutter build apk
# 构建 App Bundle
flutter build appbundle
# 构建 iOS（需要 macOS）
flutter build ios
```
### 分析和测试
```bash
# 分析代码
flutter analyze
# 运行测试
flutter test
# 查看设备
flutter devices
# 检查环境
flutter doctor -v
```
## 七、配置国内镜像加速
### 永久配置（推荐）
```bash
# 在环境变量中添加：
PUB_HOSTED_URL=https://pub.flutter-io.cn
FLUTTER_STORAGE_BASE_URL=https://storage.flutter-io.cn
```
### 临时配置
```bash
# Windows PowerShell
$env:PUB_HOSTED_URL="https://pub.flutter-io.cn"
$env:FLUTTER_STORAGE_BASE_URL="https://storage.flutter-io.cn"
# CMD
set PUB_HOSTED_URL=https://pub.flutter-io.cn
set FLUTTER_STORAGE_BASE_URL=https://storage.flutter-io.cn
```
## 八、常见问题解决
### 1. Flutter Doctor 问题
#### Android toolchain 问题
```bash
# 问题：Android license status unknown
# 解决：
flutter doctor --android-licenses
# 问题：cmdline-tools component is missing
# 解决：在 Android Studio SDK Manager 中安装 Command-line Tools
```
#### Visual Studio 问题（Windows 桌面开发）
```bash
# 如果需要开发 Windows 桌面应用
# 下载安装 Visual Studio 2022 Community
# 选择"使用 C++ 的桌面开发"工作负载
```
### 2. 网络问题
```bash
# 问题：下载依赖超时
# 解决：
1. 配置国内镜像（见上文）
2. 使用代理
3. 手动下载依赖包
```
### 3. 模拟器问题
```bash
# 问题：模拟器启动失败
# 解决：
1. 检查 BIOS 虚拟化是否开启
2. 关闭 Hyper-V
3. 使用真机调试
# 问题：模拟器很慢
# 解决：
1. 使用 x86_64 镜像
2. 增加模拟器 RAM
3. 使用真机调试
```
### 4. 真机调试
```bash
# Android 真机调试步骤：
1. 手机开启开发者选项
2. 开启 USB 调试
3. 连接手机到电脑
4. 允许 USB 调试授权
5. 运行：flutter devices
6. 运行：flutter run
```
## 九、VS Code 快捷键
### Flutter 开发常用快捷键
```bash
F5 - 启动调试
Shift+F5 - 停止调试
Ctrl+F5 - 运行（不调试）
Ctrl+Shift+F5 - 重启调试
Ctrl+S - 保存并热重载
Ctrl+Shift+P - 命令面板
Ctrl+Space - 代码补全
F12 - 跳转到定义
Alt+F12 - 查看定义
Shift+F12 - 查看引用
Ctrl+/ - 注释/取消注释
Ctrl+Shift+K - 删除行
Alt+Up/Down - 移动行
Ctrl+D - 选择下一个相同内容
```
### Flutter 特定命令
```bash
# Ctrl+Shift+P 打开命令面板，输入：
Flutter: New Project - 创建新项目
Flutter: Hot Reload - 热重载
Flutter: Hot Restart - 热重启
Flutter: Open DevTools - 打开开发者工具
Flutter: Run Flutter Doctor - 运行环境检查
Flutter: Clean Project - 清理项目
```
## 十、开发环境检查清单
```bash
✅ Flutter SDK 安装并配置环境变量
✅ 国内镜像配置完成
✅ Android Studio 安装
✅ Android SDK 安装（API 26-34）
✅ Android 许可接受
✅ VS Code 安装
✅ Flutter 和 Dart 插件安装
✅ Git 安装并配置
✅ 测试项目创建并运行成功
✅ 热重载功能正常
✅ flutter doctor 无严重错误
```
## 十一、验证环境
### 运行完整检查
```bash
# 详细检查
flutter doctor -v
# 期望输出（至少这些项目正常）：
[√] Flutter (Channel stable, 3.16.9)
[√] Android toolchain - develop for Android devices
[√] VS Code (version 1.85.0)
[√] Connected device (1 available)
# 如果有 [!] 或 [×]，根据提示解决
```
### 创建并运行测试项目
```bash
# 1. 创建项目
flutter create test_app
cd test_app
# 2. 启动模拟器或连接真机
flutter devices
# 3. 运行项目
flutter run
# 4. 看到计数器应用说明环境正常
```
## 十二、下一步
环境搭建完成后：
1. ✅ 学习 Dart 语言基础
2. ✅ 学习 Flutter Widget
3. ✅ 创建 AISee 项目
4. ✅ 开始功能开发
---
**预计时间**：
- 下载安装：30-60 分钟
- 配置调试：15-30 分钟
- 总计：1-2 小时
**提示**：
- 首次运行 `flutter doctor` 会下载必要组件，需要时间
- 首次运行项目会下载 Gradle 依赖，需要耐心等待
- 建议使用真机调试，速度更快

836
技术文档/Flutter项目初始化.md Normal file
View File

@@ -0,0 +1,836 @@
# AISee Flutter 项目初始化指南
## 1. 创建项目
```bash
cd C:\Users\xdedmi\Desktop\aisee
# 创建 Flutter 项目
flutter create --org com.aisee --project-name aisee_app --platforms android,ios aisee_app
cd aisee_app
```
## 2. 项目目录结构
```
aisee_app/
├── lib/
│ ├── main.dart # 入口文件
│ ├── app.dart # App 根组件
│ │
│ ├── config/ # 配置
│ │ ├── app_config.dart # 应用配置
│ │ ├── routes.dart # 路由配置
│ │ └── theme.dart # 主题配置
│ │
│ ├── models/ # 数据模型
│ │ ├── detection.dart # 检测结果
│ │ ├── text_region.dart # 文字区域
│ │ ├── scene_description.dart # 场景描述
│ │ └── analysis_result.dart # 分析结果
│ │
│ ├── services/ # 服务层
│ │ ├── api/
│ │ │ ├── api_client.dart # HTTP 客户端
│ │ │ ├── image_api.dart # 图像 API
│ │ │ └── analysis_api.dart # 分析 API
│ │ ├── bluetooth/
│ │ │ ├── bluetooth_service.dart # 蓝牙服务
│ │ │ └── glasses_protocol.dart # 眼镜通信协议
│ │ ├── camera/
│ │ │ └── camera_service.dart # 相机服务
│ │ ├── websocket/
│ │ │ └── ws_service.dart # WebSocket 服务
│ │ └── tts/
│ │ └── tts_service.dart # 语音合成服务
│ │
│ ├── providers/ # 状态管理
│ │ ├── camera_provider.dart
│ │ ├── analysis_provider.dart
│ │ ├── bluetooth_provider.dart
│ │ └── settings_provider.dart
│ │
│ ├── screens/ # 页面
│ │ ├── home/
│ │ │ └── home_screen.dart
│ │ ├── camera/
│ │ │ └── camera_screen.dart
│ │ ├── analysis/
│ │ │ └── analysis_screen.dart
│ │ ├── history/
│ │ │ └── history_screen.dart
│ │ ├── settings/
│ │ │ └── settings_screen.dart
│ │ └── bluetooth/
│ │ └── bluetooth_screen.dart
│ │
│ ├── widgets/ # 通用组件
│ │ ├── detection_overlay.dart # 检测结果叠加层
│ │ ├── loading_indicator.dart
│ │ └── error_widget.dart
│ │
│ └── utils/ # 工具类
│ ├── constants.dart
│ ├── image_utils.dart
│ └── permission_utils.dart
│
├── assets/ # 静态资源
│ ├── images/
│ ├── icons/
│ └── fonts/
│
├── test/ # 测试
│ ├── services/
│ ├── providers/
│ └── widgets/
│
├── android/ # Android 原生代码
├── ios/ # iOS 原生代码
├── pubspec.yaml # 依赖配置
└── analysis_options.yaml # 代码分析配置
```
## 3. 依赖配置 pubspec.yaml
```yaml
name: aisee_app
description: AISee - AI 视觉辅助眼镜系统
publish_to: 'none'
version: 0.1.0+1
environment:
sdk: '>=3.2.0 <4.0.0'
dependencies:
flutter:
sdk: flutter
# UI
cupertino_icons: ^1.0.6
google_fonts: ^6.1.0
flutter_svg: ^2.0.9
cached_network_image: ^3.3.0
shimmer: ^3.0.0
# 状态管理
riverpod: ^2.4.9
flutter_riverpod: ^2.4.9
# 路由
go_router: ^13.0.0
# 网络
dio: ^5.4.0
web_socket_channel: ^2.4.0
# 相机
camera: ^0.10.5+7
image: ^4.1.4
# 蓝牙
flutter_blue_plus: ^1.28.5
# 本地存储
sqflite: ^2.3.0
shared_preferences: ^2.2.2
path_provider: ^2.1.1
hive: ^2.2.3
hive_flutter: ^1.1.0
# 权限
permission_handler: ^11.1.0
# 语音
flutter_tts: ^3.8.5
# 图像处理
image_picker: ^1.0.5
# JSON 序列化
json_annotation: ^4.8.1
freezed_annotation: ^2.4.1
# 工具
logger: ^2.0.2+1
intl: ^0.19.0
uuid: ^4.2.1
connectivity_plus: ^5.0.2
dev_dependencies:
flutter_test:
sdk: flutter
flutter_lints: ^3.0.1
# 代码生成
build_runner: ^2.4.7
json_serializable: ^6.7.1
freezed: ^2.4.5
hive_generator: ^2.0.1
# 测试
mockito: ^5.4.3
mocktail: ^1.0.1
flutter:
uses-material-design: true
assets:
- assets/images/
- assets/icons/
fonts:
- family: AISee
fonts:
- asset: assets/fonts/AISee-Regular.ttf
- asset: assets/fonts/AISee-Bold.ttf
weight: 700
```
## 4. 核心代码
### main.dart
```dart
import 'package:flutter/material.dart';
import 'package:flutter/services.dart';
import 'package:flutter_riverpod/flutter_riverpod.dart';
import 'package:hive_flutter/hive_flutter.dart';
import 'app.dart';
void main() async {
WidgetsFlutterBinding.ensureInitialized();
// 强制竖屏
await SystemChrome.setPreferredOrientations([
DeviceOrientation.portraitUp,
]);
// 初始化 Hive 本地存储
await Hive.initFlutter();
runApp(
const ProviderScope(
child: AISeeApp(),
),
);
}
```
### app.dart
```dart
import 'package:flutter/material.dart';
import 'package:flutter_riverpod/flutter_riverpod.dart';
import 'config/routes.dart';
import 'config/theme.dart';
class AISeeApp extends ConsumerWidget {
const AISeeApp({super.key});
@override
Widget build(BuildContext context, WidgetRef ref) {
final router = ref.watch(routerProvider);
return MaterialApp.router(
title: 'AISee',
theme: AISeeTheme.lightTheme,
darkTheme: AISeeTheme.darkTheme,
themeMode: ThemeMode.system,
routerConfig: router,
debugShowCheckedModeBanner: false,
);
}
}
```
### config/theme.dart
```dart
import 'package:flutter/material.dart';
class AISeeTheme {
static const _primaryColor = Color(0xFF2196F3);
static const _secondaryColor = Color(0xFF00BCD4);
static ThemeData get lightTheme {
return ThemeData(
useMaterial3: true,
colorScheme: ColorScheme.fromSeed(
seedColor: _primaryColor,
secondary: _secondaryColor,
brightness: Brightness.light,
),
appBarTheme: const AppBarTheme(
centerTitle: true,
elevation: 0,
),
);
}
static ThemeData get darkTheme {
return ThemeData(
useMaterial3: true,
colorScheme: ColorScheme.fromSeed(
seedColor: _primaryColor,
secondary: _secondaryColor,
brightness: Brightness.dark,
),
appBarTheme: const AppBarTheme(
centerTitle: true,
elevation: 0,
),
);
}
}
```
### config/routes.dart
```dart
import 'package:flutter_riverpod/flutter_riverpod.dart';
import 'package:go_router/go_router.dart';
import '../screens/home/home_screen.dart';
import '../screens/camera/camera_screen.dart';
import '../screens/analysis/analysis_screen.dart';
import '../screens/history/history_screen.dart';
import '../screens/settings/settings_screen.dart';
import '../screens/bluetooth/bluetooth_screen.dart';
final routerProvider = Provider<GoRouter>((ref) {
return GoRouter(
initialLocation: '/',
routes: [
GoRoute(
path: '/',
builder: (context, state) => const HomeScreen(),
),
GoRoute(
path: '/camera',
builder: (context, state) => const CameraScreen(),
),
GoRoute(
path: '/analysis',
builder: (context, state) => const AnalysisScreen(),
),
GoRoute(
path: '/history',
builder: (context, state) => const HistoryScreen(),
),
GoRoute(
path: '/settings',
builder: (context, state) => const SettingsScreen(),
),
GoRoute(
path: '/bluetooth',
builder: (context, state) => const BluetoothScreen(),
),
],
);
});
```
### config/app_config.dart
```dart
class AppConfig {
// API 配置
static const String apiBaseUrl = 'https://api.aisee.com';
static const String wsBaseUrl = 'wss://api.aisee.com/ws';
// 开发环境
static const String devApiBaseUrl = 'http://10.0.2.2:8000';
static const String devWsBaseUrl = 'ws://10.0.2.2:8000/ws';
// 图像配置
static const int imageMaxWidth = 1280;
static const int imageMaxHeight = 720;
static const int imageQuality = 85;
// 蓝牙配置
static const String glassesServiceUuid = '0000ffe0-0000-1000-8000-00805f9b34fb';
static const String glassesCharUuid = '0000ffe1-0000-1000-8000-00805f9b34fb';
// 超时配置
static const Duration apiTimeout = Duration(seconds: 30);
static const Duration wsReconnectDelay = Duration(seconds: 5);
}
```
### services/api/api_client.dart
```dart
import 'package:dio/dio.dart';
import 'package:flutter_riverpod/flutter_riverpod.dart';
import '../../config/app_config.dart';
final apiClientProvider = Provider<ApiClient>((ref) {
return ApiClient();
});
class ApiClient {
late final Dio _dio;
ApiClient() {
_dio = Dio(BaseOptions(
baseUrl: AppConfig.devApiBaseUrl,
connectTimeout: AppConfig.apiTimeout,
receiveTimeout: AppConfig.apiTimeout,
headers: {
'Content-Type': 'application/json',
},
));
_dio.interceptors.add(LogInterceptor(
requestBody: true,
responseBody: true,
));
}
// 上传图像
Future<Map<String, dynamic>> uploadImage(List<int> imageBytes, String filename) async {
final formData = FormData.fromMap({
'file': MultipartFile.fromBytes(imageBytes, filename: filename),
});
final response = await _dio.post('/api/v1/images/upload', data: formData);
return response.data;
}
// 请求 AI 分析
Future<Map<String, dynamic>> analyzeImage(String imageUrl) async {
final response = await _dio.post('/api/v1/analysis/analyze', data: {
'image_url': imageUrl,
});
return response.data;
}
}
```
### services/camera/camera_service.dart
```dart
import 'package:camera/camera.dart';
import 'package:flutter_riverpod/flutter_riverpod.dart';
import 'package:logger/logger.dart';
final cameraServiceProvider = Provider<CameraService>((ref) {
return CameraService();
});
class CameraService {
final _logger = Logger();
CameraController? _controller;
List<CameraDescription> _cameras = [];
CameraController? get controller => _controller;
bool get isInitialized => _controller?.value.isInitialized ?? false;
Future<void> initialize() async {
_cameras = await availableCameras();
if (_cameras.isEmpty) {
_logger.e('No cameras available');
return;
}
_controller = CameraController(
_cameras.first,
ResolutionPreset.medium,
enableAudio: false,
imageFormatGroup: ImageFormatGroup.jpeg,
);
await _controller!.initialize();
_logger.i('Camera initialized');
}
Future<XFile?> takePicture() async {
if (!isInitialized) return null;
return await _controller!.takePicture();
}
void dispose() {
_controller?.dispose();
}
}
```
### services/bluetooth/bluetooth_service.dart
```dart
import 'dart:async';
import 'dart:convert';
import 'package:flutter_blue_plus/flutter_blue_plus.dart';
import 'package:flutter_riverpod/flutter_riverpod.dart';
import 'package:logger/logger.dart';
import '../../config/app_config.dart';
final bluetoothServiceProvider = Provider<BluetoothService>((ref) {
return BluetoothService();
});
class BluetoothService {
final _logger = Logger();
BluetoothDevice? _connectedDevice;
BluetoothCharacteristic? _writeCharacteristic;
final _dataController = StreamController<List<int>>.broadcast();
Stream<List<int>> get dataStream => _dataController.stream;
bool get isConnected => _connectedDevice != null;
// 扫描设备
Future<List<ScanResult>> scanDevices({Duration timeout = const Duration(seconds: 5)}) async {
final results = <ScanResult>[];
await FlutterBluePlus.startScan(timeout: timeout);
FlutterBluePlus.scanResults.listen((scanResults) {
results.addAll(scanResults);
});
await Future.delayed(timeout);
await FlutterBluePlus.stopScan();
return results;
}
// 连接设备
Future<bool> connect(BluetoothDevice device) async {
try {
await device.connect(timeout: const Duration(seconds: 10));
_connectedDevice = device;
// 发现服务
final services = await device.discoverServices();
for (var service in services) {
if (service.uuid.toString() == AppConfig.glassesServiceUuid) {
for (var char in service.characteristics) {
if (char.uuid.toString() == AppConfig.glassesCharUuid) {
_writeCharacteristic = char;
// 监听数据
await char.setNotifyValue(true);
char.onValueReceived.listen((data) {
_dataController.add(data);
});
}
}
}
}
_logger.i('Connected to ${device.platformName}');
return true;
} catch (e) {
_logger.e('Connection failed: $e');
return false;
}
}
// 发送数据到眼镜
Future<void> sendToGlasses(Map<String, dynamic> data) async {
if (_writeCharacteristic == null) return;
final jsonStr = jsonEncode(data);
final bytes = utf8.encode(jsonStr);
await _writeCharacteristic!.write(bytes);
}
// 断开连接
Future<void> disconnect() async {
await _connectedDevice?.disconnect();
_connectedDevice = null;
_writeCharacteristic = null;
}
void dispose() {
_dataController.close();
disconnect();
}
}
```
### screens/home/home_screen.dart
```dart
import 'package:flutter/material.dart';
import 'package:flutter_riverpod/flutter_riverpod.dart';
import 'package:go_router/go_router.dart';
class HomeScreen extends ConsumerWidget {
const HomeScreen({super.key});
@override
Widget build(BuildContext context, WidgetRef ref) {
return Scaffold(
appBar: AppBar(
title: const Text('AISee'),
actions: [
IconButton(
icon: const Icon(Icons.bluetooth),
onPressed: () => context.push('/bluetooth'),
),
IconButton(
icon: const Icon(Icons.settings),
onPressed: () => context.push('/settings'),
),
],
),
body: Padding(
padding: const EdgeInsets.all(16.0),
child: Column(
crossAxisAlignment: CrossAxisAlignment.stretch,
children: [
// 状态卡片
Card(
child: Padding(
padding: const EdgeInsets.all(16.0),
child: Column(
children: [
const Icon(Icons.visibility, size: 48, color: Colors.blue),
const SizedBox(height: 8),
Text(
'AISee 视觉辅助',
style: Theme.of(context).textTheme.headlineSmall,
),
const SizedBox(height: 4),
const Text('眼镜未连接', style: TextStyle(color: Colors.grey)),
],
),
),
),
const SizedBox(height: 24),
// 功能按钮
Expanded(
child: GridView.count(
crossAxisCount: 2,
mainAxisSpacing: 12,
crossAxisSpacing: 12,
children: [
_FeatureCard(
icon: Icons.camera_alt,
label: '拍照识别',
color: Colors.blue,
onTap: () => context.push('/camera'),
),
_FeatureCard(
icon: Icons.text_fields,
label: '文字识别',
color: Colors.green,
onTap: () => context.push('/camera'),
),
_FeatureCard(
icon: Icons.landscape,
label: '场景理解',
color: Colors.orange,
onTap: () => context.push('/camera'),
),
_FeatureCard(
icon: Icons.history,
label: '历史记录',
color: Colors.purple,
onTap: () => context.push('/history'),
),
],
),
),
],
),
),
);
}
}
class _FeatureCard extends StatelessWidget {
final IconData icon;
final String label;
final Color color;
final VoidCallback onTap;
const _FeatureCard({
required this.icon,
required this.label,
required this.color,
required this.onTap,
});
@override
Widget build(BuildContext context) {
return Card(
elevation: 2,
child: InkWell(
onTap: onTap,
borderRadius: BorderRadius.circular(12),
child: Column(
mainAxisAlignment: MainAxisAlignment.center,
children: [
Icon(icon, size: 48, color: color),
const SizedBox(height: 8),
Text(label, style: Theme.of(context).textTheme.titleMedium),
],
),
),
);
}
}
```
### 其他页面占位
```dart
// screens/camera/camera_screen.dart
import 'package:flutter/material.dart';
import 'package:flutter_riverpod/flutter_riverpod.dart';
class CameraScreen extends ConsumerWidget {
const CameraScreen({super.key});
@override
Widget build(BuildContext context, WidgetRef ref) {
return Scaffold(
appBar: AppBar(title: const Text('拍照识别')),
body: const Center(child: Text('相机页面 - 待开发')),
);
}
}
// screens/analysis/analysis_screen.dart
import 'package:flutter/material.dart';
import 'package:flutter_riverpod/flutter_riverpod.dart';
class AnalysisScreen extends ConsumerWidget {
const AnalysisScreen({super.key});
@override
Widget build(BuildContext context, WidgetRef ref) {
return Scaffold(
appBar: AppBar(title: const Text('分析结果')),
body: const Center(child: Text('分析结果页面 - 待开发')),
);
}
}
// screens/history/history_screen.dart
import 'package:flutter/material.dart';
import 'package:flutter_riverpod/flutter_riverpod.dart';
class HistoryScreen extends ConsumerWidget {
const HistoryScreen({super.key});
@override
Widget build(BuildContext context, WidgetRef ref) {
return Scaffold(
appBar: AppBar(title: const Text('历史记录')),
body: const Center(child: Text('历史记录页面 - 待开发')),
);
}
}
// screens/settings/settings_screen.dart
import 'package:flutter/material.dart';
import 'package:flutter_riverpod/flutter_riverpod.dart';
class SettingsScreen extends ConsumerWidget {
const SettingsScreen({super.key});
@override
Widget build(BuildContext context, WidgetRef ref) {
return Scaffold(
appBar: AppBar(title: const Text('设置')),
body: const Center(child: Text('设置页面 - 待开发')),
);
}
}
// screens/bluetooth/bluetooth_screen.dart
import 'package:flutter/material.dart';
import 'package:flutter_riverpod/flutter_riverpod.dart';
class BluetoothScreen extends ConsumerWidget {
const BluetoothScreen({super.key});
@override
Widget build(BuildContext context, WidgetRef ref) {
return Scaffold(
appBar: AppBar(title: const Text('蓝牙连接')),
body: const Center(child: Text('蓝牙连接页面 - 待开发')),
);
}
}
```
## 5. Android 权限配置
### android/app/src/main/AndroidManifest.xml 添加权限
```xml
<!-- 在 <manifest> 标签内添加 -->
<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.CAMERA" />
<uses-permission android:name="android.permission.BLUETOOTH" />
<uses-permission android:name="android.permission.BLUETOOTH_ADMIN" />
<uses-permission android:name="android.permission.BLUETOOTH_CONNECT" />
<uses-permission android:name="android.permission.BLUETOOTH_SCAN" />
<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
<uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
<uses-permission android:name="android.permission.RECORD_AUDIO" />
<uses-feature android:name="android.hardware.camera" android:required="true" />
<uses-feature android:name="android.hardware.bluetooth_le" android:required="true" />
```
### android/app/build.gradle 修改最低 SDK
```groovy
android {
defaultConfig {
minSdkVersion 21 // 改为 21
}
}
```
## 6. 初始化项目命令
```bash
# 1. 创建项目
cd C:\Users\xdedmi\Desktop\aisee
flutter create --org com.aisee --project-name aisee_app --platforms android,ios aisee_app
cd aisee_app
# 2. 获取依赖
flutter pub get
# 3. 运行代码生成（freezed、json_serializable）
dart run build_runner build --delete-conflicting-outputs
# 4. 运行项目
flutter run
# 5. 运行测试
flutter test
```
## 7. Git 初始化
```bash
cd C:\Users\xdedmi\Desktop\aisee\aisee_app
git init
git add .
git commit -m "feat: 初始化 AISee Flutter 项目"
```
## 8. 开发顺序建议
```
第 1 周：项目搭建 + 首页 UI
第 2 周：相机模块 + 拍照功能
第 3 周：API 对接 + 图像上传
第 4 周：AI 分析结果展示
第 5 周：蓝牙通信模块
第 6 周：语音播报 + 历史记录
第 7 周：设置页面 + 优化
第 8 周：测试 + Bug 修复
```
---
**提示**：先运行 `flutter pub get` 安装依赖，然后按照目录结构创建文件，逐步填充代码。

107
技术文档/README.md Normal file
View File

@@ -0,0 +1,107 @@
# AISee 项目文档索引
欢迎来到 AISee（AI 视觉辅助眼镜）项目！
## 项目简介
AISee 是一个基于 AI 视觉识别的智能眼镜系统，通过 AR 眼镜采集实时图像，利用人工智能进行场景理解和内容识别，并将分析结果以增强现实的方式呈现给用户。主要服务于视障人士、老年人及专业工作场景。
## 核心特性
- 🔍 **实时物体识别**：识别日常物品并语音播报
- 📖 **智能文字识别**：OCR 识别并朗读各类文字
- 🌍 **场景理解**：理解环境并提供上下文信息
- 👤 **人脸识别**：识别熟人并辅助社交
- 🧭 **导航辅助**：AR 导航和障碍物预警
- 🤖 **智能助手**：基于大模型的对话式 AI
## 文档导航
### 📋 项目规划类
- **[项目概述](./项目概述.md)** - 项目背景、目标、价值主张和系统架构
- **[项目规划](./项目规划.md)** - 详细的实施计划、团队组织、时间表和预算
### 🛠️ 技术类
- **[技术选型](./技术选型.md)** - 硬件、软件、AI 模型、云服务等技术栈选择
- **[技术方案](./技术方案.md)** - 系统架构设计、核心模块实现、性能优化方案
### 📱 产品类
- **[产品方案](./产品方案.md)** - 产品定位、功能设计、用户体验、商业模式
## 快速开始
### 了解项目
1. 先阅读 [项目概述](./项目概述.md) 了解项目背景和目标
2. 查看 [产品方案](./产品方案.md) 理解产品功能和用户体验
3. 参考 [技术选型](./技术选型.md) 了解技术栈
### 技术实现
1. 阅读 [技术方案](./技术方案.md) 了解系统架构
2. 查看 [项目规划](./项目规划.md) 了解开发计划
3. 开始编码实现
### 项目管理
1. 参考 [项目规划](./项目规划.md) 中的团队组织和时间表
2. 按照里程碑推进项目
3. 定期回顾和调整
## 技术栈概览
### 硬件
- AR 眼镜：Rokid Air / Xreal Air
- 移动设备：Android / iOS 手机
### 移动端
- Android：Kotlin + Jetpack Compose + MVVM
- iOS：Swift + SwiftUI + Combine
### 后端
- 框架：Python + FastAPI
- 数据库：PostgreSQL + Redis
- 存储：MinIO / 阿里云 OSS
### AI 模型
- 物体检测：YOLO v8
- 文字识别：PaddleOCR
- 场景理解：CLIP、BLIP-2
- 大语言模型：GPT-4 Vision / Qwen-VL
### 云服务
- 推荐：阿里云（ECS、OSS、RDS）
- 备选：AWS（EC2、S3、RDS）
## 项目阶段
```
第一阶段（2个月） ：需求调研与设计
第二阶段（3个月） ：MVP 开发
第三阶段（2个月） ：测试与迭代
第四阶段（4个月） ：v1.0 开发
第五阶段（2个月） ：公测与上线
第六阶段（6+个月） ：持续迭代
```
## 联系方式
- 项目负责人：[待定]
- 技术负责人：[待定]
- 产品负责人：[待定]
## 贡献指南
欢迎团队成员贡献代码和文档！
1. Fork 项目仓库
2. 创建功能分支
3. 提交代码并编写测试
4. 发起 Pull Request
5. 等待代码审查
## 许可证
[待定]
---
**最后更新**：2026-03-02
**文档版本**：v1.0

479
技术文档/产品方案.md Normal file
View File

@@ -0,0 +1,479 @@
# AISee 产品方案
## 产品定位
AISee 是一款面向视觉辅助场景的智能 AR 眼镜系统，通过 AI 技术为用户提供实时的视觉信息解读和增强现实体验。
### 目标用户
1. **视障人群**（核心用户）
- 全盲或低视力人士
- 需要日常生活辅助
- 年龄：18-65 岁
2. **老年人群**
- 视力退化
- 需要阅读辅助
- 年龄：60+ 岁
3. **专业人士**
- 工业检测人员
- 医疗工作者
- 物流仓储人员
4. **普通消费者**
- 旅游爱好者
- 学习者
- 科技爱好者
## 核心功能
### 1. 物体识别
#### 功能描述
实时识别用户视野中的物体，并通过语音或 AR 标注告知用户。
#### 使用场景
- **日常生活**："前方是一把椅子，距离约 2 米"
- **购物场景**："这是一瓶可口可乐，500ml，价格 3.5 元"
- **厨房场景**："这是番茄酱，保质期至 2026 年 12 月"
#### 交互方式
```
用户动作：注视物体 2 秒
系统反馈：
- 视觉：绿色边框标注物体
- 听觉：语音播报"这是一个水杯"
- 触觉：轻微震动确认
```
#### 识别类别
- 日常用品（100+ 类）
- 食品饮料（200+ 类）
- 交通工具（50+ 类）
- 动植物（500+ 类）
- 自定义物体（用户训练）
### 2. 文字识别（OCR）
#### 功能描述
识别并朗读各类文字内容，支持中英文及多种语言。
#### 使用场景
- **阅读书籍**：实时朗读书本内容
- **查看标识**：识别路牌、门牌号、商店名称
- **读取文档**：身份证、银行卡、账单等
- **产品信息**：食品标签、药品说明书
#### 交互方式
```
触发方式：
1. 语音指令："读一下这个"
2. 手势：双击眼镜侧边
3. 自动：检测到文字区域自动识别
输出方式：
- 语音朗读（可调速度）
- AR 文字高亮
- 翻译功能（多语言）
```
#### 特色功能
- **智能断句**：自然语音朗读
- **重点标注**：价格、日期、重要信息高亮
- **实时翻译**：外语即时翻译
- **文字搜索**：查找特定关键词
### 3. 场景理解
#### 功能描述
理解当前环境的整体情况，提供上下文相关的信息和建议。
#### 使用场景
- **环境感知**："您现在在一个咖啡厅，前方有空座位"
- **安全提示**："前方有台阶，请小心"
- **导航辅助**："出口在您的右前方，约 10 米"
- **社交场景**："对面有 3 个人正在交谈"
#### 智能分析
```
场景：用户进入餐厅
系统分析：
1. 环境类型：餐厅
2. 人员情况：约 20 人，较拥挤
3. 空间布局：前方有空桌，右侧是收银台
4. 建议行动："建议向前走 5 米，左侧有空位"
```
### 4. 人脸识别
#### 功能描述
识别熟人并提供身份信息，辅助社交互动。
#### 使用场景
- **熟人识别**："前方是您的朋友张三"
- **陌生人提示**："前方有一位陌生人正在接近"
- **表情识别**："对方正在微笑"
- **人数统计**："当前视野内有 5 个人"
#### 隐私保护
- 仅识别已授权的联系人
- 本地存储人脸特征
- 不上传原始人脸图像
- 用户可随时删除数据
### 5. 导航辅助
#### 功能描述
结合 GPS 和视觉信息，提供精准的室内外导航。
#### 功能特点
- **AR 箭头指引**：实时显示行走方向
- **障碍物预警**：提前提示障碍物
- **路径规划**：无障碍路线优先
- **语音导航**：详细的转向指令
#### 交互示例
```
用户："导航到最近的地铁站"
系统：
1. 规划路线（800 米，预计 10 分钟）
2. AR 显示：蓝色箭头指向前方
3. 语音："直行 50 米后右转"
4. 实时更新：距离目的地还有 750 米
```
### 6. 智能助手
#### 功能描述
基于大语言模型的对话式 AI 助手，回答用户问题。
#### 使用场景
- **信息查询**："这个水果叫什么名字？"
- **使用指导**："这个药怎么吃？"
- **知识问答**："这是什么建筑？"
- **生活建议**："这件衣服适合什么场合穿？"
#### 对话示例
```
用户："这是什么花？"
助手："这是向日葵，属于菊科植物。向日葵的花朵会随着太阳转动，
因此得名。它的种子可以食用，也可以榨油。"
用户："怎么养护？"
助手："向日葵喜欢阳光充足的环境，需要每天浇水，保持土壤湿润。
生长期需要施肥，大约 2-3 个月就能开花。"
```
## 产品功能架构
```
┌─────────────────────────────────────────────────────────┐
│ AISee 产品功能 │
├─────────────────────────────────────────────────────────┤
│ 核心功能层 │
│ ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐ │
│ │物体识别 │ │文字识别 │ │场景理解 │ │人脸识别 │ │
│ └──────────┘ └──────────┘ └──────────┘ └──────────┘ │
├─────────────────────────────────────────────────────────┤
│ 辅助功能层 │
│ ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐ │
│ │导航辅助 │ │智能助手 │ │语音交互 │ │历史记录 │ │
│ └──────────┘ └──────────┘ └──────────┘ └──────────┘ │
├─────────────────────────────────────────────────────────┤
│ 个性化层 │
│ ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐ │
│ │用户设置 │ │自定义训练│ │场景模式 │ │数据管理 │ │
│ └──────────┘ └──────────┘ └──────────┘ └──────────┘ │
└─────────────────────────────────────────────────────────┘
```
## 用户体验设计
### 1. 交互方式
#### 语音交互（主要）
```
唤醒词："小 AI" / "AISee"
常用指令：
- "这是什么？"
- "读一下"
- "导航到..."
- "识别人脸"
- "切换到阅读模式"
```
#### 手势交互
```
- 单击侧边按钮：拍照识别
- 双击侧边按钮：OCR 识别
- 长按侧边按钮：语音助手
- 滑动触控板：调整音量
```
#### 头部动作
```
- 点头：确认
- 摇头：取消
- 注视 2 秒：选择/识别
```
### 2. 反馈机制
#### 多模态反馈
```
视觉反馈：
- AR 标注（边框、文字、箭头）
- 颜色编码（绿色=安全，红色=警告，蓝色=信息）
- 动画效果（淡入淡出、闪烁）
听觉反馈：
- 语音播报（自然语音合成）
- 提示音（成功、失败、警告）
- 空间音频（方向提示）
触觉反馈：
- 震动模式（不同强度和节奏）
- 确认震动、警告震动
```
### 3. 场景模式
#### 预设模式
```
1. 日常模式（默认）
- 平衡识别速度和准确度
- 所有功能开启
- 适合日常使用
2. 阅读模式
- OCR 优先
- 自动朗读
- 减少其他提示
3. 导航模式
- 障碍物检测优先
- 路径指引
- 简化其他信息
4. 社交模式
- 人脸识别优先
- 表情分析
- 社交场景理解
5. 省电模式
- 降低识别频率
- 减少 AR 显示
- 延长续航时间
```
### 4. 界面设计原则
#### AR 显示原则
- **简洁优先**：避免信息过载
- **对比度高**：确保可见性
- **动态调整**：根据环境光自动调整
- **分层显示**：重要信息优先
#### 无障碍设计
- **大字体**：最小 24pt
- **高对比度**：4.5:1 以上
- **语音优先**：所有功能支持语音
- **简化操作**：减少复杂手势
## 产品路线图
### MVP 版本（v0.1 - 3 个月）
#### 核心功能
- ✅ 基础物体识别（50 类常见物品）
- ✅ 简单 OCR（中英文）
- ✅ 语音播报
- ✅ 手机 APP（Android）
- ✅ 基础 AR 标注
#### 目标
- 验证技术可行性
- 收集用户反馈
- 完成 100 次测试
### v1.0 版本（6 个月）
#### 新增功能
- 场景理解
- 人脸识别（熟人）
- 导航辅助（基础）
- 智能助手（对话）
- iOS APP
#### 优化
- 识别准确率 > 90%
- 响应时间 < 2 秒
- 续航时间 > 4 小时
#### 目标
- 公测 1000 用户
- 收集 10000+ 使用数据
- 准备商业化
### v2.0 版本（12 个月）
#### 高级功能
- 自定义物体训练
- 室内精准导航
- 多语言支持（10+ 语言）
- 离线模式
- 云端同步
#### 商业化
- 订阅服务
- 企业定制
- 开发者平台
### v3.0 版本（18 个月）
#### 生态建设
- 第三方应用市场
- API 开放平台
- 社区共建
- 硬件升级
## 商业模式
### 1. 硬件销售
#### 产品定价
```
基础版：1999 元
- 标准 AR 眼镜
- 基础功能
- 1 年免费服务
专业版：3999 元
- 高端 AR 眼镜
- 全部功能
- 3 年免费服务
- 优先技术支持
企业版：定制报价
- 批量采购优惠
- 定制化开发
- 专属技术支持
```
### 2. 订阅服务
#### 服务套餐
```
免费版：
- 基础物体识别
- 简单 OCR
- 每日 100 次识别
标准版：29 元/月
- 所有识别功能
- 无限次使用
- 云端存储 10GB
- 历史记录
高级版：99 元/月
- 标准版所有功能
- 自定义训练
- 云端存储 100GB
- 优先处理
- 离线模式
企业版：999 元/月起
- 高级版所有功能
- 私有化部署
- 定制化开发
- 专属客服
- SLA 保障
```
### 3. 增值服务
- **数据标注服务**：为企业提供数据标注
- **模型训练服务**：定制化 AI 模型
- **技术咨询**：AI 视觉解决方案咨询
- **广告合作**：场景化广告推荐
## 竞争分析
### 竞品对比
| 产品 | AISee | Envision Glasses | OrCam MyEye | Seeing AI |
|------|-------|------------------|-------------|-----------|
| 价格 | 1999-3999 元 | $3500 | $4500 | 免费（仅软件）|
| 形态 | AR 眼镜 | 智能眼镜 | 夹扣式 | 手机 APP |
| 物体识别 | ✅ | ✅ | ✅ | ✅ |
| OCR | ✅ | ✅ | ✅ | ✅ |
| 人脸识别 | ✅ | ✅ | ✅ | ✅ |
| AR 显示 | ✅ | ❌ | ❌ | ❌ |
| 导航 | ✅ | 基础 | ❌ | 基础 |
| 中文支持 | ✅ | 有限 | 有限 | ✅ |
| 离线模式 | v2.0 | ✅ | ✅ | 部分 |
### 竞争优势
1. **价格优势**：比国外产品便宜 50%
2. **AR 体验**：独特的增强现实显示
3. **本地化**：更好的中文支持
4. **生态开放**：支持第三方开发
5. **持续更新**：基于云端的 AI 能力持续提升
## 市场策略
### 目标市场
#### 一期市场（国内）
- 中国视障人群：1700 万
- 目标用户：50 万（3%）
- 市场规模：10 亿元
#### 二期市场（海外）
- 全球视障人群：2.85 亿
- 目标用户：100 万
- 市场规模：50 亿元
### 推广策略
1. **公益合作**
- 与残联合作
- 公益捐赠计划
- 免费试用活动
2. **渠道建设**
- 线上：官网、电商平台
- 线下：医疗器械店、眼镜店
- 合作：医院、康复中心
3. **品牌建设**
- 用户故事传播
- 科技媒体报道
- 行业展会参展
4. **社区运营**
- 用户社区
- 开发者社区
- 志愿者网络
## 成功指标
### 产品指标
- 识别准确率 > 95%
- 响应时间 < 1.5 秒
- 用户满意度 > 4.5/5
- 日活跃用户 > 10000
### 商业指标
- 第一年销售 10000 台
- 付费用户转化率 > 30%
- 用户留存率（月）> 80%
- NPS 评分 > 50
### 社会影响
- 帮助 50000+ 视障人士
- 媒体报道 100+ 次
- 获得行业奖项
- 推动无障碍标准制定

543
技术文档/技术方案.md Normal file
View File

@@ -0,0 +1,543 @@
# AISee 技术实现方案
## 系统架构设计
### 整体架构图
```
┌─────────────────────────────────────────────────────────────┐
│ 用户层 │
│ AR 智能眼镜 │
│ ┌──────────────┐ ┌──────────────┐ ┌──────────────┐ │
│ │ 摄像头模块 │ │ 显示模块 │ │ 传感器模块 │ │
│ └──────────────┘ └──────────────┘ └──────────────┘ │
└─────────────────────────────────────────────────────────────┘
↕ (蓝牙/WiFi)
┌─────────────────────────────────────────────────────────────┐
│ 移动端层 │
│ 手机 APP │
│ ┌──────────────────────────────────────────────────────┐ │
│ │ UI 层：用户界面、设置、历史记录 │ │
│ ├──────────────────────────────────────────────────────┤ │
│ │ 业务层：图像处理、数据管理、设备通信 │ │
│ ├──────────────────────────────────────────────────────┤ │
│ │ 数据层：本地缓存、数据库、网络请求 │ │
│ └──────────────────────────────────────────────────────┘ │
└─────────────────────────────────────────────────────────────┘
↕ (HTTPS/WebSocket)
┌─────────────────────────────────────────────────────────────┐
│ 云端层 │
│ ┌──────────────┐ ┌──────────────┐ ┌──────────────┐ │
│ │ API 网关 │ │ 负载均衡 │ │ CDN │ │
│ └──────────────┘ └──────────────┘ └──────────────┘ │
│ ┌──────────────────────────────────────────────────────┐ │
│ │ 应用服务层 │ │
│ │ ┌────────────┐ ┌────────────┐ ┌────────────┐ │ │
│ │ │ 图像服务 │ │ AI 服务 │ │ 用户服务 │ │ │
│ │ └────────────┘ └────────────┘ └────────────┘ │ │
│ └──────────────────────────────────────────────────────┘ │
│ ┌──────────────────────────────────────────────────────┐ │
│ │ AI 推理层 │ │
│ │ ┌────────────┐ ┌────────────┐ ┌────────────┐ │ │
│ │ │ 物体识别 │ │ OCR 识别 │ │ 场景理解 │ │ │
│ │ └────────────┘ └────────────┘ └────────────┘ │ │
│ └──────────────────────────────────────────────────────┘ │
│ ┌──────────────────────────────────────────────────────┐ │
│ │ 数据层 │ │
│ │ ┌────────────┐ ┌────────────┐ ┌────────────┐ │ │
│ │ │ PostgreSQL │ │ Redis │ │ OSS │ │ │
│ │ └────────────┘ └────────────┘ └────────────┘ │ │
│ └──────────────────────────────────────────────────────┘ │
└─────────────────────────────────────────────────────────────┘
```
## 核心模块设计
### 1. 图像采集与传输模块
#### 眼镜端
```python
# 伪代码示例
class CameraModule:
def __init__(self):
self.camera = Camera(resolution="1920x1080", fps=30)
self.encoder = H264Encoder()
def capture_frame(self):
"""采集单帧图像"""
frame = self.camera.read()
return self.preprocess(frame)
def preprocess(self, frame):
"""图像预处理"""
# 1. 调整分辨率（降低到 640x480 以减少传输）
frame = resize(frame, (640, 480))
# 2. 压缩质量优化
frame = compress(frame, quality=85)
return frame
def stream_to_phone(self):
"""实时流传输"""
while True:
frame = self.capture_frame()
self.bluetooth.send(frame)
time.sleep(0.033) # 30fps
```
#### 手机端接收
```kotlin
// Android 示例
class ImageReceiver(private val bluetoothSocket: BluetoothSocket) {
private val imageQueue = LinkedBlockingQueue<ByteArray>(10)
fun startReceiving() {
CoroutineScope(Dispatchers.IO).launch {
val inputStream = bluetoothSocket.inputStream
while (isActive) {
val imageData = readImageData(inputStream)
imageQueue.offer(imageData)
}
}
}
fun getNextImage(): ByteArray? {
return imageQueue.poll(100, TimeUnit.MILLISECONDS)
}
}
```
### 2. 手机 APP 架构
#### 目录结构
```
app/
├── data/
│ ├── local/ # 本地数据源
│ │ ├── database/ # Room 数据库
│ │ └── cache/ # 图像缓存
│ ├── remote/ # 远程数据源
│ │ ├── api/ # API 接口
│ │ └── websocket/ # WebSocket 连接
│ └── repository/ # 数据仓库
├── domain/
│ ├── model/ # 领域模型
│ ├── usecase/ # 业务用例
│ └── repository/ # 仓库接口
├── presentation/
│ ├── main/ # 主界面
│ ├── settings/ # 设置界面
│ ├── history/ # 历史记录
│ └── viewmodel/ # ViewModel
└── device/
├── bluetooth/ # 蓝牙通信
└── camera/ # 相机处理
```
#### 核心业务流程
```kotlin
class ImageProcessingViewModel @Inject constructor(
private val imageRepository: ImageRepository,
private val aiService: AIService
) : ViewModel() {
private val _aiResult = MutableStateFlow<AIResult?>(null)
val aiResult: StateFlow<AIResult?> = _aiResult.asStateFlow()
fun processImage(imageData: ByteArray) {
viewModelScope.launch {
try {
// 1. 保存到本地缓存
val imageId = imageRepository.saveImage(imageData)
// 2. 上传到服务器
val uploadResult = imageRepository.uploadImage(imageId, imageData)
// 3. 请求 AI 分析
val result = aiService.analyzeImage(uploadResult.url)
// 4. 更新 UI
_aiResult.value = result
// 5. 发送结果到眼镜
sendToGlasses(result)
} catch (e: Exception) {
handleError(e)
}
}
}
private suspend fun sendToGlasses(result: AIResult) {
val displayData = formatForAR(result)
bluetoothManager.send(displayData)
}
}
```
### 3. 后端 API 设计
#### 项目结构
```
backend/
├── app/
│ ├── api/
│ │ ├── v1/
│ │ │ ├── endpoints/
│ │ │ │ ├── images.py # 图像上传
│ │ │ │ ├── analysis.py # AI 分析
│ │ │ │ └── users.py # 用户管理
│ │ │ └── router.py
│ │ └── deps.py # 依赖注入
│ ├── core/
│ │ ├── config.py # 配置
│ │ ├── security.py # 安全
│ │ └── celery_app.py # 异步任务
│ ├── models/
│ │ ├── user.py
│ │ ├── image.py
│ │ └── analysis.py
│ ├── schemas/
│ │ ├── image.py # Pydantic 模型
│ │ └── analysis.py
│ ├── services/
│ │ ├── ai/
│ │ │ ├── object_detection.py
│ │ │ ├── ocr.py
│ │ │ ├── scene_understanding.py
│ │ │ └── model_manager.py
│ │ ├── storage.py # 对象存储
│ │ └── cache.py # 缓存服务
│ └── main.py
├── tests/
├── requirements.txt
└── Dockerfile
```
#### API 端点设计
```python
from fastapi import FastAPI, UploadFile, File, BackgroundTasks
from app.services.ai import AIService
from app.schemas import AnalysisRequest, AnalysisResponse
app = FastAPI(title="AISee API")
@app.post("/api/v1/images/upload")
async def upload_image(
file: UploadFile = File(...),
user_id: str = Depends(get_current_user)
):
"""上传图像"""
# 1. 验证图像格式
validate_image(file)
# 2. 保存到 OSS
image_url = await storage_service.upload(file)
# 3. 保存元数据到数据库
image_record = await db.images.create({
"user_id": user_id,
"url": image_url,
"uploaded_at": datetime.now()
})
return {"image_id": image_record.id, "url": image_url}
@app.post("/api/v1/analysis/analyze", response_model=AnalysisResponse)
async def analyze_image(
request: AnalysisRequest,
background_tasks: BackgroundTasks
):
"""AI 图像分析"""
# 1. 获取图像
image = await storage_service.download(request.image_url)
# 2. 并行执行多个 AI 任务
results = await asyncio.gather(
ai_service.detect_objects(image),
ai_service.recognize_text(image),
ai_service.understand_scene(image)
)
# 3. 合并结果
analysis_result = merge_results(results)
# 4. 异步保存到数据库
background_tasks.add_task(save_analysis, analysis_result)
return analysis_result
@app.websocket("/ws/realtime")
async def websocket_endpoint(websocket: WebSocket):
"""实时分析 WebSocket"""
await websocket.accept()
try:
while True:
# 接收图像数据
data = await websocket.receive_bytes()
# 快速分析
result = await ai_service.quick_analyze(data)
# 返回结果
await websocket.send_json(result)
except WebSocketDisconnect:
pass
```
### 4. AI 推理服务设计
#### 模型管理器
```python
class ModelManager:
def __init__(self):
self.models = {}
self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
def load_models(self):
"""加载所有模型"""
# 物体检测模型
self.models['yolo'] = YOLO('yolov8n.pt').to(self.device)
# OCR 模型
self.models['ocr'] = PaddleOCR(use_angle_cls=True, lang='ch')
# 场景理解模型
self.models['clip'] = CLIPModel.from_pretrained("openai/clip-vit-base-patch32")
# 多模态大模型
self.models['llm'] = load_qwen_vl_model()
def get_model(self, model_name: str):
return self.models.get(model_name)
class AIService:
def __init__(self):
self.model_manager = ModelManager()
self.model_manager.load_models()
async def detect_objects(self, image: np.ndarray) -> List[Detection]:
"""物体检测"""
model = self.model_manager.get_model('yolo')
results = model(image)
detections = []
for r in results:
boxes = r.boxes
for box in boxes:
detections.append({
"class": box.cls,
"confidence": box.conf,
"bbox": box.xyxy.tolist(),
"label": model.names[int(box.cls)]
})
return detections
async def recognize_text(self, image: np.ndarray) -> List[TextRegion]:
"""文字识别"""
ocr = self.model_manager.get_model('ocr')
result = ocr.ocr(image, cls=True)
text_regions = []
for line in result[0]:
text_regions.append({
"text": line[1][0],
"confidence": line[1][1],
"bbox": line[0]
})
return text_regions
async def understand_scene(self, image: np.ndarray) -> SceneDescription:
"""场景理解"""
# 使用多模态大模型生成场景描述
llm = self.model_manager.get_model('llm')
prompt = "请详细描述这张图片中的场景、物体和可能的上下文信息。"
description = llm.generate(image, prompt)
return {
"description": description,
"tags": extract_tags(description),
"sentiment": analyze_sentiment(description)
}
```
### 5. AR 显示模块
#### 数据格式设计
```json
{
"type": "ar_overlay",
"timestamp": 1234567890,
"elements": [
{
"id": "obj_001",
"type": "bounding_box",
"position": {"x": 100, "y": 150, "width": 200, "height": 300},
"label": "水杯",
"confidence": 0.95,
"color": "#00FF00"
},
{
"id": "text_001",
"type": "text_overlay",
"position": {"x": 50, "y": 50},
"content": "前方有台阶，请小心",
"font_size": 24,
"color": "#FF0000",
"duration": 3000
},
{
"id": "arrow_001",
"type": "direction_arrow",
"start": {"x": 320, "y": 240},
"end": {"x": 400, "y": 240},
"label": "出口方向"
}
]
}
```
#### 眼镜端渲染
```python
class ARRenderer:
def __init__(self, display):
self.display = display
self.overlay_queue = queue.Queue()
def render_frame(self, camera_frame, ar_data):
"""渲染 AR 叠加层"""
# 1. 绘制原始相机画面
frame = camera_frame.copy()
# 2. 绘制 AR 元素
for element in ar_data['elements']:
if element['type'] == 'bounding_box':
self.draw_bbox(frame, element)
elif element['type'] == 'text_overlay':
self.draw_text(frame, element)
elif element['type'] == 'direction_arrow':
self.draw_arrow(frame, element)
# 3. 显示到眼镜屏幕
self.display.show(frame)
def draw_bbox(self, frame, element):
"""绘制边界框"""
pos = element['position']
cv2.rectangle(
frame,
(pos['x'], pos['y']),
(pos['x'] + pos['width'], pos['y'] + pos['height']),
self.hex_to_rgb(element['color']),
2
)
# 绘制标签
cv2.putText(
frame,
f"{element['label']} {element['confidence']:.2f}",
(pos['x'], pos['y'] - 10),
cv2.FONT_HERSHEY_SIMPLEX,
0.5,
self.hex_to_rgb(element['color']),
2
)
```
## 性能优化方案
### 1. 图像传输优化
- 使用 H.264 硬件编码
- 动态调整分辨率和帧率
- 实现智能跳帧机制
- 使用 WiFi Direct 替代蓝牙（高带宽场景）
### 2. AI 推理优化
- 模型量化（INT8）
- 批处理推理
- 模型缓存和预热
- GPU 并行计算
- 使用 TensorRT 加速
### 3. 网络优化
- CDN 加速静态资源
- 图像压缩和格式优化（WebP）
- HTTP/2 多路复用
- 请求合并和批处理
- 智能重试机制
### 4. 缓存策略
```python
# 多级缓存
class CacheStrategy:
def __init__(self):
self.l1_cache = LRUCache(maxsize=100) # 内存缓存
self.l2_cache = RedisCache() # Redis 缓存
self.l3_cache = DatabaseCache() # 数据库
async def get(self, key):
# L1 缓存
if key in self.l1_cache:
return self.l1_cache[key]
# L2 缓存
value = await self.l2_cache.get(key)
if value:
self.l1_cache[key] = value
return value
# L3 缓存
value = await self.l3_cache.get(key)
if value:
await self.l2_cache.set(key, value, ttl=3600)
self.l1_cache[key] = value
return value
```
## 安全方案
### 1. 数据传输安全
- TLS 1.3 加密
- 证书固定（Certificate Pinning）
- 请求签名验证
### 2. 隐私保护
- 图像本地处理优先
- 敏感信息脱敏
- 用户数据加密存储
- 定期数据清理
### 3. 访问控制
- JWT 认证
- OAuth 2.0 授权
- API 限流
- IP 白名单
## 监控与运维
### 1. 性能监控
```python
# 关键指标
metrics = {
"image_upload_latency": Histogram(),
"ai_inference_time": Histogram(),
"api_response_time": Histogram(),
"error_rate": Counter(),
"active_users": Gauge()
}
```
### 2. 日志系统
- 结构化日志（JSON 格式）
- 分级日志（DEBUG/INFO/WARN/ERROR）
- 日志聚合和分析
- 告警机制
### 3. 容灾方案
- 服务降级
- 熔断机制
- 限流保护
- 数据备份

175
技术文档/技术选型.md Normal file
View File

@@ -0,0 +1,175 @@
# AISee 技术选型方案
## 1. AR 眼镜硬件选型
### 推荐方案
**Rokid Air / Xreal Air**
- 轻量化设计（约 80g）
- 支持蓝牙和 USB-C 连接
- 1080p 显示分辨率
- 内置摄像头（部分型号）
- 价格适中（2000-3000元）
### 备选方案
- **RealWear HMT-1**：工业级，更耐用但较重
- **Vuzix Blade**：集成度高但价格较贵
- **自研方案**：基于树莓派 + 微型显示器（成本可控但开发周期长）
## 2. 移动端技术栈（Flutter 跨平台）
### 选型理由
- 一套代码同时支持 Android 和 iOS，快速验证产品
- Dart 语言性能接近原生，热重载提升开发效率
- 丰富的插件生态，蓝牙、相机等硬件访问成熟
- 社区活跃，问题解决快
### 核心框架
```
语言：Dart 3.2+
框架：Flutter 3.16+
状态管理：Riverpod 2.x
路由：GoRouter
网络请求：Dio
WebSocket：web_socket_channel
本地存储：Hive + sqflite
JSON 序列化：freezed + json_serializable
```
### 硬件交互
```
相机：camera 插件
蓝牙：flutter_blue_plus
权限管理：permission_handler
语音合成：flutter_tts
图片处理：image
```
### UI 相关
```
设计规范：Material Design 3
图片加载：cached_network_image
字体：google_fonts
图标：cupertino_icons + flutter_svg
```
### 开发工具
```
IDE：VS Code + Flutter/Dart 插件
代码生成：build_runner
代码规范：flutter_lints
测试：mockito + mocktail
```
## 3. 后端技术栈
### 核心框架
```
语言：Python 3.11+
Web 框架：FastAPI
异步处理：asyncio + uvicorn
任务队列：Celery + Redis
数据库：PostgreSQL 15
缓存：Redis 7
对象存储：MinIO / 阿里云 OSS
```
### AI 推理服务
```
深度学习框架：PyTorch 2.0+
模型服务：TorchServe / TensorRT
GPU 加速：CUDA 12.0+
模型管理：MLflow
```
## 4. AI 模型选型
### 视觉识别模型
#### 物体检测
- **YOLO v8**：实时性好，精度高
- **EfficientDet**：移动端友好
- **Faster R-CNN**：高精度场景
#### 文字识别（OCR）
- **PaddleOCR**：中文支持好，开源免费
- **EasyOCR**：多语言支持
- **Tesseract**：传统方案，稳定可靠
#### 场景理解
- **CLIP**（OpenAI）：图文匹配，零样本学习
- **BLIP-2**：图像描述生成
- **SAM**（Segment Anything）：通用分割
#### 人脸识别
- **InsightFace**：高精度，商用友好
- **FaceNet**：经典方案
- **RetinaFace**：人脸检测
### 大语言模型（LLM）
- **GPT-4 Vision**：最强理解能力（API 调用）
- **Claude 3**：视觉理解能力强
- **Qwen-VL**：国产开源，可私有化部署
- **LLaVA**：开源多模态模型
## 5. 云服务选型
### 推荐：阿里云
```
计算：ECS（GPU 实例 - GN7i）
存储：OSS
数据库：RDS PostgreSQL
缓存：Redis 企业版
CDN：阿里云 CDN
负载均衡：SLB
```
### 备选：AWS
```
计算：EC2（g4dn 实例）
存储：S3
数据库：RDS
缓存：ElastiCache
CDN：CloudFront
负载均衡：ALB
```
## 6. 通信协议
### 眼镜 ↔ 手机
- **蓝牙 BLE**：低功耗，适合控制指令
- **WiFi Direct**：高带宽，适合图像传输
- **USB-C**：有线连接，最稳定
### 手机 ↔ 后端
- **HTTP/2 + gRPC**：API 调用
- **WebSocket**：实时双向通信
- **MQTT**：轻量级消息推送
## 7. 开发工具链
### 版本控制
- Git + GitHub / GitLab
### CI/CD
- GitHub Actions / GitLab CI
- Docker + Kubernetes
### 监控运维
- Prometheus + Grafana（监控）
- ELK Stack（日志）
- Sentry（错误追踪）
### 协作工具
- Jira（项目管理）
- Confluence（文档）
- Figma（设计）
- Postman（API 测试）
## 8. 技术选型原则
1. **优先开源**：降低成本，避免供应商锁定
2. **成熟稳定**：选择经过验证的技术栈
3. **性能优先**：实时性是核心需求
4. **可扩展性**：支持未来功能扩展
5. **团队熟悉度**：考虑团队技术背景
6. **社区活跃**：便于问题解决和学习

49
技术文档/项目概述.md Normal file
View File

@@ -0,0 +1,49 @@
# AISee - AI 视觉辅助眼镜项目
## 项目简介
AISee 是一个基于 AI 视觉识别的智能眼镜系统，通过 AR 眼镜采集实时图像，利用人工智能进行场景理解和内容识别，并将分析结果以增强现实的方式呈现给用户。
## 核心价值
- **实时视觉辅助**：为视障人士、老年人或特定工作场景提供实时的视觉信息解读
- **智能场景理解**：识别物体、文字、人脸、场景等多维度信息
- **AR 交互体验**：通过 AR 显示技术，将 AI 分析结果直观呈现在用户视野中
- **移动化部署**：基于手机作为计算中枢，降低硬件成本和复杂度
## 应用场景
1. **视障辅助**：帮助视障人士识别物体、阅读文字、导航环境
2. **工业检测**：辅助工人进行设备检查、质量控制
3. **医疗辅助**：手术过程中的信息提示、病历查看
4. **教育培训**：实时翻译、知识标注、学习辅助
5. **旅游导览**：景点识别、历史信息展示、路线导航
## 系统架构概览
```
AR 眼镜 <--蓝牙/WiFi--> 手机 APP <--网络--> 云端 AI 服务
↓ ↓ ↓
图像采集 数据中转 AI 分析
AR 显示 本地处理 模型推理
```
## 项目目标
### 第一阶段（MVP - 3个月）
- 完成基础图像采集和传输
- 实现基本的物体识别和文字识别
- 开发简单的 AR 显示功能
- 完成手机 APP 和后端 API
### 第二阶段（功能完善 - 6个月）
- 增强 AI 识别能力（场景理解、人脸识别）
- 优化 AR 显示效果和交互体验
- 提升系统响应速度和稳定性
- 支持离线模式和边缘计算
### 第三阶段（商业化 - 12个月）
- 多场景适配和定制化
- 大规模部署和性能优化
- 建立生态系统和开发者平台
- 数据安全和隐私保护增强

437
技术文档/项目规划.md Normal file
View File

@@ -0,0 +1,437 @@
# AISee 项目实施计划
## 项目概览
**项目名称**：AISee - AI 视觉辅助眼镜系统
**项目周期**：18 个月
**团队规模**：15-20 人
**预算范围**：500-800 万元
## 团队组织架构
### 核心团队
```
项目负责人（1人）
├── 产品团队（3人）
│ ├── 产品经理（1人）
│ ├── UI/UX 设计师（1人）
│ └── 产品运营（1人）
│
├── 技术团队（10人）
│ ├── 移动端（3人）
│ │ ├── Android 开发（2人）
│ │ └── iOS 开发（1人）
│ │
│ ├── 后端（3人）
│ │ ├── 后端架构师（1人）
│ │ └── 后端开发（2人）
│ │
│ ├── AI 团队（3人）
│ │ ├── AI 算法工程师（2人）
│ │ └── 模型训练工程师（1人）
│ │
│ └── 硬件/嵌入式（1人）
│
├── 测试团队（2人）
│ ├── 测试工程师（1人）
│ └── 质量保证（1人）
│
└── 运维团队（1人）
└── DevOps 工程师（1人）
```
### 外部协作
- **硬件供应商**：AR 眼镜制造商
- **云服务商**：阿里云/AWS
- **数据标注**：外包团队
- **法律顾问**：知识产权、隐私合规
- **用户测试**：残联、志愿者组织
## 项目阶段规划
### 第一阶段：需求调研与设计（1-2 个月）
#### 第 1-2 周：市场调研
- [ ] 竞品分析（5 款主要产品）
- [ ] 用户访谈（50+ 目标用户）
- [ ] 需求收集和优先级排序
- [ ] 可行性分析报告
#### 第 3-4 周：产品设计
- [ ] 产品功能规格书（PRD）
- [ ] 用户体验流程图
- [ ] UI/UX 设计稿
- [ ] 交互原型（Figma）
#### 第 5-6 周：技术设计
- [ ] 系统架构设计
- [ ] 技术选型确认
- [ ] 数据库设计
- [ ] API 接口设计
- [ ] 安全方案设计
#### 第 7-8 周：项目准备
- [ ] 开发环境搭建
- [ ] 代码仓库初始化
- [ ] CI/CD 流程建立
- [ ] 项目管理工具配置
- [ ] 团队培训
**交付物**：
- 产品需求文档（PRD）
- 技术架构文档
- UI/UX 设计稿
- 项目计划书
### 第二阶段：MVP 开发（3-5 个月）
#### 第 9-12 周：基础框架搭建
**移动端**
- [ ] Android APP 框架搭建
- [ ] 蓝牙通信模块
- [ ] 图像采集和预处理
- [ ] 基础 UI 界面
**后端**
- [ ] FastAPI 项目初始化
- [ ] 数据库表结构创建
- [ ] 用户认证系统
- [ ] 图像上传 API
- [ ] 对象存储集成
**AI 服务**
- [ ] 模型选型和测试
- [ ] YOLO 物体检测集成
- [ ] PaddleOCR 集成
- [ ] 推理服务搭建
**硬件**
- [ ] AR 眼镜选型和采购
- [ ] 硬件通信协议确认
- [ ] 固件开发（如需要）
#### 第 13-16 周：核心功能开发
**物体识别**
- [ ] 50 类常见物品识别
- [ ] 边界框标注
- [ ] 语音播报
- [ ] 置信度显示
**文字识别**
- [ ] 中英文 OCR
- [ ] 文字区域检测
- [ ] 文字朗读
- [ ] 结果缓存
**AR 显示**
- [ ] 基础 AR 渲染引擎
- [ ] 边界框绘制
- [ ] 文字叠加
- [ ] 颜色和样式
**系统集成**
- [ ] 端到端流程打通
- [ ] 数据流测试
- [ ] 性能初步优化
#### 第 17-20 周：功能完善与优化
- [ ] 用户设置功能
- [ ] 历史记录
- [ ] 错误处理
- [ ] 日志系统
- [ ] 性能优化
- [ ] 内存优化
- [ ] 网络优化
**交付物**：
- MVP 版本（v0.1）
- 技术文档
- 测试报告
- 演示视频
### 第三阶段：测试与迭代（2 个月）
#### 第 21-24 周：内部测试
- [ ] 单元测试（覆盖率 > 80%）
- [ ] 集成测试
- [ ] 性能测试
- [ ] 压力测试
- [ ] 安全测试
- [ ] Bug 修复
#### 第 25-28 周：用户测试
- [ ] 招募测试用户（50 人）
- [ ] 用户培训
- [ ] 实地测试
- [ ] 收集反馈
- [ ] 问题分析
- [ ] 功能迭代
**测试指标**：
- 识别准确率 > 85%
- 响应时间 < 3 秒
- 崩溃率 < 1%
- 用户满意度 > 4.0/5
**交付物**：
- 测试报告
- 用户反馈报告
- 优化方案
### 第四阶段：v1.0 开发（3-4 个月）
#### 第 29-32 周：高级功能开发
**场景理解**
- [ ] 集成多模态大模型
- [ ] 场景描述生成
- [ ] 上下文分析
- [ ] 智能建议
**人脸识别**
- [ ] InsightFace 集成
- [ ] 人脸数据库
- [ ] 熟人识别
- [ ] 隐私保护
**导航辅助**
- [ ] GPS 集成
- [ ] 路径规划
- [ ] AR 导航箭头
- [ ] 障碍物检测
**智能助手**
- [ ] LLM 集成（GPT-4V/Claude）
- [ ] 对话管理
- [ ] 上下文记忆
- [ ] 多轮对话
#### 第 33-36 周：iOS 开发
- [ ] iOS APP 开发
- [ ] 功能对齐
- [ ] 平台适配
- [ ] 测试验证
#### 第 37-40 周：优化与完善
- [ ] 性能深度优化
- [ ] UI/UX 优化
- [ ] 多语言支持
- [ ] 无障碍优化
- [ ] 文档完善
**交付物**：
- v1.0 正式版
- 用户手册
- 开发者文档
- 运营手册
### 第五阶段：公测与上线（2 个月）
#### 第 41-44 周：公测准备
- [ ] 服务器扩容
- [ ] 监控系统完善
- [ ] 客服系统搭建
- [ ] 用户社区建设
- [ ] 营销物料准备
#### 第 45-48 周：公测
- [ ] 招募 1000 名测试用户
- [ ] 灰度发布
- [ ] 问题快速响应
- [ ] 数据分析
- [ ] 持续优化
#### 第 49-52 周：正式上线
- [ ] 全量发布
- [ ] 市场推广
- [ ] 媒体宣传
- [ ] 渠道合作
- [ ] 用户运营
**交付物**：
- 正式产品
- 运营数据报告
- 市场反馈报告
### 第六阶段：持续迭代（6+ 个月）
#### v2.0 规划
- 自定义物体训练
- 离线模式
- 室内精准导航
- 更多语言支持
- 企业定制功能
#### 生态建设
- 开发者平台
- API 开放
- 第三方应用
- 社区运营
## 里程碑与关键节点
| 时间 | 里程碑 | 关键交付 |
|------|--------|----------|
| M1（2个月） | 需求与设计完成 | PRD、架构设计、UI 设计 |
| M2（5个月） | MVP 开发完成 | v0.1 版本、技术验证 |
| M3（7个月） | 测试完成 | 测试报告、用户反馈 |
| M4（11个月） | v1.0 开发完成 | 完整功能版本 |
| M5（13个月） | 公测完成 | 1000 用户验证 |
| M6（14个月） | 正式上线 | 商业化运营 |
| M7（18个月） | v2.0 规划 | 生态建设启动 |
## 风险管理
### 技术风险
| 风险 | 影响 | 概率 | 应对措施 |
|------|------|------|----------|
| AI 识别准确率不达标 | 高 | 中 | 多模型对比、数据增强、持续训练 |
| 实时性能不足 | 高 | 中 | 模型优化、边缘计算、硬件加速 |
| 硬件兼容性问题 | 中 | 高 | 多设备测试、抽象硬件层 |
| 网络延迟影响体验 | 中 | 中 | 本地缓存、离线模式、CDN 加速 |
### 产品风险
| 风险 | 影响 | 概率 | 应对措施 |
|------|------|------|----------|
| 用户需求理解偏差 | 高 | 中 | 持续用户访谈、快速迭代 |
| 竞品快速跟进 | 中 | 中 | 建立技术壁垒、专利保护 |
| 市场接受度低 | 高 | 低 | 公益合作、免费试用、口碑营销 |
### 商业风险
| 风险 | 影响 | 概率 | 应对措施 |
|------|------|------|----------|
| 成本超支 | 中 | 中 | 严格预算控制、分阶段投入 |
| 融资困难 | 高 | 低 | 多渠道融资、政府补贴申请 |
| 法律合规问题 | 高 | 低 | 法律顾问、隐私合规审查 |
### 团队风险
| 风险 | 影响 | 概率 | 应对措施 |
|------|------|------|----------|
| 核心人员流失 | 高 | 低 | 股权激励、团队文化建设 |
| 技能不匹配 | 中 | 中 | 培训、外部专家支持 |
| 沟通协作问题 | 中 | 中 | 敏捷开发、定期会议 |
## 预算规划
### 总预算：500-800 万元
#### 人力成本（60%）：300-480 万元
```
项目负责人：50 万/年
产品团队：30 万/年 × 3 = 90 万
技术团队：35 万/年 × 10 = 350 万
测试团队：25 万/年 × 2 = 50 万
运维团队：30 万/年 × 1 = 30 万
18 个月总计：570 万 × 1.5 年 = 855 万
按 15 人计算：约 640 万（18 个月）
```
#### 硬件成本（15%）：75-120 万元
```
AR 眼镜采购：3000 元 × 50 台 = 15 万
测试设备：20 万
服务器（GPU）：40 万
办公设备：20 万
```
#### 云服务成本（10%）：50-80 万元
```
计算资源（GPU 实例）：3 万/月 × 18 = 54 万
存储（OSS）：5000 元/月 × 18 = 9 万
数据库、缓存等：1 万/月 × 18 = 18 万
```
#### 第三方服务（5%）：25-40 万元
```
AI API 调用（GPT-4V）：2 万/月 × 12 = 24 万
数据标注：10 万
其他 API 服务：6 万
```
#### 营销推广（5%）：25-40 万元
```
市场调研：5 万
公测推广：15 万
媒体宣传：10 万
活动费用：10 万
```
#### 其他费用（5%）：25-40 万元
```
法律咨询：5 万
专利申请：10 万
办公场地：5 万/月 × 18 = 90 万（另计）
差旅费用：10 万
```
## 质量保证
### 代码质量
- 代码审查（Code Review）
- 单元测试覆盖率 > 80%
- 静态代码分析
- 持续集成（CI）
### 产品质量
- 功能测试
- 性能测试
- 兼容性测试
- 用户验收测试（UAT）
### 文档质量
- 技术文档
- API 文档
- 用户手册
- 运维手册
## 项目管理工具
### 开发管理
- **代码管理**：GitHub / GitLab
- **项目管理**：Jira
- **文档协作**：Confluence / 飞书文档
- **设计协作**：Figma
### 沟通协作
- **即时通讯**：Slack / 飞书
- **视频会议**：Zoom / 腾讯会议
- **邮件**：企业邮箱
### 监控运维
- **监控**：Prometheus + Grafana
- **日志**：ELK Stack
- **错误追踪**：Sentry
- **性能分析**：New Relic
## 成功标准
### 技术指标
- ✅ 物体识别准确率 > 90%
- ✅ OCR 识别准确率 > 95%
- ✅ 端到端响应时间 < 2 秒
- ✅ 系统可用性 > 99.5%
- ✅ 崩溃率 < 0.5%
### 产品指标
- ✅ 用户满意度 > 4.5/5
- ✅ 日活跃用户 > 5000
- ✅ 用户留存率（月）> 70%
- ✅ NPS 评分 > 40
### 商业指标
- ✅ 第一年销售 5000 台
- ✅ 付费转化率 > 20%
- ✅ 获得 A 轮融资
- ✅ 建立 3+ 渠道合作
### 社会影响
- ✅ 帮助 10000+ 视障人士
- ✅ 获得 50+ 媒体报道
- ✅ 获得行业奖项
- ✅ 推动无障碍技术发展