fis_lib_measure/lib/process/calcuators/formulas/cardiac.dart

import 'dart:math' as math;

import 'package:fis_common/logger/logger.dart';
import 'package:fis_measure/configs/cardiac.dart';
import 'package:fis_measure/utils/number.dart';

import 'general.dart';

class CardiacFormulas {
  CardiacFormulas._();

  /// IMP
  ///
  /// Formula: `(CO-ET)/ET`
  ///
  /// Result Unit: `None`
  static double teiIndex(double co, double et) {
    double imp = 0.0;
    if (et != 0.0) {
      imp = (((co).abs() - (et).abs()) / et).abs();
    }
    return imp;
  }

  /// EF
  /// Formula: `(EDV - ESV )/EDV`
  ///
  /// [edv] Unit: `cm³`
  ///
  /// [esv] Unit: `cm³`
  ///
  /// Result Unit: `None`
  static double ef(double edv, double esv) {
    // 这行判断暂时注释掉是为了使实际表现与旧版一致
    // if (edv < esv) {
    //   return double.nan;
    // }
    return (edv - esv) / edv * 100;
  }

  /// EDV (Teichholz)
  ///
  ///  Formula: `[7.0/(2.4 + LVIDd)] x LVIDd^3`
  ///
  /// [lvidd] Unit: `cm`
  ///
  /// Result Unit: `cm³`
  static double edvTeichholz(double lvidd) {
    double edv = double.nan;
    if (!NumUtil.almostEquals(lvidd, 0)) {
      edv = 7.0 * math.pow(lvidd, 3) / (2.4 + lvidd);
    }
    return edv;
  }

  /// EDV (Cube)
  ///
  ///  Formula: `LVIDd^3`
  ///
  /// [lvidd] Unit: `cm`
  ///
  /// Result Unit: `cm³`
  static double edvCube(double lvidd) {
    double edv = double.nan;
    if (!NumUtil.almostEquals(lvidd, 0)) {
      edv = math.pow(lvidd, 3).toDouble();
    }
    return edv;
  }

  /// ESV (Teichholz)
  ///
  ///  Formula: `[7.0/(2.4 + LVIDs)] x LVIDs^3`
  ///
  /// [lvids] Unit: `cm`
  ///
  /// Result Unit: `cm³`
  static double esvTeichholz(double lvids) {
    // 计算公式相同，入参不同
    return edvTeichholz(lvids);
  }

  /// ESV (Cube)
  ///
  ///  Formula: `LVIDs^3`
  ///
  /// [lvids] Unit: `cm`
  ///
  /// Result Unit: `cm³`
  static double esvCube(double lvids) {
    // 计算公式相同，入参不同
    return edvCube(lvids);
  }

  /// SV
  static double sv(double edv, double esv) {
    return edv - esv;
  }

  /// CO
  static double co(
    double sv, {
    required int hr,
  }) {
    return (sv - hr) / 1000.0;
  }

  /// CI
  static double ci(
    double sv, {
    required int hr,
    required double bsa,
  }) {
    return ((sv - hr) / 1000.0) / bsa;
  }

  /// LVdMass
  static double lvdMass(double ivsd, double lvidd, double lvpwd) {
    const density = GlobalCardiacConfigs.density;
    const correctionFactor = GlobalCardiacConfigs.correctionFactor;
    double part1 = math.pow(ivsd + lvidd + lvpwd, 3).toDouble();
    double part2 = math.pow(lvidd, 3).toDouble();
    double value = ((density * part1 - part2) + correctionFactor) / 1000.0;
    return value;
  }

  /// LVd Mass AL
  static double lvdMassAL(
    double lvadSaxEpi,
    double lvadSaxEndo,
    double lvldApical,
  ) {
    double t =
        math.sqrt(lvadSaxEpi / math.pi) - math.sqrt(lvadSaxEndo / math.pi);
    double mass = 1.05 *
        5 /
        6 *
        (lvadSaxEpi * (lvldApical + t) - lvadSaxEndo * lvldApical) /
        1000;
    return mass;
  }

  /// LVd Mass Index
  static double lvdMassIndex(double lvdmass, double bsa) {
    return lvdmass / bsa * 1000;
  }

  /// %FS
  static double fsPercent(double lvidd, double lvids) {
    return ((lvidd - lvids) / lvidd) * 100;
  }

  /// %IVS
  static double ivsPercent(double ivss, double ivsd) {
    return ((ivss - ivsd) / ivsd) * 100;
  }

  /// %LVPW
  static double lvpwPercent(double lvpws, double lvpwd) {
    return ((lvpws - lvpwd) / lvpwd) * 100;
  }

  /// MAM%
  static double mamPercent(double mapse, double lvidd, double lvids) {
    return mapse / (lvidd - lvids + mapse) * 100;
  }

  /// SI
  ///
  /// (EDV - ESV)/BSA
  ///
  /// [sv] cm³
  ///
  /// [bsa] m²
  ///
  /// return `cm³/m²`
  static double si(double sv, double bsa) {
    double si = sv / bsa;
    return si;
  }

  /// <summary>
  /// <para>MVA VTI = 1/4 x π x (LVOT Diam)^2 x LVOT VTI/MV VTI </para>
  /// <para>AVA VTI = 1/4 x π x (LVOT Diam)^2 x LVOT VTI/AV VTI</para>
  /// <para>TVA VTI = 1/4 x π x (RVOT Diam)^2 x RVOT VTI/TV VTI</para>
  /// <para>PVA VTI = 1/4 x π x (RVOT Diam)^2 x RVOT VTI/PV VTI</para>
  /// </summary>
  /// <param name="otDiam">cm</param>
  /// <param name="otvti">cm</param>
  /// <param name="vti">cm</param>
  /// <returns>cm^2</returns>
  static double flowAreaByVTI(double otDiam, double otvti, double vti) {
    double sv = 0.25 * math.pi * math.pow(otDiam, 2) * otvti / vti;
    return sv;
  }

  /// <param name="otvti">cm</param>
  /// <param name="vti">cm</param>
  /// <returns>Unit None</returns>
  static double dviByVTI(double otvti, double vti) {
    double dvi = double.nan;
    if (!GeneralFormulas.doubleAlmostEquals(vti, 0)) {
      dvi = otvti / vti;
    }
    return dvi;
  }

  /// <summary>
  /// AVA Index = avaByVTI/bsa
  /// </summary>
  /// <param name="avaByVTI">cm2</param>
  /// <param name="bsa">m2</param>
  /// <returns>cm2/m2</returns>
  static double avaIndex(double avaByVTI, double bsa) {
    double index = double.nan;
    if (!GeneralFormulas.doubleAlmostEquals(bsa, 0)) {
      index = avaByVTI / bsa;
    }
    return index;
  }
}