fis_lib_measure/lib/process/primitives/urm_measure/urm_shell_measure.dart

import 'dart:ui' as ui;

import 'package:fis_jsonrpc/rpc.dart';
import 'package:fis_measure/interfaces/enums/items.dart';
import 'package:fis_measure/interfaces/process/items/item.dart';
import 'package:fis_measure/interfaces/process/items/item_metas.dart';
import 'package:fis_measure/interfaces/process/workspace/point_info.dart';
import 'package:fis_measure/process/calcuators/urm_calcuators/urm_shell_den_measure.dart';
import 'package:fis_measure/process/calcuators/urm_calcuators/urm_shell_den_vel_measure.dart';
import 'package:fis_measure/process/calcuators/urm_calcuators/urm_shell_density_measure.dart';
import 'package:fis_measure/process/calcuators/urm_calcuators/urm_shell_fractal_dim_measure.dart';
import 'package:fis_measure/process/calcuators/urm_calcuators/urm_shell_hist_measure.dart';
import 'package:fis_measure/process/calcuators/urm_calcuators/urm_shell_perfusion_measure.dart';
import 'package:fis_measure/process/calcuators/urm_calcuators/urm_shell_vel_measure.dart';
import 'package:fis_measure/process/primitives/area_abstract.dart';
import 'package:fis_measure/process/primitives/trace.dart';
import 'package:fis_measure/utils/prompt_box.dart';
import 'package:flutter/material.dart';
import 'package:flutter/services.dart';

class URMShellMeasure extends Trace {
  URMShellMeasure(super.meta, super.parent);
  static bool needPerfusion = false;

  static URMShellMeasure createURMShellDenMeasure(ItemMeta meta,
      [IMeasureItem? parent]) {
    URMShellMeasure measureShellDen = URMShellMeasure(meta, parent);
    measureShellDen.calculator = URMShellDenMeasureCal(
      measureShellDen,
    );
    return measureShellDen;
  }

  static URMShellMeasure createURMShellVelMeasure(ItemMeta meta,
      [IMeasureItem? parent]) {
    URMShellMeasure measureShellVel = URMShellMeasure(meta, parent);
    measureShellVel.calculator = URMShellVelMeasureCal(
      measureShellVel,
    );
    return measureShellVel;
  }

  static URMShellMeasure createURMShellDensityMeasure(ItemMeta meta,
      [IMeasureItem? parent]) {
    URMShellMeasure measureShellDensity = URMShellMeasure(meta, parent);
    measureShellDensity.calculator = URMShellDensityMeasureCal(
      measureShellDensity,
    );
    return measureShellDensity;
  }

  static URMShellMeasure createURMShellFractalDimMeasure(ItemMeta meta,
      [IMeasureItem? parent]) {
    URMShellMeasure measureShellFractalDim = URMShellMeasure(meta, parent);
    measureShellFractalDim.calculator = URMShellFractalDimMeasureCal(
      measureShellFractalDim,
    );
    return measureShellFractalDim;
  }

  static URMShellMeasure createURMShellPerfusionMeasure(ItemMeta meta,
      [IMeasureItem? parent]) {
    needPerfusion = true;
    URMShellMeasure measureShellPerfusion = URMShellMeasure(meta, parent);
    measureShellPerfusion.calculator = URMShellPerfusionMeasureCal(
      measureShellPerfusion,
    );
    return measureShellPerfusion;
  }

  static URMShellMeasure createURMShellHistMeasure(ItemMeta meta,
      [IMeasureItem? parent]) {
    URMShellMeasure measureShellHist = URMShellMeasure(meta, parent);
    measureShellHist.calculator = URMShellHistMeasureCal(
      measureShellHist,
    );
    return measureShellHist;
  }

  static URMShellMeasure createURMShellDenVelMeasure(ItemMeta meta,
      [IMeasureItem? parent]) {
    URMShellMeasure measureShellDenVel = URMShellMeasure(meta, parent);
    measureShellDenVel.calculator = URMShellDenVelMeasureCal(
      measureShellDenVel,
    );
    return measureShellDenVel;
  }

  @override
  bool onExecuteMouse(PointInfo args) {
    if (waitingResult) return false;
    if (state == ItemStates.finished) {
      if (args.pointType == PointInfoType.mouseDown) {
        state = ItemStates.waiting;
      }
    }

    if (state == ItemStates.waiting) {
      if (args.pointType == PointInfoType.mouseDown) {
        handleMouseDownWhileWaiting(args);
      }
    } else if (state == ItemStates.running) {
      if (args.pointType == PointInfoType.mouseUp) return false;

      feature?.adopt(args);
      if (args.pointType == PointInfoType.mouseDown) {
        handleFinish();
      } else {
        checkAutoSnap(args);
      }
    }
    return true;
  }

  @override
  void handleMouseDownWhileWaiting(PointInfo args) {
    if (needPerfusion) {
      feature = ShellPerfusionImageFeature(this);
    } else {
      super.handleMouseDownWhileWaiting(args);
    }
    state = ItemStates.running;
  }

  bool waitingResult = false;

  void handleFinish() async {
    feature!.isActive = false;
    PromptBox.loading("计算中...");
    waitingResult = true;
    await doCalculateAsync();
    doFeatureFinish();
    PromptBox.dismiss();
    waitingResult = false;
  }

  /// 自动结束检测
  @override
  bool checkAutoSnap(PointInfo current, [bool autoFinishFeature = true]) {
    if (feature == null || feature!.innerPoints.length < 3) {
      isSmartMove = false;
      return _syncState(false);
    }

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

    if (isAutoSnap == false) return false;
    final pixelSize = application.displaySize;

    final p1 = feature!.innerPoints.first.scale2Size(pixelSize);
    final p2 = current.scale2Size(pixelSize);
    final length = (p1 - p2).length;
    if (length > snapThreshold * 2.0 && !isSmartMove) {
      isSmartMove = true;
    }
    if (length < snapThreshold && isSmartMove) {
      feature!.innerPoints.last = feature!.innerPoints.first.clone();

      /// 此处的最后一个点，方便计算，但是绘制时要剔除
      // feature!.innerPoints.removeLast();

      HapticFeedback.heavyImpact();
      if (autoFinishFeature) {
        handleFinish();
      }
      isSmartMove = false;
      return _syncState(true);
    } else {
      return _syncState(false);
    }
  }

  bool _syncState(bool isSnap) {
    snapState = isSnap;
    return snapState;
  }
}

class ShellPerfusionImageFeature extends TraceFeature {
  ShellPerfusionImageFeature(AreaItemAbstract refItem) : super(refItem);

  ui.Image? perfusionImg;
  IntRect? perfusionPiexlRect;
  Rect? perfusionScaleDRect;
  @override
  void paint(Canvas canvas, Size size) {
    if (perfusionImg != null) {
      Paint paint = Paint();

      Rect src = Rect.fromLTWH(
        0,
        0,
        perfusionImg!.width.toDouble(),
        perfusionImg!.height.toDouble(),
      );
      Rect dst = Rect.fromLTWH(
        perfusionScaleDRect!.left.toDouble() * size.width,
        perfusionScaleDRect!.top.toDouble() * size.height,
        perfusionScaleDRect!.width.toDouble() * size.width,
        perfusionScaleDRect!.height.toDouble() * size.height,
      );
      canvas.drawImageRect(perfusionImg!, src, dst, paint);
    }
    super.paint(canvas, size);
  }
}