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

import 'dart:math';
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:flutter/material.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';

/// 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,
    this.onUpdateChart,
  }) : 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 urmPhysicalwidth = 1.0; // URM 结果物理宽度

  double urmPhysicalheight = 1.0; // URM 结果物理高度

  double areaScaler =
      1.0; // URM 画幅缩放比例  (UrmPhysicalwidth / resultWidth) * (UrmPhysicalheight / resultHeight);

  double pixelscaler = 1.0; // URM 像素缩放比例 UrmPhysicalwidth / resultWidth

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

  final ValueChanged<URMChartParams>? onUpdateChart;

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

        double scaleX = roiRect.width / beams * beamsPercent;
        double scaleY = roiRect.height / samples;
        urmPhysicalwidth = physicalSize.width * roiRect.width / beams;
        urmPhysicalheight = physicalSize.height * scaleY;
        areaScaler = (urmPhysicalwidth / resultWidth) *
            (urmPhysicalheight / resultHeight);
        pixelscaler = urmPhysicalwidth / resultWidth;
        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;
  }

  Size getPhysicalSize(VidUsPhysicalCoordinate physicalCoordinates) {
    if (physicalCoordinates is VidUsTissuePhysicalCoordinate) {
      return Size(physicalCoordinates.width,
          physicalCoordinates.depthEnd - physicalCoordinates.depthStart);
    }
    return Size.zero;
  }

  @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;
  }

  @override
  double get displayScaleRatio {
    return max(
        1,
        min(displaySize.width / resultWidth,
            displaySize.height / resultHeight));
    // return 1.0;
  }

  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: areaScaler,
  //         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: areaScaler,
  //         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: pixelscaler,
  //         cmLength: cmlength,
  //         token: RPCBridge.ins.userToken,
  //       ),
  //     );
  //     return result;
  //   } catch (e) {
  //     return null;
  //   }
  // }
}

class URMChartParams {
  final List<Point> points;
  final double cmlength;
  final int maxPointIndex;
  final int minPointIndex;

  URMChartParams({
    required this.points,
    required this.cmlength,
    required this.maxPointIndex,
    required this.minPointIndex,
  });
}