欢迎加入开源鸿蒙跨平台社区：
https://openharmonycrossplatform.csdn.net

一、 导言：造血干细胞与昼夜节律的微观交响

在现代医学与生命组学（Life Omics）的研究语境中，睡眠的本质远非简单的“大脑皮层休息”。从骨髓深处的造血微环境，到外周血管的微循环，睡眠时长（Sleep Duration）是调控内环境稳态（Homeostasis）与氧化应激（Oxidative Stress）水平的绝对阀门。当宿主经历长期的睡眠剥夺时，系统会累积大量的活性氧（ROS）。这些剧毒物质会直接攻击循环系统中的成熟红细胞（Red Blood Cell, RBC），导致其脂质双分子层过氧化，生命周期大幅缩短。

为了维持机体基础的氧气携载需求，骨髓造血干细胞（Hematopoietic Stem Cells, HSCs）将被迫开启危险的**“代偿性过度增殖（Compensatory Hyperproliferation）”**。在短时间内，迭代速度的飙升确实弥补了血液红细胞的空缺；然而，长期的高频迭代将引发端粒极速缩短，最终导致造血系统的衰竭。

本文将展示如何利用 Flutter 强大的底层渲染管线 CustomPainter 与高性能 Ticker 状态树，建立一个拥有独立对照组的《微观红细胞代偿演算仪》。该大屏系统在实时呈现血流动态的同时，深度应用了极为严酷的防溢出弹性约束（Overflow Mitigation），以确立严谨的跨端医学可视化前端范式。

---

二、 组学测绘：代偿性增殖与细胞凋亡的数理拟合

在本项目中，我们屏弃了对单一状态的静态展示，转而引入“控制变量对照实验（Controlled Experiment）”模型。系统的左右（或上下）双视窗中，一组为永不妥协的8小时睡眠对照组，另一组则将参数接管权开放给观测者。

2.1 氧化应激积累方程

睡眠剥夺与氧化应激（ROS）的积累并非简单的线性关系。我们选用基于自然底数的反向指数衰减模型来拟合宿主体内氧化应激的水平 $O_{stress}$。设当前睡眠时长为 $S$ （单位：小时），则其应激函数可定义为：

$$O_{stress}(S)=100\cdot e^{-\lambda \cdot S}$$

在我们的推演系统中，取 $\lambda =0.3$。当 $S=8$ 时，方程收敛于一个安全的低水平生理杂讯；而当 $S\to 0$ 时，ROS 含量飙升至系统崩盘的边缘界限。

2.2 红细胞代偿迭代极限推演

骨髓的代偿性红细胞迭代乘数（Cell Iteration Rate, $I_{rate}$）是对环境缺血性缺氧信号的直接反馈。假设基线增殖率为 $1.0$，其数学逼近式为：

$$I_{rate}=1.0+\max (0,\mu \cdot (8.0-S))$$

在这一方程中，高代偿倍率会迫使系统在 CustomPainter 的每帧轮询中投射更密集的粒子；同时，每一个新生成的粒子（红细胞）都被赋予了极短的 lifeSpan。这在视觉上呈现为：实验组的血流急促、浑浊，大量携氧量低下的暗紫色细胞在半途崩溃并溶解。

---

三、 核心流体渲染与隔离管线设计

为了支撑两个相互隔离的独立环境（对照组与实验组）的并行推演运算，本架构的设计放弃了 Flutter 中高昂的 Widget Tree 遍历更新策略。转而将演算与绘制双线分离。

---

四、 源码深度勘探

下述四大核心代码截面，完整展示了本项目在跨端医学仿真领域的系统级考量，尤其是在防御 Flutter 经典的 RenderFlex Overflowed 所布下的层层结界。

4.1 独立对照组内存隔离架构

为了保证对照组的“免疫性”，我们构建了 BloodEnvironment 领域实体。其内部集成了所有的红细胞粒子队列。利用 isControlGroup 标记，强制锁定特定实例的状态不可被外部干扰。

// -----------------------------------------------------
// 核心源码一：领域环境的内存隔离与物理积分
// -----------------------------------------------------
class BloodEnvironment {
  final bool isControlGroup;
  double targetSleepDuration;
  double oxidativeStress = 0.0; 
  double cellIterationRate = 1.0; 
  List<RedBloodCell> cells = [];

  BloodEnvironment({this.isControlGroup = false, this.targetSleepDuration = 8.0});

  void tickUpdate(double dt, double width, double height) {
    if (width <= 0 || height <= 0) return;
    
    // 如果是对照组，强制接管参数重置，锁死 8.0 稳态
    if (isControlGroup) {
      targetSleepDuration = 8.0; 
    }

    // 更新生命体征矩阵
    oxidativeStress = 100.0 * exp(-0.3 * targetSleepDuration);
    cellIterationRate = 1.0 + max(0.0, (8.0 - targetSleepDuration) * 0.4);

    // [...] 省略粒子位移计算与淘汰机制
  }
}

4.2 微观流体力学粒子系统设计

在视图层中，我们使用了 CustomPainter 来取代昂贵的组件树重构。并且，通过检测 $O_{stress}$ 阈值，当宿主进入深度睡眠剥夺（如 2小时）时，直接介入底层的 Canvas 绘制原语（Canvas Primitive），通过三角函数畸变模拟产生“棘红细胞（Acanthocyte）”。

// -----------------------------------------------------
// 核心源码二：Canvas 级别的高维形态学映射
// -----------------------------------------------------
class BloodVesselPainter extends CustomPainter {
  final BloodEnvironment env;
  BloodVesselPainter(this.env);

  @override
  void paint(Canvas canvas, Size size) {
    final Paint cellPaint = Paint();
    
    for (var cell in env.cells) {
      // 通过携氧能力计算 RGB 通道：缺氧时发暗紫色
      double oxy = cell.oxygenCapacity;
      int r = (255 * oxy).toInt();
      int g = (50 * oxy).toInt();
      int b = (50 * (1.0 - oxy) + 20).toInt(); 

      double alphaScale = (cell.lifeSpan / cell.maxLife).clamp(0.0, 1.0);
      cellPaint.color = Color.fromARGB((200 * alphaScale).toInt(), r, g, b);
      
      // 氧化应激飙升：脂质过氧化导致红细胞膜破损变形成不规则椭圆
      if (env.oxidativeStress > 60) {
        canvas.drawOval(
          Rect.fromCenter(
            center: Offset(cell.x, cell.y), 
            width: 10 + sin(cell.lifeSpan * 5) * 2, 
            height: 10 + cos(cell.lifeSpan * 5) * 2
          ), 
          cellPaint
        );
      } else {
        canvas.drawCircle(Offset(cell.x, cell.y), 6.0, cellPaint);
      }
    }
  }
}

4.3 Ticker 驱动的无状态帧同步机制

在主界面的状态管理器中，SingleTickerProviderStateMixin 被用来提供全局脉冲信号。此处极具技巧性的是：setState 的调用体内是完全为空的。其作用仅仅是将整个被监控的组件树标记为 dirty，进而无伤呼叫 CustomPainter。

// -----------------------------------------------------
// 核心源码三：高精度时间增量积分回调
// -----------------------------------------------------
  @override
  void initState() {
    super.initState();
    _ticker = createTicker((elapsed) {
      double dt = (elapsed.inMilliseconds - _lastElapsed.inMilliseconds) / 1000.0;
      
      // 时间跳变防御：阻止系统休眠唤醒后造成的积分爆炸
      if (dt > 0.1) dt = 0.016; 
      _lastElapsed = elapsed;

      if (!mounted) return;
      
      // 空白状态重构呼叫：不更改树形结构，纯净透传重绘信号
      setState(() {});
    });
    _ticker.start();
  }

4.4 防溢出响应式分屏控制台

作为我们构建前端跨端应用的铁血门控，必须将“彻底消灭底部与右侧溢出”作为信仰贯彻到底。通过 LayoutBuilder 和包裹 Expanded 配合，双重观测视窗能在手机竖屏和桌面超宽屏中游刃有余地完成形态切换。

// -----------------------------------------------------
// 核心源码四：物理维度的弹性盒降维打击
// -----------------------------------------------------
  // 这是处于 Scaffold -> Column 内部的一段核心布局
  Expanded(
    child: LayoutBuilder(
      builder: (context, constraints) {
        // 如果物理宽度足以支撑双向比对
        if (constraints.maxWidth > 700) {
          return Row(
            crossAxisAlignment: CrossAxisAlignment.stretch,
            children: [
              Expanded(child: _buildVesselViewport('对照组 (8H)', _controlEnv)),
              const SizedBox(width: 16),
              Expanded(child: _buildVesselViewport('实验组 (干预)', _experimentEnv)),
            ],
          );
        } else {
          // 如果是极端受限空间（如手机竖屏），降维为上下叠拼
          return Column(
            crossAxisAlignment: CrossAxisAlignment.stretch,
            children: [
              Expanded(child: _buildVesselViewport('对照组 (8H)', _controlEnv)),
              const SizedBox(height: 16),
              Expanded(child: _buildVesselViewport('实验组 (干预)', _experimentEnv)),
            ],
          );
        }
      },
    ),
  )

不仅如此，在生成数据概览的内部文本区域，我们刻意抛弃了刚性的 Row，而采用了自适应流式排版组件 Wrap。这一细微的决策调整，确保了数据指标的长短变化（如 1.0 突然变为 12.333）再也无法顶穿父级容器的边缘。

---

五、 结语

《微观红细胞代偿演算仪》以其冷峻的对照视窗与暗黑极客美学，完成了生命科学抽象理论与跨平台计算机图形渲染的一次深度联姻。

我们看到了在 8小时睡眠基线（对照组）中，那些携氧丰富、体态饱满的红细胞粒子正以优雅而悠长的轨迹流淌；而与此同时，在那因肆意剥夺睡眠时长而陷入混乱的实验组中，大量萎缩发紫的畸形细胞只能在造血系统近乎崩溃的疯狂代偿迭代中，作着无尽的挣扎与消亡。

在最严密的防溢出弹性约束中，这套基于 Flutter 的流体积分离散引擎不仅证明了其在高频重绘时的绝对稳定性，更以一种沉默而直观的方式向我们揭示了那条生命不容僭越的边界铁律——

所有的透支，皆已在暗中标好了衰竭的价码。

源码

import 'dart:math';
import 'package:flutter/material.dart';
import 'package:flutter/scheduler.dart';

void main() {
  runApp(const HematopoiesisSimulatorApp());
}

class HematopoiesisSimulatorApp extends StatelessWidget {
  const HematopoiesisSimulatorApp({Key? key}) : super(key: key);

  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      title: '造血代偿演算仪',
      theme: ThemeData(
        brightness: Brightness.dark,
        scaffoldBackgroundColor: const Color(0xFF0D1117), // 极客深黑背景
        fontFamily: 'Courier',
        sliderTheme: SliderThemeData(
          activeTrackColor: const Color(0xFF00FFCC),
          inactiveTrackColor: Colors.white24,
          thumbColor: const Color(0xFF00FFCC),
          overlayColor: const Color(0xFF00FFCC).withOpacity(0.2),
        ),
      ),
      home: const SimulatorHomeScreen(),
    );
  }
}

// ==========================================
// 领域模型：微观粒子实体与生理环境演算
// ==========================================

class RedBloodCell {
  double x;
  double y;
  double lifeSpan; // 当前剩余寿命
  double maxLife;  // 最大寿命
  double speedX;
  double speedY;
  double oxygenCapacity; // 0.0 - 1.0，决定血色的红润度

  RedBloodCell({
    required this.x,
    required this.y,
    required this.maxLife,
    required this.speedX,
    required this.speedY,
    required this.oxygenCapacity,
  }) : lifeSpan = maxLife;
}

class BloodEnvironment {
  final bool isControlGroup;
  double targetSleepDuration; // 用户给定的睡眠时长 (Control 组固定为 8)
  
  // 核心演算指标
  double oxidativeStress = 0.0; // 氧化应激指数 (ROS) 0 - 100
  double cellIterationRate = 1.0; // 细胞迭代(代偿生成)乘数，基线为1.0
  double averageLifespan = 100.0; // 红细胞平均生理周期模拟值
  
  List<RedBloodCell> cells = [];
  final Random _rnd = Random();

  BloodEnvironment({this.isControlGroup = false, this.targetSleepDuration = 8.0});

  // 更新生理数学模型方程
  void _updateBiometrics() {
    if (isControlGroup) {
      targetSleepDuration = 8.0; // 强制隔离保护对照组数据
    }

    // 数学拟合：氧化应激与睡眠呈非线性反比
    // S=8 时 ROS ≈ 10; S=4 时 ROS ≈ 60; S=0 时 ROS ≈ 95
    oxidativeStress = 100.0 * exp(-0.3 * targetSleepDuration);

    // 迭代速度拟合：睡眠越少，红细胞凋亡越快，骨髓需要加速代偿
    // S=8 时代偿基线为 1.0; S=2 时代偿系数高达 3.5
    cellIterationRate = 1.0 + max(0.0, (8.0 - targetSleepDuration) * 0.4);

    // 平均寿命缩短方程
    averageLifespan = 100.0 / cellIterationRate;
  }

  // 每一帧的物理积分
  void tickUpdate(double dt, double width, double height) {
    if (width <= 0 || height <= 0) return;
    _updateBiometrics();

    // 1. 淘汰凋亡细胞
    cells.removeWhere((cell) => cell.lifeSpan <= 0 || cell.x > width + 50);

    // 2. 更新现存细胞状态 (位移、氧耗、寿命耗减)
    for (var cell in cells) {
      // 氧化应激加剧了流速的紊乱和寿命的衰减
      cell.x += cell.speedX * dt * (1.0 + oxidativeStress * 0.01);
      cell.y += cell.speedY * dt + (sin(cell.x * 0.05) * oxidativeStress * 0.02);
      
      // 寿命随流逝自然衰减，高应激状态下额外扣除
      cell.lifeSpan -= dt * (1.0 + oxidativeStress * 0.05);
    }

    // 3. 骨髓代偿性增殖（生成新细胞）
    // 基础生成概率为每帧 0.05（假设60fps），乘以代偿倍率
    double spawnProbability = 0.05 * cellIterationRate;
    
    // 如果缺口过大或触发概率，则压入新粒子
    int desiredCellCount = (30 * cellIterationRate).toInt(); // 维持的密度
    if (cells.length < desiredCellCount || _rnd.nextDouble() < spawnProbability) {
      int spawnCount = _rnd.nextDouble() < spawnProbability ? 1 : 0;
      if (cells.length < desiredCellCount) spawnCount += 1; // 强制补充

      for (int i = 0; i < spawnCount; i++) {
        // 高氧化应激下，新生成的细胞往往携氧能力残缺
        double initialOxygen = 1.0 - (oxidativeStress * 0.006 * _rnd.nextDouble());
        cells.add(RedBloodCell(
          x: -20.0, // 从血管左侧流出
          y: height * 0.2 + _rnd.nextDouble() * height * 0.6, // 中轴线正态波动
          maxLife: averageLifespan * (0.8 + _rnd.nextDouble() * 0.4),
          speedX: 50.0 + _rnd.nextDouble() * 30.0,
          speedY: (_rnd.nextDouble() - 0.5) * 10.0,
          oxygenCapacity: initialOxygen.clamp(0.2, 1.0),
        ));
      }
    }
  }
}

// ==========================================
// 主视图与渲染同步核心
// ==========================================

class SimulatorHomeScreen extends StatefulWidget {
  const SimulatorHomeScreen({Key? key}) : super(key: key);

  @override
  State<SimulatorHomeScreen> createState() => _SimulatorHomeScreenState();
}

class _SimulatorHomeScreenState extends State<SimulatorHomeScreen> with SingleTickerProviderStateMixin {
  late Ticker _ticker;
  Duration _lastElapsed = Duration.zero;

  // 实例化双独立引擎：对照组(固定8h) 与 实验组(动态可调)
  final BloodEnvironment _controlEnv = BloodEnvironment(isControlGroup: true, targetSleepDuration: 8.0);
  final BloodEnvironment _experimentEnv = BloodEnvironment(isControlGroup: false, targetSleepDuration: 8.0);

  @override
  void initState() {
    super.initState();
    _ticker = createTicker((elapsed) {
      double dt = (elapsed.inMilliseconds - _lastElapsed.inMilliseconds) / 1000.0;
      // 防止长暂停导致的时间跳变
      if (dt > 0.1) dt = 0.016; 
      _lastElapsed = elapsed;

      // 如果没有任何渲染区域，直接返回
      if (!mounted) return;
      
      setState(() {
        // 这里只是为了触发全局 CustomPainter 重绘，并未构建新 Widget 树节点
      });
    });
    _ticker.start();
  }

  @override
  void dispose() {
    _ticker.dispose();
    super.dispose();
  }

  void _onSleepDurationChanged(double value) {
    // UI状态直接驱动实验组的模型参数
    setState(() {
      _experimentEnv.targetSleepDuration = value;
    });
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      body: Container(
        decoration: const BoxDecoration(
          image: DecorationImage(
            image: AssetImage('assets/images/explore_ohos.png'),
            fit: BoxFit.cover,
            opacity: 0.08,
          ),
        ),
        child: SafeArea(
          child: Padding(
            padding: const EdgeInsets.all(16.0),
            child: Column(
              crossAxisAlignment: CrossAxisAlignment.stretch, // 顶部与底部占满
              children: [
                _buildHeader(),
                const SizedBox(height: 16),
                // 核心防溢出区：Expanded 会吸收所有的中间剩余高度
                Expanded(
                  child: LayoutBuilder(
                    builder: (context, constraints) {
                      // 响应式截断：宽屏双并排，窄屏上下叠
                      if (constraints.maxWidth > 700) {
                        return Row(
                          crossAxisAlignment: CrossAxisAlignment.stretch,
                          children: [
                            Expanded(child: _buildVesselViewport('对照组 (Control Group: 8H Sleep)', _controlEnv)),
                            const SizedBox(width: 16),
                            Expanded(child: _buildVesselViewport('实验组 (Experimental Group)', _experimentEnv)),
                          ],
                        );
                      } else {
                        return Column(
                          crossAxisAlignment: CrossAxisAlignment.stretch,
                          children: [
                            Expanded(child: _buildVesselViewport('对照组 (Control Group: 8H)', _controlEnv)),
                            const SizedBox(height: 16),
                            Expanded(child: _buildVesselViewport('实验组 (Experimental Group)', _experimentEnv)),
                          ],
                        );
                      }
                    },
                  ),
                ),
                const SizedBox(height: 24),
                _buildControlPanel(),
              ],
            ),
          ),
        ),
      ),
    );
  }

  Widget _buildHeader() {
    return Row(
      children: [
        const Icon(Icons.biotech, color: Color(0xFF00FFCC), size: 32),
        const SizedBox(width: 12),
        // 对长标题使用 Expanded 防横向撕裂
        Expanded(
          child: Column(
            crossAxisAlignment: CrossAxisAlignment.start,
            children: const [
              Text(
                'ERYTHROPOIESIS COMPENSATORY ENGINE // 造血代偿系统演算仪',
                style: TextStyle(fontSize: 18, fontWeight: FontWeight.bold, color: Colors.white, letterSpacing: 1.2),
                softWrap: true,
              ),
              Text(
                'Observing Bone Marrow Hemopoietic Stem Cell Hyperproliferation vs Sleep Deprivation',
                style: TextStyle(fontSize: 12, color: Colors.white54),
                softWrap: true,
              ),
            ],
          ),
        ),
      ],
    );
  }

  // 血管观测视窗构建
  Widget _buildVesselViewport(String title, BloodEnvironment env) {
    return Container(
      decoration: BoxDecoration(
        color: const Color(0xFF161B22).withOpacity(0.8),
        borderRadius: BorderRadius.circular(12),
        border: Border.all(color: env.isControlGroup ? const Color(0xFF00FFCC).withOpacity(0.3) : Colors.orangeAccent.withOpacity(0.3)),
      ),
      child: Column(
        crossAxisAlignment: CrossAxisAlignment.stretch,
        children: [
          // 面板头部：数据实时输出
          Container(
            padding: const EdgeInsets.symmetric(horizontal: 16, vertical: 12),
            decoration: BoxDecoration(
              color: Colors.black45,
              borderRadius: const BorderRadius.only(topLeft: Radius.circular(12), topRight: Radius.circular(12)),
            ),
            child: Wrap( // 用 Wrap 而不是 Row，防止数据项过多导致的挤压溢出
              spacing: 16,
              runSpacing: 8,
              children: [
                Text(
                  title, 
                  style: TextStyle(color: env.isControlGroup ? const Color(0xFF00FFCC) : Colors.orangeAccent, fontWeight: FontWeight.bold)
                ),
                Text('睡眠时长: ${env.targetSleepDuration.toStringAsFixed(1)} h', style: const TextStyle(color: Colors.white70, fontSize: 13)),
                Text('迭代倍率: x${env.cellIterationRate.toStringAsFixed(2)}', style: const TextStyle(color: Colors.white70, fontSize: 13)),
                Text('应激指数(ROS): ${env.oxidativeStress.toStringAsFixed(1)}', style: TextStyle(color: env.oxidativeStress > 50 ? Colors.redAccent : Colors.white70, fontSize: 13)),
              ],
            ),
          ),
          // 渲染核心：LayoutBuilder 取到真实高宽传递给物理引擎
          Expanded(
            child: LayoutBuilder(
              builder: (context, constraints) {
                // 每帧都在这里执行物理积分
                env.tickUpdate(0.016, constraints.maxWidth, constraints.maxHeight);
                // 绘制画布时使用 ClipRect 裁剪防止粒子飞出框外
                return ClipRect(
                  child: CustomPaint(
                    painter: BloodVesselPainter(env),
                  ),
                );
              },
            ),
          ),
        ],
      ),
    );
  }

  // 底部调参台
  Widget _buildControlPanel() {
    return Container(
      padding: const EdgeInsets.all(16),
      decoration: BoxDecoration(
        color: Colors.black54,
        borderRadius: BorderRadius.circular(12),
        border: Border.all(color: Colors.white12),
      ),
      child: Column(
        crossAxisAlignment: CrossAxisAlignment.start,
        children: [
          const Text('EXPERIMENTAL OVERRIDE // 实验参数干预: 宿主睡眠剥夺 (0-12 Hrs)', style: TextStyle(color: Colors.orangeAccent, fontWeight: FontWeight.bold)),
          const SizedBox(height: 8),
          Row(
            children: [
              const Icon(Icons.nightlight_round, color: Colors.indigoAccent),
              Expanded(
                child: Slider(
                  value: _experimentEnv.targetSleepDuration,
                  min: 0.0,
                  max: 12.0,
                  divisions: 24,
                  label: '${_experimentEnv.targetSleepDuration.toStringAsFixed(1)} H',
                  onChanged: _onSleepDurationChanged,
                ),
              ),
              const Icon(Icons.wb_sunny, color: Colors.orangeAccent),
            ],
          ),
        ],
      ),
    );
  }
}

// ==========================================
// 高性能 Canvas 渲染器
// ==========================================

class BloodVesselPainter extends CustomPainter {
  final BloodEnvironment env;

  BloodVesselPainter(this.env);

  @override
  void paint(Canvas canvas, Size size) {
    // 绘制血管肌底纹理
    final Paint bgPaint = Paint()..color = const Color(0xFF2A0D15).withOpacity(0.3);
    canvas.drawRect(Offset.zero & size, bgPaint);

    final Paint cellPaint = Paint();

    // 遍历绘制粒子
    for (var cell in env.cells) {
      // 颜色计算：缺氧会导致红细胞发紫/发暗
      double oxy = cell.oxygenCapacity;
      int r = (255 * oxy).toInt();
      int g = (50 * oxy).toInt();
      int b = (50 * (1.0 - oxy) + 20).toInt(); // 缺氧时 B 通道略微增加，呈暗紫色

      // 透明度计算：生命即将耗尽时渐隐
      double alphaScale = (cell.lifeSpan / cell.maxLife).clamp(0.0, 1.0);
      
      // 绘制光晕层
      cellPaint.color = Color.fromARGB((80 * alphaScale).toInt(), r, g, b);
      cellPaint.maskFilter = const MaskFilter.blur(BlurStyle.normal, 4.0);
      canvas.drawCircle(Offset(cell.x, cell.y), 8.0, cellPaint);

      // 绘制细胞实体层 (双凹圆盘形抽象为一个椭圆或清晰圆)
      cellPaint.color = Color.fromARGB((200 * alphaScale).toInt(), r, g, b);
      cellPaint.maskFilter = null;
      // 如果氧化应激过高，红细胞结构被破坏，绘制不规则形状（利用正弦抖动模拟棘红细胞）
      if (env.oxidativeStress > 60) {
        canvas.drawOval(
          Rect.fromCenter(
            center: Offset(cell.x, cell.y), 
            width: 10 + sin(cell.lifeSpan * 5) * 2, 
            height: 10 + cos(cell.lifeSpan * 5) * 2
          ), 
          cellPaint
        );
      } else {
        canvas.drawCircle(Offset(cell.x, cell.y), 6.0, cellPaint);
      }
    }
  }

  // 由于依赖传入对象内部的持续突变，且已被外部 Ticker 驱动，这里直接返回 true 以执行高频刷帧
  @override
  bool shouldRepaint(covariant BloodVesselPainter oldDelegate) => true;
}