simpson

lib/process/calcuators/formulas/cardiac.dart

@@ -114,6 +114,16 @@ class CardiacFormulas {
     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
   static double lvdMass(double ivsd, double lvidd, double lvpwd) {
     const density = GlobalCardiacConfigs.density;

lib/process/calcuators/lv_study.dart

@@ -225,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
@@ -256,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
@@ -272,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,3 +1,4 @@
+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';
@@ -14,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;
   }
 }
 
@@ -32,12 +117,14 @@ class LvSingleSimpsonCal extends LvStudyCalculatorBase<LvStudySingleSimpson> {
 
     restoreVals();
 
+    feature.updateStringValue(
+      ItemOutputMeta(
+          ref.meta.description, ref.meta.description, VidUsUnit.None),
+      "",
+    );
+
     for (var output in ref.meta.outputs) {
       switch (output.name) {
-        // TODO: xxx
-        case MeasureTerms.LvStudySimple:
-          feature.updateStringValue(output, "");
-          break;
         case MeasureTerms.LVEDV:
           updateLVEDV();
           break;
@@ -50,11 +137,30 @@ class LvSingleSimpsonCal extends LvStudyCalculatorBase<LvStudySingleSimpson> {
         case MeasureTerms.EF:
           updateEF();
           break;
-        case MeasureTerms.FS:
-          updatePercentFS();
+        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
@@ -85,7 +191,7 @@ class LvSingleSimpsonCal extends LvStudyCalculatorBase<LvStudySingleSimpson> {
     double longDiameter = roundDouble(feature.centerLineLength);
     int index = 0;
     List<double> bDiameters =
-        List.generate(SimpsonPath.SplitterCount, (index) => 0);
+        List.generate(SimpsonPath.splitterCount, (index) => 0);
     feature.horizontalSplitterLegths.forEach((key, value) {
       bDiameters[index++] = value;
     });
@@ -94,7 +200,7 @@ class LvSingleSimpsonCal extends LvStudyCalculatorBase<LvStudySingleSimpson> {
       longDiameter,
       bDiameters,
       bDiameters,
-      SimpsonPath.SplitterCount,
+      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,4 +1,5 @@
 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';
@@ -20,6 +21,8 @@ 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,
@@ -31,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);
 
@@ -70,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 {
@@ -277,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);
   }
@@ -443,8 +469,6 @@ class SimpsonGeometryGenerator {
       return;
     }
 
-    // TODO: 辛普森绘制核心
-
     // Center line
     DVector centerLine = centerLineMovablePoint - centerLineFixedPoint;
     var horizontalStart = DPoint(-50, centerLineFixedPoint.y);
@@ -462,26 +486,75 @@ class SimpsonGeometryGenerator {
       double midPointY =
           centerLineFixedPoint.y - cellHeight * (i - 1) - cellHeight / 2;
       //horizontal splitter line
-      final tempLinePath = Path();
-      tempLinePath.moveTo(-50, midPointY);
-      tempLinePath.lineTo(50, midPointY);
-
-      var matrix = Matrix4.identity();
-      matrix.rotateZ(angleToVertical * 0.0174533); // Convert degrees to radians
-      // matrix.translate(centerLineFixedPoint.dx, centerLineFixedPoint.dy);
-      matrix.scale(1, 1, 1); // Adjust scale if needed
-      matrix.translate(
-          -50, -midPointY); // Adjust translation to center the line
-      // tempLinePath.transform(matrix)
-      // LineGeometry templineGeometry =
-      //     new LineGeometry(Point(-50, midPointY), Point(50, midPointY));
-      // templineGeometry.Transform = new RotateTransform(
-      //     -angleToVertical, centerLineFixedPoint.x, centerLineFixedPoint.y);
-      // temSplittersGeometry.addGeometry(templineGeometry);
+      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(
@@ -499,26 +572,65 @@ 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;
 
@@ -531,22 +643,74 @@ class PathGeometryContainer implements IPathGeometry {
     geometries.add(geometry);
   }
 
-  void addPath(Path path) {
-    pathList.add(path);
-  }
-
   @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;
   }
 }
 

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,
+  );
+}