fis_lib_measure/lib/process/calcuators/sv.dart

import 'package:fis_measure/configs/patient.dart';
import 'package:fis_measure/interfaces/process/calculators/values.dart';
import 'package:fis_measure/interfaces/process/items/item_metas.dart';
import 'package:fis_measure/interfaces/process/items/terms.dart';
import 'package:fis_measure/process/primitives/combos/sv.dart';
import 'package:fis_measure/process/primitives/multi_method/multiple_trace.dart';
import 'package:vid/us/vid_us_unit.dart';

import 'calculator.dart';
import 'trace.dart';
import 'unit_formulas/index.dart';

class SvCal extends Calculator<Sv, double> {
  SvCal(super.ref);

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

    final feature = ref.feature!;

    feature.values.clear();

    final itemName = ref.meta.name;
    if (['qp', 'qs'].contains(itemName.toLowerCase())) {
      final output = ItemOutputMeta(itemName, itemName, VidUsUnit.None);
      // Qp、Qs仅占位
      feature.updateStringValue(output, '');
    } else {
      updateStringValue("");
    }

    final diam = pickChildToFloatValue(ref.l)?.toUnitFloatValue();
    if (diam == null) {
      return;
    }

    final viewport = ref.application.currentVisualArea.viewport!;

    UnitFloatValue? vti;
    UnitFloatValue? sv;
    UnitFloatValue? co;
    int? hr;
    final bsa = GlobalPatientConfig.bsa;

    TraceItemFeatureAbstract? traceFeature = ref.trace.feature;
    if (traceFeature == null) {
      if (ref.trace.measuredFeatures.isNotEmpty) {
        traceFeature = ref.trace.measuredFeatures.first;
      }
    }

    if (traceFeature != null) {
      final countVTIResult = TraceCal.getCountVTI(traceFeature);
      var outputVTI = countVTIResult[0];
      var outputHR = countVTIResult[5];

      // vti = UnitFloatValue(outputVTI, viewport.yUnit);
      vti = UnitFloatValue(outputVTI, VidUsUnit.cm); // TODO: cm/s 取 cm
      hr = outputHR.toInt();

      sv = UnitFormulas.general.svDiam(diam, vti);
    }

    if (traceFeature != null) {
      //  Trace 输出
      for (var output in ref.trace.meta.outputs) {
        if (output.name == MeasureTerms.SV_Trace) {
          // feature.updateStringValue(output, '', VidUsUnit.None);
        } else if (output.name == MeasureTerms.VTI) {
          // if (vti != null) {
          //   feature.updateFloatValue(output, vti, VidUsUnit.cm);
          // }
        } else if (output.name == MeasureTerms.HeartRate) {
          if (hr != null) {
            feature.updateFloatValue(output, hr.toDouble(), VidUsUnit.HR);
          }
        }
      }
    }

    if (sv != null) {
      for (var output in ref.meta.outputs) {
        switch (output.name) {
          case MeasureTerms.SV:
            feature.updateFloatValue(output, sv.value, sv.unit);
            break;
          case MeasureTerms.SI:
            if (bsa > 0) {
              final si = UnitFormulas.cardiac.si(sv, bsa: bsa);
              feature.updateFloatValue(output, si.value, si.unit);
            }
            break;
          case MeasureTerms.CO:
            if (hr != null) {
              final co = UnitFormulas.cardiac.co(sv, hr: hr);
              feature.updateFloatValue(output, co.value, co.unit);
            }
            break;
          case MeasureTerms.CI:
            if (hr != null && bsa > 0) {
              final ci = UnitFormulas.cardiac.ci(sv, bsa: bsa, hr: hr);
              feature.updateFloatValue(output, ci.value, ci.unit);
            }
            break;
        }
      }
    }

    final csaIndex =
        ref.meta.outputs.indexWhere((e) => e.name == MeasureTerms.CSA);
    if (csaIndex > -1) {
      final output = ref.meta.outputs[csaIndex];
      final csa = UnitFormulas.general.csa(diam);
      feature.updateFloatValue(output, csa.value, csa.unit);
    }
  }
}