fis_lib_measure/lib/process/workspace/urm/application.dart

import 'dart:ui';
// import 'package:fis_measure/interfaces/date_types/rect_region.dart';
// import 'package:fis_measure/interfaces/date_types/size.dart';
import 'package:fis_jsonrpc/services/aIDiagnosis.m.dart';
import 'package:fis_measure/interfaces/date_types/point.dart';
import 'package:fis_measure/interfaces/process/visuals/visual.dart';
import 'package:fis_measure/process/visual/v2d_visual.dart';
import 'package:fis_measure/process/workspace/rpc_bridge.dart';
import 'package:vid/us/vid_us_probe.dart';
import '../application.dart';
import 'package:fis_measure/interfaces/date_types/rect_region.dart';
import 'package:vid/us/vid_us_2d_visual.dart';
import 'package:vid/us/vid_us_logical_coordinate.dart';
import 'package:vid/us/vid_us_physical_coordinate.dart';
import 'package:vid/us/vid_us_visual.dart';
import 'package:fis_measure/interfaces/process/workspace/point_info.dart';
import 'package:flutter/painting.dart';

/// URM 专业应用
class URMApplication extends Application {
  URMApplication(
    VidUsProbe probe, {
    required this.beams,
    required this.samples,
    required this.roiRect,
    required this.resultWidth,
    required this.resultHeight,
    required this.remedicalCode,
    required this.originVisuals,
  }) : super(probe);

  @override
  bool get isThirdPart => true;

  List<IVisual> originVisuals; // 原始的视图坐标系

  int beams; // 原图有效的beam数量

  int samples; // 原图有效的sample数量

  Rect roiRect; // ROI区域

  int resultWidth; // 分析结果图像宽度

  int resultHeight; // 分析结果图像高度

  String remedicalCode; // 图像 Code

  bool syncDisplay = false; // 是否开启同步显示

  double areaScaler = 1.0; // URM 画幅缩放比例

  double urmMinVel = 1.0; // TODO 从分析结果获取该值

  @override
  List<IVisual> convertVisuals() {
    var urmVisuals = originVisuals;
    double beamsPercent = 1;
    if (originVisuals.isNotEmpty) {
      IVisual visual = originVisuals[0];
      if (visual is V2dVisual) {
        VidUsVisual visualData = visual.visualData;
        if (visualData is VidUs2DVisual) {
          if (visualData.logicalCoordinates.length == 2 &&
              visualData.physicalCoordinates.length == 2) {
            beamsPercent = getBeamsPercent(
              visualData.logicalCoordinates.entries.first.value,
              visualData.physicalCoordinates.entries.first.value,
            );
          }
        }

        double scaleX = roiRect.width / beams * beamsPercent;
        double scaleY = roiRect.height / samples;
        RectRegion region =
            RectRegion(left: 0, top: 0, right: 1 / scaleX, bottom: 1 / scaleY);
        V2dVisual v2dVisual = V2dVisual(visualData, region);
        urmVisuals = [v2dVisual];
      }
    }
    return urmVisuals;
  }

  double getBeamsPercent(VidUsLogicalCoordinate logicalCoordinate,
      VidUsPhysicalCoordinate physicalCoordinates) {
    if (physicalCoordinates is VidUsTissuePhysicalCoordinate) {
      return (physicalCoordinates.width /
          (logicalCoordinate.region.right - logicalCoordinate.region.left));
    }
    return 1;
  }

  @override
  PointInfo createPointInfo(Offset offset, PointInfoType type) {
    final width = displaySize.width;
    final height = displaySize.height;
    final x = offset.dx / width;
    final y = offset.dy / height;
    final percentOffset = Offset(x, y);
    final info = PointInfo.fromOffset(percentOffset, type);
    info.hostVisualArea = currentVisualArea; // 未切换区域则沿用当前区域

    if (isAnnotationWorking) {
      activeAnnotationItem?.execute(info);
    } else {
      activeMeasureItem?.execute(info);
      if (type == PointInfoType.touchMove) {
        mobileTouchEvent.emit(this, offset); // 传出移动事件
      }
      if (type == PointInfoType.touchUp) {
        mobileTouchEndEvent.emit(this, offset); // 传出触摸结束事件
      }
    }
    return info;
  }

  void loadURMVisuals() {
    loadVisuals();
  }

  Future<GetSRCurvatureResult?> getSRCurvatureResult(
      DPoint startPoint, DPoint endPoint) async {
    try {
      print("调接口获取测量值 getSRCurvatureAsync");
      GetSRCurvatureResult result =
          await RPCBridge.ins.rpc.aIDiagnosis.getSRCurvatureAsync(
        GetSRCurvatureRequest(
          remedicalCode: remedicalCode,
          measureMode: 5, // 5-URM测量Den，6-URM测量Vel
          dataWidth: resultWidth,
          dataHeight: resultHeight,
          startPointX: startPoint.x,
          startPointY: startPoint.y,
          endPointX: endPoint.x,
          endPointY: endPoint.y,
          token: RPCBridge.ins.userToken,
        ),
      );
      return result;
    } catch (e) {
      return null;
    }
  }

  Future<GetSRRoiVelResult?> getSRRoiVelResult(
      DPoint startPoint, DPoint endPoint) async {
    try {
      print("调接口获取测量值 getSRRoiVelAsync");
      GetSRRoiVelResult result =
          await RPCBridge.ins.rpc.aIDiagnosis.getSRRoiVelAsync(
        GetSRRoiVelRequest(
          remedicalCode: remedicalCode,
          measureMode: 5,
          dataWidth: resultWidth,
          dataHeight: resultHeight,
          startPointX: startPoint.x,
          startPointY: startPoint.y,
          endPointX: endPoint.x,
          endPointY: endPoint.y,
          token: RPCBridge.ins.userToken,
        ),
      );
      return result;
    } catch (e) {
      return null;
    }
  }

  Future<GetSRRoiFractalDimResult?> getSRRoiFractalDimResult(
      DPoint startPoint, DPoint endPoint) async {
    try {
      print("调接口获取测量值 getSRRoiFractalDimAsync");
      GetSRRoiFractalDimResult result =
          await RPCBridge.ins.rpc.aIDiagnosis.getSRRoiFractalDimAsync(
        GetSRRoiFractalDimRequest(
          remedicalCode: remedicalCode,
          measureMode: 5,
          dataWidth: resultWidth,
          dataHeight: resultHeight,
          startPointX: startPoint.x,
          startPointY: startPoint.y,
          endPointX: endPoint.x,
          endPointY: endPoint.y,
          token: RPCBridge.ins.userToken,
        ),
      );
      return result;
    } catch (e) {
      return null;
    }
  }

  Future<GetSRTraceVelResult?> getSRTraceVelResult(
    List<UrmPoint> points,
  ) async {
    try {
      print("调接口获取测量值 getSRTraceVelResult");
      GetSRTraceVelResult result =
          await RPCBridge.ins.rpc.aIDiagnosis.getSRTraceVelAsync(
        GetSRTraceVelRequest(
          remedicalCode: remedicalCode,
          measureMode: 5,
          dataWidth: resultWidth,
          dataHeight: resultHeight,
          inputPoints: points,
          token: RPCBridge.ins.userToken,
        ),
      );
      return result;
    } catch (e) {
      return null;
    }
  }

  Future<GetSRTraceFractalDimResult?> getSRTraceFractalDimResult(
    List<UrmPoint> points,
  ) async {
    try {
      print("调接口获取测量值 getSRTraceFractalDimAsync");
      GetSRTraceFractalDimResult result =
          await RPCBridge.ins.rpc.aIDiagnosis.getSRTraceFractalDimAsync(
        GetSRTraceFractalDimRequest(
          remedicalCode: remedicalCode,
          measureMode: 5,
          dataWidth: resultWidth,
          dataHeight: resultHeight,
          inputPoints: points,
          token: RPCBridge.ins.userToken,
        ),
      );
      return result;
    } catch (e) {
      return null;
    }
  }

  Future<GetSRLoactionVelResult?> getSRLoactionVelResult(
    DPoint point,
  ) async {
    try {
      print("调接口获取测量值 getSRLoactionVelAsync");
      GetSRLoactionVelResult result =
          await RPCBridge.ins.rpc.aIDiagnosis.getSRLoactionVelAsync(
        GetSRLoactionVelRequest(
          remedicalCode: remedicalCode,
          measureMode: 6,
          dataWidth: resultWidth,
          dataHeight: resultHeight,
          startPointX: point.x,
          startPointY: point.y,
          token: RPCBridge.ins.userToken,
        ),
      );
      return result;
    } catch (e) {
      return null;
    }
  }

  Future<GetSRRoiSpeedResult?> getSRRoiSpeedResult(
    DPoint startPoint,
    DPoint endPoint,
  ) async {
    try {
      print("调接口获取测量值 getSRRoiSpeedAsync");
      GetSRRoiSpeedResult result =
          await RPCBridge.ins.rpc.aIDiagnosis.getSRRoiSpeedAsync(
        GetSRRoiSpeedRequest(
          remedicalCode: remedicalCode,
          measureMode: 6,
          dataWidth: resultWidth,
          dataHeight: resultHeight,
          startPointX: startPoint.x,
          startPointY: startPoint.y,
          endPointX: endPoint.x,
          endPointY: endPoint.y,
          token: RPCBridge.ins.userToken,
        ),
      );
      return result;
    } catch (e) {
      return null;
    }
  }

  Future<GetURMDenMeasureResult?> getURMDenMeasureResult(
      DPoint startPoint, DPoint endPoint) async {
    try {
      print("调接口获取测量值 getURMDenMeasureAsync");
      GetURMDenMeasureResult result =
          await RPCBridge.ins.rpc.aIDiagnosis.getURMDenMeasureAsync(
        GetURMDenMeasureRequest(
          remedicalCode: remedicalCode,
          measureMode: 5,
          dataWidth: resultWidth,
          dataHeight: resultHeight,
          startPointX: startPoint.x,
          startPointY: startPoint.y,
          endPointX: endPoint.x,
          endPointY: endPoint.y,
          areaScaler: 1.0,
          token: RPCBridge.ins.userToken,
        ),
      );
      return result;
    } catch (e) {
      return null;
    }
  }

  Future<GetURMVelMeasureResult?> getURMVelMeasureResult(
      DPoint startPoint, DPoint endPoint) async {
    try {
      print("调接口获取测量值 getURMVelMeasureAsync");
      GetURMVelMeasureResult result =
          await RPCBridge.ins.rpc.aIDiagnosis.getURMVelMeasureAsync(
        GetURMVelMeasureRequest(
          remedicalCode: remedicalCode,
          measureMode: 6,
          dataWidth: resultWidth,
          dataHeight: resultHeight,
          startPointX: startPoint.x,
          startPointY: startPoint.y,
          endPointX: endPoint.x,
          endPointY: endPoint.y,
          areaScaler: 1.0,
          token: RPCBridge.ins.userToken,
        ),
      );
      return result;
    } catch (e) {
      return null;
    }
  }

  Future<GetUrmVessMeasureResult?> getURMVessMeasureResult(
      DPoint startPoint, DPoint endPoint, double cmlength) async {
    try {
      print("调接口获取测量值 getURMVelMeasureAsync");
      GetUrmVessMeasureResult result =
          await RPCBridge.ins.rpc.aIDiagnosis.getUrmVessMeasureAsync(
        GetUrmVessMeasureRequest(
          remedicalCode: remedicalCode,
          measureMode: 6,
          dataWidth: resultWidth,
          dataHeight: resultHeight,
          startPointX: startPoint.x,
          startPointY: startPoint.y,
          endPointX: endPoint.x,
          endPointY: endPoint.y,
          areaScaler: 1.0,
          token: RPCBridge.ins.userToken,
        ),
      );
      return result;
    } catch (e) {
      return null;
    }
  }
}