feat(v2): compose realtime monitor pipeline

2026-07-22 21:20:13 +08:00
parent d183170554
commit 8e093acb9b
4 changed files with 300 additions and 5 deletions
@@ -0,0 +1,191 @@
+// Package monitor composes source, pose, fall and evidence work off the UI thread.
+package monitor
+
+import (
+	"context"
+	"fmt"
+	"image"
+	"sync"
+	"time"
+
+	"silverpose/v2/internal/alert"
+	"silverpose/v2/internal/fall"
+	"silverpose/v2/internal/pose"
+	"silverpose/v2/internal/render"
+	"silverpose/v2/internal/source"
+)
+
+type FrameSource interface {
+	Frames() <-chan source.Frame
+	Statuses() <-chan source.Update
+}
+
+type PoseRuntime interface {
+	Run([]float32) ([]float32, error)
+	Close()
+}
+
+type EventProcessor interface {
+	Process(fall.Frame) fall.FrameResult
+}
+
+type Update struct {
+	Image         *image.RGBA
+	Result        fall.FrameResult
+	Events        []alert.Record
+	SourceStatus  source.Status
+	SourceMessage string
+	Sequence      uint64
+}
+
+type Monitor struct {
+	source     FrameSource
+	runtime    PoseRuntime
+	processor  EventProcessor
+	confidence float32
+	dispatcher *alert.Dispatcher
+	clock      func() time.Time
+	updates    chan Update
+	alerts     chan alert.Record
+	done       chan struct{}
+	closeOnce  sync.Once
+}
+
+func New(
+	stream FrameSource,
+	runtime PoseRuntime,
+	processor EventProcessor,
+	confidence float32,
+	dispatcher *alert.Dispatcher,
+	clock func() time.Time,
+) (*Monitor, error) {
+	if stream == nil || runtime == nil || processor == nil || dispatcher == nil {
+		return nil, fmt.Errorf("monitor dependencies must be non-nil")
+	}
+	if confidence < 0 || confidence > 1 {
+		return nil, fmt.Errorf("pose confidence must be between 0 and 1")
+	}
+	if clock == nil {
+		clock = time.Now
+	}
+	return &Monitor{
+		source: stream, runtime: runtime, processor: processor, confidence: confidence,
+		dispatcher: dispatcher, clock: clock, updates: make(chan Update, 1), alerts: make(chan alert.Record, 16), done: make(chan struct{}),
+	}, nil
+}
+
+func (monitor *Monitor) Updates() <-chan Update      { return monitor.updates }
+func (monitor *Monitor) Done() <-chan struct{}       { return monitor.done }
+func (monitor *Monitor) Alerts() <-chan alert.Record { return monitor.alerts }
+
+// Run blocks until the source closes or the supplied context is cancelled.
+// The caller owns the goroutine; all expensive work stays out of Walk's UI thread.
+func (monitor *Monitor) Run(ctx context.Context) {
+	defer monitor.close()
+	defer monitor.runtime.Close()
+	frames := monitor.source.Frames()
+	statuses := monitor.source.Statuses()
+	currentStatus := source.Connecting
+	currentMessage := "正在连接视频流"
+	for frames != nil || statuses != nil {
+		select {
+		case <-ctx.Done():
+			return
+		case status, open := <-statuses:
+			if !open {
+				statuses = nil
+				continue
+			}
+			currentStatus, currentMessage = status.Status, status.Message
+			monitor.publish(Update{SourceStatus: currentStatus, SourceMessage: currentMessage})
+		case frame, open := <-frames:
+			if !open {
+				frames = nil
+				continue
+			}
+			statuses, currentStatus, currentMessage = monitor.drainStatuses(statuses, currentStatus, currentMessage)
+			monitor.processFrame(frame, currentStatus, currentMessage)
+		}
+	}
+}
+
+func (monitor *Monitor) drainStatuses(statuses <-chan source.Update, current source.Status, message string) (<-chan source.Update, source.Status, string) {
+	for statuses != nil {
+		select {
+		case status, open := <-statuses:
+			if !open {
+				return nil, current, message
+			}
+			current, message = status.Status, status.Message
+		default:
+			return statuses, current, message
+		}
+	}
+	return nil, current, message
+}
+
+func (monitor *Monitor) processFrame(frame source.Frame, status source.Status, message string) {
+	input, transform, err := pose.PreprocessBGR(frame.BGR, frame.Width, frame.Height, 640)
+	if err != nil {
+		monitor.publish(Update{SourceStatus: status, SourceMessage: "视频帧格式无效", Sequence: frame.Sequence})
+		return
+	}
+	output, err := monitor.runtime.Run(input)
+	if err != nil {
+		monitor.publish(Update{SourceStatus: status, SourceMessage: "姿态推理失败", Sequence: frame.Sequence})
+		return
+	}
+	people, err := pose.ParseYOLOv8Pose(output, transform, monitor.confidence, 0.70)
+	if err != nil {
+		monitor.publish(Update{SourceStatus: status, SourceMessage: "姿态结果无效", Sequence: frame.Sequence})
+		return
+	}
+	result := monitor.processor.Process(fall.Frame{
+		Timestamp: frame.Timestamp.Seconds(), Width: frame.Width, Height: frame.Height, Poses: people,
+	})
+	capturedAt := monitor.clock().UTC()
+	canvas, err := render.Render(frame.BGR, frame.Width, frame.Height, result, capturedAt)
+	if err != nil {
+		monitor.publish(Update{Result: result, SourceStatus: status, SourceMessage: "画面渲染失败", Sequence: frame.Sequence})
+		return
+	}
+	records := make([]alert.Record, 0, len(result.Events))
+	for _, event := range result.Events {
+		record, err := monitor.dispatcher.Dispatch(event, canvas, capturedAt)
+		if err != nil {
+			monitor.publish(Update{Image: canvas, Result: result, SourceStatus: status, SourceMessage: "事件证据保存失败", Sequence: frame.Sequence})
+			return
+		}
+		if record.Written {
+			records = append(records, record)
+			monitor.alerts <- record
+		}
+	}
+	monitor.publish(Update{
+		Image: canvas, Result: result, Events: records, SourceStatus: status, SourceMessage: message, Sequence: frame.Sequence,
+	})
+}
+
+func (monitor *Monitor) publish(update Update) {
+	select {
+	case monitor.updates <- update:
+		return
+	default:
+	}
+	select {
+	case <-monitor.updates:
+	default:
+	}
+	select {
+	case monitor.updates <- update:
+	default:
+	}
+}
+
+func (monitor *Monitor) close() {
+	monitor.closeOnce.Do(func() {
+		close(monitor.updates)
+		close(monitor.alerts)
+		close(monitor.done)
+	})
+}