fis_lib_measure/lib/process/primitives/multi_method/semiauto_trace.dart

import 'dart:ui';

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/workspace/application.dart';
import 'package:fis_measure/interfaces/process/workspace/point_info.dart';
import 'package:fis_measure/process/calcuators/semiauto_trace.dart';
import 'package:fis_measure/process/items/item.dart';
import 'package:fis_measure/process/items/item_feature.dart';
import 'package:fis_measure/process/physical_coordinates/doppler.dart';
import 'package:fis_measure/process/primitives/multi_method/dop_trace_disp/cardiac_cycle.dart';
import 'package:fis_measure/process/primitives/multi_method/dop_trace_disp/data.dart';
import 'package:fis_measure/utils/canvas.dart';
import 'package:fis_measure/view/gesture/positioned_touch_cursor.dart';
import 'package:flutter/material.dart';
import 'package:get/get.dart';

class SemiautoTrace extends TraceItemAbstract {
  SemiautoTrace(ItemMeta meta, IMeasureItem? parent) : super(meta, parent);
  late final touchState = Get.find<ITouchPointState>();

  @override
  bool onExecuteMouse(PointInfo args) {
    if (state == ItemStates.finished) {
      if (args.pointType == PointInfoType.mouseDown) {
        state = ItemStates.waiting;
      }
    }
    final point = args.toAreaLogicPoint();

    if (state == ItemStates.waiting) {
      if (args.pointType == PointInfoType.mouseDown) {
        handleMouseDownWhileWaiting(args);
      }
    } else if (state == ItemStates.running) {
      if (args.pointType == PointInfoType.mouseUp) return false;
      feature?.adopt(args);
      doCalculate();
      if (args.pointType == PointInfoType.mouseDown) {
        List<CardiacCycle> currentCardiacCycleList =
            feature?.refItem.currentCardiacCycleList ?? [];
        if (currentCardiacCycleList.isNotEmpty) {
          feature?.refItem.setInnerPoints([
            convertToAreaPoint(currentCardiacCycleList.first.systoleStart)
                .addVector(DVector(convertToAreaPoint(DPoint(-1, 0)).x,
                    convertToAreaPoint(DPoint(-1, 0)).y)),
            convertToAreaPoint(currentCardiacCycleList.last.diastoleEnd)
          ]);
        }

        feature?.refItem.setCurrentCardiacCycleList([]);
        doFeatureFinish();
      }
    }
    return true;
  }

  DPoint convertToAreaPoint(DPoint point) {
    /// 像素坐标
    final x = point.x;
    final y = point.y;
    final application = Get.find<IApplication>();
    Size displaySize = application.displaySize;

    return DPoint(x / displaySize.width, y / displaySize.height);
  }

  @override
  void doFeatureFinish() {
    super.doFeatureFinish();
  }

  void synchToMainMonitorScreen(PointInfo args) {
    final point = args.toAreaLogicPoint();
    var x = point.x;
    var y = point.y;
  }

  void handleMouseDownWhileWaiting(PointInfo args) {
    // TODO: 判断是否当前area
    // 转换为Area逻辑位置
    feature = SemiautoTraceFeature(this);
    if (args.hostVisualArea != null) {
      feature!.hostVisualArea = args.hostVisualArea;
    }
    final point = args.toAreaLogicPoint();
    feature!.adopt(point);
    state = ItemStates.running;
  }

  void handleTouchDownWhileWaiting(PointInfo args) {
    // TODO: 判断是否当前area
    // 转换为Area逻辑位置
    feature = SemiautoTraceFeature(this);
    if (args.hostVisualArea != null) {
      feature!.hostVisualArea = args.hostVisualArea;
    }
    final point = args.toAreaLogicPoint();
    feature!.adopt(point);
    // state = ItemStates.running;
  }

  PointInfo? startPoint;
  DPoint touchStartPosition = DPoint(0, 0); // 相对位移起始触摸点
  bool isFirstPointMove = false;
  @override
  bool onExecuteTouch(PointInfo args) {
    if (state == ItemStates.finished) {
      if (args.pointType == PointInfoType.touchDown) {
        state = ItemStates.waiting;
      }
    }

    if (state == ItemStates.waiting) {
      if (isFirstPointMove) {
        args.addOffset(0, -0.2);
      }
      switch (args.pointType) {
        case PointInfoType.touchDown:
          isFirstPointMove = false;
          startPoint = args; // 设置线段起点
          handleTouchDownWhileWaiting(startPoint!); // 通过设置的起点开始一个绘制事件
          break;
        case PointInfoType.touchUp:
          startPoint = args; // 设置线段起点
          state = ItemStates.running;
          touchState.touchOffset = Offset.zero;
          break; // 按下立即抬起无事发生
        case PointInfoType.touchMove:
          if (isMoveTargetOutOfRange(args)) return true;
          isFirstPointMove = true;
          final pixelSize = application.displaySize;
          touchState.touchOffset =
              DPoint(0, -0.2).scale2Size(pixelSize).toOffset();
          feature?.innerPoints.first = args;
          break;
        default:
          break;
      }
    } else if (state == ItemStates.running) {
      if (args.pointType == PointInfoType.touchDown) {
        touchStartPosition = args;
        final pixelSize = application.displaySize;
        touchState.touchOffset = startPoint!.scale2Size(pixelSize).toOffset() -
            args.scale2Size(pixelSize).toOffset();
      }
      if (args.pointType == PointInfoType.touchUp) {
        touchState.touchOffset = Offset.zero;
        doFeatureFinish();
      }
      if (args.pointType == PointInfoType.touchMove) {
        PointInfo newPoint = PointInfo.fromOffset(
            startPoint!.clone().addVector(args - touchStartPosition).toOffset(),
            startPoint!.pointType);
        if (isMoveTargetOutOfRange(newPoint)) return true;
        feature?.adopt(newPoint);
        doCalculate();
      }
    }
    return true;
  }

  static SemiautoTrace createTrace(
    ItemMeta meta, [
    IMeasureItem? parent,
  ]) {
    SemiautoTrace trace = SemiautoTrace(meta, parent);
    trace.calculator = SemiautoTraceCal(trace);
    return trace;
  }
}

class SemiautoTraceFeature extends SemiautoTraceItemFeatureAbstract {
  SemiautoTraceFeature(TraceItemAbstract refItem) : super(refItem);
  final greenPen = Paint()
    ..color = const Color.fromARGB(255, 0, 255, 0)
    ..isAntiAlias = true
    ..strokeWidth = 1
    ..style = PaintingStyle.stroke;
  final dashLinePan = Paint()
    ..color = const Color.fromARGB(255, 255, 255, 0)
    ..isAntiAlias = false
    ..strokeWidth = 1
    ..style = PaintingStyle.stroke;
  DPoint furthestPoint = DPoint(0, 0);
  static const double threshold = 1;
  List<CardiacCycle> currentCardiacCycleList = [];

  @override
  void paint(Canvas canvas, Size size) {
    final double areaTop = hostVisualArea!.displayRegion.top * size.height;
    final double areaBottom =
        hostVisualArea!.displayRegion.bottom * size.height;
    if (innerPoints.isEmpty) return;
    if (innerPoints.length == 1) {
      drawVertex(canvas, convert2ViewPoint(size, innerPoints[0]).toOffset());
      drawId(canvas, size);
      return;
    }
    double maxDistance = 0;
    drawId(canvas, size);
    Path path = Path();

    final points = innerPoints.map((e) => convert2ViewPoint(size, e)).toList();
    final startOffset = convert2ViewPoint(size, startPoint);
    final endOffset = convert2ViewPoint(size, endPoint);

    double baseLine =
        (hostVisualArea!.viewport!.physical as DopplerPhysicalCoordinate)
            .baseLine;
    double pwHeight = size.height * hostVisualArea!.layoutRegion!.height;

    double baseLineHeight = areaTop + baseLine * pwHeight;

    var data = TraceListData.instance;

    /// 最大点集
    List<DPoint> maxPonints = data.maxPonints;
    if (startOffset.y < baseLineHeight) {
      data.setLocation(TraceLocationType.above);
    } else {
      data.setLocation(TraceLocationType.below);
    }

    /// 当前周期数据
    List<CardiacCycle> cardiacCycleList = data.cardiacCycleList;

    if (points.length > 1) {
      DPoint startDPoint = maxPonints.firstWhere(
        (element) => element.x.toInt() == startOffset.x.toInt(),
      );
      path.moveTo(startDPoint.x, startDPoint.y);

      final firstPoint = points.first;
      final lastPoint = points.last;
      var firstIndex = maxPonints.indexWhere(
        (element) => element.x.toInt() == firstPoint.x.toInt(),
      );
      var lastIndex = maxPonints.indexWhere(
        (element) => element.x.toInt() == lastPoint.x.toInt(),
      );
      List<DPoint> points2 = [];
      path = Path();
      path.moveTo(maxPonints[firstIndex].x, maxPonints[firstIndex].y);
      for (int i = 0; i < maxPonints.length; i++) {
        if (firstIndex == lastIndex) {
          return;
        }
        if (firstIndex > lastIndex) {
          points2 = maxPonints.sublist(lastIndex, firstIndex);
        } else {
          points2 = maxPonints.sublist(firstIndex, lastIndex);
        }
      }

      if (firstIndex > lastIndex) {
        for (var i = points2.length - 1; i > 1; i--) {
          final point = points2[i];
          DPoint endDPoint = maxPonints
              .firstWhere((element) => element.x.toInt() == point.x.toInt());
          path.lineTo(endDPoint.x, endDPoint.y);
          // final distance = (endDPoint.y - startOffset.y).abs();
          // if (distance > maxDistance) {
          //   maxDistance = distance;
          //   furthestPoint = endDPoint;
          // }
        }
      } else {
        for (var i = 1; i < points2.length; i++) {
          final point = points2[i];
          DPoint endDPoint = maxPonints
              .firstWhere((element) => element.x.toInt() == point.x.toInt());
          path.lineTo(endDPoint.x, endDPoint.y);
          // final distance = (endDPoint.y - startOffset.y).abs();
          // if (distance > maxDistance) {
          //   maxDistance = distance;
          //   furthestPoint = endDPoint;
          // }
        }
      }

      /// 根据周期绘制
      for (CardiacCycle i in cardiacCycleList) {
        if (i.diastoleEnd.x <= endOffset.x &&
            i.systoleStart.x >= startOffset.x) {
          canvas.drawDashLine(
            Offset(i.systoleStart.x, areaTop),
            Offset(i.systoleStart.x, areaBottom),
            3,
            3,
            dashLinePan,
          );
          canvas.drawDashLine(
            Offset(i.diastoleEnd.x, areaTop),
            Offset(i.diastoleEnd.x, areaBottom),
            3,
            3,
            dashLinePan,
          );
          drawCrossVertex(
            canvas,
            TraceListData.convert(i.peakSystolic).toOffset(),
          );
          if (!currentCardiacCycleList.contains(i)) {
            currentCardiacCycleList.add(i);
          }
        } else if (i.diastoleEnd.x > endOffset.x) {
          if (currentCardiacCycleList.contains(i)) {
            currentCardiacCycleList.remove(i);
          }
        }
      }
      refItem
          .setCurrentCardiacCycleList(currentCardiacCycleList.toSet().toList());

      // // drawCrossVertex(canvas, furthestPoint.toOffset());
      // for (SemiautoTraceItemFeatureAbstract i in refItem.measuredFeatures) {
      //   path = Path();
      //   CardiacCycle firstCardiacCycle =
      //       i.refItem.currentCardiacCycleList.first;
      //   CardiacCycle lastCardiacCycle = i.refItem.currentCardiacCycleList.last;
      //   path.moveTo(
      //       firstCardiacCycle.systoleStart.x, firstCardiacCycle.systoleStart.y);
      //   //     for(CardiacCycle i in currentCardiacCycleList) {
      //   //   path.lineTo(i.peakSystolic.x, i.peakSystolic.y);
      //   // }
      //   var firstIndex = maxPonints.indexWhere(
      //     (element) =>
      //         element.x.toInt() == firstCardiacCycle.systoleStart.x.toInt(),
      //   );
      //   var lastIndex = maxPonints.indexWhere(
      //     (element) =>
      //         element.x.toInt() == lastCardiacCycle.diastoleEnd.x.toInt(),
      //   );
      //   List<DPoint> points = [];
      //   for (int i = 0; i < maxPonints.length; i++) {
      //     points = maxPonints.sublist(firstIndex, lastIndex);
      //   }
      //   print(points);
      //   for (DPoint i in points) {
      //     path.lineTo(i.x, i.y);
      //   }
      // }

      // if (refItem.feature != null &&
      //     refItem.feature!.id < refItem.measuredFeatures.length &&
      //     currentCardiacCycleList.isNotEmpty) {
      //   path = Path();
      //   CardiacCycle firstCardiacCycle = currentCardiacCycleList.first;
      //   CardiacCycle lastCardiacCycle = currentCardiacCycleList.last;
      //   path.moveTo(
      //       firstCardiacCycle.systoleStart.x, firstCardiacCycle.systoleStart.y);
      //   //     for(CardiacCycle i in currentCardiacCycleList) {
      //   //   path.lineTo(i.peakSystolic.x, i.peakSystolic.y);
      //   // }
      //   var firstIndex = maxPonints.indexWhere(
      //     (element) =>
      //         element.x.toInt() == firstCardiacCycle.systoleStart.x.toInt(),
      //   );
      //   var lastIndex = maxPonints.indexWhere(
      //     (element) =>
      //         element.x.toInt() == lastCardiacCycle.diastoleEnd.x.toInt(),
      //   );
      //   List<DPoint> points = [];
      //   for (int i = 0; i < maxPonints.length; i++) {
      //     points = maxPonints.sublist(firstIndex, lastIndex);
      //   }
      //   print(points);
      //   for (DPoint i in points) {
      //     path.lineTo(i.x, i.y);
      //   }
      //   //     for(CardiacCycle i in currentCardiacCycleList) {
      //   //   path.lineTo(i.peakSystolic.x, i.peakSystolic.y);
      //   // }
      // }
      canvas.drawPath(
        path,
        greenPen,
      );
    }
  }

  /// 转成物理坐标
  DPoint convert2LogicPoint(
    Size size,
    DPoint viewPoint,
    double baseLine,
    double width,
    double height,
  ) {
    final x = viewPoint.x / size.width * width;
    final y = viewPoint.y - (baseLine * size.height) * height;
    return DPoint(x, y);
  }
}

abstract class SemiautoTraceItemFeatureAbstract extends MeasureItemFeature {
  SemiautoTraceItemFeatureAbstract(TraceItemAbstract refItem) : super(refItem);

  @override
  TraceItemAbstract get refItem => super.refItem as TraceItemAbstract;

  DPoint get startPoint => innerPoints.first;
  DPoint get endPoint => innerPoints.last;

  bool ifRightSide = true;

  /// 接收新坐标
  void adopt(DPoint point) {
    if (innerPoints.isEmpty) {
      innerPoints.add(point);
    }
    if (point.x > startPoint.x) {
      handleChangeSide(point);
      if (point.x < innerPoints.last.x) {
        clearRight(point.x);
      } else if (point.x > innerPoints.last.x) {
        innerPoints.add(point);
      }
    } else {
      handleChangeSide(point);
      if (point.x > innerPoints.last.x) {
        clearLeft(point.x);
      } else if (point.x < innerPoints.last.x) {
        innerPoints.add(point);
      }
    }
  }

  void clearRight(double X) {
    if (innerPoints.isEmpty) return;
    for (var i = innerPoints.length - 1; i >= 0; i--) {
      if (innerPoints[i].x >= X) {
        innerPoints.removeAt(i);
      }
    }
  }

  void clearLeft(double X) {
    if (innerPoints.isEmpty) return;
    for (var i = innerPoints.length - 1; i >= 0; i--) {
      if (innerPoints[i].x <= X) {
        innerPoints.removeAt(i);
      }
    }
  }

  void handleChangeSide(point) {
    if (ifRightSide) {
      if (point.x < startPoint.x) {
        ifRightSide = false;
        innerPoints.clear();
        innerPoints.add(point);
      }
    } else {
      if (point.x > startPoint.x) {
        ifRightSide = true;
        innerPoints.clear();
        innerPoints.add(point);
      }
    }
  }
}

abstract class TraceItemAbstract
    extends MeasureItem<SemiautoTraceItemFeatureAbstract> {
  TraceItemAbstract(ItemMeta meta, IMeasureItem? parent) : super(meta, parent);

  List<CardiacCycle> currentCardiacCycleList = [];
  void setCurrentCardiacCycleList(List<CardiacCycle> _currentCardiacCycleList) {
    currentCardiacCycleList = _currentCardiacCycleList;
  }

  void setInnerPoints(List<DPoint> points) {
    feature!.innerPoints.clear();
    feature!.innerPoints.addAll(points);
  }
}