fis_lib_measure/lib/process/calcuators/lv_study.dart

import 'package:fis_measure/configs/cardiac.dart';
import 'package:fis_measure/configs/patient.dart';
import 'package:fis_measure/interfaces/enums/calcuator.dart';
import 'package:fis_measure/interfaces/process/items/item.dart';
import 'package:fis_measure/interfaces/process/items/terms.dart';
import 'package:fis_measure/process/items/top_item.dart';
import 'package:fis_measure/process/primitives/combos/lv_study.dart';
import 'package:fis_measure/process/primitives/combos/two_straightline.dart';
import 'package:fis_measure/process/primitives/straightline.dart';
import 'package:flutter/foundation.dart';
import 'package:vid/us/vid_us_unit.dart';
import 'dart:math' as math;

import 'calculator.dart';
import 'formulas/cardiac.dart';

class LvStudySimpleCal extends LvStudyCalculatorBase<LvStudy> {
  late final StraightLine kidLVIDd;
  late final StraightLine kidLVIDs;

  LvStudySimpleCal(super.ref) {
    kidLVIDd = ref.findChildByName("L1") as StraightLine;
    kidLVIDs = ref.findChildByName("L2") as StraightLine;
  }

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

    final feature = ref.feature!;

    restoreVals();
    v.lvidd = pickChildFloatValue(kidLVIDd);
    v.lvids = pickChildFloatValue(kidLVIDs);

    for (var output in ref.meta.outputs) {
      switch (output.name) {
        case MeasureTerms.LvStudySimple:
          feature.updateStringValue(output, "");
          break;
        case MeasureTerms.LVEDV:
          updateLVEDV();
          break;
        case MeasureTerms.LVESV:
          updateLVESV();
          break;
        case MeasureTerms.SV:
          updateSV();
          break;
        case MeasureTerms.EF:
          updateEF();
          break;
        case MeasureTerms.FS:
          updatePercentFS();
          break;
      }
    }
  }
}

class LvStudyDistanceGroupCal extends LvStudyCalculatorBase<LvStudy> {
  late final StraightLine kidIVSd;
  late final StraightLine kidLVIDd;
  late final StraightLine kidLVPWd;
  late final StraightLine kidIVSs;
  late final StraightLine kidLVIDs;
  late final StraightLine kidLVPWs;

  LvStudyDistanceGroupCal(super.ref) {
    kidIVSd = ref.findChildByName(MeasureTerms.IVSd) as StraightLine;
    kidLVIDd = ref.findChildByName(MeasureTerms.LVIDd) as StraightLine;
    kidLVPWd = ref.findChildByName(MeasureTerms.LVPWd) as StraightLine;
    kidIVSs = ref.findChildByName(MeasureTerms.IVSs) as StraightLine;
    kidLVIDs = ref.findChildByName(MeasureTerms.LVIDs) as StraightLine;
    kidLVPWs = ref.findChildByName(MeasureTerms.LVPWs) as StraightLine;
  }

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

    final feature = ref.feature!;

    v = _ValTemp();
    v.ivsd = pickChildFloatValue(kidIVSd);
    v.ivss = pickChildFloatValue(kidIVSs);
    v.lvidd = pickChildFloatValue(kidLVIDd);
    v.lvids = pickChildFloatValue(kidLVIDs);
    v.lvpwd = pickChildFloatValue(kidLVPWd);
    v.lvpws = pickChildFloatValue(kidLVPWs);

    for (var output in ref.meta.outputs) {
      switch (output.name) {
        case MeasureTerms.LvStudy:
          feature.updateStringValue(output, "");
          break;
        case MeasureTerms.LVEDV:
          updateLVEDV();
          break;
        case MeasureTerms.LVESV:
          updateLVESV();
          break;
        case MeasureTerms.LVdMass:
          updateLVdMass();
          break;
        case MeasureTerms.PercentIVS:
          updatePercentIVS();
          break;
        case MeasureTerms.SV:
          updateSV();
          break;
        case MeasureTerms.EF:
          updateEF();
          break;
        case MeasureTerms.FS:
          updatePercentFS();
          break;
        case MeasureTerms.PercentLVPW:
          updatePercentLVPW();
          break;
        case MeasureTerms.CO:
          updateCO();
          break;
        case MeasureTerms.CI:
          updateCI();
          break;
        case MeasureTerms.SI:
          updateSI();
          break;
      }
    }
  }
}

class LvStudyCalculatorBase<T extends TopMeasureItem>
    extends Calculator<T, double> {
  LvStudyCalculatorBase(super.ref);

  @protected
  late _ValTemp v;

  @override
  void calculate() {
    // TODO: implement calculate
  }

  void restoreVals() {
    v = _ValTemp();
  }

  @protected
  void updateLVEDV() {
    if (v.lvidd == null) {
      return;
    }
    final lvidd = v.lvidd!;

    double value = 0;
    if (GlobalCardiacConfigs.EDVFormulaMode ==
        CardiacEDVFormulaMode.teichholz) {
      value = CardiacFormulas.edvTeichholz(lvidd);
    } else if (GlobalCardiacConfigs.EDVFormulaMode ==
        CardiacEDVFormulaMode.cube) {
      value = CardiacFormulas.edvCube(lvidd);
    }
    updateFloatValueByName(MeasureTerms.LVEDV, value, unit: VidUsUnit.cm3);
    v.lvedv = value;
  }

  @protected
  void updateLVESV() {
    if (v.lvids == null) {
      return;
    }
    final lvids = v.lvids!;

    double value = 0;
    if (GlobalCardiacConfigs.EDVFormulaMode ==
        CardiacEDVFormulaMode.teichholz) {
      value = CardiacFormulas.esvTeichholz(lvids);
    } else if (GlobalCardiacConfigs.EDVFormulaMode ==
        CardiacEDVFormulaMode.cube) {
      value = CardiacFormulas.esvCube(lvids);
    }
    updateFloatValueByName(MeasureTerms.LVESV, value, unit: VidUsUnit.cm3);
    v.lvesv = value;
  }

  @protected
  void updateLVdMass() {
    if (v.ivsd == null || v.lvidd == null || v.lvpwd == null) {
      return;
    }

    double value = CardiacFormulas.lvdMass(v.ivsd!, v.lvidd!, v.lvpwd!);
    updateFloatValueByName(MeasureTerms.LVdMass, value, unit: VidUsUnit.kg);
  }

  @protected
  void updatePercentIVS() {
    if (v.ivsd == null || v.ivss == null) {
      return;
    }
    double value = CardiacFormulas.ivsPercent(v.ivss!, v.ivsd!);
    updateFloatValueByName(MeasureTerms.PercentIVS, value);
  }

  @protected
  void updateSV() {
    if (v.lvedv == null || v.lvesv == null) {
      return;
    }
    final edv = v.lvedv!;
    final esv = v.lvesv!;
    double value = CardiacFormulas.sv(edv, esv);
    updateFloatValueByName(MeasureTerms.SV, value, unit: VidUsUnit.cm3);
    v.sv = value;
  }

  @protected
  void updateEF() {
    if (v.lvedv == null || v.lvesv == null) {
      return;
    }
    final edv = v.lvedv!;
    final esv = v.lvesv!;
    double value = CardiacFormulas.ef(edv, esv);
    updateFloatValueByName(MeasureTerms.EF, value, unit: VidUsUnit.percent);
  }

  @protected
  void updatePercentFS() {
    if (v.lvidd == null || v.lvids == null) {
      return;
    }
    final lvidd = v.lvidd!;
    final lvids = v.lvids!;
    double value = CardiacFormulas.fsPercent(lvidd, lvids);
    updateFloatValueByName(MeasureTerms.FS, value);
  }

  @protected
  void updatePercentLVPW() {
    if (v.lvpws == null || v.lvpwd == null) {
      return;
    }
    final lvpws = v.lvpws!;
    final lvpwd = v.lvpwd!;
    double value = CardiacFormulas.lvpwPercent(lvpws, lvpwd);
    updateFloatValueByName(MeasureTerms.PercentLVPW, value);
  }

  @protected
  void updateCO() {
    if (v.sv == null || v.hr == null) {
      return;
    }
    double value = CardiacFormulas.co(v.sv!, hr: v.hr!);
    updateFloatValueByName(MeasureTerms.CO, value, unit: VidUsUnit.Lmin);
  }

  @protected
  void updateCI() {
    if (v.sv == null || v.hr == null) {
      return;
    }
    if (GlobalPatientConfig.bsa == 0) {
      return;
    }
    double value = CardiacFormulas.ci(
      v.sv!,
      hr: v.hr!,
      bsa: GlobalPatientConfig.bsa,
    );
    updateFloatValueByName(MeasureTerms.CI, value, unit: VidUsUnit.Lminm2);
  }

  @protected
  void updateLVEDVI() {
    if (v.lvedv == null) {
      return;
    }
    if (GlobalPatientConfig.bsa == 0) {
      return;
    }
    final value = CardiacFormulas.lvevi(v.lvedv!, GlobalPatientConfig.bsa);
    updateFloatValueByName(MeasureTerms.LVEDVI, value, unit: VidUsUnit.mlm2);
  }

  @protected
  void updateLVESVI() {
    if (v.lvesv == null) {
      return;
    }
    if (GlobalPatientConfig.bsa == 0) {
      return;
    }
    final value = CardiacFormulas.lvevi(v.lvesv!, GlobalPatientConfig.bsa);
    updateFloatValueByName(MeasureTerms.LVESVI, value, unit: VidUsUnit.mlm2);
  }

  @protected
  void updateSI() {
    if (v.sv == null) {
      return;
    }
    if (GlobalPatientConfig.bsa == 0) {
      return;
    }
    double value = CardiacFormulas.si(v.sv!, GlobalPatientConfig.bsa);
    updateFloatValueByName(MeasureTerms.SI, value, unit: VidUsUnit.mlm2);
  }

  @protected
  void updateFloatValueByName(
    String name,
    double value, {
    VidUsUnit? unit,
  }) {
    ref.measuredFeatures;
    final feature = ref.feature!;
    final outputMeta = ref.meta.outputs.firstWhere((x) => x.name == name);
    feature.updateFloatValue(outputMeta, value, unit ?? outputMeta.unit);
  }
}

class _ValTemp {
  double? ivsd;
  double? lvidd;
  double? lvpwd;
  double? ivss;
  double? lvids;
  double? lvpws;

  double? lvedv;
  double? lvesv;
  double? sv;
  int? hr = GlobalPatientConfig.hr; // TODO: from vid ext
}