支持FL/BPD|CI(BPD/OFD)|Thyroid Width|GS|URA|%IVS

lib/interfaces/process/items/types.dart

@@ -107,6 +107,24 @@ class MeasureTypes {
   static const FS = "FS";
 /* Two StraightLine  [end] */
 
+/* OB  [begin] */
+  static const HcBpdOfd = "HcBpdOfd";
+  static const Afi = "Afi";
+  static const AutoOBDistance = "AutoOBDistance";
+  static const AutoPerimeter = "AutoPerimeter";
+  static const OBDistance = "OBDistance";
+  static const GS = "GS";
+  static const HC = "HC";
+  static const AC = "AC";
+  static const OBRatioFLAC = "OBRatioFLAC";
+  static const OBRatioFLHC = "OBRatioFLHC";
+  static const OBRatioHCAC = "OBRatioHCAC";
+  static const OBRatioFLBPD = "OBRatioFLBPD";
+  static const OBRatioBPDOFD = "OBRatioBPDOFD";
+  static const OBRatioTCDAC = "OBRatioTCDAC";
+  static const CardiacAxis = "CardiacAxis";
+/* OB  [end] */
+
   static const TimeSpan = "TimeSpan";
   static const Slope = "Slope";
 }

lib/process/calcuators/calculator.dart

@@ -25,14 +25,24 @@ abstract class Calculator<T extends IMeasureItem, TValue>
   void finishOnce() {}
 
   @protected
-  FloatValue? updateFloatValue(double value) {
+  FloatValue? updateFloatValue(
+    double value, {
+    VidUsUnit? unit,
+    bool useUnitY = false,
+    bool useRound = false,
+  }) {
     if (ref.feature == null) return null;
     final feature = ref.feature! as MeasureItemFeature;
-    final viewport = feature.hostVisualArea!.viewport!;
+    if (unit == null) {
+      final viewport = feature.hostVisualArea!.viewport!;
+      unit = useUnitY ? viewport.yUnit : viewport.xUnit;
+    }
+    final output = ref.meta.outputs.first;
+    final val = useRound ? roundDouble(value, output.fractionalDigits) : value;
     return feature.updateFloatValue(
       ref.meta.outputs.first,
-      value,
-      viewport.xUnit,
+      val,
+      unit,
     );
   }
 

lib/process/calcuators/curve.dart

@@ -121,8 +121,6 @@ class CurveLengthCal extends Calculator<AreaItemAbstract, double> {
     double perimeter = AreaPerimeterCal.calcPerimeter(
         points, ref.feature!.isClosed, threshold);
 
-    final output = ref.meta.outputs.first;
-    var value = roundDouble(perimeter, output.fractionalDigits);
-    feature.updateFloatValue(output, value, viewport.xUnit);
+    updateFloatValue(perimeter, useRound: true);
   }
 }

lib/process/calcuators/formulas/obstetrics.dart

@@ -1,3 +1,4 @@
+import 'dart:math' as math;
 import 'package:fis_measure/utils/number.dart';
 
 class ObstetricsFormulas {
@@ -21,4 +22,15 @@ class ObstetricsFormulas {
     }
     return mean;
   }
+
+  ///Max(D1, D2, D3)
+  static double gsMax(double d1, double d2, double d3) {
+    double max = double.nan;
+    if (!(NumUtil.almostEquals(d1, 0) &&
+        NumUtil.almostEquals(d2, 0) &&
+        NumUtil.almostEquals(d3, 0))) {
+      max = math.max(d1, math.max(d2, d3));
+    }
+    return max;
+  }
 }

lib/process/calcuators/three_distance.dart

@@ -5,6 +5,7 @@ import 'package:fis_measure/process/items/item.dart';
 import 'package:fis_measure/process/primitives/combos/lwh_straightline.dart';
 import 'package:fis_measure/process/primitives/ellipse.dart';
 import 'package:fis_measure/process/primitives/straightline.dart';
+import 'package:vid/us/vid_us_unit.dart';
 
 import 'calculator.dart';
 import 'formulas/obstetrics.dart';
@@ -52,3 +53,27 @@ class ThreeDistMeanCalculator extends Calculator<LWHStraightLine, double> {
     }
   }
 }
+
+class ThreeDistMaxCalculator extends Calculator<LWHStraightLine, double> {
+  ThreeDistMaxCalculator(LWHStraightLine ref) : super(ref);
+
+  @override
+  void calculate() {
+    if (ref.feature == null) return;
+
+    final l = findChildFeature(ref.l);
+    final w = findChildFeature(ref.w);
+    final h = findChildFeature(ref.h);
+    if (l == null && w == null && h == null) return;
+
+    double lineL = 0;
+    double lineW = 0;
+    double lineH = 0;
+    if (l != null) lineL = l.value?.pickFloat() ?? 0;
+    if (w != null) lineW = w.value?.pickFloat() ?? 0;
+    if (h != null) lineH = h.value?.pickFloat() ?? 0;
+
+    double gs = ObstetricsFormulas.gsMax(lineL, lineW, lineH);
+    updateFloatValue(gs, unit: VidUsUnit.cm, useRound: true);
+  }
+}

lib/process/calcuators/two_distance.dart

@@ -1,3 +1,4 @@
+import 'package:fis_measure/interfaces/date_types/vector.dart';
 import 'package:fis_measure/interfaces/process/calculators/values.dart';
 import 'package:fis_measure/interfaces/process/items/terms.dart';
 import 'package:fis_measure/process/calcuators/formulas/urology.dart';
@@ -92,3 +93,86 @@ class TwoDistanceVolumeCal extends Calculator<TwoStraightLine, double> {
     }
   }
 }
+
+class TwoDistanceSumCal extends Calculator<TwoStraightLine, double> {
+  TwoDistanceSumCal(TwoStraightLine ref) : super(ref);
+
+  @override
+  void calculate() {
+    if (ref.feature == null) return;
+
+    final f1 = findChildFeature(ref.child1);
+    final f2 = findChildFeature(ref.child2);
+    if (f1 == null || f2 == null) return;
+
+    final feature = ref.feature!;
+
+    final val1 = f1.value?.pickFloat() ?? 0;
+    final val2 = f2.value?.pickFloat() ?? 0;
+
+    var unitY = f1.hostVisualArea!.viewport!.yUnit;
+    if (unitY == VidUsUnit.None) {
+      if (f1.value != null) {
+        unitY = f1.value!.unit;
+      }
+    }
+    for (var ouput in ref.meta.outputs) {
+      if (ouput.name == MeasureTerms.Distance) {
+        var dis = val1 + val2;
+        feature.updateFloatValue(
+          ouput,
+          roundDouble(dis, ouput.fractionalDigits),
+          unitY,
+        );
+      } else if (ouput.name == MeasureTerms.AvgDistance) {
+        double avg = (val1 + val2) / 2;
+        feature.updateFloatValue(
+          ouput,
+          roundDouble(avg, ouput.fractionalDigits),
+          unitY,
+        );
+      }
+    }
+  }
+}
+
+class TwoStraightLineAngleCal extends Calculator<TwoStraightLine, double> {
+  TwoStraightLineAngleCal(TwoStraightLine ref) : super(ref);
+
+  @override
+  void calculate() {
+    if (ref.feature == null) return;
+
+    final f1 = findChildFeature(ref.child1);
+    final f2 = findChildFeature(ref.child2);
+    if (f1 == null || f2 == null) return;
+
+    if (f1.innerPoints.length == f2.innerPoints.length) {
+      var l1 = f1.innerPoints[0] - f1.innerPoints[1];
+      var l2 = f2.innerPoints[0] - f2.innerPoints[1];
+      var value = (DVector.angleBetween(l1, l2)).abs();
+      updateFloatValue(value, unit: VidUsUnit.degree, useRound: true);
+    }
+  }
+}
+
+class IvsThckCal extends Calculator<TwoStraightLine, double> {
+  IvsThckCal(TwoStraightLine ref) : super(ref);
+
+  @override
+  void calculate() {
+    if (ref.feature == null) return;
+
+    final len1 = pickChildFloatValue(ref.child1) ?? 0;
+    final len2 = pickChildFloatValue(ref.child2) ?? 0;
+    final ivs = calcIvs(len1, len2);
+    updateFloatValue(ivs, unit: VidUsUnit.percent, useRound: true);
+  }
+
+  static double calcIvs(double ivsd, double ivss) {
+    if (ivsd == 0) {
+      return 0;
+    }
+    return (ivss - ivsd) / ivsd * 100;
+  }
+}

lib/process/items/factory.dart

@@ -82,6 +82,10 @@ class MeasureItemFactory {
     // Three StraightLine
     _singleton._register(
         MeasureTypes.VolumeThreeDistance, LWHStraightLine.createVolume);
+    _singleton._register(
+        MeasureTypes.ThreeDistanceMean, LWHStraightLine.createMean);
+    _singleton._register(
+        MeasureTypes.ThreeDistanceMax, LWHStraightLine.createMax);
 
     _singleton._register(
         MeasureTypes.VolumeTwoDistance, TwoStraightLine.createVolume);
@@ -99,6 +103,15 @@ class MeasureItemFactory {
         TwoStraightLine.createStenosisTwoDistance);
     _singleton._register(
         MeasureTypes.AbRatioTwoDistance, TwoStraightLine.createAbRatioDistance);
+    _singleton._register(
+        MeasureTypes.OBRatioFLBPD, TwoStraightLine.createAbRatioDistance);
+    _singleton._register(
+        MeasureTypes.OBRatioBPDOFD, TwoStraightLine.createAbRatioDistance);
+    _singleton._register(MeasureTypes.TwoDistanceAverage,
+        TwoStraightLine.createTwoDistanceAverage);
+    _singleton._register(
+        MeasureTypes.TwoStraightLineAngle, TwoStraightLine.createAngle);
+    _singleton._register(MeasureTypes.IvsThck, TwoStraightLine.createIvsThck);
 
     // Angle
     _singleton._register(
@@ -124,10 +137,6 @@ class MeasureItemFactory {
     _singleton._register(
         MeasureTypes.AreaPerimeterTrace, Trace.createAreaPerimeter);
 
-    //Threee straight line types
-    _singleton._register(
-        MeasureTypes.ThreeDistanceMean, LWHStraightLine.createMean);
-
     // Area & H
     _singleton._register(
         MeasureTypes.AreaStraightLine, AreaStraightLine.createVolume);

lib/process/primitives/combos/area_straightline.dart

@@ -90,12 +90,7 @@ class AreaStraightLineVolumeCal extends Calculator<AreaStraightLine, double> {
       height = (lineFeature.value as FloatValue).value ?? 0;
     }
     var volume = _caleVolume(area, height);
-    final output = ref.meta.outputs.first;
-    feature.updateFloatValue(
-      output,
-      roundDouble(volume, output.fractionalDigits),
-      VidUsUnit.cm3,
-    );
+    updateFloatValue(volume, unit: VidUsUnit.cm3, useRound: true);
   }
 
   static double _caleVolume(double area, double d2) {

lib/process/primitives/combos/lwh_straightline.dart

@@ -76,7 +76,12 @@ class LWHStraightLine extends TopMeasureItem<LWHStraightlineFeature> {
     }
     var lwh = LWHStraightLine(meta);
     lwh.calculator = ThreeDistMeanCalculator(lwh);
+    return lwh;
+  }
 
+  static LWHStraightLine createMax(ItemMeta meta, [IMeasureItem? parent]) {
+    var lwh = LWHStraightLine(meta);
+    lwh.calculator = ThreeDistMaxCalculator(lwh);
     return lwh;
   }
 }

lib/process/primitives/combos/two_straightline.dart

@@ -88,7 +88,6 @@ class TwoStraightLine extends TwoLengthAbstract<TwoStraightLineFeature> {
       [IMeasureItem? parent]) {
     var twoStraightline = TwoStraightLine(meta);
     twoStraightline.calculator = StenosisCal(twoStraightline);
-
     return twoStraightline;
   }
 
@@ -96,7 +95,6 @@ class TwoStraightLine extends TwoLengthAbstract<TwoStraightLineFeature> {
       [IMeasureItem? parent]) {
     var twoStraightline = TwoStraightLine(meta, ifVertical: true);
     twoStraightline.calculator = StenosisCal(twoStraightline);
-
     return twoStraightline;
   }
 
@@ -104,14 +102,31 @@ class TwoStraightLine extends TwoLengthAbstract<TwoStraightLineFeature> {
       [IMeasureItem? parent]) {
     var twoStraightline = TwoStraightLine(meta, ifVertical: true);
     twoStraightline.calculator = ABRatioCal(twoStraightline);
-
     return twoStraightline;
   }
 
   static TwoStraightLine createVolume(ItemMeta meta, [IMeasureItem? parent]) {
     var twoStraightline = TwoStraightLine(meta);
     twoStraightline.calculator = TwoDistanceVolumeCal(twoStraightline);
+    return twoStraightline;
+  }
 
+  static TwoStraightLine createTwoDistanceAverage(ItemMeta meta,
+      [IMeasureItem? parent]) {
+    var twoStraightline = TwoStraightLine(meta);
+    twoStraightline.calculator = TwoDistanceSumCal(twoStraightline);
+    return twoStraightline;
+  }
+
+  static TwoStraightLine createAngle(ItemMeta meta, [IMeasureItem? parent]) {
+    var twoStraightline = TwoStraightLine(meta);
+    twoStraightline.calculator = TwoStraightLineAngleCal(twoStraightline);
+    return twoStraightline;
+  }
+
+  static TwoStraightLine createIvsThck(ItemMeta meta, [IMeasureItem? parent]) {
+    var twoStraightline = TwoStraightLine(meta);
+    twoStraightline.calculator = IvsThckCal(twoStraightline);
     return twoStraightline;
   }
 }