fis_lib_measure/lib/process/calcuators/semiauto_trace.dart

import 'dart:ui';

import 'package:fis_measure/interfaces/date_types/point.dart';
import 'package:fis_measure/interfaces/date_types/vector.dart';
import 'package:fis_measure/interfaces/process/items/terms.dart';
import 'package:fis_measure/interfaces/process/workspace/application.dart';
import 'package:fis_measure/process/calcuators/formulas/cardiac.dart';
import 'package:fis_measure/process/calcuators/formulas/general.dart';
import 'package:fis_measure/process/items/item_feature.dart';
import 'package:fis_measure/process/primitives/multi_method/dop_trace_disp/cardiac_cycle.dart';
import 'package:fis_measure/process/primitives/multi_method/dop_trace_disp/data.dart';
import 'dart:math' as math;
import 'package:fis_measure/process/primitives/multi_method/semiauto_trace.dart';
import 'package:get/get.dart';
import 'calculator.dart';

class SemiautoTraceCal extends Calculator<TraceItemAbstract, double> {
  SemiautoTraceCal(TraceItemAbstract ref) : super(ref);
  double cyclesStart = double.maxFinite;
  double cyclesEnd = double.minPositive;
  int validSystoleCyclesLength = 0;

  @override
  void calculate() {
    if (ref.feature == null) return;

    Map<String, double> calculateDopplerTraceResult = {};

    final feature = ref.feature!;
    final viewport = feature.hostVisualArea!.viewport!;

    Size displaySize = Get.find<IApplication>().displaySize;
    // 加入画布偏移量
    final canvasOffset = feature.hostVisualArea!.layoutRegion!.topLeft;
    //加入坐标系偏移量
    final coordinateOffset = viewport.region;

    var data = TraceListData.instance;

    /// 最大点集
    List<DPoint> maxPhysicalPonints = data.maxPonints;

    List<CardiacCycle> validSystoleCycles = ref.currentCardiacCycleList;
    if (validSystoleCycles.isEmpty) {
      final regionPoints = feature.innerPoints
          .map((e) => viewport
              .convert(e
                  .clone()
                  .addVector(DVector(-canvasOffset.x, -canvasOffset.y)))
              .addVector(DVector(coordinateOffset.left, -coordinateOffset.top)))
          .toList();
      final yFlippedPoints =
          regionPoints.map((e) => DPoint(e.x, -e.y)).toList();
      double min = math.min(yFlippedPoints.first.x, yFlippedPoints.last.x);
      double max = math.max(yFlippedPoints.first.x, yFlippedPoints.last.x);
      calculateDopplerTraceResult =
          calculateDopplerTrace(yFlippedPoints, min, max);
    }

    if (validSystoleCyclesLength != validSystoleCycles.length) {
      for (CardiacCycle i in validSystoleCycles) {
        List<DPoint> regionPoints =
            getPoints(maxPhysicalPonints, i, displaySize);
        final points = regionPoints.map((e) {
          final currentPoint = viewport
              .convert(DPoint(e.x / displaySize.width, e.y / displaySize.height)
                  .clone()
                  .addVector(DVector(-canvasOffset.x, -canvasOffset.y)))
              .addVector(DVector(coordinateOffset.left, -coordinateOffset.top));
          return DPoint(currentPoint.x, -currentPoint.y);
        }).toList();
        double min = math.min(points.first.x, points.last.x);
        double max = math.max(points.first.x, points.last.x);

        calculateDopplerTraceResult =
            calculateDopplerTrace(points, min, max, i);
      }

      if (validSystoleCycles.isEmpty) {
        feature.initValues();
      }
      validSystoleCyclesLength = validSystoleCycles.length;
    }

    for (var output in ref.meta.outputs) {
      ///TODO:[Gavin] 实现以下计算逻辑
      switch (output.name) {
        case MeasureTerms.TAMAX:
          if (calculateDopplerTraceResult[MeasureTerms.TAMAX] != null) {
            feature.updateFloatValue(output,
                calculateDopplerTraceResult[MeasureTerms.TAMAX]!, output.unit);
          }
          break;
        case MeasureTerms.TAMEAN:
          if (calculateDopplerTraceResult[MeasureTerms.TAMEAN] != null) {
            feature.updateFloatValue(output,
                calculateDopplerTraceResult[MeasureTerms.TAMEAN]!, output.unit);
          }
          break;
        case MeasureTerms.PS:
          if (calculateDopplerTraceResult[MeasureTerms.PS] != null) {
            feature.updateFloatValue(output,
                calculateDopplerTraceResult[MeasureTerms.PS]!, output.unit);
          }
          break;
        case MeasureTerms.ED:
          if (calculateDopplerTraceResult[MeasureTerms.ED] != null) {
            feature.updateFloatValue(output,
                calculateDopplerTraceResult[MeasureTerms.ED]!, output.unit);
          }
          break;
        case MeasureTerms.MD:
          if (calculateDopplerTraceResult[MeasureTerms.MD] != null) {
            feature.updateFloatValue(output,
                calculateDopplerTraceResult[MeasureTerms.MD]!, output.unit);
          }
          break;
        case MeasureTerms.HeartRate:
          if (calculateDopplerTraceResult[MeasureTerms.HeartRate] != null) {
            feature.updateFloatValue(
                output,
                calculateDopplerTraceResult[MeasureTerms.HeartRate]!,
                output.unit);
          }
          break;
        case MeasureTerms.Acceleration:
          if (calculateDopplerTraceResult[MeasureTerms.Acceleration] != null) {
            feature.updateFloatValue(
                output,
                calculateDopplerTraceResult[MeasureTerms.Acceleration]!,
                output.unit);
          }
          break;
        case MeasureTerms.AT:
          if (calculateDopplerTraceResult[MeasureTerms.AT] != null) {
            feature.updateFloatValue(output,
                calculateDopplerTraceResult[MeasureTerms.AT]!, output.unit);
          }
          break;
        case MeasureTerms.PSED:
          if (calculateDopplerTraceResult[MeasureTerms.PSED] != null) {
            feature.updateFloatValue(output,
                calculateDopplerTraceResult[MeasureTerms.PSED]!, output.unit);
          }
          break;
        case MeasureTerms.EDPS:
          if (calculateDopplerTraceResult[MeasureTerms.EDPS] != null) {
            feature.updateFloatValue(output,
                calculateDopplerTraceResult[MeasureTerms.EDPS]!, output.unit);
          }
          break;
        case MeasureTerms.PI:
          if (calculateDopplerTraceResult[MeasureTerms.PI] != null) {
            feature.updateFloatValue(output,
                calculateDopplerTraceResult[MeasureTerms.PI]!, output.unit);
          }
          break;
        case MeasureTerms.PIMD:
          if (calculateDopplerTraceResult[MeasureTerms.PIMD] != null) {
            feature.updateFloatValue(output,
                calculateDopplerTraceResult[MeasureTerms.PIMD]!, output.unit);
          }
          break;
        case MeasureTerms.RI:
          if (calculateDopplerTraceResult[MeasureTerms.RI] != null) {
            feature.updateFloatValue(output,
                calculateDopplerTraceResult[MeasureTerms.RI]!, output.unit);
          }
          break;
        case MeasureTerms.RIMD:
          if (calculateDopplerTraceResult[MeasureTerms.RIMD] != null) {
            feature.updateFloatValue(output,
                calculateDopplerTraceResult[MeasureTerms.RIMD]!, output.unit);
          }
          break;
        case MeasureTerms.MaxPG:
          if (calculateDopplerTraceResult[MeasureTerms.MaxPG] != null) {
            feature.updateFloatValue(output,
                calculateDopplerTraceResult[MeasureTerms.MaxPG]!, output.unit);
          }
          break;
        case MeasureTerms.VelocityMax:
          if (calculateDopplerTraceResult[MeasureTerms.VelocityMax] != null) {
            feature.updateFloatValue(
                output,
                calculateDopplerTraceResult[MeasureTerms.VelocityMax]!,
                output.unit);
          }
          break;
        case MeasureTerms.VelocityMean:
          if (calculateDopplerTraceResult[MeasureTerms.VelocityMean] != null) {
            feature.updateFloatValue(
                output,
                calculateDopplerTraceResult[MeasureTerms.VelocityMean]!,
                output.unit);
          }
          break;
        case MeasureTerms.PeakPG:
          if (calculateDopplerTraceResult[MeasureTerms.PeakPG] != null) {
            feature.updateFloatValue(output,
                calculateDopplerTraceResult[MeasureTerms.PeakPG]!, output.unit);
          }
          break;
        case MeasureTerms.VTI:
          if (calculateDopplerTraceResult[MeasureTerms.VTI] != null) {
            feature.updateFloatValue(output,
                calculateDopplerTraceResult[MeasureTerms.VTI]!, output.unit);
          }
          break;
        case MeasureTerms.VTIMean:
          if (calculateDopplerTraceResult[MeasureTerms.VTIMean] != null) {
            feature.updateFloatValue(
                output,
                calculateDopplerTraceResult[MeasureTerms.VTIMean]!,
                output.unit);
          }
          break;
        case MeasureTerms.MPG:
          if (calculateDopplerTraceResult[MeasureTerms.MPG] != null) {
            feature.updateFloatValue(output,
                calculateDopplerTraceResult[MeasureTerms.MPG]!, output.unit);
          }
          break;
        case MeasureTerms.MMPG:
          if (calculateDopplerTraceResult[MeasureTerms.MMPG] != null) {
            feature.updateFloatValue(output,
                calculateDopplerTraceResult[MeasureTerms.MMPG]!, output.unit);
          }
          break;
        case MeasureTerms.TiEnv:
          // var outputTiEnv = GeneralFormulas.countEnvelopeTime(points);
          if (calculateDopplerTraceResult[MeasureTerms.TiEnv] != null) {
            feature.updateFloatValue(output,
                calculateDopplerTraceResult[MeasureTerms.TiEnv]!, output.unit);
          }
          break;
        case MeasureTerms.EVEL:
          if (calculateDopplerTraceResult[MeasureTerms.EVEL] != null) {
            feature.updateFloatValue(output,
                calculateDopplerTraceResult[MeasureTerms.EVEL]!, output.unit);
          }
          break;
        case MeasureTerms.AVEL:
          if (calculateDopplerTraceResult[MeasureTerms.AVEL] != null) {
            feature.updateFloatValue(output,
                calculateDopplerTraceResult[MeasureTerms.AVEL]!, output.unit);
          }
          break;
        case MeasureTerms.EARatio:
          if (calculateDopplerTraceResult[MeasureTerms.EARatio] != null) {
            feature.updateFloatValue(
                output,
                calculateDopplerTraceResult[MeasureTerms.EARatio]!,
                output.unit);
          }
          break;
        case MeasureTerms.DT:
          if (calculateDopplerTraceResult[MeasureTerms.DT] != null) {
            feature.updateFloatValue(output,
                calculateDopplerTraceResult[MeasureTerms.DT]!, output.unit);
          }
          break;
        case MeasureTerms.PHT:
          if (calculateDopplerTraceResult[MeasureTerms.PHT] != null) {
            feature.updateFloatValue(output,
                calculateDopplerTraceResult[MeasureTerms.PHT]!, output.unit);
          }
          break;
        case MeasureTerms.VA:
          if (calculateDopplerTraceResult[MeasureTerms.VA] != null) {
            feature.updateFloatValue(output,
                calculateDopplerTraceResult[MeasureTerms.VA]!, output.unit);
          }
          break;
        case MeasureTerms.ADur:
          if (calculateDopplerTraceResult[MeasureTerms.ADur] != null) {
            feature.updateFloatValue(output,
                calculateDopplerTraceResult[MeasureTerms.ADur]!, output.unit);
          }
          break;
        case MeasureTerms.ATDTRatio:
          if (calculateDopplerTraceResult[MeasureTerms.ATDTRatio] != null) {
            feature.updateFloatValue(
                output,
                calculateDopplerTraceResult[MeasureTerms.ATDTRatio]!,
                output.unit);
          }
          break;
        case MeasureTerms.ATETRatio:
          if (calculateDopplerTraceResult[MeasureTerms.ATETRatio] != null) {
            feature.updateFloatValue(
                output,
                calculateDopplerTraceResult[MeasureTerms.ATETRatio]!,
                output.unit);
          }
          break;
        // case MeasureTerms.Trace:
        //   if (calculateDopplerTraceResult[MeasureTerms.TAMAX] != null) {

        //   break;
        default:
          break;
      }
    }
  }

  DPoint transitionPoint(DPoint i) {
    final feature = ref.feature!;
    final viewport = feature.hostVisualArea!.viewport!;
    // RectRegion? region = feature.hostVisualArea!.layoutRegion;

    Size displaySize = Get.find<IApplication>().displaySize;
    final widthScale = Get.find<IApplication>().displayScaleRatio;
    // 加入画布偏移量
    final canvasOffset = feature.hostVisualArea!.layoutRegion!.topLeft;
    //加入坐标系偏移量
    final coordinateOffset = viewport.region;
    return viewport
        .convert(DPoint(i.clone().x / displaySize.width * widthScale,
                i.clone().y / displaySize.height * widthScale)
            .clone()
            .addVector(DVector(-canvasOffset.x, -canvasOffset.y)))
        .addVector(DVector(coordinateOffset.left, -coordinateOffset.top));
  }

  List<DPoint> getPoints(List<DPoint> lines, CardiacCycle cycle, Size size) {
    List<DPoint> points = [];
    for (DPoint line in lines) {
      DPoint point = DPoint(line.x, line.y);
      if (point.x >= cycle.systoleStart.x && point.x <= cycle.diastoleEnd.x) {
        points.add(DPoint(point.x / size.width, point.y / size.height));
      }
    }
    return points;
  }

  /// 转成物理坐标
  DPoint convert2LogicPoint(Size size, DPoint viewPoint, double baseLine,
      double width, double height) {
    final x = viewPoint.x / size.width * width;
    final y = viewPoint.y - (baseLine * size.height) * height;
    return DPoint(x, y);
  }

  static List<DPoint> getFeatureYFlippedPoints(MeasureItemFeature feature) {
    final viewport = feature.hostVisualArea!.viewport!;
    // 加入画布偏移量
    final canvasOffset = feature.hostVisualArea!.layoutRegion!.topLeft;
    //加入坐标系偏移量
    final coordinateOffset = viewport.region;
    final regionPoints = feature.innerPoints
        .map((e) => viewport
            .convert(
                e.clone().addVector(DVector(-canvasOffset.x, -canvasOffset.y)))
            .addVector(DVector(coordinateOffset.left, -coordinateOffset.top)))
        .toList();
    final points = regionPoints.map((e) => DPoint(e.x, -e.y)).toList();
    return points;
  }

  static List<double> getCountVTI(MeasureItemFeature feature) {
    final yFlippedPoints = getFeatureYFlippedPoints(feature);
    final result = GeneralFormulas.countVTI(yFlippedPoints);
    return result;
  }

  /// 获取到值之后
  Map<String, double> calculateHeartCycleRelevantValues(
    CardiacCycle heartCycle,
    List<DPoint> maxTraceLineOfCycle,
    List<DPoint> meanTraceLineOfCycle,
  ) {
    double pv = double.nan;
    double vtiMean = double.nan;
    double taMean = double.nan;
    double mmpg = double.nan;
    if (meanTraceLineOfCycle.isNotEmpty) {
      vtiMean = GeneralFormulas.countVTI(meanTraceLineOfCycle).first;
    }

    double vti = double.nan;
    double taMax = double.nan;
    double mpg = double.nan;
    double ps = double.nan;
    double ed = double.nan;
    double md = double.nan;
    double acctime = double.nan;
    double accel = double.nan;
    if (maxTraceLineOfCycle.isNotEmpty) {
      List<double> vtiResult = GeneralFormulas.countVTI(maxTraceLineOfCycle);

      vti = vtiResult.first;
      ps = heartCycle.peakSystolic.y;
      ed = heartCycle.diastoleEnd.y;
      md = heartCycle.minimumAbsoluteVelocity.y;
      taMax = vtiResult[2];
      pv = vtiResult[3];
      mpg = vtiResult[4];
      mmpg = vtiResult[4];
      acctime = heartCycle.peakSystolic.x - heartCycle.systoleStart.x;
      accel = (heartCycle.peakSystolic.y - heartCycle.systoleStart.y).abs() /
          acctime;
    }
    double velE = double.nan;
    double velA = double.nan;
    double dt = double.nan;
    double pht = double.nan;
    double va = double.nan;
    double aDur = double.nan;
    double eAration = double.nan;

    if (heartCycle.ePeak != DPoint.zero && heartCycle.ePeak != null) {
      velE = heartCycle.ePeak!.y;
      if (heartCycle.ePeakEnd != DPoint.zero &&
          heartCycle.ePeak != DPoint.zero) {
        acctime = heartCycle.ePeak!.x - heartCycle.systoleStart.x;
        accel =
            (heartCycle.ePeak!.y - heartCycle.systoleStart.y).abs() / acctime;
      }
    }
    if (heartCycle.aPeak != DPoint.zero && heartCycle.aPeak != null) {
      velA = heartCycle.aPeak!.y;
    }
    if (heartCycle.ePeak != DPoint.zero && heartCycle.aPeak != DPoint.zero) {
      eAration = (velE - velA).abs();
    }
    if (heartCycle.ePeak != DPoint.zero &&
        heartCycle.ePeakEnd != DPoint.zero &&
        heartCycle.aPeak != null &&
        heartCycle.ePeakEnd != null) {
      dt = (heartCycle.ePeakEnd!.x - heartCycle.ePeak!.x).abs();
      pht = CardiacFormulas.phtByDecT(dt);
      va = CardiacFormulas.mvaByPht(pht);
    }
    if (heartCycle.aPeakStart != DPoint.zero && heartCycle.aPeakStart != null) {
      aDur = (heartCycle.diastoleEnd.x - heartCycle.aPeakStart!.x).abs();
    }

    return {
      MeasureTerms.PS: ps,
      MeasureTerms.ED: ed,
      MeasureTerms.MD: md,
      MeasureTerms.VelocityMax: pv,
      MeasureTerms.AT: acctime,
      MeasureTerms.Acceleration: accel,
      MeasureTerms.TAMAX: taMax,
      MeasureTerms.TAMEAN: taMean,
      MeasureTerms.VTI: vti,
      MeasureTerms.VTIMean: vtiMean,
      MeasureTerms.MPG: mpg,
      MeasureTerms.MMPG: mmpg,
      MeasureTerms.EVEL: velE,
      MeasureTerms.AVEL: velA,
      MeasureTerms.EARatio: eAration,
      MeasureTerms.DT: dt,
      MeasureTerms.PHT: pht,
      MeasureTerms.VA: va,
      MeasureTerms.ADur: aDur,
    };
  }

  double ratio(double d1, double d2) {
    return d1 / d2;
  }

  Map<String, double> calculateDopplerTrace([
    List<DPoint>? maxTraceLine,
    double envStart = double.nan,
    double envEnd = double.nan,
    CardiacCycle? cardiacCycle,
  ]) {
    Map<String, double> baseValues = {};

    if (cardiacCycle != null) {
      CardiacCycle transitionCardiacCycle = CardiacCycle(
        diastoleEnd: DPoint(0, 0),
        systoleStart: DPoint(0, 0),
        peakSystolic: DPoint(0, 0),
        minimumAbsoluteVelocity: DPoint(0, 0),
        index: 0,
      );
      transitionCardiacCycle.peakSystolic = DPoint(
          transitionPoint(cardiacCycle.peakSystolic).x,
          -transitionPoint(cardiacCycle.peakSystolic).y);
      transitionCardiacCycle.systoleStart = DPoint(
          transitionPoint(cardiacCycle.systoleStart).x,
          -transitionPoint(cardiacCycle.systoleStart).y);
      transitionCardiacCycle.diastoleEnd = DPoint(
          transitionPoint(cardiacCycle.diastoleEnd).x,
          -transitionPoint(cardiacCycle.diastoleEnd).y);

      cyclesStart =
          math.min(transitionCardiacCycle.systoleStart.x, cyclesStart);
      cyclesEnd = math.max(transitionCardiacCycle.diastoleEnd.x, cyclesEnd);

      List<DPoint> maxTraceLineOfCycle = maxTraceLine ?? [];
      List<DPoint> meanTraceLineOfCycle = maxTraceLine ?? [];
      baseValues = calculateHeartCycleRelevantValues(
        transitionCardiacCycle,
        maxTraceLineOfCycle,
        meanTraceLineOfCycle,
      );
      double? ps = baseValues[MeasureTerms.PS];
      double? ed = baseValues[MeasureTerms.ED];
      double? md = baseValues[MeasureTerms.MD];
      double? taMax = baseValues[MeasureTerms.TAMAX];

      if (ps != null) {
        if (ed != null) {
          double maxPG = GeneralFormulas.maxPG(ps, ed);
          double psed = ratio(ps, ed).abs();
          double edps = ratio(ed, ps).abs();
          double ri = GeneralFormulas.countRI(ps, ed);
          double velocityMean = GeneralFormulas.medianVelocity(ps, ed);
          baseValues.addAll({
            MeasureTerms.MaxPG: maxPG,
            MeasureTerms.PSED: psed,
            MeasureTerms.EDPS: edps,
            MeasureTerms.RI: ri.abs(),
            MeasureTerms.VelocityMean: velocityMean,
          });
          if (taMax != null) {
            double pi = GeneralFormulas.pi(ps, ed, taMax);
            baseValues.addAll({
              MeasureTerms.PI: pi,
            });
          }
          double vMean = GeneralFormulas.medianVelocity(ps, ed);
          double piTCD = GeneralFormulas.pi(ps, ed, vMean);
          if (!piTCD.isNaN) {
            baseValues.addAll({
              MeasureTerms.PITCD: piTCD,
            });
          }
        }
        if (md != null) {
          double rimd = GeneralFormulas.countRI(ps, md).abs();
          baseValues.addAll({
            MeasureTerms.RIMD: rimd,
          });
          if (taMax != null) {
            double piMd = GeneralFormulas.pi(ps, md, taMax);
            if (!piMd.isNaN) {
              baseValues.addAll({
                MeasureTerms.PIMD: piMd,
              });
            }
          }
        }
      }
      double? pv = baseValues[MeasureTerms.VelocityMax];

      if (pv != null) {
        double peakPG = GeneralFormulas.countPressure(pv);
        baseValues.addAll({
          MeasureTerms.PeakPG: peakPG,
        });
      }
      double cycleEnvTimeSpan = (cyclesEnd - cyclesStart).abs();

      if (cycleEnvTimeSpan > 0) {
        /// dopplerTrace.AvgHeartCycle, 需要获取
        double? hr = GeneralFormulas.countHR(cycleEnvTimeSpan);
        baseValues.addAll({
          MeasureTerms.HeartRate: hr,
          MeasureTerms.TiEnv: cycleEnvTimeSpan,
        });
      }

      double? velE = baseValues[MeasureTerms.EVEL];
      double? velA = baseValues[MeasureTerms.AVEL];
      if (velA != null && velE != null) {
        double? eARatio = ratio(velA, velE).abs();
        baseValues.addAll({
          MeasureTerms.EARatio: eARatio,
        });
      }
    } else if (!envStart.isNaN &&
        !envEnd.isNaN &&
        !envStart.almostEquals(double.minPositive, 0.000001) &&
        !envEnd.almostEquals(double.minPositive, 0.000001)) {
      // List<DPoint> maxTraceLine = [];
      List<DPoint> meanTraceLine = [];
      Map<String, double> meanValues =
          tryCalculateByTrace(meanTraceLine, envStart, envEnd, false);
      Map<String, double> maxValues =
          tryCalculateByTrace(maxTraceLine!, envStart, envEnd, true);
      baseValues.addAll(meanValues);
      baseValues.addAll(maxValues);
    }

    double? at = baseValues[MeasureTerms.AT];
    double? dt = baseValues[MeasureTerms.DT];
    double? et = baseValues[MeasureTerms.TiEnv];

    if (at != null && dt != null && et != null) {
      double? atdt = ratio(at, dt).abs();
      double? atet = ratio(at, et).abs();
      baseValues.addAll({
        MeasureTerms.ATDTRatio: atdt,
        MeasureTerms.ATETRatio: atet,
      });
    }

    return baseValues;
  }

  Map<String, double> tryCalculateByTrace(
    List<DPoint> traceLine,
    double envStart,
    double envEnd,
    bool isMax,
  ) {
    double vti = double.nan;
    double tiEnv = double.nan;
    double ta = double.nan;
    double pv = double.nan;
    double meanPG = double.nan;

    if (traceLine.isNotEmpty) {
      List<DPoint> line = [];
      for (var point in traceLine) {
        line.add(point);
        // if (point.x.almostNotLessThan(point.x, envStart) &&
        //     point.x.almostNotGreaterThan(point.x, envEnd)) {
        //   line.add(point);
        // }
      }
      if (line.isNotEmpty) {
        List<double> vueResult = GeneralFormulas.countVTI(line);
        vti = vueResult.first;
        var isShowAbsValue = true; // 假设这是从某个服务获取的值
        if (isShowAbsValue) {
          ta = vueResult[2].abs();
          pv = vueResult[3].abs();
          tiEnv = vueResult[1];
          meanPG = vueResult[4];
        }
      }
    }
    if (isMax) {
      return {
        MeasureTerms.TAMAX: ta,
        MeasureTerms.VTI: vti,
        MeasureTerms.MPG: meanPG,
        MeasureTerms.TiEnv: tiEnv,
        MeasureTerms.VelocityMax: pv
      };
    }
    return {
      MeasureTerms.TAMEAN: ta,
      MeasureTerms.VTIMean: vti,
      MeasureTerms.MMPG: meanPG,
      MeasureTerms.TiEnv: tiEnv,
      MeasureTerms.VelocityMax: pv,
      MeasureTerms.PeakPG: pv,
    };
  }
}

extension DoubleExtensions on double {
  bool almostEquals(double other, double precision) {
    if (isNaN && other.isNaN) {
      return true;
    }
    return (this - other).abs() <= precision.abs();
  }

  bool almostNotLessThan(double double1, double double2,
      [double precision = 0.000001]) {
    if (double1 < double2) {
      return true;
    }
    return double1.almostEquals(double2, precision);
  }

  bool almostNotGreaterThan(double double1, double double2,
      [double precision = 0.000001]) {
    if (double1 > double2) {
      return true;
    }
    return double1.almostEquals(double2, precision);
  }
}