fis_lib_measure/lib/process/calcuators/urm.dart

import 'dart:math';
import 'dart:ui';

import 'package:fis_common/logger/logger.dart';
import 'package:fis_jsonrpc/rpc.dart';
import 'package:fis_measure/interfaces/date_types/point.dart';
import 'package:fis_measure/interfaces/process/calculators/values.dart';
import 'package:fis_measure/interfaces/process/items/terms.dart';
import 'package:fis_measure/interfaces/process/items/types.dart';
import 'package:fis_measure/process/items/item.dart';
import 'package:fis_measure/process/primitives/area_abstract.dart';
import 'package:fis_measure/process/primitives/combos/urm_den_combo.dart';
import 'package:fis_measure/process/primitives/combos/urm_sr_roi_rect_combo.dart';
import 'package:fis_measure/process/primitives/combos/urm_vel_combo.dart';
import 'package:fis_measure/process/primitives/location.dart';
import 'package:fis_measure/process/primitives/straightline.dart';
import 'package:fis_measure/process/primitives/urm_rect.dart';
import 'package:fis_measure/process/workspace/urm/application.dart';
import 'package:vid/us/vid_us_unit.dart';

import 'calculator.dart';

class URMRectCal extends Calculator<URMRect, double> {
  URMRectCal(
    URMRect ref, {
    required this.type,
  }) : super(ref);
  final String type;
  @override
  void calculate() {}

  @override
  Future<void> calculateAsync() async {
    if (ref.feature == null) return;
    Size urmResultSize = const Size(0, 0);
    try {
      if (ref.application is! URMApplication) {
        return;
      }
      final URMApplication urmApplication = ref.application as URMApplication;
      urmResultSize = Size(urmApplication.resultWidth.toDouble(),
          urmApplication.resultHeight.toDouble());
      final p1 = ref.feature!.startPoint;
      final p2 = ref.feature!.endPoint;
      //左上顶点
      final leftTopPercent =
          DPoint(p1.x < p2.x ? p1.x : p2.x, p1.y < p2.y ? p1.y : p2.y);
      //右下顶点
      final rightBottomPercent =
          DPoint(p1.x > p2.x ? p1.x : p2.x, p1.y > p2.y ? p1.y : p2.y);

      final startPoint = leftTopPercent.scale2Size(urmResultSize);
      final endPoint = rightBottomPercent.scale2Size(urmResultSize);

      String description = "URM\n Calculating...";
      updateStringValue(description);

      switch (type) {
        case MeasureTypes.DensitySR:
        case MeasureTypes.SRRoiDensity:
        case MeasureTypes.Roi1:
        case MeasureTypes.Roi2:
          await getSRRoiDensityResult(urmApplication, startPoint, endPoint);
          break;
        case MeasureTypes.FractalDimSR:
        case MeasureTypes.SRROIFractalDim:
          await getSRRoiFractalDimResult(urmApplication, startPoint, endPoint);
          break;
        case MeasureTypes.SRRoiVel:
          await getSRRoiVelResult(urmApplication, startPoint, endPoint);
          break;
        case MeasureTypes.URMVelMeasure:
          await getURMVelMeasureResult(urmApplication, startPoint, endPoint);
          break;
        default:
      }
    } catch (e) {
      logger.e('URM Measure error: $e');
      return;
    }
  }

  //✅ URM 测量项 2
  Future<void> getSRRoiDensityResult(
      URMApplication app, DPoint startPoint, DPoint endPoint) async {
    String description = "URM\n Measuring";
    try {
      GetSRRoiVelResult? result =
          await app.getSRRoiVelResult(startPoint, endPoint);
      if (result != null) {
        print("URM Measure output: ${result.output} ");
        final feature = ref.feature!;
        for (var output in ref.meta.outputs) {
          if ([MeasureTerms.URMDenROI, MeasureTerms.URMDenFractalDim]
              .contains(output.name)) {
            output.unit = VidUsUnit.percent;
            feature.updateFloatValue(output, result.output, output.unit);
          }
        }
      } else {
        throw Exception("URM Measure API error");
      }
    } catch (e) {
      description = " ";
      updateStringValue(description);
      return;
    }
    ref.application.updateRenderReady.emit(this, null);
  }

  //✅ URM 测量项 3 未验证需要组合测量项
  Future<void> getSRRoiFractalDimResult(
      URMApplication app, DPoint startPoint, DPoint endPoint) async {
    String description = "URM\n Measuring";
    try {
      GetSRRoiFractalDimResult? result =
          await app.getSRRoiFractalDimResult(startPoint, endPoint);
      if (result != null) {
        print("URM Measure output: ${result.output} ");
        final feature = ref.feature!;
        for (var output in ref.meta.outputs) {
          if (output.name == MeasureTerms.URMDenFractalDim) {
            output.unit = VidUsUnit.None;
            feature.updateFloatValue(output, result.output, output.unit);
          }
        }
      } else {
        throw Exception("URM Measure API error");
      }
    } catch (e) {
      description = " ";
      updateStringValue(description);

      return;
    }
    ref.application.updateRenderReady.emit(this, null);
  }

  //✅ URM 测量项 7 未验证需要组合测量项
  Future<void> getSRRoiVelResult(
      URMApplication app, DPoint startPoint, DPoint endPoint) async {
    String description = "URM\n Measuring";
    try {
      GetSRRoiVelResult? result =
          await app.getSRRoiVelResult(startPoint, endPoint);
      if (result != null) {
        print("URM Measure output: ${result.output} ");
        final feature = ref.feature!;
        for (var output in ref.meta.outputs) {
          if (output.name == MeasureTerms.SRRoiVel) {
            output.unit = VidUsUnit.percent;
            feature.updateFloatValue(output, result.output, output.unit);
          }
        }
      } else {
        throw Exception("URM Measure API error");
      }
    } catch (e) {
      description = " ";
      updateStringValue(description);

      return;
    }
    ref.application.updateRenderReady.emit(this, null);
  }

  //✅ URM 测量项 9
  Future<void> getURMVelMeasureResult(
      URMApplication app, DPoint startPoint, DPoint endPoint) async {
    String description = "URM\n Measuring";
    try {
      GetURMVelMeasureResult? result =
          await app.getURMVelMeasureResult(startPoint, endPoint);
      if (result != null) {
        // TODO 全部内容展示
        print("URM Measure inMaxVel: ${result.inMaxVel} ");
        final feature = ref.feature!;
        for (var output in ref.meta.outputs) {
          if (output.name == MeasureTerms.URMVelMax) {
            output.unit = VidUsUnit.mms;
            feature.updateFloatValue(
                output, result.maxVel + app.urmMinVel, VidUsUnit.mms);
          }
          if (output.name == MeasureTerms.URMVelMin) {
            output.unit = VidUsUnit.mms;
            feature.updateFloatValue(
                output, result.minVel + app.urmMinVel, VidUsUnit.mms);
          }
          if (output.name == MeasureTerms.URMVelMean) {
            output.unit = VidUsUnit.mms;
            feature.updateFloatValue(
                output, result.meanVel + app.urmMinVel, VidUsUnit.mms);
          }
          if (output.name == MeasureTerms.URMVelStd) {
            output.unit = VidUsUnit.mms;
            feature.updateFloatValue(
                output, sqrt(result.varianceVel), VidUsUnit.mms);
          }
          if (output.name == MeasureTerms.Area) {
            output.unit = VidUsUnit.cm2;
            feature.updateFloatValue(output, result.roiArea, VidUsUnit.cm2);
          }
        }
      } else {
        throw Exception("URM Measure API error");
      }
    } catch (e) {
      description = " ";
      updateStringValue(description);

      return;
    }
    ref.application.updateRenderReady.emit(this, null);
  }
}

class URMLocationCal extends Calculator<Location, double> {
  URMLocationCal(Location ref) : super(ref);

  @override
  void calculate() {}

  @override
  Future<void> calculateAsync() async {
    if (ref.feature == null) return;
    Size urmResultSize = const Size(0, 0);
    try {
      if (ref.application is! URMApplication) {
        return;
      }
      final URMApplication urmApplication = ref.application as URMApplication;
      urmResultSize = Size(urmApplication.resultWidth.toDouble(),
          urmApplication.resultHeight.toDouble());
      // urmResultWidth = urmApplication.resultWidth;
      // urmResultHeight = urmApplication.resultHeight;
      final point = ref.feature!.point.clone();
      final startPoint = point.scale2Size(urmResultSize);
      print("URM Measure startPoint: $startPoint");
      await getSRLoactionVelResult(urmApplication, startPoint);
      return;
    } catch (e) {
      logger.e('URM Measure error: $e');
      return;
    }
  }

  // ✅ URM 测量项 6
  Future<void> getSRLoactionVelResult(
      URMApplication app, DPoint startPoint) async {
    String description = "URM\n Measuring";
    try {
      GetSRLoactionVelResult? result =
          await app.getSRLoactionVelResult(startPoint);
      if (result != null) {
        print("URM Measure output: ${result.output}");
        final feature = ref.feature!;
        for (var output in ref.meta.outputs) {
          if (output.name == MeasureTerms.SRVel) {
            output.unit = VidUsUnit.mms;
            feature.updateFloatValue(output, result.output, output.unit);
          }
        }
      } else {
        throw Exception("URM Measure API error");
      }
    } catch (e) {
      description = " ";
      updateStringValue(description);
      return;
    }
    ref.application.updateRenderReady.emit(this, null);
  }
}

class URMStraightLineCal extends Calculator<StraightLine, double> {
  URMStraightLineCal(
    StraightLine ref, {
    required this.type,
  }) : super(ref);
  final String type;
  @override
  void calculate() {}

  @override
  Future<void> calculateAsync() async {
    if (ref.feature == null) return;

    try {
      if (ref.application is! URMApplication) {
        return;
      }
      Size urmResultSize = const Size(0, 0);
      final URMApplication urmApplication = ref.application as URMApplication;
      urmResultSize = Size(urmApplication.resultWidth.toDouble(),
          urmApplication.resultHeight.toDouble());
      final p1 = ref.feature!.startPoint;
      final p2 = ref.feature!.endPoint;
      final leftTopPercent =
          DPoint(p1.x < p2.x ? p1.x : p2.x, p1.y < p2.y ? p1.y : p2.y);
      final rightBottomPercent =
          DPoint(p1.x > p2.x ? p1.x : p2.x, p1.y > p2.y ? p1.y : p2.y);

      final startPoint = leftTopPercent.scale2Size(urmResultSize);
      final endPoint = rightBottomPercent.scale2Size(urmResultSize);

      switch (type) {
        case MeasureTypes.SRCurvature:
          await getSRCurvatureResult(urmApplication, startPoint, endPoint);
          break;
        case MeasureTypes.URMDensityMeasure:
          await getURMDenMeasureResult(urmApplication, startPoint, endPoint);
          break;
        case MeasureTypes.URMVesselMeasure:
          final feature = ref.feature!;
          final viewport = feature.hostVisualArea!.viewport!;
          final p1 = feature.startPoint;
          final p2 = feature.endPoint;
          final pp1 = viewport.convert(p1);
          final pp2 = viewport.convert(p2);
          final cmlength = (pp2 - pp1).length.abs();
          await getURMVessMeasureResult(
              urmApplication, startPoint, endPoint, cmlength);
          break;
        default:
      }
    } catch (e) {
      logger.e('URM Measure error: $e');
      return;
    }
  }

  // ✅ URM 测量项 1
  Future<void> getSRCurvatureResult(
      URMApplication app, DPoint startPoint, DPoint endPoint) async {
    String description = "URM\n Measuring";
    try {
      GetSRCurvatureResult? result =
          await app.getSRCurvatureResult(startPoint, endPoint);
      if (result != null) {
        print(
            "URM Measure curvature: ${result.curvature} nums: ${result.outPointsNum}");
        final feature = ref.feature!;
        for (var output in ref.meta.outputs) {
          if (output.name == MeasureTerms.SRCurvature) {
            output.unit = VidUsUnit.None;
            feature.updateFloatValue(output, result.curvature, output.unit);
          }
        }
      } else {
        throw Exception("URM Measure API error");
      }
    } catch (e) {
      description = " ";
      updateStringValue(description);
      return;
    }
    ref.application.updateRenderReady.emit(this, null);
  }

  //✅ URM 测量项 8
  Future<void> getURMDenMeasureResult(
      URMApplication app, DPoint startPoint, DPoint endPoint) async {
    String description = "URM\n Measuring";
    try {
      GetURMDenMeasureResult? result =
          await app.getURMDenMeasureResult(startPoint, endPoint);
      if (result != null) {
        print(
            "URM Measure inMaxDensity: ${result.inMaxDensity} inMeanDensity: ${result.inMeanDensity}");
        // description = "${(result.inMaxDensity).toStringAsFixed(2)}mm/s ...";
        final feature = ref.feature!;
        for (var output in ref.meta.outputs) {
          if (output.name == MeasureTerms.URMDenROI) {
            output.unit = VidUsUnit.percent;
            feature.updateFloatValue(
                output, result.roiDen * 100, VidUsUnit.percent);
          }
          if (output.name == MeasureTerms.URMDenFractalDim) {
            output.unit = VidUsUnit.None;
            feature.updateFloatValue(
                output, result.roiFractalDim, VidUsUnit.None);
          }
          if (output.name == MeasureTerms.URMDenMax) {
            output.unit = VidUsUnit.None;
            feature.updateFloatValue(output, result.maxDensity, VidUsUnit.None);
          }
          if (output.name == MeasureTerms.URMDenMin) {
            output.unit = VidUsUnit.None;
            feature.updateFloatValue(output, result.minDensity, VidUsUnit.None);
          }
          if (output.name == MeasureTerms.URMDenMean) {
            output.unit = VidUsUnit.None;
            feature.updateFloatValue(
                output, result.meanDensity, VidUsUnit.None);
          }
          if (output.name == MeasureTerms.URMDenStd) {
            output.unit = VidUsUnit.None;
            feature.updateFloatValue(
                output, sqrt(result.varianceDensity), VidUsUnit.None);
          }
          if (output.name == MeasureTerms.Area) {
            output.unit = VidUsUnit.cm2;
            feature.updateFloatValue(output, result.roiArea, VidUsUnit.cm2);
          }
        }
      } else {
        throw Exception("URM Measure API error");
      }
    } catch (e) {
      description = " ";
      updateStringValue(description);
      return;
    }
    ref.application.updateRenderReady.emit(this, null);
  }

  //✅ URM 测量项 10
  Future<void> getURMVessMeasureResult(URMApplication app, DPoint startPoint,
      DPoint endPoint, double cmlength) async {
    String description = "URM\n Measuring";
    try {
      GetUrmVessMeasureResult? result =
          await app.getURMVessMeasureResult(startPoint, endPoint, cmlength);
      if (result != null) {
        app.onUpdateChart?.call(
          URMChartParams(
            cmlength: cmlength,
            minPointIndex: result.minPos,
            maxPointIndex: result.maxPos,
            points: convertPoints(result.outputPoints),
          ),
        );
        print(
            "URM Measure inMaxDensity: ${result.maxVessDiameter} inMeanDensity: ${result.meanVessDistacne}");
        final feature = ref.feature!;
        for (var output in ref.meta.outputs) {
          if (output.name == MeasureTerms.MaxVessDistance) {
            output.unit = VidUsUnit.mm;
            feature.updateFloatValue(
                output, result.maxVessDistance, VidUsUnit.mm);
          }
          if (output.name == MeasureTerms.MinVessDistance) {
            output.unit = VidUsUnit.mm;
            feature.updateFloatValue(
                output, result.minVessDistance, VidUsUnit.mm);
          }
          if (output.name == MeasureTerms.MeanVessDistacne) {
            output.unit = VidUsUnit.mm;
            feature.updateFloatValue(
                output, result.meanVessDistacne, VidUsUnit.mm);
          }
          if (output.name == MeasureTerms.StdVessDistance) {
            output.unit = VidUsUnit.mm;
            feature.updateFloatValue(
                output, sqrt(result.varianceVessDistance), VidUsUnit.mm);
          }
          if (output.name == MeasureTerms.MaxVessDiameter) {
            output.unit = VidUsUnit.mm;
            feature.updateFloatValue(
                output, result.maxVessDiameter, VidUsUnit.mm);
          }
          if (output.name == MeasureTerms.MinVessDiameter) {
            output.unit = VidUsUnit.mm;
            feature.updateFloatValue(
                output, result.minVessDiameter, VidUsUnit.mm);
          }
          if (output.name == MeasureTerms.MeanVessDiameter) {
            output.unit = VidUsUnit.mm;
            feature.updateFloatValue(
                output, result.meanVessDiameter, VidUsUnit.mm);
          }
          if (output.name == MeasureTerms.StdVessDiameter) {
            output.unit = VidUsUnit.mm;
            feature.updateFloatValue(
                output, sqrt(result.varianceVessDiameter), VidUsUnit.mm);
          }
        }
      } else {
        throw Exception("URM Measure API error");
      }
    } catch (e) {
      description = " ";
      updateStringValue(description);
      return;
    }
    ref.application.updateRenderReady.emit(this, null);
  }

  List<Point> convertPoints(List<UrmPoint>? points) {
    if (points == null) return [];
    List<Point> urmPoints = [];
    for (var point in points) {
      urmPoints.add(Point(point.x, point.y));
    }
    return urmPoints;
  }

  //
}

class URMTraceCal extends Calculator<AreaItemAbstract, double> {
  URMTraceCal(
    AreaItemAbstract ref, {
    required this.type,
  }) : super(ref);
  final String type;

  @override
  void calculate() {}

  @override
  Future<void> calculateAsync() async {
    if (ref.feature == null) return;
    final feature = ref.feature!;
    try {
      if (ref.application is! URMApplication) {
        return;
      }
      Size urmResultSize = const Size(0, 0);
      final URMApplication urmApplication = ref.application as URMApplication;
      urmResultSize = Size(urmApplication.resultWidth.toDouble(),
          urmApplication.resultHeight.toDouble());
      final List<DPoint> points =
          feature.innerPoints.map((e) => e.scale2Size(urmResultSize)).toList();

      switch (type) {
        case MeasureTypes.SRTraceDensity:
          await getSRTraceVelResult(urmApplication, convertPoints(points));
          break;
        case MeasureTypes.SRTraceFractalDim:
          await getSRTraceFractalDimResult(
              urmApplication, convertPoints(points));
          break;
        default:
      }
    } catch (e) {
      logger.e('URM Measure error: $e');
      return;
    }
  }

  //✅ URM 测量项 4
  Future<void> getSRTraceVelResult(
      URMApplication app, List<UrmPoint> points) async {
    String description = "URM\n Measuring";
    try {
      GetSRTraceVelResult? result = await app.getSRTraceVelResult(points);
      if (result != null) {
        print("URM Measure output: ${result.output} ");
        final feature = ref.feature!;
        for (var output in ref.meta.outputs) {
          if (output.name == MeasureTerms.URMDenROI) {
            output.unit = VidUsUnit.percent;
            feature.updateFloatValue(output, result.output, output.unit);
          }
        }
      } else {
        throw Exception("URM Measure API error");
      }
    } catch (e) {
      description = " ";
      updateStringValue(description);

      return;
    }
    ref.application.updateRenderReady.emit(this, null);
  }

  //✅ URM 测量项 5
  Future<void> getSRTraceFractalDimResult(
      URMApplication app, List<UrmPoint> points) async {
    String description = "URM\n Measuring";
    try {
      GetSRTraceFractalDimResult? result =
          await app.getSRTraceFractalDimResult(points);
      if (result != null) {
        print("URM Measure output: ${result.output} ");
        final feature = ref.feature!;
        for (var output in ref.meta.outputs) {
          if (output.name == MeasureTerms.URMDenFractalDim) {
            output.unit = VidUsUnit.None;
            feature.updateFloatValue(output, result.output, output.unit);
          }
        }
      } else {
        throw Exception("URM Measure API error");
      }
    } catch (e) {
      description = " ";
      updateStringValue(description);

      return;
    }
    ref.application.updateRenderReady.emit(this, null);
  }

  List<UrmPoint> convertPoints(List<DPoint> points) {
    List<UrmPoint> urmPoints = [];
    for (var point in points) {
      urmPoints.add(UrmPoint(x: point.x, y: point.y));
    }
    return urmPoints;
  }
}

class URMVelCal extends Calculator<URMVelAbstract, double> {
  URMVelCal(URMVelAbstract ref) : super(ref);

  @override
  void calculate() {
    if (ref.feature == null) return;

    final a1 = _pickChildValue(ref.child1);
    final a2 = _pickChildValue(ref.child2);
    final a3 = _pickChildValue(ref.child2);

    final feature = ref.feature!;
    final viewport = feature.hostVisualArea!.viewport!;

    // if (a1 != null && a2 != null) {
    //   final value = GeneralFormulas.countStenosis(
    //     a1,
    //     a2,
    //   );
    //   updateFloatValue(value);
    // }
  }

  double? _pickChildValue(MeasureItem item) {
    if (item.calculator == null) return null;
    ValueBase? value;
    if (item.measuredFeatures.isNotEmpty) {
      value = item.measuredFeatures.first.value;
    } else if (item.feature != null) {
      value = item.feature!.value;
    }
    if (value != null && value is FloatValue) {
      return (value).value ?? 0;
    }
    return null;
  }
}

class URMDenCal extends Calculator<URMDenAbstract, double> {
  URMDenCal(URMDenAbstract ref) : super(ref);

  @override
  void calculate() {
    if (ref.feature == null) return;

    final a1 = _pickChildValue(ref.child1);
    final a2 = _pickChildValue(ref.child2);
    final a3 = _pickChildValue(ref.child2);

    final feature = ref.feature!;
    final viewport = feature.hostVisualArea!.viewport!;

    // if (a1 != null && a2 != null) {
    //   final value = GeneralFormulas.countStenosis(
    //     a1,
    //     a2,
    //   );
    //   updateFloatValue(value);
    // }
  }

  double? _pickChildValue(MeasureItem item) {
    if (item.calculator == null) return null;
    ValueBase? value;
    if (item.measuredFeatures.isNotEmpty) {
      value = item.measuredFeatures.first.value;
    } else if (item.feature != null) {
      value = item.feature!.value;
    }
    if (value != null && value is FloatValue) {
      return (value).value ?? 0;
    }
    return null;
  }
}

class URMSrDensityCal extends Calculator<URMTwoSRRoiRectAbstract, double> {
  URMSrDensityCal(URMTwoSRRoiRectAbstract ref) : super(ref);

  @override
  void calculate() {
    if (ref.feature == null) return;

    final a1 = _pickChildValue(ref.child1);
    final a2 = _pickChildValue(ref.child2);
    final a3 = _pickChildValue(ref.child2);

    final feature = ref.feature!;
    final viewport = feature.hostVisualArea!.viewport!;

    // if (a1 != null && a2 != null) {
    //   final value = GeneralFormulas.countStenosis(
    //     a1,
    //     a2,
    //   );
    //   updateFloatValue(value);
    // }
  }

  double? _pickChildValue(MeasureItem item) {
    if (item.calculator == null) return null;
    ValueBase? value;
    if (item.measuredFeatures.isNotEmpty) {
      value = item.measuredFeatures.first.value;
    } else if (item.feature != null) {
      value = item.feature!.value;
    }
    if (value != null && value is FloatValue) {
      return (value).value ?? 0;
    }
    return null;
  }
}