fis_lib_measure/lib/process/primitives/urm_measure/urm_rect_measure.dart

import 'dart:ui';

import 'package:fis_jsonrpc/rpc.dart';
import 'package:fis_measure/interfaces/date_types/point.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/urm_calcuators/urm_rect_den_measure.dart';
import 'package:fis_measure/process/calcuators/urm_calcuators/urm_rect_den_vel_measure.dart';
import 'package:fis_measure/process/calcuators/urm_calcuators/urm_rect_density.dart';
import 'package:fis_measure/process/calcuators/urm_calcuators/urm_rect_fractal_dim.dart';
import 'package:fis_measure/process/calcuators/urm_calcuators/urm_rect_hist.dart';
import 'package:fis_measure/process/calcuators/urm_calcuators/urm_rect_perfusion.dart';
import 'package:fis_measure/process/calcuators/urm_calcuators/urm_rect_vel_measure.dart';
import 'package:fis_measure/process/items/item.dart';
import 'package:fis_measure/process/primitives/utils/urm_sharp_copy.dart';
import 'package:fis_measure/utils/canvas.dart';
import 'package:fis_measure/utils/prompt_box.dart';
import 'dart:ui' as ui;

import '../../items/item_feature.dart';

class URMRectMeasure extends MeasureItem<URMRectFeature> {
  URMRectMeasure(ItemMeta meta, IMeasureItem? parent) : super(meta, parent);

  static URMRectMeasure createURMRectDensity(ItemMeta meta,
      [IMeasureItem? parent]) {
    URMRectMeasure measureRect = URMRectMeasure(meta, parent);
    measureRect.calculator = URMRectDensityCal(
      measureRect,
    );
    return measureRect;
  }

  static URMRectMeasure createURMRectFractalDim(ItemMeta meta,
      [IMeasureItem? parent]) {
    URMRectMeasure measureRect = URMRectMeasure(meta, parent);
    measureRect.calculator = URMRectFractalDimCal(
      measureRect,
    );
    return measureRect;
  }

  static URMRectMeasure createURMRectDenMeasure(ItemMeta meta,
      [IMeasureItem? parent]) {
    URMRectMeasure measureRect = URMRectMeasure(meta, parent);
    measureRect.calculator = URMRectDenMeasureCal(
      measureRect,
    );
    return measureRect;
  }

  static URMRectMeasure createURMRectPerfusion(ItemMeta meta,
      [IMeasureItem? parent]) {
    URMRectMeasure measureRect = URMRectMeasure(meta, parent);
    measureRect.calculator = URMRectPerfusionCal(
      measureRect,
    );
    return measureRect;
  }

  static URMRectMeasure createURMRectHist(ItemMeta meta,
      [IMeasureItem? parent]) {
    URMRectMeasure measureRect = URMRectMeasure(meta, parent);
    measureRect.calculator = URMRectHistCal(
      measureRect,
    );
    return measureRect;
  }

  static URMRectMeasure createURMRectDenVelMeasure(ItemMeta meta,
      [IMeasureItem? parent]) {
    URMRectMeasure measureRect = URMRectMeasure(meta, parent);
    measureRect.calculator = URMRectDenVelMeasureCal(
      measureRect,
    );
    return measureRect;
  }

  static URMRectMeasure createURMRectVelMeasure(ItemMeta meta,
      [IMeasureItem? parent]) {
    URMRectMeasure measureRectVel = URMRectMeasure(meta, parent);
    measureRectVel.calculator = URMRectVelMeasureCal(
      measureRectVel,
    );
    return measureRectVel;
  }

  @override
  bool onExecuteMouse(PointInfo args) {
    if (waitingResult) return false;
    if (state == ItemStates.finished) {
      if (args.pointType == PointInfoType.mouseDown) {
        state = ItemStates.waiting;
      }
    }

    if (state == ItemStates.waiting) {
      if (args.pointType == PointInfoType.mouseDown) {
        handleMouseDownWhileWaiting(args);
      }
    } else if (state == ItemStates.running) {
      if (args.pointType == PointInfoType.mouseUp) return false;

      feature?.endPoint = args;
      if (args.pointType == PointInfoType.mouseDown) {
        handleFinish();
      }
    }
    return true;
  }

  bool waitingResult = false;

  void handleFinish({bool recordSharp = true}) async {
    if (recordSharp) {
      _recordSharp();
    }

    feature!.isActive = false;
    waitingResult = true;
    await doCalculateAsync();
    doFeatureFinish();
    PromptBox.dismiss();
    waitingResult = false;
  }

  void _recordSharp() {
    UrmSharpCopyBoard.recordSharp(
      UrmSharpCopyDataType.rect,
      [feature!.startPoint, feature!.endPoint],
    );
  }

  @override
  bool onExecuteTouch(PointInfo args) {
    // TODO: implement onExecuteTouch
    throw UnimplementedError();
  }

  void handleMouseDownWhileWaiting(PointInfo args) {
    // TODO: 判断是否当前area
    // 转换为Area逻辑位置
    final point = args.toAreaLogicPoint();
    if (meta.measureType == MeasureTypes.URMRectPerfusion) {
      feature = RectPerfusionImageFeature(this, point, point);
      if (args.hostVisualArea != null) {
        feature!.hostVisualArea = args.hostVisualArea;
      }
    } else {
      feature = URMRectFeature(this, point, point);
      if (args.hostVisualArea != null) {
        feature!.hostVisualArea = args.hostVisualArea;
      }
    }

    state = ItemStates.running;
  }
}

class URMRectFeature extends MeasureItemFeature {
  URMRectFeature(
    IMeasureItem refItem,
    DPoint startPoint,
    DPoint endPoint,
  ) : super(refItem) {
    innerPoints.add(startPoint);
    innerPoints.add(endPoint);
  }

  /// 起点
  DPoint get startPoint => innerPoints[0];
  set startPoint(DPoint value) => innerPoints[0] = value;

  /// 终点
  DPoint get endPoint => innerPoints[1];
  set endPoint(DPoint value) => innerPoints[1] = value;

  List<List<Offset>> offsetsList = [];
  // List<List<Offset>> scaledOffsetsList = [];

  @override
  void paint(Canvas canvas, Size size) {
    if (startPoint == endPoint) return;
    drawId(canvas, size, idText);

    final startOffset = convert2ViewPoint(size, startPoint).toOffset();
    drawVertex(canvas, startOffset);

    final endOffset = convert2ViewPoint(size, endPoint).toOffset();
    canvas.drawDashRect(startOffset, endOffset, 1, 10, paintPan);
    drawVertex(canvas, endOffset, isActive);
    //绘制点集连线
    // scaledOffsetsList = offsetsList.map((e) {
    //   return e.map((e) {
    //     return e * refItem.scaleRatio;
    //   }).toList();
    // }).toList();
    for (var offsets in offsetsList) {
      canvas.drawPointsLine(offsets, paintLinePan);
    }
  }

  /// 绘制灌注图
  @override
  void paintPerfusion(Canvas canvas, Size size) {}
}

class RectPerfusionImageFeature extends URMRectFeature {
  RectPerfusionImageFeature(
    IMeasureItem refItem,
    DPoint startPoint,
    DPoint endPoint,
  ) : super(refItem, startPoint, endPoint);

  ui.Image? perfusionImg;
  IntRect? perfusionPiexlRect;
  DPoint? leftTopPoint;
  DPoint? rightBottomPoint;

  /// 绘制灌注图
  @override
  void paintPerfusion(Canvas canvas, Size size) {
    if (perfusionImg != null) {
      Paint paint = Paint();

      Rect src = Rect.fromLTWH(
        0,
        0,
        perfusionImg!.width.toDouble(),
        perfusionImg!.height.toDouble(),
      );
      if (leftTopPoint == null || rightBottomPoint == null) {
        return;
      }
      DPoint leftTop = convert2ViewPoint(size, leftTopPoint!);
      DPoint rightBottom = convert2ViewPoint(size, rightBottomPoint!);
      convert2ViewPoint(size, rightBottomPoint!);
      Rect dst = Rect.fromPoints(
          Offset(leftTop.x, leftTop.y), Offset(rightBottom.x, rightBottom.y));
      canvas.drawImageRect(perfusionImg!, src, dst, paint);
    }
  }
}