MediaPipe 系列 01：框架全景——从感知流水线到 IMS 开发完整指南

前言：为什么选择 MediaPipe？

1.1 智能座舱监控的技术挑战

IMS（Intelligent Monitoring System）是车规级感知系统的典型代表，面临多重挑战：

挑战维度 具体要求 传统方案痛点
实时性 延迟 < 50ms（法规要求） OpenCV 推理线程调度复杂
跨平台 Android/iOS/嵌入式统一代码 框架碎片化，维护成本高
性能优化 CPU 占用 < 30% 手写优化工作量大
模块化 算法组件可复用 硬编码耦合严重
多模型融合 TFLite/NCNN/QNN 统一接入 后端切换困难
可视化 实时调试输出 缺乏统一工具链

1.2 MediaPipe 的核心价值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
┌─────────────────────────────────────────────────────────────┐
│                    MediaPipe 核心价值                      │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│   ┌─────────────────────────────────────────────┐              │
│   │         跨平台感知流水线框架          │              │
│   │                                       │              │
│   │   ┌─────────┐  ┌─────────┐  ┌─────────┐ │              │
│   │   │ Desktop │  │ Android │  │ iOS     │ │              │
│   │   │         │  │         │  │         │ │              │
│   │   └─────────┘  └─────────┘  └─────────┘ │              │
│   │        │            │            │          │              │
│   │        ▼            ▼            ▼          │              │
│   │   ┌─────────────────────────────────────┐   │              │
│   │   │   统一 Graph 配置 + C++ 代码    │   │              │
│   │   │                                 │   │              │
│   │   │   ├─ 实时流式处理             │   │              │
│   │   │   ├─ 自动线程调度             │   │              │
│   │   │   ├─ GPU 加速（OpenGL/Vulkan）   │   │              │
│   │   │   ├─ 零拷贝数据传递           │   │              │
│   │   │   └─ 模块化 Calculator 组件  │   │              │
│   │   │                                 │   │              │
│   │   └─────────────────────────────────────┘   │              │
│   └─────────────────────────────────────────────┘              │
│                                                             │
│   核心优势：                                                 │
│   ────────────────────────────────────────────────  │
│   • 单一代码库，多平台部署                              │
│   • 流式处理，延迟可控                                    │
│   • Calculator 模块化，复用性强                            │
│   • 可视化调试工具链                                       │
│   • 多推理后端无缝切换                                  │
│                                                             │
└─────────────────────────────────────────────────────────────┘

二、MediaPipe 发展历程

2.1 开源时间线

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
2012 ── Google 内部开发
        │
        ▼
2015 ── YouTube 视频处理（超分辨率、视频分类）
        │
        ▼
2017 ── Google Lens（AR 实时物体识别）
        │
        ▼
2019 ── MediaPipe 开源发布
        • 首个公开版本：v0.7.0
        • 支持：Face Mesh、Hands、Pose
        │
        ▼
2021 ── iOS/Android 支持
        • 移动端 GPU 加速
        • Metal/Vulkan 后端
        │
        ▼
2023 ── 多推理后端
        • TFLite GPU Delegate
        • NCNN（腾讯）
        │
        ▼
2024 ── v0.10.x 版本
        • Graph 可视化工具
        • 性能分析器
        │
        ▼
现在 ── IMS 全线采用
        • 高通 QNN、TI TIDL 集成
        • 自定义 Calculator 生态
        • Euro NCAP 5 星方案

2.2 论文参考

MediaPipe 的理论基础来自 2019 年的论文：

MediaPipe: A Framework for Building Perception Pipelines on Real-Time Media
C. Lugaresi, J. Tang, S. Chandrasekhar
arXiv:1906.08172 [CVPR 2019]

核心贡献：

  1. 流式感知：将视频帧作为时间序列处理
  2. 可组合性：计算节点可灵活组合
  3. 跨平台：移动端和桌面端统一架构
  4. 性能优化：零拷贝、SIMD、GPU 加速

三、核心概念详解

3.1 核心四要素

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
┌─────────────────────────────────────────────────────────────┐
│                    MediaPipe 核心概念                       │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│   ┌─────────────────────────────────────────────┐              │
│   │         Graph (感知流水线）           │              │
│   │                                       │              │
│   │   input_stream: "video_frame"              │              │
│   │   output_stream: "detections"              │              │
│   │                                       │              │
│   │   ┌───────────────────────────────────┐    │              │
│   │   │                            │    │              │
│   │   │  node {                    │    │              │
│   │   │    calculator: "FaceDetect"  │    │              │
│   │   │    input_stream: "video_frame"│    │              │
│   │   │    output_stream: "faces"     │    │              │
│   │   │  }                        │    │              │
│   │   │                            │    │              │
│   │   └───────────────────────────────────┘    │              │
│   │                                       │              │
│   └─────────────────────────────────────────────┘              │
│                                                             │
│   ┌─────────────────────────────────────────────┐              │
│   │         Calculator (计算节点）           │              │
│   │                                       │              │
│   │   • 输入：Packet 时间序列          │              │
│   │   • 处理：模型推理、数据转换       │              │
│   │   • 输出：新的 Packet             │              │
│   │   • 生命周期：Open → Process → Close │              │
│   │                                       │              │
│   └─────────────────────────────────────────────┘              │
│                                                             │
│   ┌─────────────────────────────────────────────┐              │
│   │         Packet (数据包）               │              │
│   │                                       │              │
│   │   • 携带时间戳                      │              │
│   │   • 任意类型（图像、矩阵、结构体）  │              │
│   │   • 零拷贝传递                    │              │
│   │                                       │              │
│   └─────────────────────────────────────────────┘              │
│                                                             │
│   ┌─────────────────────────────────────────────┐              │
│   │         Stream (数据流）              │              │
│   │                                       │              │
│   │   • Packet 的有序序列          │              │
│   │   • 自动时间同步              │              │
│   │   • 支持背压（Backpressure）         │              │
│   │                                       │              │
│   └─────────────────────────────────────────────┘              │
│                                                             │
└─────────────────────────────────────────────────────────────┘

3.2 概念类比

MediaPipe 概念 工厂类比 技术类比
Graph 生产流水线 数据处理 DAG（有向无环图）
Calculator 工位/工站 计算节点/函数
Packet 零件/半成品 数据包（带时间戳）
Stream 传送带/流水线 时间序列数据流
Side Packet 工具/参数配置 静态配置数据
Executor 车间调度器 线程池/任务调度器
Graph Runner 工厂控制器 图执行引擎

四、Graph 配置文件

4.1 pbtxt 语法详解

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
# ========== 输入输出定义 ==========
input_stream: "INPUT_VIDEO:video_frame"      # 原始视频帧
input_stream: "VEHICLE_SPEED:speed"         # 车速（来自 CAN）
input_stream: "TIMESTAMP:timestamp"        # 时间戳

output_stream: "FATIGUE_SCORE:fatigue"    # 疲劳得分
output_stream: "ALERT:alert"                # 告警信号

# ========== Calculator 节点 ==========
node {
  calculator: "FaceMeshCalculator"              # Calculator 类名
  input_stream: "IMAGE:video_frame"           # 输入流引用
  output_stream: "LANDMARKS:face_landmarks"  # 输出流引用
  options {
    [mediapipe.FaceMeshOptions.ext] {        # Calculator 特定选项
      model_path: "/models/face_landmark.tflite"
      num_faces: 1                            # 检测人数
      enable_iris: true                        # 启用虹膜
    }
  }
}

node {
  calculator: "FatigueScoreCalculator"
  input_stream: "LANDMARKS:face_landmarks"
  input_stream: "VEHICLE_SPEED:speed"
  output_stream: "FATIGUE_SCORE:fatigue"
  options {
    [mediapipe.FatigueOptions.ext] {
      ear_threshold: 0.2                      # EAR 阈值
      perclos_window: 30000                    # PERCLOS 窗口（毫秒）
      speed_factor_enabled: true                 # 启用速度因子
    }
  }
}

# ========== 流连接 ==========
# Stream 自动按照 input_stream 标签连接
# 例如：FaceMesh 输出的 "LANDMARKS" 自动连接到
#       FatigueScoreCalculator 输入的 "LANDMARKS"

4.2 复杂 Graph 示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
# IMS DMS 完整流水线
input_stream: "IR_IMAGE:ir_frame"
output_stream: "DMS_RESULT:dms_output"

# 1. 人脸检测
node {
  calculator: "FaceDetectionCalculator"
  input_stream: "IMAGE:ir_frame"
  output_stream: "FACE_DETECTIONS:detections"
}

# 2. 条件分流（检测到人脸才处理）
node {
  calculator: "GateCalculator"
  input_stream: "INPUT:detections"
  output_stream: "OUTPUT:valid_detections"
  options {
    [mediapipe.GateCalculatorOptions.ext] {
      allow: true                                 # 条件：允许通过
    }
  }
}

# 3. 并行处理（多路输出）
node {
  calculator: "PassThroughCalculator"
  input_stream: "INPUT:valid_detections"
  output_stream: "OUTPUT_A:detections"
  output_stream: "OUTPUT_B:detections"
}

# 4. 数据聚合（多流同步）
node {
  calculator: "MergeCalculator"
  input_stream: "INPUT_A:detections"
  input_stream: "INPUT_B:landmarks"
  input_stream: "INPUT_C:pose"
  output_stream: "MERGED:all_features"
}

# 5. 时序处理（滑动窗口）
node {
  calculator: "SlidingWindowCalculator"
  input_stream: "INPUT:all_features"
  output_stream: "WINDOW:windowed_features"
  options {
    [mediapipe.SlidingWindowOptions.ext] {
      window_size: 30                           # 30 帧窗口（1秒@30fps）
      step_size: 1                              # 步长
    }
  }
}

五、Calculator 开发基础

5.1 Calculator 接口

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
// 自定义 Calculator 继承 CalculatorBase
class MyCalculator : public CalculatorBase {
 public:
  // ========== 静态方法：定义接口 ==========
  static absl::Status GetContract(CalculatorContract* cc) {
    // 定义输入输出类型
    cc->Inputs().Tag("INPUT").Set<ImageFrame>();
    cc->Outputs().Tag("OUTPUT").Set<float>();
    cc->Options().Add<MyOptions>();
    return absl::OkStatus();
  }

  // ========== 初始化方法 ==========
  absl::Status Open(CalculatorContext* cc) override {
    // Graph 启动时调用一次
    // • 读取配置参数
    // • 初始化模型、资源
    // • 分配内存
    const auto& options = cc->Options<MyOptions>();
    threshold_ = options.threshold();
    return absl::OkStatus();
  }

  // ========== 处理方法 ==========
  absl::Status Process(CalculatorContext* cc) override {
    // 每个输入 Packet 调用一次
    // • 检查输入是否可用
    // • 获取输入数据
    // • 执行计算
    // • 输出结果
    if (cc->Inputs().Tag("INPUT").IsEmpty()) {
      return absl::OkStatus();  // 输入为空，跳过
    }
    
    const auto& input = cc->Inputs().Tag("INPUT").Get<ImageFrame>();
    
    // 执行计算
    float result = Compute(input);
    
    // 输出
    cc->Outputs().Tag("OUTPUT").AddPacket(
        MakePacket<float>(result).At(cc->InputTimestamp()));
    
    return absl::OkStatus();
  }

  // ========== 清理方法 ==========
  absl::Status Close(CalculatorContext* cc) override {
    // Graph 关闭时调用一次
    // • 释放模型
    // • 释放内存
    // • 清理资源
    return absl::OkStatus();
  }

 private:
  float threshold_;
  float Compute(const ImageFrame& input);
};

5.2 Calculator 配置

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
message MyOptions {
  extend mediapipe.CalculatorOptions {
    
    // 基本类型
    optional float threshold = 1 [default = 0.5];
    optional int32 window_size = 2 [default = 10];
    optional bool enabled = 3 [default = true];
    
    // 复杂类型
    repeated float thresholds = 4;          // 数组
    optional ModelConfig model_config = 5;   // 嵌套消息
    map<string, float> params = 6;         // 键值对
  }
}

message ModelConfig {
  optional string model_path = 1;
  optional int32 num_classes = 2 [default = 100];
}

六、Packet 与 Stream 机制

6.1 Packet 数据包

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
// Packet 是不可变数据包
class Packet {
 public:
  // 获取数据
  template<typename T>
  T Get() const;
  
  // 获取时间戳
  Timestamp Timestamp() const;
  
  // 判断是否为空
  bool IsEmpty() const;
  
 private:
  std::shared_ptr<void> data_;  // 共享指针，零拷贝
  Timestamp timestamp_;
};

// 使用示例
void MyCalculator::Process(CalculatorContext* cc) {
  const auto& packet = cc->Inputs().Tag("INPUT").Get<ImageFrame>();
  
  // 获取时间戳
  Timestamp ts = packet.Timestamp();
  
  // 数据不可修改
  // packet.Set(new_data);  // 编译错误
}

6.2 Stream 数据流

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
// Stream 是有序的 Packet 序列
class InputStream {
 public:
  // 获取当前 Packet
  template<typename T>
  const T& Get() const;
  
  // 判断是否有数据
  bool IsEmpty() const;
  
  // 获取元数据
  std::string Name() const;
};

// 时间同步机制
class Timestamp {
 public:
  // 微秒精度
  static Timestamp FromMicroseconds(int64_t us);
  
  // 比较
  bool IsEarlierThan(const Timestamp& other) const;
  bool IsSameAs(const Timestamp& other) const;
  
  // 加减
  Timestamp Plus(int64_t offset_us) const;
};

// 时间对齐示例
node {
  calculator: "SyncCalculator"
  input_stream: "VIDEO:video_frame"      # 30 FPS
  input_stream: "SENSOR:sensor_data"    # 10 Hz
  output_stream: "SYNCED:aligned_data"   # 同步输出
  # MediaPipe 自动对齐时间戳
}

6.3 Side Packet 静态配置

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# Graph 配置中定义 Side Packet
input_side_packet: "MODEL:model_weights"  # 静态模型权重
input_side_packet: "CONFIG:detection_config"  # 静态配置

# Calculator 使用 Side Packet
node {
  calculator: "InferenceCalculator"
  input_stream: "IMAGE:video_frame"
  input_side_packet: "MODEL:model_weights"  # 静态输入
  output_stream: "OUTPUT:detections"
}

# Side Packet 特性：
# • 只在 Graph 启动时传入一次
# • 不会随时间变化
# • 适用于：模型权重、配置参数、查找表

七、IMS 实战应用

7.1 IMS DMS 完整架构

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
┌─────────────────────────────────────────────────────────────────────────┐
│                    IMS DMS 完整感知流水线                              │
├─────────────────────────────────────────────────────────────────────────┤
│                                                                         │
│  输入层                                                                 │
│  ┌─────────────┐    ┌─────────────┐    ┌─────────────┐              │
│  │ IR Camera   │    │ CAN 总线    │    │ 车速传感器  │              │
│  │ 640×480    │    │            │    │            │              │
│  └─────────────┘    └─────────────┘    └─────────────┘              │
│         │                   │                   │                      │
│         └───────────────────┴───────────────────┘                      │
│                             ▼                                          │
│  ┌─────────────────────────────────────────────────────┐              │
│  │            感知层 (MediaPipe Graph)           │              │
│  │  ┌─────────┐  ┌─────────┐  ┌─────────┐  │              │
│  │  │Face Mesh│──▶│Landmark │──▶│EAR      │──▶│PERCLOS  │              │
│  │  └─────────┘  └─────────┘  └─────────┘  └─────────┘  │              │
│  │  ┌─────────┐  ┌─────────┐  ┌─────────┐  │              │
│  │  │Iris Det │──▶│Gaze Est │──▶│Head Pose│──▶│Fatigue  │              │
│  │  └─────────┘  └─────────┘  └─────────┘  └─────────┘  │              │
│  └─────────────────────────────────────────────────────┘              │
│                             │                                          │
│                             ▼                                          │
│  ┌─────────────────────────────────────────────────────┐              │
│  │              融合层                         │              │
│  │  ┌─────────┐  ┌─────────┐  ┌─────────┐  │              │
│  │  │EAR +     │──▶│Weighted  │──▶│Fatigue  │              │
│  │  │PERCLOS   │  │Score     │  │Level     │              │
│  │  └─────────┘  └─────────┘  └─────────┘  │              │
│  └─────────────────────────────────────────────────────┘              │
│                             │                                          │
│                             ▼                                          │
│  输出层                   │                                          │
│  ┌─────────────────────────────────────────────────────────┐          │
│  │ IMSOutput {                                           │          │
│  │   fatigue_level: 2,         // 0-3                   │          │
│  │   fatigue_score: 0.75,                             │          │
│  │   alert_required: true,                            │          │
│  │   alert_type: "fatigue"                           │          │
│  │ }                                                      │          │
│  └─────────────────────────────────────────────────────────┘          │
│                                                                         │
└─────────────────────────────────────────────────────────────────────────┘

7.2 IMS 自定义 Calculator 生态

Calculator 功能 输入 输出
NCNNInferenceCalculator NCNN 模型推理 ImageFrame Detection
QNNInferenceCalculator 高通 Hexagon DSP ImageFrame Detection
TIDLInferenceCalculator TI C66x DSP ImageFrame Detection
ARCalculator 眼纵横比 Landmarks EAR
PERCLOSCalculator 疲劳计算 EAR PERCLOS
GazeZoneCalculator 视线区域 GazeVector Zone
FatigueAggregatorCalculator 多指标融合 EAR, PERCLOS, Pose FatigueScore

八、环境准备

8.1 编译依赖

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
# Ubuntu 20.04+
sudo apt update
sudo apt install -y \
    build-essential \
    cmake \
    git \
    python3 \
    python3-pip \
    libopencv-dev \
    libeigen3-dev

# 安装 Bazel（MediaPipe 构建系统）
wget https://github.com/bazelbuild/bazel/releases/download/6.1.2/bazel-6.1.2-installer-linux-x86_64.sh
chmod +x bazel-6.1.2-installer-linux-x86_64.sh
./bazel-6.1.2-installer-linux-x86_64.sh --user

# 克隆 MediaPipe
cd ~/.openclaw/workspace
git clone https://github.com/google/mediapipe.git
cd mediapipe

# 初始化子模块
git submodule update --init --recursive

8.2 编译 Hello World

1
2
3
4
5
6
7
8
9
10
11
# 编译示例
cd mediapipe
bazel build -c opt \
    mediapipe/examples/desktop/hello_world:hello_world

# 运行
GLOG_logtostderr=1 bazel-bin/mediapipe/examples/desktop/hello_world/hello_world

# 预期输出：
# Hello World!
# MediaPipe initialized successfully

九、调试与性能

9.1 可视化工具

1
2
3
4
5
6
7
8
9
10
# MediaPipe 可视化调试工具
# 生成 Graph 结构图
bazel run -c opt mediapipe/framework/tools:graph_visualizer \
    -- --graph_config_file=mediapipe/graphs/dms.pbtxt \
    --output_file=/tmp/dms_graph.html

# 生成 Calculator 调用图
bazel run -c opt mediapipe/framework/tools:packet_inspector \
    -- --graph_config_file=mediapipe/graphs/dms.pbtxt \
    --output_file=/tmp/dms_packets.json

9.2 性能分析

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
┌─────────────────────────────────────────────────────────────┐
│                    MediaPipe 性能指标                         │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│   指标              目标值          测量方法                  │
│   ────────────────────────────────────────────────────────  │
│   帧率 (FPS)        > 30           FrameCounterCalculator      │
│   端到端延迟        < 50ms        Timestamp 差值          │
│   CPU 占用          < 30%          top/htop                 │
│   内存占用          < 100 MB       /proc/pid/status          │
│   Calculator 延迟  < 5ms         MediaPipe Profiler        │
│                                                             │
│   优化策略：                                                 │
│   ────────────────────────────────────────────────────────  │
│   1. 使用 GPU Delegate                                     │
│   2. 零拷贝传递                                           │
│   3. Calculator 并行度调整                                │
│   4. 输入分辨率自适应                                    │
│   5. 模型量化（FP16/INT8）                                 │
│                                                             │
└─────────────────────────────────────────────────────────────┘

十、学习路径

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
┌─────────────────────────────────────────────────────────────┐
│                    MediaPipe 学习路径                        │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│   阶段一：框架基础（10 篇）                                │
│   ┌─────────────────────────────────────────────┐              │
│   │ 01-10: Graph、Calculator、Packet、       │              │
│   │        Stream、Side Packet、线程模型      │              │
│   └─────────────────────────────────────────────┘              │
│                          │                                  │
│                          ▼                                  │
│   阶段二：自定义 Calculator 开发（15 篇）                       │
│   ┌─────────────────────────────────────────────┐              │
│   │ 11-25: 推理、图像处理、数据聚合、     │              │
│   │        后处理、错误处理、性能优化         │              │
│   └─────────────────────────────────────────────┘              │
│                          │                                  │
│                          ▼                                  │
│   阶段三：内置 Solution 解析（15 篇）                         │
│   ┌─────────────────────────────────────────────┐              │
│   │ 26-40: Face Detection、Face Mesh、       │              │
│   │        Hand Tracking、Pose、Object、      │              │
│   │        Segmentation、Iris、Holistic      │              │
│   └─────────────────────────────────────────────┘              │
│                          │                                  │
│                          ▼                                  │
│   阶段四：IMS 实战应用（10 篇）                                │
│   ┌─────────────────────────────────────────────┐              │
│   │ 41-50: 疲劳检测、分心检测、眼动追踪、   │              │
│   │        头部姿态、危险行为、乘员检测、     │              │
│   │        遗留物检测、CPD、安全带、数据融合│              │
│   └─────────────────────────────────────────────┘              │
│                          │                                  │
│                          ▼                                  │
│   阶段五：跨平台部署（5 篇）                                   │
│   ┌─────────────────────────────────────────────┐              │
│   │ 51-55: Android JNI、iOS Obj-C++、       │              │
│   │        高通 QNN、TI TIDA4、路线图       │              │
│   └─────────────────────────────────────────────┘              │
│                                                             │
└─────────────────────────────────────────────────────────────┘

十一、总结

维度 核心要点
为什么 MediaPipe 跨平台、实时、模块化、多后端
核心概念 Graph、Calculator、Packet、Stream、Side Packet
Calculator 生命周期 Open → Process → Close
IMS 应用 疲劳、分心、眼动追踪、姿态估计
学习路径 基础 → 开发 → Solution → 实战 → 部署

下篇预告

MediaPipe 系列 02：Graph 与 Calculator——核心抽象详解

深入讲解 Graph 配置文件 pbtxt、Calculator 接口、Packet/Stream 传递机制。

参考资料

  1. Lugaresi et al. (2019). MediaPipe: A Framework for Building Perception Pipelines. arXiv:1906.08172
  2. Google AI Edge. MediaPipe Framework Documentation
  3. LearnOpenCV. MediaPipe: The Ultimate Guide to Video Processing

系列进度： 1/55
更新时间： 2026-03-12

MediaPipe 系列 > 框架基础
#DMS #IMS #MediaPipe #C++ #感知流水线 #架构
MediaPipe 系列 01：框架全景——从感知流水线到 IMS 开发完整指南
https://dapalm.com/2026/03/12/MediaPipe系列01-框架全景：从感知流水线到IMS开发/
作者
Mars
发布于
2026年3月12日
许可协议