266 lines
8.5 KiB
Dart
266 lines
8.5 KiB
Dart
import 'dart:async';
|
|
import 'dart:isolate';
|
|
import 'dart:typed_data';
|
|
|
|
import 'package:camera/camera.dart';
|
|
import 'package:flutter/foundation.dart' show debugPrint;
|
|
import 'package:flutter/services.dart' show rootBundle;
|
|
|
|
import '../camera/motion_detector.dart';
|
|
import 'background_model.dart';
|
|
import 'detection_result.dart';
|
|
import 'tflite_detector.dart';
|
|
import 'visual_prior.dart';
|
|
|
|
/// 推理工作单元：模型加载与检测全部在后台 isolate 执行，
|
|
/// 主 isolate 只投递帧数据、接收结果，UI 不被推理阻塞（iOS 真机卡顿根因）。
|
|
class DetectorWorker {
|
|
static const String modelAsset = 'assets/model.tflite';
|
|
static const String labelsAsset = 'assets/labels.txt';
|
|
|
|
final Isolate _isolate;
|
|
final ReceivePort _responses;
|
|
|
|
final _controlPort = Completer<SendPort>();
|
|
final _ready = Completer<void>();
|
|
|
|
SendPort? _port;
|
|
|
|
/// 在途帧数（主 isolate 侧计数，用于丢帧）
|
|
int _inFlight = 0;
|
|
bool _dead = false;
|
|
|
|
/// 结果回调：结果 / 运动区域 / 新颖区域 / 旋转角 / 图宽 / 图高 / 处理耗时 ms
|
|
void Function(List<DetectionResult>, List<MotionRegion>, List<MotionRegion>,
|
|
int, int, int, int)? onResult;
|
|
|
|
/// 单帧处理异常回调（不影响相机流）
|
|
void Function(String)? onError;
|
|
|
|
/// 最近一次创建失败的诊断原因（UI 展示用）
|
|
static String? lastLoadError;
|
|
|
|
/// worker 最近上报的执行步骤（诊断用）
|
|
static String? lastLog;
|
|
|
|
DetectorWorker._(this._isolate, this._responses) {
|
|
_responses.listen(_onMessage, onDone: () {
|
|
_dead = true;
|
|
if (!_ready.isCompleted) {
|
|
_ready.completeError(StateError('推理进程异常退出'));
|
|
}
|
|
onError?.call('推理进程异常退出');
|
|
});
|
|
}
|
|
|
|
/// 读取模型资产并启动后台推理 isolate；加载失败返回 null（App 降级为仅预览）。
|
|
static Future<DetectorWorker?> create() async {
|
|
try {
|
|
final data = await rootBundle.load(modelAsset);
|
|
final modelBytes =
|
|
data.buffer.asUint8List(data.offsetInBytes, data.lengthInBytes);
|
|
final labels = (await rootBundle.loadString(labelsAsset))
|
|
.split('\n')
|
|
.where((l) => l.trim().isNotEmpty)
|
|
.toList();
|
|
|
|
final responses = ReceivePort();
|
|
final isolate = await Isolate.spawn(_workerMain, responses.sendPort);
|
|
final worker = DetectorWorker._(isolate, responses);
|
|
|
|
final port = await worker._controlPort.future
|
|
.timeout(const Duration(seconds: 10),
|
|
onTimeout: () => throw TimeoutException('worker port timeout'));
|
|
worker._port = port;
|
|
port.send(['load', modelBytes, labels]);
|
|
await worker._ready.future
|
|
.timeout(const Duration(seconds: 20), onTimeout: () {
|
|
throw TimeoutException('model load timeout');
|
|
});
|
|
return worker;
|
|
} catch (e) {
|
|
lastLoadError = e.toString();
|
|
debugPrint('[DetectorWorker] create failed: $e');
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/// 是否忙（上一帧尚未返回）：忙则丢帧，避免在途积压
|
|
bool get busy => _inFlight > 0;
|
|
|
|
void analyze(CameraImage image, int rotationDegrees) {
|
|
final port = _port;
|
|
if (port == null || _dead) return;
|
|
_inFlight++;
|
|
port.send([
|
|
'frame',
|
|
[
|
|
image.planes.map((p) => p.bytes).toList(),
|
|
image.planes.map((p) => p.bytesPerRow).toList(),
|
|
image.width,
|
|
image.height,
|
|
image.format.group == ImageFormatGroup.bgra8888,
|
|
rotationDegrees,
|
|
],
|
|
]);
|
|
}
|
|
|
|
void _onMessage(dynamic msg) {
|
|
final list = msg as List;
|
|
switch (list[0] as String) {
|
|
case 'port':
|
|
_controlPort.complete(list[1] as SendPort);
|
|
break;
|
|
case 'ready':
|
|
_ready.complete();
|
|
break;
|
|
case 'load-error':
|
|
_ready.completeError(StateError(
|
|
list.length > 1 ? list[1] as String : 'model load failed'));
|
|
break;
|
|
case 'result':
|
|
_inFlight--;
|
|
final dets = (list[4] as List).map((d) {
|
|
final v = d as List;
|
|
return DetectionResult(
|
|
label: v[0] as String,
|
|
score: v[1] as double,
|
|
left: v[2] as double,
|
|
top: v[3] as double,
|
|
right: v[4] as double,
|
|
bottom: v[5] as double,
|
|
);
|
|
}).toList();
|
|
final motion = (list[5] as List)
|
|
.map((m) => m as List)
|
|
.map((v) => MotionRegion(
|
|
v[0] as double, v[1] as double, v[2] as double, v[3] as double))
|
|
.toList();
|
|
final novelty = (list[6] as List)
|
|
.map((m) => m as List)
|
|
.map((v) => MotionRegion(
|
|
v[0] as double, v[1] as double, v[2] as double, v[3] as double))
|
|
.toList();
|
|
onResult?.call(dets, motion, novelty, list[1] as int, list[2] as int,
|
|
list[3] as int, list[7] as int);
|
|
break;
|
|
case 'log':
|
|
lastLog = list[1] as String;
|
|
debugPrint('[DetectorWorker] $lastLog');
|
|
break;
|
|
case 'error':
|
|
_inFlight--;
|
|
onError?.call(list[1] as String);
|
|
}
|
|
}
|
|
|
|
/// 相机切换/场景变化后重置运动与背景参考
|
|
void reset() {
|
|
final port = _port;
|
|
if (port == null || _dead) return;
|
|
port.send(['reset']);
|
|
}
|
|
|
|
void dispose() {
|
|
_dead = true;
|
|
_isolate.kill(priority: Isolate.immediate);
|
|
_responses.close();
|
|
}
|
|
}
|
|
|
|
/// 后台 isolate 入口：串行处理 load / frame / reset 命令。
|
|
/// 所有回发必须走 [mainPort]（主 isolate 的端口）；control 是 worker 自己的
|
|
/// 收件箱，往 control.sendPort 发消息等于发给自己，主 isolate 永远收不到。
|
|
Future<void> _workerMain(SendPort mainPort) async {
|
|
final control = ReceivePort();
|
|
mainPort.send(['port', control.sendPort]);
|
|
mainPort.send(['log', 'worker-start']);
|
|
|
|
TfliteDetector? detector;
|
|
MotionDetector? motion;
|
|
BackgroundModel? background;
|
|
await for (final msg in control) {
|
|
try {
|
|
final list = msg as List;
|
|
switch (list[0] as String) {
|
|
case 'load':
|
|
mainPort.send(['log', 'load-received']);
|
|
try {
|
|
detector = await TfliteDetector.fromBuffer(
|
|
list[1] as Uint8List, (list[2] as List).cast<String>());
|
|
if (detector == null) {
|
|
mainPort.send(['load-error', 'fromBuffer 返回 null']);
|
|
} else {
|
|
mainPort.send(['log', 'fromBuffer-ok']);
|
|
motion = MotionDetector();
|
|
background = BackgroundModel();
|
|
mainPort.send(['ready']);
|
|
}
|
|
} catch (e) {
|
|
mainPort.send(['load-error', '$e']);
|
|
}
|
|
break;
|
|
case 'frame':
|
|
final d = detector;
|
|
final m = motion;
|
|
final b = background;
|
|
if (d == null || m == null || b == null) break;
|
|
final frame = list[1] as List;
|
|
final planes = (frame[0] as List).cast<Uint8List>();
|
|
final strides = (frame[1] as List).cast<int>();
|
|
final width = frame[2] as int;
|
|
final height = frame[3] as int;
|
|
final isBgra = frame[4] as bool;
|
|
final rotation = frame[5] as int;
|
|
|
|
final sw = Stopwatch()..start();
|
|
var results = d.detectRaw(
|
|
planes: planes,
|
|
strides: strides,
|
|
width: width,
|
|
height: height,
|
|
isBgra: isBgra,
|
|
);
|
|
// 低分野鸡框过视觉先验（颜色/位置），减少户外误报
|
|
results = VisualPrior.filter(
|
|
results,
|
|
planes: planes,
|
|
strides: strides,
|
|
width: width,
|
|
height: height,
|
|
isBgra: isBgra,
|
|
);
|
|
final motionRegions = m.detectMotionRaw(
|
|
planes[0], strides[0], width, height);
|
|
final noveltyRegions =
|
|
b.updateRaw(planes[0], strides[0], width, height);
|
|
sw.stop();
|
|
|
|
mainPort.send([
|
|
'result',
|
|
rotation,
|
|
width,
|
|
height,
|
|
results
|
|
.map((r) =>
|
|
[r.label, r.score, r.left, r.top, r.right, r.bottom])
|
|
.toList(),
|
|
motionRegions
|
|
.map((mr) => [mr.left, mr.top, mr.right, mr.bottom])
|
|
.toList(),
|
|
noveltyRegions
|
|
.map((mr) => [mr.left, mr.top, mr.right, mr.bottom])
|
|
.toList(),
|
|
sw.elapsedMilliseconds,
|
|
]);
|
|
break;
|
|
case 'reset':
|
|
motion?.reset();
|
|
background?.reset();
|
|
}
|
|
} catch (e) {
|
|
mainPort.send(['error', '$e']);
|
|
}
|
|
}
|
|
}
|