Merge branch 'master' of http://git.ius.plus:88/Project-Wing/fis_lib_measure

lib/process/calcuators/formulas/cardiac.dart

@@ -186,6 +186,16 @@ class BaseCardiacFormulas implements ICardiacFormulaStrategy {
     return ((sv - hr) / 1000.0) / bsa;
   }
 
+  /// <summary>
+  /// LVEVI = LVEV / BSA
+  /// </summary>
+  /// <param name="lvev">Unit cm³</param>
+  /// <param name="bsa">Unit m²</param>
+  /// <returns>cm³/m²</returns>
+  static double lvevi(double lvev, double bsa) {
+    return lvev / bsa;
+  }
+
   /// LVdMass
   @override
   double lvdMass(double ivsd, double lvidd, double lvpwd) {
@@ -301,6 +311,24 @@ class BaseCardiacFormulas implements ICardiacFormulaStrategy {
     }
     return index;
   }
+
+  /// <summary>
+  /// Formular : V= π/4×∑_(i=1)^20▒〖(a_i×b_i)〗×L/20
+  /// </summary>
+  /// <returns></returns>
+  static double lvSimsonVolume(double l, List<double>? a, List<double>? b,
+      [int num = 20]) {
+    double volume = double.nan;
+    if (a != null && b != null) {
+      double sum = 0;
+      for (int i = 0; i < num; i++) {
+        sum += a[i] * b[i] * l / num;
+      }
+      volume = math.pi / 4 * sum;
+    }
+
+    return volume;
+  }
 }
 
 class MouseCardiacFormulas extends BaseCardiacFormulas {

lib/process/calcuators/lv_study.dart

@@ -29,7 +29,7 @@ class LvStudySimpleCal extends LvStudyCalculatorBase<LvStudy> {
 
     final feature = ref.feature!;
 
-    v = _ValTemp();
+    restoreVals();
     v.lvidd = pickChildFloatValue(kidLVIDd);
     v.lvids = pickChildFloatValue(kidLVIDs);
 
@@ -144,6 +144,10 @@ class LvStudyCalculatorBase<T extends TopMeasureItem>
     // TODO: implement calculate
   }
 
+  void restoreVals() {
+    v = _ValTemp();
+  }
+
   @protected
   void updateLVEDV() {
     if (v.lvidd == null) {
@@ -221,7 +225,7 @@ class LvStudyCalculatorBase<T extends TopMeasureItem>
     final edv = v.lvedv!;
     final esv = v.lvesv!;
     double value = CardiacFormulas.ef(edv, esv);
-    updateFloatValueByName(MeasureTerms.EF, value);
+    updateFloatValueByName(MeasureTerms.EF, value, unit: VidUsUnit.percent);
   }
 
   @protected
@@ -252,7 +256,7 @@ class LvStudyCalculatorBase<T extends TopMeasureItem>
       return;
     }
     double value = CardiacFormulas.co(v.sv!, hr: v.hr!);
-    updateFloatValueByName(MeasureTerms.CO, value);
+    updateFloatValueByName(MeasureTerms.CO, value, unit: VidUsUnit.Lmin);
   }
 
   @protected
@@ -268,13 +272,43 @@ class LvStudyCalculatorBase<T extends TopMeasureItem>
       hr: v.hr!,
       bsa: GlobalPatientConfig.bsa,
     );
-    updateFloatValueByName(MeasureTerms.CI, value);
+    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() {
-    //_updateSI
-    // TODO:
+    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

lib/process/calcuators/simpson.dart

@@ -1,5 +1,11 @@
+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/simpson.dart';
+import 'package:fis_measure/process/primitives/multi_method/multi_simpson_path.dart';
+import 'package:fis_measure/process/primitives/simpson_path.dart';
+import 'package:vid/us/vid_us_unit.dart';
 
+import 'formulas/cardiac.dart';
 import 'lv_study.dart';
 
 class LvSimpsonCal extends LvStudyCalculatorBase<LvStudySimpson> {
@@ -9,8 +15,92 @@ class LvSimpsonCal extends LvStudyCalculatorBase<LvStudySimpson> {
 
   @override
   void calculate() {
-    // TODO: implement calculate
-    super.calculate();
+    if (ref.feature == null) return;
+
+    final feature = ref.feature!;
+
+    restoreVals();
+
+    feature.updateStringValue(
+      ItemOutputMeta(
+          ref.meta.description, ref.meta.description, VidUsUnit.None),
+      "",
+    );
+
+    for (var output in ref.meta.outputs) {
+      switch (output.name) {
+        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;
+        case MeasureTerms.SI:
+          updateSI();
+          break;
+        case MeasureTerms.LVEDVI:
+          updateLVEDVI();
+          break;
+        case MeasureTerms.LVESVI:
+          updateLVESVI();
+          break;
+      }
+    }
+  }
+
+  @override
+  void updateLVEDV() {
+    final value = _clacLvedv(ref.a2cLvedv, ref.a4cLvedv);
+    if (value != null) {
+      updateFloatValueByName(MeasureTerms.LVEDV, value, unit: VidUsUnit.cm3);
+      v.lvedv = value;
+    }
+  }
+
+  @override
+  void updateLVESV() {
+    final value = _clacLvedv(ref.a2cLvesv, ref.a4cLvesv);
+    if (value != null) {
+      updateFloatValueByName(MeasureTerms.LVESV, value, unit: VidUsUnit.cm3);
+      v.lvesv = value;
+    }
+  }
+
+  double? _clacLvedv(MultiSimpsonPath a2c, MultiSimpsonPath a4c) {
+    if (a2c.feature == null || a4c.feature == null) {
+      return null;
+    }
+    final a2cFeature = a2c.feature!;
+    final a4cFeature = a4c.feature!;
+    double a2cL = a2cFeature.centerLineLength;
+    double a4cL = a4cFeature.centerLineLength;
+
+    List<double> aDiameters =
+        List.generate(SimpsonPath.splitterCount, (index) => 0);
+    int index = 0;
+    a4cFeature.horizontalSplitterLegths.forEach((key, value) {
+      aDiameters[index++] = value;
+    });
+
+    List<double> bDiameters =
+        List.generate(SimpsonPath.splitterCount, (index) => 0);
+    index = 0;
+    a2cFeature.horizontalSplitterLegths.forEach((key, value) {
+      bDiameters[index++] = value;
+    });
+    final longDiameter = (a2cL + a4cL) / 2.0;
+    final lvesv = CardiacFormulas.lvSimsonVolume(
+        longDiameter, aDiameters, bDiameters, SimpsonPath.splitterCount);
+    return lvesv;
   }
 }
 
@@ -21,7 +111,96 @@ class LvSingleSimpsonCal extends LvStudyCalculatorBase<LvStudySingleSimpson> {
 
   @override
   void calculate() {
-    // TODO: implement calculate
-    super.calculate();
+    if (ref.feature == null) return;
+
+    final feature = ref.feature!;
+
+    restoreVals();
+
+    feature.updateStringValue(
+      ItemOutputMeta(
+          ref.meta.description, ref.meta.description, VidUsUnit.None),
+      "",
+    );
+
+    for (var output in ref.meta.outputs) {
+      switch (output.name) {
+        case MeasureTerms.LVEDV:
+          updateLVEDV();
+          break;
+        case MeasureTerms.LVESV:
+          updateLVESV();
+          break;
+        case MeasureTerms.SV:
+          updateSV();
+          break;
+        case MeasureTerms.EF:
+          updateEF();
+          break;
+        case MeasureTerms.SI:
+          updateSI();
+          break;
+        case MeasureTerms.LVEDVI:
+          updateLVEDVI();
+          break;
+        case MeasureTerms.LVESVI:
+          updateLVESVI();
+          break;
+      }
+    }
+
+    /**
+     * 
+     <OutPut Id="LVEDV" IsEnabled="False" CalculationIDs="LVEDV(BP Simp)"/>
+<OutPut Id="LVESV" IsEnabled="False" CalculationIDs="LVESV(BP Simp)"/>
+<OutPut Id="SV" IsEnabled="False" CalculationIDs="SV(Mod Simp)"/>
+<OutPut Id="EF" IsEnabled="False" CalculationIDs="EF(Mod Simp)"/>
+<OutPut Id="SI" IsEnabled="False" CalculationIDs="SI(Mod Simp)"/>
+<OutPut Id="LVEDVI" IsEnabled="False" CalculationIDs="LVEDVI(Mod Simp)"/>
+<OutPut Id="LVESVI" IsEnabled="False" CalculationIDs="LVESVI(Mod Simp)"/>
+<OutPut Id="CO" IsEnabled="False" CalculationIDs="CO(Mod Simp)"/>
+<OutPut Id="CI" IsEnabled="False" CalculationIDs="CI(Mod Simp)"/>
+     */
+  }
+
+  @override
+  void updateLVEDV() {
+    final value = _calcLvedv(ref.lvedv);
+    if (value != null) {
+      updateFloatValueByName(MeasureTerms.LVEDV, value, unit: VidUsUnit.cm3);
+      v.lvedv = value;
+    }
+  }
+
+  @override
+  void updateLVESV() {
+    final value = _calcLvedv(ref.lvesv);
+    if (value != null) {
+      updateFloatValueByName(MeasureTerms.LVESV, value, unit: VidUsUnit.cm3);
+      v.lvesv = value;
+    }
+  }
+
+  double? _calcLvedv(MultiSimpsonPath item) {
+    if (item.feature == null) {
+      return null;
+    }
+
+    final feature = item.feature!;
+
+    double longDiameter = roundDouble(feature.centerLineLength);
+    int index = 0;
+    List<double> bDiameters =
+        List.generate(SimpsonPath.splitterCount, (index) => 0);
+    feature.horizontalSplitterLegths.forEach((key, value) {
+      bDiameters[index++] = value;
+    });
+
+    return CardiacFormulas.lvSimsonVolume(
+      longDiameter,
+      bDiameters,
+      bDiameters,
+      SimpsonPath.splitterCount,
+    );
   }
 }

lib/process/primitives/combos/simpson.dart

@@ -9,15 +9,29 @@ import 'package:fis_measure/process/items/top_item_feature.dart';
 import '../multi_method/multi_simpson_path.dart';
 
 class LvStudySimpson extends TopMeasureItem<LvStudySimpsonFeature> {
-  static const String _lvedvKey = "LVEDV";
-  static const String _lvesvKey = "LVESV";
+  static const String _a2CLvedvKey = "A2C LVEdV";
+  static const String _a2CLvesvKey = "A2C LVEsV";
+  static const String _a4CLvedvKey = "A4C LVEdV";
+  static const String _a4CLvesvKey = "A4C LVEsV";
 
-  // late final Trace epi;
-  // late final Trace endo;
-  // late final StraightLine l;
+  late final MultiSimpsonPath a2cLvedv;
+  late final MultiSimpsonPath a2cLvesv;
+  late final MultiSimpsonPath a4cLvedv;
+  late final MultiSimpsonPath a4cLvesv;
 
   LvStudySimpson(super.meta) {
-    //
+    final a2cLvedvMeta = meta.getChildByName(_a2CLvedvKey)!;
+    final a2cLvesvMeta = meta.getChildByName(_a2CLvesvKey)!;
+    final a4cLvedvMeta = meta.getChildByName(_a4CLvedvKey)!;
+    final a4cLvesvMeta = meta.getChildByName(_a4CLvesvKey)!;
+    a2cLvedv = MultiSimpsonPath.create(a2cLvedvMeta, this);
+    a2cLvesv = MultiSimpsonPath.create(a2cLvesvMeta, this);
+    a4cLvedv = MultiSimpsonPath.create(a4cLvedvMeta, this);
+    a4cLvesv = MultiSimpsonPath.create(a4cLvesvMeta, this);
+    childItems.add(a2cLvedv);
+    childItems.add(a2cLvesv);
+    childItems.add(a4cLvedv);
+    childItems.add(a4cLvesv);
   }
 
   @override

lib/process/primitives/simpson_path.dart

@@ -1,11 +1,14 @@
 import 'dart:ui';
+import 'dart:math' as math;
 
 import 'package:fis_measure/interfaces/date_types/point.dart';
+import 'package:fis_measure/interfaces/date_types/vector.dart';
 import 'package:fis_measure/interfaces/enums/items.dart';
 import 'package:fis_measure/interfaces/process/items/item.dart';
 import 'package:fis_measure/interfaces/process/items/item_metas.dart';
 import 'package:fis_measure/interfaces/process/items/types.dart';
 import 'package:fis_measure/interfaces/process/workspace/point_info.dart';
+import 'package:fis_measure/process/calcuators/curve.dart';
 import 'package:fis_measure/process/calcuators/formulas/general.dart';
 import 'package:fis_measure/process/items/item.dart';
 import 'package:fis_measure/process/items/item_feature.dart';
@@ -14,8 +17,13 @@ import 'package:fis_measure/process/primitives/area_abstract.dart';
 import 'package:fis_measure/process/primitives/utils/auto_snap.dart';
 import 'package:fis_measure/utils/canvas.dart';
 import 'package:flutter/foundation.dart';
+import 'package:flutter/rendering.dart';
 import 'package:path_drawing/path_drawing.dart';
 
+import 'spline.dart';
+import 'utils/line.dart';
+import 'utils/spline.dart';
+
 enum LvSimpsonStep {
   none,
   splineBeginEdit,
@@ -26,8 +34,8 @@ enum LvSimpsonStep {
 }
 
 class SimpsonPath extends AreaItemAbstract with AutoSnapMixin {
-  static const int SplitterCount = 20;
-  static const double MaxPointsCount = 10000;
+  static const int splitterCount = 20;
+  static const double maxPointsCount = 10000;
 
   SimpsonPath(ItemMeta meta, IMeasureItem? parent) : super(meta, parent);
 
@@ -65,7 +73,7 @@ class SimpsonPath extends AreaItemAbstract with AutoSnapMixin {
             final lineLen = (args - firstPoint!).length;
             if ((feature!.innerPoints.length > 3 &&
                     GeneralFormulas.doubleAlmostEquals(lineLen, 0)) ||
-                feature!.innerPoints.length >= MaxPointsCount) {
+                feature!.innerPoints.length >= maxPointsCount) {
               lvSimpsonStep = LvSimpsonStep.splineCompleted;
               feature!.fixedSpline();
             } else {
@@ -153,23 +161,34 @@ class SimpsonPath extends AreaItemAbstract with AutoSnapMixin {
 }
 
 class SimpsonPathFeature extends AreaItemFeatureAbstract {
-  Map<int, double> horizontalSplitterLegths = {};
+  static const autoGetApexPoint = false; // TODO
+
+  late Map<int, double> horizontalSplitterLegths;
+  late DPoint moveBasedPoint;
+
   IPathGeometry? _pathGeometry;
   List<DPoint>? _splinePoints;
   IPathGeometry? _spline;
   late DPoint _centerLineFixedPoint;
   late DPoint _centerLineMovablePoint;
+
+  late MovablePointsInfo _movablePtsInfo;
   late DPoint _leftPoint;
   late DPoint _rightPoint;
   late DPoint _apexPoint;
 
   SimpsonPathFeature(AreaItemAbstract refItem) : super(refItem) {
-    // _splinePoints = [];
+    _splinePoints = [];
     _centerLineFixedPoint = DPointExt.empty;
     _centerLineMovablePoint = DPointExt.empty;
+
+    _movablePtsInfo = MovablePointsInfo.empty();
     _leftPoint = DPointExt.empty;
     _rightPoint = DPointExt.empty;
     _apexPoint = DPointExt.empty;
+
+    moveBasedPoint = DPointExt.empty;
+    horizontalSplitterLegths = {};
   }
 
   @override
@@ -181,10 +200,61 @@ class SimpsonPathFeature extends AreaItemFeatureAbstract {
       _centerLineMovablePoint = val;
 
       updateSplitters();
-      // OnVertexPointChanged();
+      _onVertexPointChanged();
+    }
+  }
+
+  DPoint get centerLineFixedPoint => _centerLineFixedPoint;
+
+  MovablePointsInfo get movablePtsInfo => _movablePtsInfo;
+  set movablePtsInfo(MovablePointsInfo val) {
+    if (val != _movablePtsInfo) {
+      _movablePtsInfo = val;
+      _onSplineMovablePointsInfoChanged();
+    }
+  }
+
+  DPoint get leftPoint => _leftPoint;
+  set leftPoint(DPoint val) {
+    if (val != _leftPoint) {
+      _leftPoint = val;
+      _onVertexPointChanged();
+    }
+  }
+
+  DPoint get rightPoint => _rightPoint;
+  set rightPoint(DPoint val) {
+    if (val != _rightPoint) {
+      _rightPoint = val;
+      _onVertexPointChanged();
+    }
+  }
+
+  DPoint get apexPoint => _apexPoint;
+  set apexPoint(DPoint val) {
+    if (val != _apexPoint) {
+      _apexPoint = val;
+      _onVertexPointChanged();
     }
   }
 
+  double get centerLineLength {
+    final viewport = hostVisualArea!.viewport!;
+    final p1 = viewport.convert(_centerLineFixedPoint);
+    final p2 = viewport.convert(_centerLineMovablePoint);
+    final value = (p2 - p1).length.abs();
+    return value;
+  }
+
+  double get area {
+    final viewport = hostVisualArea!.viewport!;
+    final points = innerPoints.map((e) => viewport.convert(e)).toList();
+    final value = AreaPerimeterCal.calcArea(points);
+    return value;
+  }
+
+  bool isClosed = false; // TODO
+
   @override
   void paint(Canvas canvas, Size size) {
     if (innerPoints.isEmpty) return;
@@ -210,6 +280,29 @@ class SimpsonPathFeature extends AreaItemFeatureAbstract {
     //     paintLinePan,
     //   );
     // }
+    if (_pathGeometry != null) {
+      final geometry = _pathGeometry as PathGeometryContainer;
+      for (var fragment in geometry.geometries) {
+        final path = Path();
+        if (fragment is PathGeometry) {
+          for (var i = 0; i < fragment.points.length; i++) {
+            final point = convert2ViewPoint(size, fragment.points[i]);
+            if (i == 0) {
+              path.moveTo(point.x, point.y);
+            } else {
+              path.lineTo(point.x, point.y);
+            }
+          }
+        } else if (fragment is LineGeometry) {
+          DPoint point;
+          point = convert2ViewPoint(size, fragment.start);
+          path.moveTo(point.x, point.y);
+          point = convert2ViewPoint(size, fragment.end);
+          path.lineTo(point.x, point.y);
+        }
+        canvas.drawPath(path, paintLinePan);
+      }
+    }
 
     drawVertex(canvas, points.last.toOffset(), isActive);
   }
@@ -222,73 +315,70 @@ class SimpsonPathFeature extends AreaItemFeatureAbstract {
 
   void updateActivePoint(DPoint point) {
     if (activeIndex > 0 && activeIndex <= innerPoints.length) {
-      // ActivePoint = point;
+      activePoint = point;
       recreateSpline(false);
     }
   }
 
+  DPoint get activePoint {
+    if (activeIndex < 0 || activeIndex >= innerPoints.length) {
+      throw IndexError.withLength(activeIndex, innerPoints.length);
+    }
+    return innerPoints[activeIndex];
+  }
+
+  set activePoint(DPoint val) {
+    if (activeIndex < 0 || activeIndex >= innerPoints.length) {
+      throw IndexError.withLength(activeIndex, innerPoints.length);
+    }
+    innerPoints[activeIndex] = val;
+  }
+
   void fixedSpline() {
-    return;
     if (innerPoints.isEmpty) {
       return;
     }
-    // _centerLineFixedPoint =
-    DPoint((innerPoints.last.x + innerPoints.first.x) * 0.5,
-        (innerPoints.last.y + innerPoints.first.y) * 0.5);
+    _centerLineFixedPoint = DPoint(
+      (innerPoints.last.x + innerPoints.first.x) * 0.5,
+      (innerPoints.last.y + innerPoints.first.y) * 0.5,
+    );
 
     var movablePoint = DPoint(0, double.infinity);
 
-    // if (BaseType == MeasureTypes.SimpsonAutoTrace)
-    // {
-    //     movablePoint = InnerPoints[InnerPoints.Count >> 1];
-    // }
-    // else
-    // {
-    // var isFindMin = innerPoints[innerPoints.length >> 1].y - innerPoints[0].y < 0;
-    // if (AutoGetApexPoint)
-    // {
-    //     movablePoint = isFindMin ? movablePoint :  DPoint(0, double.negativeInfinity);
-    // }
+    var isFindMin =
+        innerPoints[innerPoints.length >> 1].y - innerPoints[0].y < 0;
+    if (autoGetApexPoint) {
+      movablePoint =
+          isFindMin ? movablePoint : DPoint(0, double.negativeInfinity);
+    }
 
-    // foreach (DPoint point in InnerPoints)
-    // {
-    //     if (AutoGetApexPoint && innerPoints.Count > 0)
-    //     {
-    //         if (isFindMin)
-    //         {
-    //             if (point.Y < movablePoint.Y)
-    //             {
-    //                 movablePoint = point;
-    //             }
-    //         }
-    //         else
-    //         {
-    //             if (point.Y > movablePoint.Y)
-    //             {
-    //                 movablePoint = point;
-    //             }
-    //         }
-    //     }
-    //     else
-    //     {
-    //         if (point.Y < movablePoint.Y)
-    //         {
-    //             movablePoint = point;
-    //         }
-    //     }
-    // }
-    // }
+    for (DPoint point in innerPoints) {
+      if (autoGetApexPoint && innerPoints.isNotEmpty) {
+        if (isFindMin) {
+          if (point.y < movablePoint.y) {
+            movablePoint = point;
+          }
+        } else {
+          if (point.y > movablePoint.y) {
+            movablePoint = point;
+          }
+        }
+      } else {
+        if (point.y < movablePoint.y) {
+          movablePoint = point;
+        }
+      }
+    }
 
-    // if (_centerLineMovablePoint != movablePoint)
-    // {
-    //     _centerLineMovablePoint = movablePoint;
-    //     if (!DPointExtension.IsEmpty(_centerLineMovablePoint) && (BaseType != MeasureTypes.SimpsonAutoTrace))
-    //     {
-    //         _centerLineMovablePoint.SynchToMainMonitorScreen(HostArea);
-    //     }
-    // }
-    // UpdateSplitters();
-    // OnVertexPointChanged();
+    if (_centerLineMovablePoint != movablePoint) {
+      _centerLineMovablePoint = movablePoint;
+      if (!_centerLineMovablePoint.isEmpty) {
+        // TODO 重设光标位置，暂不支持
+        // _centerLineMovablePoint.SynchToMainMonitorScreen(HostArea);
+      }
+    }
+    updateSplitters();
+    _onVertexPointChanged();
   }
 
   void adjustEndPoint(DPoint point) {
@@ -360,6 +450,9 @@ class SimpsonPathFeature extends AreaItemFeatureAbstract {
       }
     }
   }
+
+  void _onVertexPointChanged() {}
+  void _onSplineMovablePointsInfoChanged() {}
 }
 
 class SimpsonGeometryGenerator {
@@ -372,7 +465,96 @@ class SimpsonGeometryGenerator {
     DPoint centerLineMovablePoint,
     Map<int, double> horizontalSplitterLegths,
   ) {
-    // TODO: 辛普森绘制核心
+    if (centerLineFixedPoint.isEmpty || centerLineMovablePoint.isEmpty) {
+      return;
+    }
+
+    // Center line
+    DVector centerLine = centerLineMovablePoint - centerLineFixedPoint;
+    var horizontalStart = DPoint(-50, centerLineFixedPoint.y);
+    // horizonta line
+    DVector horizontalLine = horizontalStart - centerLineFixedPoint;
+    // Get angle between horizontal and center line
+    double angle = DVector.angleBetween(horizontalLine, centerLine);
+    double angleToVertical = 90.0 - angle;
+
+    double cellHeight = centerLine.length / splitterCount;
+
+    //Create a 20 splitters path geometry
+    PathGeometryContainer temSplittersGeometry = PathGeometryContainer(Path());
+    for (int i = 1; i <= splitterCount; i++) {
+      double midPointY =
+          centerLineFixedPoint.y - cellHeight * (i - 1) - cellHeight / 2;
+      //horizontal splitter line
+      DPoint p1 = DPoint(-50, midPointY);
+      DPoint p2 = DPoint(50, midPointY);
+
+      final lineGeometry = LineGeometry(p1, p2);
+      lineGeometry.rotateTransform(
+        angle,
+        centerLineFixedPoint.x,
+        centerLineFixedPoint.y,
+      );
+
+      temSplittersGeometry.addGeometry(lineGeometry);
+    }
+
+    //Get intersection points
+    List<DPoint> points = getIntersectionPoints(temSplittersGeometry, spline);
+    List<DPoint> leftPoints = [];
+    List<DPoint> rightPoints = [];
+    //Split point by center line
+    const double constMagnify = 1000.0;
+    for (DPoint point in points) {
+      var magnifyPoint = point;
+      magnifyPoint.x *= constMagnify;
+      magnifyPoint.y *= constMagnify;
+
+      DVector line = magnifyPoint -
+          DPoint(
+            (centerLineFixedPoint.x + centerLineMovablePoint.x) /
+                2.0 *
+                constMagnify,
+            (centerLineFixedPoint.y + centerLineMovablePoint.y) /
+                2.0 *
+                constMagnify,
+          );
+
+      double angleToCenter = DVector.angleBetween(line, centerLine);
+
+      if (angleToCenter >= 0.0) {
+        leftPoints.add(point);
+      } else {
+        rightPoints.add(point);
+      }
+      //order point by vertical axis value
+      orderByCalc(DPoint point) => rotaeY(
+            point,
+            centerLineFixedPoint,
+            angleToVertical * math.pi / 180.0,
+          );
+      leftPoints.sort((a, b) {
+        final vA = orderByCalc(a);
+        final vB = orderByCalc(b);
+        return vA.compareTo(vB);
+      });
+      rightPoints.sort((a, b) {
+        final vA = orderByCalc(a);
+        final vB = orderByCalc(b);
+        return vA.compareTo(vB);
+      });
+      var finalLeftPoint = leftPoints;
+      var finalRightPoint = rightPoints;
+
+      if (finalLeftPoint.length == finalRightPoint.length &&
+          finalLeftPoint.length == splitterCount) {
+        for (int i = 0; i < splitterCount; i++) {
+          horizontalSplitterLegths[i + 1] =
+              (finalLeftPoint[i] - finalRightPoint[i]).length;
+          pathGeometry.addLineGeometry(finalLeftPoint[i], finalRightPoint[i]);
+        }
+      }
+    }
   }
 
   IPathGeometry? createSpline(
@@ -390,26 +572,66 @@ class SimpsonGeometryGenerator {
       return null;
     }
     List<DPoint> samplePoints = [];
-    // var points = Spline.Create(sourcePoints, tension, tensions, isClosed, tolerance, true, out length, samplePoints,true);
-    var points = <DPoint>[];
+    var points = SplineUtils.create(
+      sourcePoints,
+      tension: tension,
+      tensions: tensions,
+      isClosed: isClosed,
+      tolerance: tolerance,
+      closeByStraightLine: true,
+      samplePoints: samplePoints,
+      isSimpsonSpline: true,
+    );
     // var myPoints = GeomTools.ToWindowPoints(points.ToArray());
     // var polyLineSegment = new PolyLineSegment { Points = new PointCollection(myPoints) };
     // var pathFigure = new PathFigure { IsClosed = isClosed, IsFilled = true, StartPoint = sourcePoints[0].ToWindowPoint() };
     // pathFigure.Segments.Add(polyLineSegment);
-    var pathGeometry = Path();
     // pathGeometry.Figures.Add(pathFigure);
 
     splinePoints = points;
-    return PathGeometryContainer(pathGeometry);
+
+    final pathGeometry = PathGeometry(points);
+    final continer = PathGeometryContainer(Path());
+    continer.addGeometry(pathGeometry);
+    return continer;
   }
 
   IPathGeometry createPathGeometry() {
     return PathGeometryContainer(Path());
   }
+
+  static double rotaeY(DPoint point, DPoint cenPoint, double theta) {
+    return math.sin(theta) * (point.x - cenPoint.x) +
+        math.cos(theta) * (point.y - cenPoint.y) +
+        cenPoint.y;
+  }
+
+  List<DPoint> getIntersectionPoints(IPathGeometry g1, IPathGeometry g2) {
+    final result = <DPoint>[];
+    final splittersGeometry = g1 as PathGeometryContainer;
+    final splineGeometry = g2 as PathGeometry;
+    for (var splitter in splittersGeometry.geometries) {
+      splitter as LineGeometry;
+      DPoint lastPoint = splineGeometry.points.first;
+      final endLimit = splineGeometry.points.length - 1;
+      for (var i = 1; i < splineGeometry.points.length; i++) {
+        final point = splineGeometry.points[i];
+        final intersection = LineUtils.calculateIntersection(
+            splitter.start, splitter.end, lastPoint, point);
+        if (intersection != null) {
+          result.add(intersection);
+        }
+        if (i != endLimit) {
+          lastPoint = point;
+        }
+      }
+    }
+    return result;
+  }
 }
 
 class PathGeometryContainer implements IPathGeometry {
-  final pathList = <Path>[];
+  final geometries = <IPathGeometry>[];
   late final Path control;
 
   PathGeometryContainer(Path geometry) {
@@ -418,26 +640,77 @@ class PathGeometryContainer implements IPathGeometry {
 
   @override
   void addGeometry(IPathGeometry geometry) {
-    // TODO:
-    // pathList.addAll(geometry.pathList);
-  }
-
-  void addPath(Path path) {
-    pathList.add(path);
+    geometries.add(geometry);
   }
 
   @override
   void clear() {
-    pathList.clear();
+    geometries.clear();
   }
 
   @override
   void addLineGeometry(
       DPoint centerLineFixedPoint, DPoint centerLineMovablePoint) {
-    final linePath = Path()
-      ..moveTo(centerLineFixedPoint.x, centerLineFixedPoint.y)
-      ..lineTo(centerLineMovablePoint.x, centerLineMovablePoint.y);
-    addPath(linePath);
+    // final linePath = Path()
+    //   ..moveTo(centerLineFixedPoint.x, centerLineFixedPoint.y)
+    //   ..lineTo(centerLineMovablePoint.x, centerLineMovablePoint.y);
+    addGeometry(LineGeometry(centerLineFixedPoint, centerLineMovablePoint));
+  }
+}
+
+class PathGeometry implements IPathGeometry {
+  final List<DPoint> points;
+
+  PathGeometry(this.points);
+
+  @override
+  void addGeometry(IPathGeometry spline) {}
+
+  @override
+  void addLineGeometry(
+      DPoint centerLineFixedPoint, DPoint centerLineMovablePoint) {}
+
+  @override
+  void clear() {}
+}
+
+class LineGeometry implements IPathGeometry {
+  final DPoint start;
+  final DPoint end;
+
+  LineGeometry(this.start, this.end);
+
+  @override
+  void addGeometry(IPathGeometry spline) {}
+
+  @override
+  void addLineGeometry(
+      DPoint centerLineFixedPoint, DPoint centerLineMovablePoint) {}
+
+  @override
+  void clear() {}
+
+  void rotateTransform(double angle, double centerX, double centerY) {
+    rotatePoint(start, centerX, centerY, angle);
+    rotatePoint(end, centerX, centerY, angle);
+  }
+
+  static void rotatePoint(
+    DPoint point,
+    double centerX,
+    double centerY,
+    double angle,
+  ) {
+    double radians = angle * math.pi / 180;
+    double cosTheta = math.cos(radians);
+    double sinTheta = math.sin(radians);
+
+    point.x = centerX +
+        (point.x - centerX) * cosTheta -
+        (point.y - centerY) * sinTheta;
+    point.y = centerY +
+        (point.x - centerX) * sinTheta +
+        (point.y - centerY) * cosTheta;
   }
 }
 
@@ -455,3 +728,15 @@ extension DPointExt on DPoint {
     return this == empty;
   }
 }
+
+class MovablePointsInfo {
+  int index;
+  int start;
+  int end;
+
+  MovablePointsInfo(this.index, this.start, this.end);
+
+  factory MovablePointsInfo.empty() {
+    return MovablePointsInfo(-1, -1, -1);
+  }
+}

lib/process/primitives/utils/line.dart

@@ -0,0 +1,58 @@
+import 'package:fis_measure/interfaces/date_types/point.dart';
+
+class LineUtils {
+  // 计算两条直线是否有交点
+  static DPoint? calculateIntersection(
+    DPoint startA,
+    DPoint endA,
+    DPoint startB,
+    DPoint endB,
+  ) {
+    final lineA = _IntersectionTempLine.fromPoints(startA, endA);
+    final lineB = _IntersectionTempLine.fromPoints(startB, endB);
+
+    if (lineA.isVertical && lineB.isVertical) {
+      // 两条直线都是垂直线，没有交点
+      return null;
+    } else if (lineA.isVertical) {
+      // 第一条直线是垂直线，交点的x坐标是第一条直线的x坐标
+      return DPoint(
+          lineA.intercept, lineB.slope * lineA.intercept + lineB.intercept);
+    } else if (lineB.isVertical) {
+      // 第二条直线是垂直线，交点的x坐标是第二条直线的x坐标
+      return DPoint(
+          lineB.intercept, lineA.slope * lineB.intercept + lineA.intercept);
+    } else if (lineA.slope == lineB.slope) {
+      // 斜率相同，直线平行或重合，没有交点
+      return null;
+    } else {
+      // 斜率不同，计算交点
+      double x =
+          (lineB.intercept - lineA.intercept) / (lineA.slope - lineB.slope);
+      double y = lineA.slope * x + lineA.intercept;
+      return DPoint(x, y);
+    }
+  }
+}
+
+class _IntersectionTempLine {
+  final double slope;
+  final double intercept;
+  final bool isVertical;
+
+  _IntersectionTempLine(this.slope, this.intercept, this.isVertical);
+
+// 根据两个端点创建直线对象
+  factory _IntersectionTempLine.fromPoints(DPoint p1, DPoint p2) {
+    if (p1.x == p2.x) {
+      // 垂直线
+      return _IntersectionTempLine(double.nan, p1.x, true);
+    } else {
+      // 斜率
+      double m = (p2.y - p1.y) / (p2.x - p1.x);
+      // y轴截距
+      double b = p1.y - m * p1.x;
+      return _IntersectionTempLine(m, b, false);
+    }
+  }
+}

lib/process/primitives/utils/spline.dart

@@ -0,0 +1,281 @@
+import 'package:fis_measure/interfaces/date_types/point.dart';
+
+class SplineUtils {
+  static List<DPoint> create(
+    List<DPoint>? sourcePoints, {
+    double tension = 0.5,
+    List<double>? tensions,
+    bool isClosed = false,
+    double tolerance = 1.0,
+    bool closeByStraightLine = false,
+    List<DPoint> samplePoints = const [],
+    bool isSimpsonSpline = false,
+  }) {
+    List<DPoint> splinePoints = [];
+    double length = 0;
+
+    if (sourcePoints == null || sourcePoints.isEmpty) {
+      return splinePoints;
+    }
+
+    splinePoints.add(sourcePoints[0]);
+    if (sourcePoints.length == 1) {
+      generateSamplePointsFromTraceLine(
+          sourcePoints[0], sourcePoints[0], samplePoints);
+      return splinePoints;
+    }
+
+    var pts = List<DPoint>.from(sourcePoints);
+    if (pts.length > 2 &&
+        (pts[pts.length - 1] - pts[pts.length - 2]).length < tolerance) {
+      pts.removeAt(pts.length - 1);
+    }
+
+    _ModifiableInt segmentStart = _ModifiableInt(-1);
+    if (pts.length == 2) {
+      if (!isClosed) {
+        length += _segment(splinePoints, pts[0], pts[0], pts[1], pts[1],
+            tension, tension, tolerance, segmentStart);
+      } else {
+        length += _segment(splinePoints, pts[1], pts[0], pts[1], pts[0],
+            tension, tension, tolerance, segmentStart);
+        length += _segment(splinePoints, pts[0], pts[1], pts[0], pts[1],
+            tension, tension, tolerance, segmentStart);
+      }
+
+      generateSamplePointsFromTraceLine(pts[0], pts[1], samplePoints);
+    } else {
+      // var startEndTension = ResourceManager.GetValue("Measurement", "Tension", 0.1);
+      var startEndTension = 0.1; // TODO
+
+      List<int> pointSegments = [];
+      var useTensionCollection = tensions != null && tensions.isNotEmpty;
+
+      for (var i = 0; i < pts.length; i++) {
+        var t1 = useTensionCollection ? tensions[i % tensions.length] : tension;
+        var t2 = useTensionCollection
+            ? tensions[(i + 1) % tensions.length]
+            : tension;
+
+        if (isSimpsonSpline &&
+            (i == 0 || i == pts.length - 2 || i == pts.length - 1)) {
+          t1 = t2 = startEndTension;
+        }
+
+        if (i == 0) {
+          length += _segment(
+            splinePoints,
+            isClosed ? pts[pts.length - 1] : pts[0],
+            pts[0],
+            pts[1],
+            pts[2],
+            t1,
+            t2,
+            tolerance,
+            segmentStart,
+          );
+          if (segmentStart.value != -1) {
+            pointSegments.add(segmentStart.value);
+          }
+        } else if (i == pts.length - 2) {
+          length += _segment(
+            splinePoints,
+            pts[i - 1],
+            pts[i],
+            pts[i + 1],
+            isClosed ? pts[0] : pts[i + 1],
+            t1,
+            t2,
+            tolerance,
+            segmentStart,
+          );
+          if (segmentStart.value != -1) {
+            pointSegments.add(segmentStart.value);
+          }
+        } else if (i == pts.length - 1) {
+          if (isClosed) {
+            if (closeByStraightLine) {
+              length += (pts[i] - pts[0]).length;
+            } else {
+              length += _segment(splinePoints, pts[i - 1], pts[i], pts[0],
+                  pts[1], t1, t2, tolerance, segmentStart);
+              if (segmentStart.value != -1) {
+                pointSegments.add(segmentStart.value);
+              }
+            }
+          }
+        } else {
+          length += _segment(splinePoints, pts[i - 1], pts[i], pts[i + 1],
+              pts[i + 2], t1, t2, tolerance, segmentStart);
+          if (segmentStart.value != -1) {
+            pointSegments.add(segmentStart.value);
+          }
+        }
+      }
+
+      if (samplePoints.isNotEmpty) {
+        if (pointSegments.length <= samplePoints.length) {
+          int samples = 0;
+          int totalPoints = splinePoints.length;
+
+          for (int i = 0; i < pointSegments.length; i++) {
+            var nextStart = i == pointSegments.length - 1
+                ? splinePoints.length
+                : pointSegments[i + 1];
+            var startIndex = pointSegments[i];
+            var segCount = nextStart - startIndex;
+            var totalSamples = samplePoints.length - samples;
+            var interval = totalPoints / totalSamples;
+
+            if (interval >= 1) {
+              int count = (segCount / interval).round();
+              if (count <= 1) {
+                samplePoints[samples++] =
+                    splinePoints[startIndex + segCount - 1];
+                if (samples == samplePoints.length) {
+                  return splinePoints;
+                }
+              } else {
+                var step = segCount ~/ count;
+                var seek = (segCount % count + step - 1).toInt();
+                for (int index = seek; index < segCount; index += step) {
+                  samplePoints[samples++] = splinePoints[startIndex + index];
+                  if (samples == samplePoints.length) {
+                    return splinePoints;
+                  }
+                }
+              }
+            } else {
+              for (int index = 0; index < segCount; index++) {
+                samplePoints[samples++] = splinePoints[startIndex + index];
+                if (samples == samplePoints.length) {
+                  return splinePoints;
+                }
+              }
+            }
+
+            totalPoints -= segCount;
+          }
+
+          if (samples > 1 && samples < samplePoints.length) {
+            List<DPoint> temp = samplePoints.take(samples).toList();
+            int insertIndex = temp.length - 1;
+            while (temp.length < samplePoints.length) {
+              var vector = (temp[insertIndex] - temp[insertIndex - 1]) / 2;
+              var point = temp[insertIndex - 1].addVector(vector);
+              temp.insert(insertIndex, point);
+              insertIndex--;
+              if (insertIndex == 0) {
+                insertIndex = temp.length - 1;
+              }
+            }
+
+            for (int i = 0; i < samplePoints.length; i++) {
+              samplePoints[i] = temp[i];
+            }
+          }
+        } else {
+          throw ArgumentError("Too many trace point segments.");
+        }
+      }
+    }
+
+    // ... 省略中间部分的转换，因为它需要根据C#代码逐行转换 ...
+
+    // 假设已经转换了所有需要的部分，并且现在返回生成的样条点列表
+    return splinePoints;
+  }
+
+  static void generateSamplePointsFromTraceLine(
+    DPoint start,
+    DPoint end,
+    List<DPoint> samplePoints,
+  ) {
+    if (samplePoints.length > 1) {
+      if (start.x == end.x && start.y == end.y) {
+        for (int i = 0; i < samplePoints.length; i++) {
+          samplePoints[i] = start;
+        }
+      } else {
+        DPoint step = DPoint((end.x - start.x) / (samplePoints.length - 1),
+            (end.y - start.y) / (samplePoints.length - 1));
+        for (int i = 0; i < samplePoints.length; i++) {
+          samplePoints[i] = DPoint(start.x + step.x * i, start.y + step.y * i);
+        }
+      }
+    }
+  }
+
+  static double _segment(
+    List<DPoint> points,
+    DPoint pt0,
+    DPoint pt1,
+    DPoint pt2,
+    DPoint pt3,
+    double t1,
+    double t2,
+    double tolerance,
+    _ModifiableInt segmentStart,
+  ) {
+    segmentStart.value = -1;
+
+    double length = (pt1 - pt2).length;
+    double sx1 = t1 * (pt2.x - pt0.x);
+    double sy1 = t1 * (pt2.y - pt0.y);
+    double sx2 = t2 * (pt3.x - pt1.x);
+    double sy2 = t2 * (pt3.y - pt1.y);
+
+    double ax = sx1 + sx2 + 2 * pt1.x - 2 * pt2.x;
+    double ay = sy1 + sy2 + 2 * pt1.y - 2 * pt2.y;
+    double bx = -2 * sx1 - sx2 - 3 * pt1.x + 3 * pt2.x;
+    double by = -2 * sy1 - sy2 - 3 * pt1.y + 3 * pt2.y;
+    double cx = sx1;
+    double cy = sy1;
+    double dx = pt1.x;
+    double dy = pt1.y;
+
+    int num =
+        ((pt1.x - pt2.x).abs() + (pt1.y - pt2.y).abs() ~/ tolerance).toInt();
+
+    for (int i = 1; i < num; i++) {
+      double t = i / (num - 1);
+      DPoint pt = DPoint(
+        ax * t * t * t + bx * t * t + cx * t + dx,
+        ay * t * t * t + by * t * t + cy * t + dy,
+      );
+      if (i == 1) {
+        length += (pt - pt1).length;
+      } else {
+        length += (pt - points[points.length - 1]).length;
+      }
+
+      if (segmentStart.value == -1) {
+        segmentStart.value = points.length;
+      }
+      points.add(pt);
+    }
+
+    return length;
+  }
+}
+
+class _ModifiableInt extends _ModifiableValue<int> {
+  _ModifiableInt(super.value);
+
+  _ModifiableInt operator +(int other) {
+    value += other;
+    return this;
+  }
+
+  _ModifiableInt operator -(int other) {
+    value -= other;
+    return this;
+  }
+}
+
+class _ModifiableValue<T> {
+  T value;
+  _ModifiableValue(
+    this.value,
+  );
+}

lib/process/workspace/urm/application.dart

@@ -138,6 +138,15 @@ class URMApplication extends Application {
     return info;
   }
 
+  @override
+  double get displayScaleRatio {
+    return max(
+        1,
+        min(displaySize.width / resultWidth,
+            displaySize.height / resultHeight));
+    // return 1.0;
+  }
+
   void loadURMVisuals() {
     loadVisuals();
   }