fis_lib_measure/lib/process/workspace/application.dart

import 'package:fis_measure/interfaces/enums/annotation.dart';
import 'package:fis_measure/interfaces/enums/operate.dart';
import 'package:fis_measure/interfaces/process/annotations/annotation.dart';
import 'package:fis_measure/interfaces/process/items/item.dart';
import 'package:fis_measure/interfaces/process/items/item_feature.dart';
import 'package:fis_measure/interfaces/process/items/measure_terms.dart';
import 'package:fis_measure/interfaces/process/visuals/visual_area.dart';
import 'package:fis_measure/interfaces/process/visuals/visual.dart';
import 'package:fis_measure/interfaces/process/viewports/viewport.dart';
import 'package:fis_measure/interfaces/process/modes/mode.dart';
import 'package:fis_common/event/event_type.dart';
import 'package:fis_measure/interfaces/process/workspace/application.dart';
import 'package:fis_measure/interfaces/process/workspace/point_info.dart';
import 'package:fis_measure/process/annotations/arrow_annotation.dart';
import 'package:fis_measure/process/annotations/input_annotation.dart';
import 'package:fis_measure/process/annotations/label_annotation.dart';
import 'package:fis_measure/process/primitives/location.dart';
import 'package:fis_measure/process/primitives/straightline.dart';
import 'package:flutter/painting.dart';
import 'package:vid/us/vid_us_image.dart';
import 'package:vid/us/vid_us_probe.dart';
import 'package:vid/us/vid_us_unit.dart';

import '../primitives/poyline.dart';
import '../visual/visual.dart';

class Application implements IApplication {
  static const C_VID_THIRDPART_NAME = "ThirdPart";
  late VidUsProbe _probe;
  VidUsImage? _frame;
  List<IVisual>? _visuals;
  IMeasureItem? _activeMeasureItem;
  IAnnotationItem? _activeAnnotationItem;
  bool _canOperate = false;
  Size _displaySize = Size.zero;
  MeasureOperateType _currOpType = MeasureOperateType.measure;
  final Set<IMeasureItem> _measureItems = {};
  final Set<IAnnotationItem> _annotationItems = {};

  Application(VidUsProbe probe) {
    _probe = probe;
    currentModeChanged = FEventHandler<IMode>();
    visualAreaChanged = FEventHandler<IVisualArea>();
    canMeasureChanged = FEventHandler<bool>();
    activeMeasureItemChanged = FEventHandler<IMeasureItem?>();
    activeAnnotationItemChanged = FEventHandler<IAnnotationItem?>();
    updateRenderReady = FEventHandler<void>();
    operateTypeChanged = FEventHandler<MeasureOperateType>();
  }

  @override
  bool get canMeasure => _canOperate;
  @override
  set canMeasure(bool value) {
    if (value != _canOperate) {
      _canOperate = value;
      _doCanMeasureChanged();
    }
  }

  @override
  bool get canOperate => _canOperate;
  @override
  set canOperate(bool value) {
    if (value != _canOperate) {
      _canOperate = value;
      _doCanMeasureChanged();
    }
  }

  /// 是否扇形探头
  bool get isProbeConvex => probe.type == VidUsProbeType.Convex;

  @override
  VidUsProbe get probe => _probe;

  @override
  String get applicationName => _probe.application.applicationName;

  @override
  String get categoryName => _probe.application.applicationCategoryName;

  @override
  bool get isThirdPart => probe.name == C_VID_THIRDPART_NAME;

  @override
  IMode get currentMode => currentVisualArea.mode;

  @override
  IViewPort get currentViewPort => currentVisualArea.viewport!;

  @override
  IVisual get currentVisual => visuals.firstWhere((e) => e.activeArea != null);

  @override
  IVisualArea get currentVisualArea => currentVisual.activeArea!;

  @override
  VidUsImage? get frameData => _frame;

  @override
  List<IVisual> get visuals => _visuals!;

  @override
  Set<IMeasureItem> get measureItems => _measureItems;

  @override
  Set<IAnnotationItem> get annotationItems => _annotationItems;

  @override
  MeasureOperateType get currentOperateType => _currOpType;

  @override
  Size get displaySize => _displaySize;
  @override
  set displaySize(Size value) {
    if (value != _displaySize) {
      _displaySize = value;
    }
  }

  @override
  double get displayScaleRatio {
    if (frameData != null) {
      return displaySize.width / frameData!.width;
    }
    return 1.0;
  }

  @override
  List<IMode> get avaliableModes {
    final modes = <IMode>[];
    for (var visual in visuals) {
      modes.addAll(visual.modes);
    }
    return modes;
  }

  @override
  IMeasureItem? get activeMeasureItem => _activeMeasureItem;
  set activeMeasureItem(IMeasureItem? value) {
    if (value != _activeMeasureItem) {
      // 解绑失活测量项事件监听
      _activeMeasureItem?.featureUpdated
          .removeListener(_onActiveMeasureItemFeatureUpdated);
      _activeMeasureItem = value;
      if (_activeMeasureItem != null) {
        _measureItems.add(_activeMeasureItem!);
        // 添加活动测量项事件监听
        _activeMeasureItem!.featureUpdated
            .addListener(_onActiveMeasureItemFeatureUpdated);
      }
      // 通知更新事件
      activeMeasureItemChanged.emit(this, value);
      _updateRender();
    }
  }

  @override
  IAnnotationItem? get activeAnnotationItem => _activeAnnotationItem;
  set activeAnnotationItem(IAnnotationItem? value) {
    if (value != _activeAnnotationItem) {
      // 解绑失活注释项事件监听
      _activeAnnotationItem?.featureUpdated
          .removeListener(_onActiveAnnotationItemFeatureUpdated);
      _activeAnnotationItem = value;
      if (_activeMeasureItem != null) {
        _annotationItems.add(_activeAnnotationItem!);
        // 添加活动注释项事件监听
        _activeAnnotationItem!.featureUpdated
            .addListener(_onActiveAnnotationItemFeatureUpdated);
      }
      // 通知更新事件
      activeAnnotationItemChanged.emit(this, value);
      _updateRender();
    }
  }

  /// 是否注释模式工作中
  bool get isAnnotationWorking =>
      currentOperateType == MeasureOperateType.annotation;

  @override
  late final FEventHandler<IMode> currentModeChanged;

  @override
  late final FEventHandler<IVisualArea> visualAreaChanged;

  @override
  late final FEventHandler<bool> canMeasureChanged;

  @override
  late final FEventHandler<IMeasureItem?> activeMeasureItemChanged;

  @override
  late final FEventHandler<IAnnotationItem?> activeAnnotationItemChanged;

  @override
  late final FEventHandler<void> updateRenderReady;
  @override
  late final FEventHandler<MeasureOperateType> operateTypeChanged;

  @override
  void loadFrame(VidUsImage frame) {
    bool frameLoaded = _frame != null;
    _frame = frame;
    if (!frameLoaded && canMeasure) {
      _loadVisuals();
    }
  }

  @override
  PointInfo createPointInfo(Offset offset, PointInfoType type) {
    if (frameData == null) {
      throw NullThrownError();
    }
    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 = visuals.first.visualAreas.first; // TODO: 找区域
    if (isAnnotationWorking) {
      activeAnnotationItem?.execute(info);
    } else {
      activeMeasureItem?.execute(info);
    }
    return info;
  }

  @override
  void switchItemByName(String name) {
    _updateOperateType(MeasureOperateType.measure);
    // TODO: create from map
    if (name == MeasureTerms.Distance) {
      activeMeasureItem = StraightLine.createDistance(
        ItemMeta(
          MeasureTerms.Distance,
          {
            "Description": MeasureTerms.Distance,
            "BriefDescription": "D",
            "Unit": VidUsUnit.cm,
          },
        ),
      );
      return;
    }

    if (name == MeasureTerms.Perimeter) {
      activeMeasureItem = PolyLine.createPerimeter(
        ItemMeta(
          MeasureTerms.Perimeter,
          {
            "Description": MeasureTerms.Perimeter,
            "BriefDescription": MeasureTerms.Perimeter,
            "Unit": VidUsUnit.cm,
          },
        ),
        null,
      );
      return;
    }
    if (name == MeasureTerms.Area) {
      activeMeasureItem = PolyLine.createArea(
        ItemMeta(
          MeasureTerms.Area,
          {
            "Description": MeasureTerms.Area,
            "BriefDescription": MeasureTerms.Area,
            "Unit": VidUsUnit.cm2,
          },
        ),
        null,
      );
      return;
    }
    if (name == MeasureTerms.Depth) {
      final Location Function(ItemMeta, [IMeasureItem?]) fn = isProbeConvex
          ? Location.createTissueConvexDepth
          : Location.createTissueDepth;
      activeMeasureItem = fn(
        ItemMeta(
          MeasureTerms.Depth,
          {
            "Description": MeasureTerms.Depth,
            "BriefDescription": MeasureTerms.Depth,
            "Unit": VidUsUnit.cm,
          },
        ),
        null,
      );
      return;
    }
  }

  @override
  void switchAnnotation([AnnotationType? type, String? text]) {
    _updateOperateType(MeasureOperateType.annotation);
    final targetType = type ?? AnnotationType.input;
    if (activeAnnotationItem != null &&
        activeAnnotationItem!.type == targetType &&
        activeAnnotationItem!.text == text) {
      return;
    }
    // activeAnnotationItem?.finishLast();

    final cachedItems = annotationItems.toList();
    final cachedItemIdx = cachedItems.indexWhere((e) => e.type == targetType);
    if (cachedItemIdx > -1) {
      activeAnnotationItem = cachedItems[cachedItemIdx];
    } else {
      switch (targetType) {
        case AnnotationType.label:
          activeAnnotationItem = LabelAnnotation();
          break;
        case AnnotationType.input:
          activeAnnotationItem = InputAnnotation();
          break;
        case AnnotationType.arrow:
          activeAnnotationItem = ArrowAnnotation();
          break;
      }
      cachedItems.add(activeAnnotationItem!);
    }
    activeAnnotationItem?.text = text;
    activeAnnotationItemChanged.emit(this, activeAnnotationItem);
  }

  void _updateOperateType(MeasureOperateType type) {
    if (currentOperateType == MeasureOperateType.annotation) {
      activeAnnotationItem?.finishLast();
    }
    if (currentOperateType != type) {
      _currOpType = type;
      operateTypeChanged.emit(this, type);
    }
  }

  void _updateRender() {
    updateRenderReady.emit(this, null);
  }

  void _doCanMeasureChanged() {
    canMeasureChanged.emit(this, canMeasure);

    _clear();
    if (canMeasure) {
      if (frameData != null) {
        _loadVisuals();
      }
    }
  }

  void _onActiveMeasureItemFeatureUpdated(
    Object sender,
    IMeasureItemFeature? e,
  ) {
    _updateRender();
  }

  void _onActiveAnnotationItemFeatureUpdated(
    Object sender,
    IAnnotationItemFeature? e,
  ) {
    _updateRender();
  }

  void _loadVisuals() {
    _clearVisuals();
    for (final data in frameData!.visuals) {
      _visuals!.add(VisualBase(data));
    }
  }

  void _clear() {
    for (var item in measureItems) {
      item.clear();
    }
    _clearVisuals();
  }

  void _clearVisuals() {
    _visuals = [];
  }
}