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_measure/urm_rect_measure.dart';
// import 'package:fis_measure/process/primitives/urm_straightline.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<URMRectMeasure, double> {
  URMRectCal(
    URMRectMeasure 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 URMAutoLineLineCal extends Calculator<StraightLine, double> {
//   URMAutoLineLineCal(
//     StraightLine ref, {
//     required this.type,
//   }) : super(ref);
//   final String type;
//   @override
//   void calculate() {}

//   @override
//   Future<void> calculateAsync() async {
//     try {
//       if (ref.feature == null) return;
//       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 startPoint = leftTopPercent.scale2Size(urmResultSize);
//       // final endPoint = rightBottomPercent.scale2Size(urmResultSize);
//       // final startPoint = DPoint(0.478335, 0.315384);
//       // final endPoint = DPoint(0.538395, 0.526373);

//       switch (type) {
//         case MeasureTypes.SRCurvature:
//           await getSRCurvatureResult(urmApplication, p1, p2);
//           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 {
//       URMMeasureProcessResult? result = await app.getURMMeasureResult(
//         urmMeasureType: URMMeasureType.URMCurvature,
//         rOIType: URMROIType.placeHolder_0,
//         srcDPoints: [
//           UrmPoint(x: startPoint.x, y: startPoint.y),
//           UrmPoint(x: endPoint.x, y: endPoint.y)
//         ],
//       );
//       if (result != null) {
//         print(
//             "URM Measure curvature: ${result} nums: ${result.resultDPoints?.length}");
//         // TODO 将返回的视图百分比区域的点集转换为全图百分比点集，然会然后绘制
//         final feature = ref.feature!;
//         if (feature is! StraightCurvatureFeature) return;
//         feature.autoLinePoints = urmPointsToDPoints(result.resultDPoints);

//         /// TODO 只转数据类型还不够，需要将 视图区域百分比坐标转为全图百分比坐标
//         for (var output in ref.meta.outputs) {
//           if (output.name == MeasureTerms.SRCurvature) {
//             output.unit = VidUsUnit.None;
//             feature.updateFloatValue(output, result.resultData, 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<DPoint> urmPointsToDPoints(List<UrmPoint>? points) {
//     if (points == null) return [];
//     List<DPoint> urmPoints = [];
//     for (var point in points) {
//       urmPoints.add(DPoint(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 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;
  }
}