fis_lib_measure/lib/process/calcuators/trace.dart

import 'package:fis_measure/interfaces/date_types/point.dart';
import 'package:fis_measure/interfaces/date_types/vector.dart';
import 'package:fis_measure/interfaces/process/items/terms.dart';
import 'package:fis_measure/process/calcuators/formulas/general.dart';
import 'package:fis_measure/process/items/item_feature.dart';
import 'package:fis_measure/process/primitives/multi_method/multiple_trace.dart';
import 'calculator.dart';

class TraceCal extends Calculator<TraceItemAbstract, double> {
  TraceCal(TraceItemAbstract ref) : super(ref);

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

    final feature = ref.feature!;
    final viewport = feature.hostVisualArea!.viewport!;
    // 加入画布偏移量
    final canvasOffset = feature.hostVisualArea!.layoutRegion!.topLeft;
    //加入坐标系偏移量
    final coordinateOffset = viewport.region;
    final regionPoints = feature.innerPoints
        .map((e) => viewport
            .convert(
                e.clone().addVector(DVector(-canvasOffset.x, -canvasOffset.y)))
            .addVector(DVector(coordinateOffset.left, -coordinateOffset.top)))
        .toList();
    final yFlippedPoints = regionPoints.map((e) => DPoint(e.x, -e.y)).toList();
    double fakeOutputDate = 0;
    var countVTIResult = GeneralFormulas.countVTI(yFlippedPoints);
    var outputVTI = countVTIResult[0];
    var outputVTIMean = countVTIResult[0];
    var outputTiEnv = countVTIResult[1];
    var outputTAMAX = countVTIResult[2];
    var outputTAMEAN = countVTIResult[2];
    var outputVelocityMax = countVTIResult[3];
    var outputVelocityMean = countVTIResult[3];
    var outputMPG = countVTIResult[4];
    var outputMMPG = countVTIResult[4];
    var outputHR = countVTIResult[5];

    for (var output in ref.meta.outputs) {
      ///TODO:[Gavin] 实现以下计算逻辑
      switch (output.name) {
        case MeasureTerms.TAMAX:
          feature.updateFloatValue(output, outputTAMAX, output.unit);
          break;
        case MeasureTerms.TAMEAN:
          feature.updateFloatValue(output, outputTAMEAN, output.unit);
          break;
        case MeasureTerms.PS:
          feature.updateFloatValue(output, fakeOutputDate, output.unit);
          break;
        case MeasureTerms.ED:
          feature.updateFloatValue(output, fakeOutputDate, output.unit);
          break;
        case MeasureTerms.MD:
          feature.updateFloatValue(output, fakeOutputDate, output.unit);
          break;
        case MeasureTerms.HeartRate:
          feature.updateFloatValue(output, outputHR, output.unit);
          break;
        case MeasureTerms.Acceleration:
          feature.updateFloatValue(output, fakeOutputDate, output.unit);
          break;
        case MeasureTerms.AT:
          feature.updateFloatValue(output, fakeOutputDate, output.unit);
          break;
        case MeasureTerms.PSED:
          feature.updateFloatValue(output, fakeOutputDate, output.unit);
          break;
        case MeasureTerms.EDPS:
          feature.updateFloatValue(output, fakeOutputDate, output.unit);
          break;
        case MeasureTerms.PI:
          feature.updateFloatValue(output, fakeOutputDate, output.unit);
          break;
        case MeasureTerms.PIMD:
          feature.updateFloatValue(output, fakeOutputDate, output.unit);
          break;
        case MeasureTerms.RI:
          feature.updateFloatValue(output, fakeOutputDate, output.unit);
          break;
        case MeasureTerms.RIMD:
          feature.updateFloatValue(output, fakeOutputDate, output.unit);
          break;
        case MeasureTerms.MaxPG:
          feature.updateFloatValue(output, fakeOutputDate, output.unit);
          break;
        case MeasureTerms.VelocityMax:
          feature.updateFloatValue(output, outputVelocityMax, output.unit);
          break;
        case MeasureTerms.VelocityMean:
          feature.updateFloatValue(output, outputVelocityMean, output.unit);
          break;
        case MeasureTerms.PeakPG:
          feature.updateFloatValue(output, fakeOutputDate, output.unit);
          break;
        case MeasureTerms.VTI:
          feature.updateFloatValue(output, outputVTI, output.unit);
          break;
        case MeasureTerms.VTIMean:
          feature.updateFloatValue(output, outputVTIMean, output.unit);
          break;
        case MeasureTerms.MPG:
          feature.updateFloatValue(output, outputMPG, output.unit);
          break;
        case MeasureTerms.MMPG:
          feature.updateFloatValue(output, outputMMPG, output.unit);
          break;
        case MeasureTerms.TiEnv:
          // var outputTiEnv = GeneralFormulas.countEnvelopeTime(points);
          feature.updateFloatValue(output, outputTiEnv, output.unit);
          break;
        // case MeasureTerms.EVEL:
        //   feature.updateFloatValue(output, fakeOutputDate, output.unit);
        //   break;
        // case MeasureTerms.AVEL:
        //   feature.updateFloatValue(output, fakeOutputDate, output.unit);
        //   break;
        // case MeasureTerms.EARatio:
        //   feature.updateFloatValue(output, fakeOutputDate, output.unit);
        //   break;
        // case MeasureTerms.DT:
        //   feature.updateFloatValue(output, fakeOutputDate, output.unit);
        //   break;
        // case MeasureTerms.PHT:
        //   feature.updateFloatValue(output, fakeOutputDate, output.unit);
        //   break;
        // case MeasureTerms.VA:
        //   feature.updateFloatValue(output, fakeOutputDate, output.unit);
        //   break;
        // case MeasureTerms.ADur:
        //   feature.updateFloatValue(output, fakeOutputDate, output.unit);
        //   break;
        // case MeasureTerms.ATDTRatio:
        //   feature.updateFloatValue(output, fakeOutputDate, output.unit);
        //   break;
        // case MeasureTerms.ATETRatio:
        //   feature.updateFloatValue(output, fakeOutputDate, output.unit);
        //   break;
        // case MeasureTerms.Trace:
        //   feature.updateFloatValue(output, fakeOutputDate, output.unit);
        //   break;
        default:
          break;
      }
    }
  }

  static List<DPoint> getFeatureYFlippedPoints(MeasureItemFeature feature) {
    final viewport = feature.hostVisualArea!.viewport!;
    // 加入画布偏移量
    final canvasOffset = feature.hostVisualArea!.layoutRegion!.topLeft;
    //加入坐标系偏移量
    final coordinateOffset = viewport.region;
    final regionPoints = feature.innerPoints
        .map((e) => viewport
            .convert(
                e.clone().addVector(DVector(-canvasOffset.x, -canvasOffset.y)))
            .addVector(DVector(coordinateOffset.left, -coordinateOffset.top)))
        .toList();
    final points = regionPoints.map((e) => DPoint(e.x, -e.y)).toList();
    return points;
  }

  static List<double> getCountVTI(MeasureItemFeature feature) {
    final yFlippedPoints = getFeatureYFlippedPoints(feature);
    final result = GeneralFormulas.countVTI(yFlippedPoints);
    return result;
  }
}